Community
Hi,
First, to avoid COM versions dependency, you can use the dynamic type (requires framework 4.0 or later) or late binding with Reflection, these way you won't have to reference any AutoCAD COM library.
The main inconvenient is that you won't have no more help from Visual Studio intellisense, but you can build your program referencing the COM libraries and the convert it to dynamic or late binding.
Here're three examples of the same little Console Application which creates a new instance of AutoCAD, make it visible and change the cursor size to 100.
Using COM libraries reference and strong typing, the progId have to be same version à the referenced libraries.
static void Main()
{
AcadApplication acadApp;
try
{
acadApp = (AcadApplication)Activator.CreateInstance(System.Type.GetTypeFromProgID("AutoCAD.Application.18.1"));
}
catch (Exception)
{
MessageBox.Show("Unable to launch AutoCAD");
return;
}
WaitForAcadIsQuiescent(acadApp);
acadApp.Visible = true;
WaitForAcadIsQuiescent(acadApp);
acadApp.Preferences.Display.CursorSize = 100;
}
static void WaitForAcadIsQuiescent(AcadApplication acadApp)
{
while (true)
{
try
{
AcadState state = acadApp.GetAcadState();
if (state.IsQuiescent)
break;
}
catch { }
}
}
Converting to dynamic is the easiest way: remove references to the COM references and replace all AutoCAD COM strong types in the code with the 'dynamic' keyword.
Using dynamic typing, requires the Framework 4
static void Main()
{
dynamic acadApp;
try
{
acadApp = Activator.CreateInstance(System.Type.GetTypeFromProgID("AutoCAD.Application.18"));
}
catch (Exception)
{
MessageBox.Show("Unable to launch AutoCAD");
return;
}
WaitForAcadIsQuiescent(acadApp);
acadApp.Visible = true;
WaitForAcadIsQuiescent(acadApp);
acadApp.Preferences.Display.CursorSize = 100;
}
static void WaitForAcadIsQuiescent(dynamic acadApp)
{
while (true)
{
try
{
dynamic state = acadApp.GetAcadState();
if (state.IsQuiescent)
break;
}
catch { }
}
}
Using late binding is a little more tricky, but to avoid all the object.GetType().InvokeMember( ...) stuff, you can use the below extension methods which allow to write code in a frienly way (LISP vlax-* syntax like).
Using late bindig with Reflection, requires the LateBindingHelper extension methods
static void Main(string[] args)
{
object acadApp;
try
{
acadApp = LateBindingHelper.CreateInstance("AutoCAD.Application");
}
catch (Exception)
{
MessageBox.Show("Unable to launch AutoCAD");
return;
}
WaitForAcadIsQuiescent(acadApp);
acadApp.Set("Visible", true);
WaitForAcadIsQuiescent(acadApp);
acadApp.Get("Preferences").Get("Display").Set("CursorSize", 100);
}
static void WaitForAcadIsQuiescent(object acadApp)
{
while (true)
{
try
{
object state = acadApp.Invoke("GetAcadState");
if ((bool)state.Get("IsQuiescent"))
break;
}
catch { }
}
}
Late binding helper extension methods, requires reference to System.Reflection and System.runtime.InteropServices.
public static class LateBindingHelper
{
public static object GetInstance(string appName)
{
return Marshal.GetActiveObject(appName);
}
public static object CreateInstance(string appName)
{
return Activator.CreateInstance(System.Type.GetTypeFromProgID(appName));
}
public static object GetOrCreateInstance(string appName)
{
try { return GetInstance(appName); }
catch { return CreateInstance(appName); }
}
public static void ReleaseInstance(this object obj)
{
Marshal.ReleaseComObject(obj);
}
public static object Get(this object obj, string propName)
{
return obj.GetType().InvokeMember(propName, BindingFlags.GetProperty, null, obj, new object[0]);
}
public static void Set(this object obj, string propName, object value)
{
obj.GetType().InvokeMember(propName, BindingFlags.SetProperty, null, obj, new object[1] { value });
}
public static object Invoke(this object obj, string methName, params object[] parameters)
{
return obj.GetType().InvokeMember(methName, BindingFlags.InvokeMethod, null, obj, parameters);
}
}
For the second problem, as far as I know, using the ProgId without specifying version ("AutoCAD.Application") launches the latest opened version. Using only the major version ("AutoCAD.Application.19") launches the latest opened AutoCAD for this major version.
This helper just provides extension methods to make late binding less noisy.
This is useless since .NET Framework 4.0 brings the dynamic type.
From the code you're showing (using Editor.Command), it looks like you're targerting AutoCAD 2015 or later. That means you have at least the NET Framework 4.5 installed, so you absolutely do not need to use this helper and should use dynamic type instead.
Sorry, I cannot understand what you're trying to achieve.
The code you are showing does not use the COM interface, so there is no reason to use late binding or the dynamic type to get rid of dependencies on AutoCAD versions. However, you use the Editor.Command () method, which only exists for versions of AutoCAD 2015 and later.
I don't clearly understand your request.
The process to get or create an AutoCAD instance and call custom .NET commands is described in this topic.
To load a DLL just use SendCommand with a string figuring the (command "NETLOAD" ...) LISP expression as shown in the upper link.
acadDoc.SendCommand("(command \"NETLOAD\" \"C:\\NET commands\\CreateLayer.dll\") ");
To call a command with inputs, just build a string with the command name and the inputs as you'd do at AutoCAD Command line and pass it to SendCommand (example to call your command to create a layer named "Layer_1" with color index = 7):
acadDoc.SendCommand("CreateLayer_DWG Layer_1 7 ");
And please, create a new post. You'd get more help.
@tvmanalan wrote:
Hi,
Thanks. If we use dynamic type then its a dependency of particular version like "AutoCAD.Application.18".So we cant achieve multiple version type.
Am right?
thanks,
vallimanalan.T
The only requirement for using the dynamic type is the Framework 4.0 or upper is installed.
You can use "AutoCAD.Application" as progId to launch the last opened version of AutoCAD.
acadApp = Activator.CreateInstance(System.Type.GetTypeFromProgID("AutoCAD.Application"));
@tvmanalan wrote:
Hi,
only i have confusion on how i need to write the below commands in LateBinderHelp with parameters
acadDoc.SendCommand("CreateLayer_DWG Layer_1 7 ")
In the above example, Layer & color index are parameters
You're confusing method parameters and command inputs.
There's only one parameter for the SendCommand method which is a string containing the command inputs.
Using the dynamic type (you can safely use this for AutoCAD 2012 and later versions):
try
{
dynamic acadApp;
try
{
acadApp = LateBindingHelper.CreateInstance("AutoCAD.Application");
}
catch (Exception)
{
Console.WriteLine("Unable to launch AutoCAD");
return;
}
WaitForAcadIsQuiescent(acadApp);
acadApp.Visible = true;
WaitForAcadIsQuiescent(acadApp);
dynamic acadDoc = acadApp.ActiveDocument;
acadDoc.SendCommand(@"(command ""NETLOAD"" ""C:\\Temp\\AcadStandaloneLateBinding\\CreateLayerSample.dll"") ");
acadDoc.SendCommand("CreateLayer_DWG Layer_1\n7 ");
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
Using late binding (only required if the .NET Framework is lower than 4.0):
try
{
object acadApp;
try
{
acadApp = LateBindingHelper.CreateInstance("AutoCAD.Application");
}
catch (Exception)
{
Console.WriteLine("Unable to launch AutoCAD");
return;
}
WaitForAcadIsQuiescent(acadApp);
acadApp.Set("Visible", true);
WaitForAcadIsQuiescent(acadApp);
object acadDoc = acadApp.Get("ActiveDocument");
acadDoc.Invoke("SendCommand", @"(command ""NETLOAD"" ""C:\\NET Commands\\AcadStandaloneLateBinding\\CreateLayerSample.dll"") ");
acadDoc.Invoke("SendCommand", "CreateLayer_DWG Layer_1\n7 ");
}
catch(System.Exception e)
{
Console.WriteLine(e.Message);
}
@tvmanalan wrote:
Basically I want to access the autocad command line through your latebindhelper.
acDoc.SendStringToExecute("._circle 2,2,0 4 ", true, false, false); acDoc.SendStringToExecute("._zoom _all ", true, false, false);
if you can send the equivalent code for the above two line it will be very useful for me.
thanks a lot.
Using dynamic:
acadDoc.SendCommand("._circle 2,2,0 4 ");
acadDoc.SendCommand("._zoom _all ");
Using late binding helper
acadDoc.Invoke("SendCommand", "._circle 2,2,0 4 ");
acadDoc.Invoke("SendCommand", "._zoom _all ");
