Kean专题(6)—Runtime

雪山飞狐_lzh · 发表于 2009-5-21 20:09

本帖最后由作者于 2009-5-22 21:45:11 编辑

原帖：http://through-the-interface.typepad.com/through_the_interface/runtime/
一、初始化例程
September 06, 2006
Initialization code in your AutoCAD .NET application
It's very common to need to execute some code as your application modules are loaded, and then to clean-up as they get unloaded or as AutoCAD terminates. Managed AutoCAD applications can do this by implementing the Autodesk.AutoCAD.Runtime.IExtensionApplication interface, which require Initialize() and Terminate() methods.
During the Initialize() method, you will typically want to set system variables and perhaps call commands which execute some pre-existing initialization code for your application.
Here's some code showing how to implement this interface using VB.NET:

Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.EditorInput
Imports System
Public Class InitializationTest
Implements Autodesk.AutoCAD.Runtime.IExtensionApplication
Public Sub Initialize() Implements _
IExtensionApplication.Initialize
Dim ed As Editor = _
Application.DocumentManager.MdiActiveDocument.Editor
ed.WriteMessage("Initializing - do something useful.")
End Sub
Public Sub Terminate() Implements _
IExtensionApplication.Terminate
Console.WriteLine("Cleaning up...")
End Sub
<CommandMethod("TST")> _
Public Sub Test()
Dim ed As Editor = _
Application.DocumentManager.MdiActiveDocument.Editor
ed.WriteMessage("This is the TST command.")
End Sub
End Class

And here's the equivalent code in C#:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using System;
public class InitializationTest
: Autodesk.AutoCAD.Runtime.IExtensionApplication
{
public void Initialize()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("Initializing - do something useful.");
}
public void Terminate()
{
Console.WriteLine("Cleaning up...");
}
[CommandMethod("TST")]
public void Test()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("This is the TST command.");
}
}

A few notes about this code:
.NET modules are not currently unloaded until AutoCAD terminates. While this is a popular request from developers (as it would make debugging much simpler), my understanding is that this is an issue that is inherent to the implementation of .NET - see this MSDN blog post for more information.
What this means is that by the time the Terminate() method is called, AutoCAD is already in the process of closing. This is why I've used Console.Write() rather than ed.WriteMessage(), as by this point there's no command-line to write to.
That said, you can and should use the Terminate() callback to close any open files, database connections etc.
Something else you might come across when implementing this... I've implemented a single command in this application for a couple of reasons: in my next post I'm going to segregate the command into a different class, to show how you can tweak your application architecture both to follow a more logical structure and to optimize load performance.
The second reason I added the command was to raise a subtle you might well hit while coding: you might see the initialization string sent to the command-line as the application loads, but then the command is not found when you enter "TST" at the command-line. If you experience this behaviour, you're probably hitting an issue that can come up when coding managed applications against AutoCAD 2007: there's been a change in this version so that acmgd.dll is loaded on startup, and under certain circumstances this assembly might end up getting loaded again if found on a different path, causing your commands not to work.
The issue can be tricky to identify but is one that can be resolved in a number of ways:
Edit the Registry to disable the demand-loading "load on startup" of acmgd.dll (a bad idea, in my opinion - it's safer not to second guess what assumptions might have been made about the availability of core modules)
Make sure AutoCAD is launched from its own working directory - commonly this issue is hit while debugging because Visual Studio doesn't automatically pick up the debugging application's working directory
Set the "Copy Local" flag for acmgd.dll to "False". "Copy Local" tells Visual Studio whether the build process should make copies of the assemblies referenced by the project in its output folder
My preference is for the third approach, as on a number of occasions I've overwritten acmgd.dll and acdbmgd.dll with those from another AutoCAD version (inadvertently trashing my AutoCAD installation). This usually happens when testing projects across versions (projects that's I've set to output directly to AutoCAD's program folder, for convenience), and I've forgotten to change the assemblies references before building.
So I would actually set both your references to acdbmgd.dll and acmgd.dll to "Copy Local = False". You can do this either by selecting the Reference(s) via the Solution Explorer (in C#) or via the References tab in your Project Properties (in VB.NET) and then editing the reference's Properties.

雪山飞狐_lzh · 发表于 2009-5-21 20:16

二、优化.Net模块的载入
September 08, 2006
Optimizing the loading of AutoCAD .NET applications
In my previous post I described how you could use the Autodesk.AutoCAD.Runtime.IExtensionApplication interface to implement initialization code in your .NET module. Building on this, we're now going to look at how use of the Autodesk.AutoCAD.Runtime.IExtensionApplication interface can also allow you - with very little effort - to optimize the architecture of your managed modules for faster loading into AutoCAD.
First some information from the "Using .NET for AutoCAD documentation" (which is available in the ObjectARX Developer's Guide on the ObjectARX SDK):
When AutoCAD loads a managed application, it queries the application's assembly for an ExtensionApplication custom attribute. If this attribute is found, AutoCAD sets the attribute's associated type as the application's entry point. If no such attribute is found, AutoCAD searches all exported types for an IExtensionApplication implementation. If no implementation is found, AutoCAD simply skips the application-specific initialization step.
...
In addition to searching for an IExtensionApplication implementation, AutoCAD queries the application's assembly for one or more CommandClass attributes. If instances of this attribute are found, AutoCAD searches only their associated types for command methods. Otherwise, it searches all exported types.
The samples that I've shown in this blog - and most of those on the ObjectARX SDK - do not show how you can use the ExtensionApplication or CommandClass attribute in your code, as it's not essential to implement them for your application to work. But if you have a large .NET module to be loaded into AutoCAD, it might take some time for AutoCAD to check the various objects in the assembly, to find out which is the ExtensionApplication and which are the various CommandClasses.
The attributes you need to implement are very straightforward:
C#:

[assembly: ExtensionApplication(typeof(InitClass))]
[assembly: CommandClass(typeof(CmdClass))]

复制代码

VB.NET:

<Assembly: ExtensionApplication(GetType(InitClass))>
<Assembly: CommandClass(GetType(CmdClass))>

复制代码

These assembly-level attributes simply tell AutoCAD where to look for the various objects it will otherwise need to identify by searching. Here's some more information from the documentation on the use of these attributes:
The ExtensionApplication attribute can be attached to only one type. The type to which it is attached must implement the IExtensionApplication interface.
...
A CommandClass attribute may be declared for any type that defines AutoCAD command handlers. If an application uses the CommandClass attribute, it must declare an instance of this attribute for every type that contains an AutoCAD command handler method.
While optimizing yesterday's code to reduce load-time, I also changed the structure slightly to be more logical. The above attributes also take classes within a namespace, so I decided to split the initialization code (the "Initialization" class) away from the command implementations (the "Commands" class), but keeping them both in the same ("ManagedApplication") namespace.
And here's the code...
C#:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using System;
[assembly:
ExtensionApplication(
typeof(ManagedApplication.Initialization)
)
]
[assembly:
CommandClass(
typeof(ManagedApplication.Commands)
)
]
namespace ManagedApplication
{
public class Initialization
: Autodesk.AutoCAD.Runtime.IExtensionApplication
{
public void Initialize()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("Initializing - do something useful.");
}
public void Terminate()
{
Console.WriteLine("Cleaning up...");
}
}
public class Commands
{
[CommandMethod("TST")]
public void Test()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("This is the TST command.");
}
}
}

VB.NET:

Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.EditorInput
Imports System
<Assembly: _
ExtensionApplication( _
GetType(ManagedApplication.Initialization))>
<Assembly: _
CommandClass( _
GetType(ManagedApplication.Commands))>
Namespace ManagedApplication
Public Class Initialization
Implements Autodesk.AutoCAD.Runtime.IExtensionApplication
Public Sub Initialize() Implements _
IExtensionApplication.Initialize
Dim ed As Editor = _
Application.DocumentManager.MdiActiveDocument.Editor
ed.WriteMessage("Initializing - do something useful.")
End Sub
Public Sub Terminate() Implements _
IExtensionApplication.Terminate
Console.WriteLine("Cleaning up...")
End Sub
End Class
Public Class Commands
<CommandMethod("TST")> _
Public Sub Test()
Dim ed As Editor = _
Application.DocumentManager.MdiActiveDocument.Editor
ed.WriteMessage("This is the TST command.")
End Sub
End Class
End Namespace

Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.EditorInput
Imports System
<Assembly: _
  ExtensionApplication( _
    GetType(ManagedApplication.Initialization))> 
<Assembly: _
  CommandClass( _
    GetType(ManagedApplication.Commands))> 
Namespace ManagedApplication
  Public Class Initialization
    Implements Autodesk.AutoCAD.Runtime.IExtensionApplication
    Public Sub Initialize() Implements _
    IExtensionApplication.Initialize
      Dim ed As Editor = _
        Application.DocumentManager.MdiActiveDocument.Editor
      ed.WriteMessage("Initializing - do something useful.")
    End Sub
    Public Sub Terminate() Implements _
    IExtensionApplication.Terminate
      Console.WriteLine("Cleaning up...")
    End Sub
  End Class
  Public Class Commands
    <CommandMethod("TST")> _
    Public Sub Test()
      Dim ed As Editor = _
        Application.DocumentManager.MdiActiveDocument.Editor
      ed.WriteMessage("This is the TST command.")
    End Sub
  End Class
End Namespace

雪山飞狐_lzh · 发表于 2009-5-21 20:19

三、自动加载
September 11, 2006
Automatic loading of .NET modules
Clearly it’s far from ideal to ask your users to load your application modules manually into AutoCAD whenever they need them, so over the years a variety of mechanisms have been put in place to enable automatic loading of applications – acad.lsp, acad.ads, acad.rx, the Startup Suite, to name but a few.
The most elegant way to auto-load both ObjectARX and .NET applications is the demand-loading mechanism. This mechanism is based on information stored in the Registry describing the conditions under which modules should be loaded and how to load them.
Demand loading is fairly straightforward and well documented in the ObjectARX Developer’s Guide (look under “demand loading applications”).
Essentially the information can be stored in one of two places: under HKEY_LOCAL_MACHINE or under HKEY_CURRENT_USER. The decision on where to place the information will depend on a few things – mainly whether the application is to be shared across all users but also whether your application installer has the privileges to write to HKEY_LOCAL_MACHINE or not.
It’s not really the place to talk about the pros and cons of these two locations – for the sake of simplicity the following examples show writing the information to HKEY_CURRENT_USER. Let’s start by looking at the root location for the demand-loading information:
HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications
Most of this location is logical enough (to humans), although the “ACAD-5001:409” piece needs a bit of explanation. This number has evolved over the releases, but right now 5001 means AutoCAD 2007 (it was 4001 for AutoCAD 2006, 301 for AutoCAD 2005 and 201 for AutoCAD 2004), and 409 is the “locale” corresponding to English.
A more complete description of the meaning of this key is available to ADN members at:
Registry values for ProductID and LocaleID for AutoCAD and the vertical products
There are two common times to load a .NET application: on AutoCAD startup and on command invocation. ObjectARX applications might also be loaded on object detection, but as described in a previous post this is not something that is currently available to .NET applications.
Let’s take the two common scenarios and show typical settings for the test application shown in this previous post.
Loading modules on AutoCAD startup
Under the root key (HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications) there is some basic information needed for our application. Firstly, you need to create a key just for our application: in this case I’ve used “MyTestApp” (as a rule it is recommended that professional software vendors prefix this string with their Registered Developer Symbol (RDS), which can be logged here, but for in-house development this is not necessary – just avoid beginning the key with “Acad” :-).
Under our application key (HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApp), we then create a number of values:

DESCRIPTION A string value describing the purpose of the module
LOADCTRLS A DWORD (numeric) value describing the reasons for loading the app
MANAGED Another DWORD that should be set to "1" for .NET modules
LOADER A string value containing the path to the module

复制代码

The interesting piece is the LOADCTRLS value – the way to encode this is described in detail in the ObjectARX Developer’s Guide, but to save time I’ll cut to the chase: this needs to have a value of "2" for AutoCAD to load the module on startup.
Here's a sample .reg file:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApplication]
"DESCRIPTION"="Kean's test application"
"LOADCTRLS"=dword:00000002
"MANAGED"=dword:00000001
"LOADER"="C:\\My Path\\MyTestApp.dll"

复制代码

After merging it into the Registry, here's what happens when you launch AutoCAD:
Regenerating model.

Initializing - do something useful.
AutoCAD menu utilities loaded.
Command: tst
This is the TST command.
Command:

复制代码

Loading modules on command invocation
To do this we need to add a little more information into the mix.
Firstly we need to change the value of LOADCTRLS to "12" (or "c" in hexadecimal), which is actually a combination of 4 (which means "on command invocation") and 8 (which means "on load request"). For people that want to know the other flags that can be used, check out rxdlinkr.h in the inc folder of the ObjectARX SDK.
Secondly we need to add a couple more keys, to contain information about our commands and command-groups.
Beneath a "Commands" key (HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApp\Commands), we'll create as many string values as we have commands, each with the name of the "global" command name, and the value of the "local" command name. As well as the "TST" command, I've added one more called "ANOTHER".
Beneath a "Groups" key (HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApp\Groups), we'll do the same for the command-groups we've registered our commands under (I used the default CommandMethod attribute that doesn't mention a group name, so this is somewhat irrelevant for our needs - I'll use "ASDK_CMDS" as an example, though).
Here's the the updated .reg file:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApplication]
"DESCRIPTION"="Kean's test application"
"LOADCTRLS"=dword:0000000c
"MANAGED"=dword:00000001
"LOADER"="C:\\My Path\\MyTestApp.dll"
[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApp\Commands]
"TST"="TST"
"ANOTHER"="ANOTHER"
[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R17.0\ACAD-5001:409\Applications\MyTestApp\Groups]
"ASDK_CMDS"="ASDK_CMDS"

复制代码

And here's what happens when we launch AutoCAD this time, and run the tst command. You see the module is only loaded once the command is invoked:

Regenerating model.
AutoCAD menu utilities loaded.
Command: tst
Initializing - do something useful.This is the TST command.
Command:

复制代码

雪山飞狐_lzh · 发表于 2009-5-21 20:29

四、程序集的路径
November 22, 2006
Finding the location of a .NET module
A quick pre-Thanksgiving tip that came from an internal discussion today: how to find the location of a .NET module (meaning the currently executing assembly).
Two techniques were identified:
Identify the current assembly by asking where one of its types is defined
Use the Assembly.GetExecutingAssembly() to get the assembly from where the current code is executing
Here's the C# code showing the two techniques:

using System;
using System.Reflection;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
namespace AssemblyLocationTest
{
public class AssemblyCmds
{
[CommandMethod("LOC")]
public void GetModuleLocation()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
// First technique
Type type = typeof(AssemblyCmds);
Assembly asm1 = type.Assembly;
ed.WriteMessage(
"\nAssembly location (1) is: "
+ asm1.Location
);
// Second technique
Assembly asm2 = Assembly.GetExecutingAssembly();
ed.WriteMessage(
"\nAssembly location (2) is: "
+ asm2.Location
);
}
}
}

And here are the results, just to show they return the same thing:

Command: loc
Assembly location (1) is: C:\temp\MyAssembly.dll
Assembly location (2) is: C:\temp\MyAssembly.dll

复制代码

雪山飞狐_lzh · 发表于 2009-5-21 20:34

五、在注册表保存设置
May 05, 2008
Storing custom AutoCAD application settings in the Registry using .NET
Thanks to Sreekar Devatha, Gopinath Taget & Jeremy Tammik (from DevTech India, Americas and Europe, respectively) for contributing to my knowledge in this area over the last few months (whether they knew they were doing so, or not :-).
This post shows how to make use of a handy interface inside AutoCAD to place custom settings in the Registry and how to then read them back. The code is very simple: you simply open up the current profile and then access/modify your hierarchy of setting beneath it. I've used a Registered Developer Symbol (RDS) to prefix the section of the Registry directly beneath the profile, to avoid conflicts with other applications.
There are other ways of saving more complex settings to the Registry: in a future post I'll go more in-depth with the System.Configuration namespace (especially how to implement your own System.Configuration.ConfigurationSettings class and save it to the Registry).
Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
namespace ApplicationSettings
{
public class Commands
{
// We're using our Registered Developer Symbol (RDS)
// TTIF == Through the Interface
// for the section name.
// The entries beneath don't need this.
const string sectionName = "TTIFSettings";
const string intProperty = "TestInteger";
const string doubleProperty = "TestDouble";
const string stringProperty = "TestString";
[CommandMethod("ATR")]
static public void AddToRegistry()
{
IConfigurationSection con =
Application.UserConfigurationManager.OpenCurrentProfile();
using (con)
{
IConfigurationSection sec =
con.CreateSubsection(sectionName);
using (sec)
{
sec.WriteProperty(intProperty, 1);
sec.WriteProperty(doubleProperty, 2.0);
sec.WriteProperty(stringProperty, "Hello");
}
}
}
[CommandMethod("RFR")]
static public void RetrieveFromRegistry()
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
IConfigurationSection prf =
Application.UserConfigurationManager.OpenCurrentProfile();
using (prf)
{
if (prf.ContainsSubsection(sectionName))
{
IConfigurationSection sec =
prf.OpenSubsection(sectionName);
using (sec)
{
double doubleValue =
(double)sec.ReadProperty(doubleProperty, 0.0);
string stringValue =
(string)sec.ReadProperty(stringProperty, "");
int intValue =
(int)sec.ReadProperty(intProperty, 0);
object defValue =
sec.ReadProperty("NotThere", 3.142);
ed.WriteMessage("\nInt value: " + intValue);
ed.WriteMessage("\nDouble value: " + doubleValue);
ed.WriteMessage("\nString value: " + stringValue);
ed.WriteMessage("\nNon-existent value: " + defValue);
}
}
}
}
}
}

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
namespace ApplicationSettings
{
  public class Commands
  {
    // We're using our Registered Developer Symbol (RDS)
    //  TTIF == Through the Interface
    // for the section name.
    // The entries beneath don't need this.
    const string sectionName = "TTIFSettings";
    const string intProperty = "TestInteger";
    const string doubleProperty = "TestDouble";
    const string stringProperty = "TestString";
    [CommandMethod("ATR")]
    static public void AddToRegistry()
    {
      IConfigurationSection con =
        Application.UserConfigurationManager.OpenCurrentProfile();
      using (con)
      {
        IConfigurationSection sec =
          con.CreateSubsection(sectionName);
        using (sec)
        {
          sec.WriteProperty(intProperty, 1);
          sec.WriteProperty(doubleProperty, 2.0);
          sec.WriteProperty(stringProperty, "Hello");
        }
      }
    }
    [CommandMethod("RFR")]
    static public void RetrieveFromRegistry()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      IConfigurationSection prf =
        Application.UserConfigurationManager.OpenCurrentProfile();
      using (prf)
      {
        if (prf.ContainsSubsection(sectionName))
        {
          IConfigurationSection sec =
            prf.OpenSubsection(sectionName);
          using (sec)
          {
            double doubleValue =
              (double)sec.ReadProperty(doubleProperty, 0.0);
            string stringValue =
              (string)sec.ReadProperty(stringProperty, "");
            int intValue =
              (int)sec.ReadProperty(intProperty, 0);
            object defValue =
              sec.ReadProperty("NotThere", 3.142);
            ed.WriteMessage("\nInt value: " + intValue);
            ed.WriteMessage("\nDouble value: " + doubleValue);
            ed.WriteMessage("\nString value: " + stringValue);
            ed.WriteMessage("\nNon-existent value: " + defValue);
          }
        }
      }
    }
  }
}

Here's what we see when we run the RFR command (after having run the ATR beforehand, whether in the same session or a previous one):

Command: RFR
Int value: 1
Double value: 2
String value: Hello
Non-existent value: 3.142

复制代码

And here are the contents of our new section of the Registry:

The observant among you will notice I've switched across to Vista (having just received a new machine). So far I've actually enjoyed using it, having disabled UAC within the first few minutes of getting it. :-)

雪山飞狐_lzh · 发表于 2009-5-21 20:51

六、程序集无法卸载的挽救方法

September 29, 2008
Tired of not being able to NETUNLOAD from AutoCAD? "Edit and Continue" to the rescue!
A question came in on a previous post:

Hello, I write applications for Autocad Map and Civil3d platforms, mostly with ObjectARX. I would like to do more with .NET but so far the main reason preventing this is not having the NETUNLOAD command.. With arx I can just arxunload and arxload the application for modifications in a second. But with .NET I have to restart the heavy environment and do all kinds of lengthy initializations before being able to try even small changes in code, this can take a minute or more.. Maybe it is possible to create an utility, for development purposes, to unload a .net assembly from Autocad ?

NETUNLOAD has been requested many times by developers, but unfortunately would require a significant change for the .NET API - one it's unclear there'd be significant benefit in making. The root of the situation is that .NET assemblies cannot be unloaded from an AppDomain.

To implement a NETUNLOAD command, we would have to host each assembly in a separate AppDomain and then destroy the AppDomain to unload it. It's altogether possible to implement your own bootstrapper assembly that does just this: I'm going to give that a try, to see how it works, but in the meantime I thought I'd point out (or remind you of) a capability that to greatly reduces the need to continually unload modules from AutoCAD: Visual Studio's Edit and Continue.

Edit and Continue has been around since VB6, although you may not have looked at it in recent versions of Visual Studio. I personally didn't start finding it usable again until Visual Studio 2005 (and its Express Editions). If you'd previously turned your back on it, I suggest taking another look.

To enable Edit and Continue, start by editing the Debugging options (accessed via Tools -> Options in the Visual Studio editor):

If you attempt to edit the code before the module has been loaded, you'll get this error:

And if you try to edit the code before a breakpoint has hit, you'll get this altogether more obscure error:

This message wasn't very helpful - at least not to me. My code wasn't running, as such (although I agree that someone's code was :-) and the setting mentioned was set correctly. Anyway - breaking into your code allows you to then edit the code, which should be obvious by a message on the application status-bar that tells you when the "continue" piece is successful:

I'd be curious to hear about others opinions of Edit and Continue: does it meet your debugging needs, or do you still see NETUNLOAD as important functionality? (There are clearly still areas - unrelated to debugging - where it might be useful to unload .NET assemblies. To be clear, I'd be happy to receive input on those areas, also.)

雪山飞狐_lzh · 发表于 2009-5-21 20:56

本帖最后由作者于 2009-5-26 16:06:58 编辑

七、实现Com接口
May 20, 2009
Interfacing an external COM application with a .NET module in-process to AutoCAD
This question came in recently by email from Michael Fichter of Superstructures Engineers and Architects:
Could you suggest an approach that would enable me to drive a .NET function (via COM) that could return a value from .NET back to COM? I have used SendCommand in certain instances where return values were not needed.
Michael’s referring to a technique used in this previous post, which shows how to launch AutoCAD from a .NET executable via COM and then launch a command which can then safely interface with AutoCAD in-process via its managed API.
And yes, this technique is fine if you don’t want to return results, but has limitations if you do. You could populate AutoCAD user variables or create a file for the calling application to read but such approaches are cumbersome.
So… in spite of my initial doubtful reaction I decided to give it a try. Here are the steps I used to get this working…
First we create a Class Library for our in-process component with references to the usual acmgd.dll and acdbmgd.dll assemblies, adding the following C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Runtime.InteropServices;
namespace LoadableComponent
{
[ProgId("LoadableComponent.Commands")]
public class Commands
{
// A simple test command, just to see that commands
// are loaded properly from the assembly
[CommandMethod("MYCOMMAND")]
public void MyCommand()
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
ed.WriteMessage("\nTest command executed.");
}
// A function to add two numbers and create a
// circle of that radius. It returns a string
// withthe result of the addition, just to use
// a different return type
public string AddNumbers(int arg1, double arg2)
{
// During tests it proved unreliable to rely
// on DocumentManager.MdiActiveDocument
// (which was null) so we will go from the
// HostApplicationServices' WorkingDatabase
Database db =
HostApplicationServices.WorkingDatabase;
Document doc =
Application.DocumentManager.GetDocument(db);
// Perform our addition
double res = arg1 + arg2;
// Lock the document before we access it
DocumentLock loc = doc.LockDocument();
using (loc)
{
Transaction tr =
db.TransactionManager.StartTransaction();
using (tr)
{
// Create our circle
Circle cir =
new Circle(
new Point3d(0, 0, 0),
new Vector3d(0, 0, 1),
res
);
cir.SetDatabaseDefaults(db);
// Add it to the current space
BlockTableRecord btr =
(BlockTableRecord)tr.GetObject(
db.CurrentSpaceId,
OpenMode.ForWrite
);
btr.AppendEntity(cir);
tr.AddNewlyCreatedDBObject(cir, true);
// Commit the transaction
tr.Commit();
}
}
// Return our string result
return res.ToString();
}
}
}

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Runtime.InteropServices;
 
namespace LoadableComponent
{
  [ProgId("LoadableComponent.Commands")]
  public class Commands
  {
    // A simple test command, just to see that commands
    // are loaded properly from the assembly
 
    [CommandMethod("MYCOMMAND")]
    public void MyCommand()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      ed.WriteMessage("\nTest command executed.");
    }
 
    // A function to add two numbers and create a
    // circle of that radius. It returns a string
    // withthe result of the addition, just to use
    // a different return type
 
    public string AddNumbers(int arg1, double arg2)
    {
      // During tests it proved unreliable to rely
      // on DocumentManager.MdiActiveDocument
      // (which was null) so we will go from the
      // HostApplicationServices' WorkingDatabase
 
      Database db =
        HostApplicationServices.WorkingDatabase;
      Document doc =
        Application.DocumentManager.GetDocument(db);
 
      // Perform our addition
 
      double res = arg1 + arg2;
 
      // Lock the document before we access it
 
      DocumentLock loc = doc.LockDocument();
      using (loc)
      {
        Transaction tr =
          db.TransactionManager.StartTransaction();
        using (tr)
        {
          // Create our circle
 
          Circle cir =
            new Circle(
              new Point3d(0, 0, 0),
              new Vector3d(0, 0, 1),
              res
            );
 
          cir.SetDatabaseDefaults(db);
 
          // Add it to the current space
 
          BlockTableRecord btr =
            (BlockTableRecord)tr.GetObject(
              db.CurrentSpaceId,
              OpenMode.ForWrite
            );
          btr.AppendEntity(cir);
          tr.AddNewlyCreatedDBObject(cir, true);
 
          // Commit the transaction
 
          tr.Commit();
        }
      }
 
      // Return our string result
 
      return res.ToString();
    }
  }
}

You’ll see we mark our Commands class as having the ProgId of “LoadableComponent.Commands” (this doesn’t have to follow the namespace.class-name convention, if you’d rather use something else). Be sure to edit the AssemblyInfo.cs file to make sure the ComVisible assembly attribute is set to true (the default is false), otherwise no classes will be exposed via COM.
The code is mostly pretty simple… it includes a command just to make sure commands are registered when the assembly loads. The AddNumbers() function uses a slightly different technique to get the working database and its document, mainly because I found MdiActiveDocument to be null when I needed it. I suspect this is simply a timing issue, and that if AutoCAD had the time to fully initialize we wouldn’t have to code this defensively. There may well be a clean way to wait for this to happen (comments, anyone?).
Once we’ve built the assembly it needs to be registered via COM. The way I tend to do this is via a “Visual Studio Command Prompt” (which has the path set nicely to call the VS development tools). I browse to the location of my assembly and then run “regasm LoadableComponent.dll” (you can specify the optional /reg parameter if you’d rather create a .reg file rather than modifying the Registry directly).
Now we can create an executable project to drive this component with COM references to the AutoCAD Type Library (I’m using the one for AutoCAD 2010) and the AutoCAD/ObjectDBX Common Type Library (AutoCAD 2010’s is version 18.0), as well as a reference to our .NET assembly (which I have called LoadableComponent.dll).
Inside the default form created with the executable project we can add a button behind which we copy the code in the post referred to earlier, adding some logic to load our component and dynamically execute its AddNumbers() function:

using Autodesk.AutoCAD.Interop;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Reflection;
using System;
using LoadableComponent;
namespace DrivingAutoCAD
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
const string progID = "AutoCAD.Application.18";
AcadApplication acApp = null;
try
{
acApp =
(AcadApplication)Marshal.GetActiveObject(progID);
}
catch
{
try
{
Type acType =
Type.GetTypeFromProgID(progID);
acApp =
(AcadApplication)Activator.CreateInstance(
acType,
true
);
}
catch
{
MessageBox.Show(
"Cannot create object of type "" +
progID + """
);
}
}
if (acApp != null)
{
try
{
// By the time this is reached AutoCAD is fully
// functional and can be interacted with through code
acApp.Visible = true;
object app =
acApp.GetInterfaceObject("LoadableComponent.Commands");
if (app != null)
{
// Let's generate the arguments to pass in:
// an integer and a double
object[] args = { 5, 6.3 };
// Now let's call our method dynamically
object res =
app.GetType().InvokeMember(
"AddNumbers",
BindingFlags.InvokeMethod,
null,
app,
args
);
acApp.ZoomAll();
MessageBox.Show(
this,
"AddNumbers returned: " + res.ToString()
);
}
}
catch (Exception ex)
{
MessageBox.Show(
this,
"Problem executing component: " +
ex.Message
);
}
}
}
}
}

using Autodesk.AutoCAD.Interop;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Reflection;
using System;
using LoadableComponent;
 
namespace DrivingAutoCAD
{
  public partial class Form1 : Form
  {
    public Form1()
    {
      InitializeComponent();
    }
 
    private void button1_Click(object sender, EventArgs e)
    {
      const string progID = "AutoCAD.Application.18";
 
      AcadApplication acApp = null;
      try
      {
        acApp =
          (AcadApplication)Marshal.GetActiveObject(progID);
      }
      catch
      {
        try
        {
          Type acType =
            Type.GetTypeFromProgID(progID);
          acApp =
            (AcadApplication)Activator.CreateInstance(
              acType,
              true
            );
        }
        catch
        {
          MessageBox.Show(
            "Cannot create object of type "" +
            progID + """
          );
        }
      }
      if (acApp != null)
      {
        try
        {
          // By the time this is reached AutoCAD is fully
          // functional and can be interacted with through code
 
          acApp.Visible = true;
 
          object app =
            acApp.GetInterfaceObject("LoadableComponent.Commands");
 
          if (app != null)
          {
            // Let's generate the arguments to pass in:
            // an integer and a double
 
            object[] args = { 5, 6.3 };
 
            // Now let's call our method dynamically
 
            object res =
              app.GetType().InvokeMember(
                "AddNumbers",
                BindingFlags.InvokeMethod,
                null,
                app,
                args
              );
            acApp.ZoomAll();
            MessageBox.Show(
              this,
              "AddNumbers returned: " + res.ToString()
            );
          }
        }
        catch (Exception ex)
        {
          MessageBox.Show(
            this,
            "Problem executing component: " +
            ex.Message
          );
        }
      }
    }
  }
}

I decided to try Application.GetInterfaceObject() – the classic way to load an old VB6 ActiveX DLL into AutoCAD from VBA or Visual LISP – to see whether it worked for .NET assemblies that have a ProgId assigned. It not only worked, but the commands contained within the module were registered properly. A nice surprise! :-)
I started by defining an interface in the Class Library to be used in the Executable, but ended up going with a more dynamic approach, using InvokeMember() on the class of the object returned by GetInterfaceObject(). This avoids having to define and cast to the interface but adds a little uncertainty to the operation (as I’ve mentioned a number of times in recent weeks when we start getting dynamic we lose most of the compiler crutches we’ve all become used to :-). I also hit a problem if the command function was declared as static, but presumably that can be resolved with the right arguments to InvokeMember().
When we run this code and select the button, we see a circle get created with the radius of 11.3, the result of adding the integer (5) and double (6.3) we passed to the AddNumbers() function:

The combination of COM for out-of-process control with .NET for in-process power and performance will hopefully be a useful technique for many of you needing to automate AutoCAD from an external executable. Be sure to post comments if any of you have things to share on this topic. Thanks for the question, Michael! :-)

雪山飞狐_lzh · 发表于 2009-5-26 16:09

May 25, 2009
Interfacing an external COM application with a .NET module in-process to AutoCAD (redux)
Thanks to all of your interest in this recent post, which looked at a way to interface an out-of-process .NET application with an assembly running in-process to AutoCAD. After some obvious functionality gaps were raised, Renze de Waal, one of our ADN members, pointed out a DevNote on the ADN website covering – and more completely addressing – this topic. Shame on me for not checking there before writing the post. Anyway, onwards and upwards…
The information in the DevNote highlights some of the problems I and other people had hit with my previous code, mostly related to the fact it wasn’t executed on the main AutoCAD thread (which meant we were effectively limited in the interactions we had with the AutoCAD application).
To fix this we can derive our application from System.EnterpriseServices.ServicedComponent (also adding an additional project reference to the System.EnterpriseServices .NET assembly). Here is the updated C# code for the LoadableComponent:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Runtime.InteropServices;
using System.EnterpriseServices;
namespace LoadableComponent
{
[Guid("5B5B731C-B37A-4aa2-8E50-42192BD51B17")]
public interface INumberAddition
{
[DispId(1)]
string AddNumbers(int arg1, double arg2);
}
[ProgId("LoadableComponent.Commands"),
Guid("44D8782B-3F60-4cae-B14D-FA060E8A4D01"),
ClassInterface(ClassInterfaceType.None)]
public class Commands : ServicedComponent, INumberAddition
{
// A simple test command, just to see that commands
// are loaded properly from the assembly
[CommandMethod("MYCOMMAND")]
static public void MyCommand()
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
ed.WriteMessage("\nTest command executed.");
}
// A function to add two numbers and create a
// circle of that radius. It returns a string
// withthe result of the addition, just to use
// a different return type
public string AddNumbers(int arg1, double arg2)
{
// During tests it proved unreliable to rely
// on DocumentManager.MdiActiveDocument
// (which was null) so we will go from the
// HostApplicationServices' WorkingDatabase
Document doc =
Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
ed.WriteMessage(
"\nAdd numbers called with {0} and {1}.",
arg1, arg2
);
// Perform our addition
double res = arg1 + arg2;
// Lock the document before we access it
DocumentLock loc = doc.LockDocument();
using (loc)
{
Transaction tr =
db.TransactionManager.StartTransaction();
using (tr)
{
// Create our circle
Circle cir =
new Circle(
new Point3d(0, 0, 0),
new Vector3d(0, 0, 1),
res
);
cir.SetDatabaseDefaults(db);
// Add it to the current space
BlockTableRecord btr =
(BlockTableRecord)tr.GetObject(
db.CurrentSpaceId,
OpenMode.ForWrite
);
btr.AppendEntity(cir);
tr.AddNewlyCreatedDBObject(cir, true);
// Commit the transaction
tr.Commit();
}
}
// Return our string result
return res.ToString();
}
}
}

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Runtime.InteropServices;
using System.EnterpriseServices;
 
namespace LoadableComponent
{
  [Guid("5B5B731C-B37A-4aa2-8E50-42192BD51B17")]
  public interface INumberAddition
  {
    [DispId(1)]
    string AddNumbers(int arg1, double arg2);
  }
 
  [ProgId("LoadableComponent.Commands"),
   Guid("44D8782B-3F60-4cae-B14D-FA060E8A4D01"),
   ClassInterface(ClassInterfaceType.None)]
  public class Commands : ServicedComponent, INumberAddition
  {
    // A simple test command, just to see that commands
    // are loaded properly from the assembly
 
    [CommandMethod("MYCOMMAND")]
    static public void MyCommand()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      ed.WriteMessage("\nTest command executed.");
    }
 
    // A function to add two numbers and create a
    // circle of that radius. It returns a string
    // withthe result of the addition, just to use
    // a different return type
 
    public string AddNumbers(int arg1, double arg2)
    {      
      // During tests it proved unreliable to rely
      // on DocumentManager.MdiActiveDocument
      // (which was null) so we will go from the
      // HostApplicationServices' WorkingDatabase
 
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      ed.WriteMessage(
        "\nAdd numbers called with {0} and {1}.",
        arg1, arg2
      );
 
      // Perform our addition
 
      double res = arg1 + arg2;
 
      // Lock the document before we access it
 
      DocumentLock loc = doc.LockDocument();
      using (loc)
      {
        Transaction tr =
          db.TransactionManager.StartTransaction();
        using (tr)
        {
          // Create our circle
 
          Circle cir =
            new Circle(
              new Point3d(0, 0, 0),
              new Vector3d(0, 0, 1),
              res
            );
 
          cir.SetDatabaseDefaults(db);
 
          // Add it to the current space
 
          BlockTableRecord btr =
            (BlockTableRecord)tr.GetObject(
              db.CurrentSpaceId,
              OpenMode.ForWrite
            );
          btr.AppendEntity(cir);
          tr.AddNewlyCreatedDBObject(cir, true);
 
          // Commit the transaction
 
          tr.Commit();
        }
      }
 
      // Return our string result
 
      return res.ToString();
    }
  }
}

Some points to note...
We now use an interface to expose functionality from our component, which allows us more flexibility in the way we return data to the calling application.
We're labeling our interface and component with specific GUIDs - generated by guidgen.exe - although we could probably skip this step.
We're now able to use the MdiActiveDocument property safely, as well as being able to write messages via the editor.
When we build the component we can - as before - register it via the regasm.exe tool. Here's the .reg output if you specify the /regfile option:

REGEDIT4
[HKEY_CLASSES_ROOT\LoadableComponent.Commands]
@="LoadableComponent.Commands"
[HKEY_CLASSES_ROOT\LoadableComponent.Commands\CLSID]
@="{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}"
[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}]
@="LoadableComponent.Commands"
[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\InprocServer32]
@="mscoree.dll"
"ThreadingModel"="Both"
"Class"="LoadableComponent.Commands"
"Assembly"="LoadableComponent, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
"RuntimeVersion"="v2.0.50727"
[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\InprocServer32\1.0.0.0]
"Class"="LoadableComponent.Commands"
"Assembly"="LoadableComponent, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
"RuntimeVersion"="v2.0.50727"
[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\ProgId]
@="LoadableComponent.Commands"
[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\Implemented Categories\{62C8FE65-4EBB-45E7-B440-6E39B2CDBF29}]

复制代码

One thing to mention - I found that the calling application was not able to to cast the returned System.__COMObject to LoadableComponent.INumberAddition unless I updated the project settings to "Register from COM Interop" (near the bottom of the Build tab).
Now for our calling application… here’s the updated C# code:

using Autodesk.AutoCAD.Interop;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Reflection;
using System;
using LoadableComponent;
namespace DrivingAutoCAD
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
const string progID = "AutoCAD.Application.18";
AcadApplication acApp = null;
try
{
acApp =
(AcadApplication)Marshal.GetActiveObject(progID);
}
catch
{
try
{
Type acType =
Type.GetTypeFromProgID(progID);
acApp =
(AcadApplication)Activator.CreateInstance(
acType,
true
);
}
catch
{
MessageBox.Show(
"Cannot create object of type "" +
progID + """
);
}
}
if (acApp != null)
{
try
{
// By the time this is reached AutoCAD is fully
// functional and can be interacted with through code
acApp.Visible = true;
INumberAddition app =
(INumberAddition)acApp.GetInterfaceObject(
"LoadableComponent.Commands"
);
// Now let's call our method
string res = app.AddNumbers(5, 6.3);
acApp.ZoomAll();
MessageBox.Show(
this,
"AddNumbers returned: " + res
);
}
catch (Exception ex)
{
MessageBox.Show(
this,
"Problem executing component: " +
ex.Message
);
}
}
}
}
}

using Autodesk.AutoCAD.Interop;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Reflection;
using System;
using LoadableComponent;
 
namespace DrivingAutoCAD
{
  public partial class Form1 : Form
  {
    public Form1()
    {
      InitializeComponent();
    }
 
    private void button1_Click(object sender, EventArgs e)
    {
      const string progID = "AutoCAD.Application.18";
 
      AcadApplication acApp = null;
      try
      {
        acApp =
          (AcadApplication)Marshal.GetActiveObject(progID);
      }
      catch
      {
        try
        {
          Type acType =
            Type.GetTypeFromProgID(progID);
          acApp =
            (AcadApplication)Activator.CreateInstance(
              acType,
              true
            );
        }
        catch
        {
          MessageBox.Show(
            "Cannot create object of type "" +
            progID + """
          );
        }
      }
      if (acApp != null)
      {
        try
        {
          // By the time this is reached AutoCAD is fully
          // functional and can be interacted with through code
 
          acApp.Visible = true;
 
          INumberAddition app =
            (INumberAddition)acApp.GetInterfaceObject(
              "LoadableComponent.Commands"
            );
 
          // Now let's call our method
 
          string res = app.AddNumbers(5, 6.3);
 
          acApp.ZoomAll();
 
          MessageBox.Show(
            this,
            "AddNumbers returned: " + res
          );
        }
        catch (Exception ex)
        {
          MessageBox.Show(
            this,
            "Problem executing component: " +
            ex.Message
          );
        }
      }
    }
  }
}

You should be able to see straightaway that it’s simpler – we cast the results of the GetInterfaceObject call to our interface and call the AddNumbers method on it.
And when we execute the code, we can see we’re now able to write to the command-line, as well as getting better results from our ZoomAll():

雪山飞狐_lzh · 发表于 2009-5-29 14:54

May 28, 2009
Creating demand-loading entries automatically for your AutoCAD application using .NET
Here’s a question I received recently by email:
How do you set up a .NET plugin for AutoCAD to install & demand load in the same way as ObjectARX plugins? The documentation is not very clear at making the distinctions visible.
In ARX terms, we currently write a set of registry entries as part of our installer, along with refreshing these via an AcadAppInfo registration during ARX load. The ARX itself can be located anywhere as long as the registry entries point to it. I’m not sure of the correct procedure for .NET plugins to duplicate this.
Augusto Gonçalves, from our DevTech Americas team, provided a solution for this which showed how to create demand-loading Registry keys programmatically based on the current assembly’s name and location. It occurred to me that extending the code to make further use of reflection to query the commands defined by an assembly would make this really interesting, and could essentially create a very flexible approach for creation of a demand-loading entries as an application initializes or during execution of a custom command.
Here’s the C# code:

using System.Collections.Generic;
using System.Reflection;
using System.Resources;
using System;
using Microsoft.Win32;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
namespace DemandLoading
{
public class RegistryUpdate
{
public static void RegisterForDemandLoading()
{
// Get the assembly, its name and location
Assembly assem = Assembly.GetExecutingAssembly();
string name = assem.GetName().Name;
string path = assem.Location;
// We'll collect information on the commands
// (we could have used a map or a more complex
// container for the global and localized names
// - the assumption is we will have an equal
// number of each with possibly fewer groups)
List<string> globCmds = new List<string>();
List<string> locCmds = new List<string>();
List<string> groups = new List<string>();
// Iterate through the modules in the assembly
Module[] mods = assem.GetModules(true);
foreach(Module mod in mods)
{
// Within each module, iterate through the types
Type[] types = mod.GetTypes();
foreach (Type type in types)
{
// We may need to get a type's resources
ResourceManager rm =
new ResourceManager(type.FullName, assem);
rm.IgnoreCase = true;
// Get each method on a type
MethodInfo[] meths = type.GetMethods();
foreach (MethodInfo meth in meths)
{
// Get the methods custom command attribute(s)
object[] attbs =
meth.GetCustomAttributes(
typeof(CommandMethodAttribute),
true
);
foreach (object attb in attbs)
{
CommandMethodAttribute cma =
attb as CommandMethodAttribute;
if (cma != null)
{
// And we can finally harvest the information
// about each command
string globName = cma.GlobalName;
string locName = globName;
string lid = cma.LocalizedNameId;
// If we have a localized command ID,
// let's look it up in our resources
if (lid != null)
{
// Let's put a try-catch block around this
// Failure just means we use the global
// name twice (the default)
try
{
locName = rm.GetString(lid);
}
catch
{}
}
// Add the information to our data structures
globCmds.Add(globName);
locCmds.Add(locName);
if (cma.GroupName != null &&
!groups.Contains(cma.GroupName))
groups.Add(cma.GroupName);
}
}
}
}
}
// Let's register the application to load on demand (12)
// if it contains commands, otherwise we will have it
// load on AutoCAD startup (2)
int flags = (globCmds.Count > 0 ? 12 : 2);
// By default let's create the commands in HKCU
// (pass false if we want to create in HKLM)
CreateDemandLoadingEntries(
name, path, globCmds, locCmds, groups, flags, true
);
}
public static void UnregisterForDemandLoading()
{
RemoveDemandLoadingEntries(true);
}
// Helper functions
private static void CreateDemandLoadingEntries(
string name,
string path,
List<string> globCmds,
List<string> locCmds,
List<string> groups,
int flags,
bool currentUser
)
{
// Choose a Registry hive based on the function input
RegistryKey hive =
(currentUser ? Registry.CurrentUser : Registry.LocalMachine);
// Open the main AutoCAD (or vertical) and "Applications" keys
RegistryKey ack =
hive.OpenSubKey(
HostApplicationServices.Current.RegistryProductRootKey
);
RegistryKey appk =
ack.OpenSubKey("Applications", true);
// Already registered? Just return
string[] subKeys = appk.GetSubKeyNames();
foreach (string subKey in subKeys)
{
if (subKey.Equals(name))
{
appk.Close();
return;
}
}
// Create the our application's root key and its values
RegistryKey rk =
appk.CreateSubKey(name);
rk.SetValue("DESCRIPTION", name, RegistryValueKind.String);
rk.SetValue("LOADCTRLS", flags, RegistryValueKind.DWord);
rk.SetValue("LOADER", path, RegistryValueKind.String);
rk.SetValue("MANAGED", 1, RegistryValueKind.DWord);
// Create a subkey if there are any commands...
if ((globCmds.Count == locCmds.Count) &&
globCmds.Count > 0)
{
RegistryKey ck =
rk.CreateSubKey("Commands");
for (int i=0; i < globCmds.Count; i++)
ck.SetValue(
globCmds[i],
locCmds[i],
RegistryValueKind.String
);
}
// And the command groups, if there are any
if (groups.Count > 0)
{
RegistryKey gk =
rk.CreateSubKey("Groups");
foreach (string grpName in groups)
gk.SetValue(grpName, grpName, RegistryValueKind.String);
}
appk.Close();
}
private static void RemoveDemandLoadingEntries(bool currentUser)
{
// Choose a Registry hive based on the function input
RegistryKey hive =
(currentUser ? Registry.CurrentUser : Registry.LocalMachine);
// Open the main AutoCAD (or vertical) and "Applications" keys
RegistryKey ack =
hive.OpenSubKey(
HostApplicationServices.Current.RegistryProductRootKey
);
RegistryKey appk =
ack.OpenSubKey("Applications", true);
// Delete the key with the same name as this assembly
appk.DeleteSubKeyTree(
Assembly.GetExecutingAssembly().GetName().Name
);
appk.Close();
}
}
}

using System.Collections.Generic;
using System.Reflection;
using System.Resources;
using System;
using Microsoft.Win32;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
 
namespace DemandLoading
{
  public class RegistryUpdate
  {
    public static void RegisterForDemandLoading()
    {
      // Get the assembly, its name and location
 
      Assembly assem = Assembly.GetExecutingAssembly();
      string name = assem.GetName().Name;
      string path = assem.Location;
 
      // We'll collect information on the commands
      // (we could have used a map or a more complex
      // container for the global and localized names
      // - the assumption is we will have an equal
      // number of each with possibly fewer groups)
 
      List<string> globCmds = new List<string>();
      List<string> locCmds = new List<string>();
      List<string> groups = new List<string>();
 
      // Iterate through the modules in the assembly
 
      Module[] mods = assem.GetModules(true);
      foreach(Module mod in mods)
      {
        // Within each module, iterate through the types
 
        Type[] types = mod.GetTypes();
        foreach (Type type in types)
        {
          // We may need to get a type's resources
 
          ResourceManager rm =
            new ResourceManager(type.FullName, assem);
          rm.IgnoreCase = true;
 
          // Get each method on a type
 
          MethodInfo[] meths = type.GetMethods();
          foreach (MethodInfo meth in meths)
          {
            // Get the methods custom command attribute(s)
 
            object[] attbs =
              meth.GetCustomAttributes(
                typeof(CommandMethodAttribute),
                true
              );
            foreach (object attb in attbs)
            {
              CommandMethodAttribute cma =
                attb as CommandMethodAttribute;
              if (cma != null)
              {
                // And we can finally harvest the information
                // about each command
 
                string globName = cma.GlobalName;
                string locName = globName;
                string lid = cma.LocalizedNameId;
 
                // If we have a localized command ID,
                // let's look it up in our resources
 
                if (lid != null)
                {
                  // Let's put a try-catch block around this
                  // Failure just means we use the global
                  // name twice (the default)
 
                  try
                  {
                    locName = rm.GetString(lid);
                  }
                  catch
                  {}
                }
 
                // Add the information to our data structures
 
                globCmds.Add(globName);
                locCmds.Add(locName);
 
                if (cma.GroupName != null &&
                    !groups.Contains(cma.GroupName))
                  groups.Add(cma.GroupName);
              }
            }
          }
        }
      }
 
      // Let's register the application to load on demand (12)
      // if it contains commands, otherwise we will have it
      // load on AutoCAD startup (2)
 
      int flags = (globCmds.Count > 0 ? 12 : 2);
 
      // By default let's create the commands in HKCU
      // (pass false if we want to create in HKLM)
 
      CreateDemandLoadingEntries(
        name, path, globCmds, locCmds, groups, flags, true
      );
    }
 
    public static void UnregisterForDemandLoading()
    {
      RemoveDemandLoadingEntries(true);
    }
 
    // Helper functions
 
    private static void CreateDemandLoadingEntries(
      string name,
      string path,
      List<string> globCmds,
      List<string> locCmds,
      List<string> groups,
      int flags,
      bool currentUser
    )
    {
      // Choose a Registry hive based on the function input
 
      RegistryKey hive =
        (currentUser ? Registry.CurrentUser : Registry.LocalMachine);
 
      // Open the main AutoCAD (or vertical) and "Applications" keys
 
      RegistryKey ack =
        hive.OpenSubKey(
          HostApplicationServices.Current.RegistryProductRootKey
        );
      RegistryKey appk =
        ack.OpenSubKey("Applications", true);
 
      // Already registered? Just return
 
      string[] subKeys = appk.GetSubKeyNames();
      foreach (string subKey in subKeys)
      {
        if (subKey.Equals(name))
        {
          appk.Close();
          return;
        }
      }
 
      // Create the our application's root key and its values
 
      RegistryKey rk =
        appk.CreateSubKey(name);
      rk.SetValue("DESCRIPTION", name, RegistryValueKind.String);
      rk.SetValue("LOADCTRLS", flags, RegistryValueKind.DWord);
      rk.SetValue("LOADER", path, RegistryValueKind.String);
      rk.SetValue("MANAGED", 1, RegistryValueKind.DWord);
 
      // Create a subkey if there are any commands...
 
      if ((globCmds.Count == locCmds.Count) &&
          globCmds.Count > 0)
      {
        RegistryKey ck =
          rk.CreateSubKey("Commands");
 
        for (int i=0; i < globCmds.Count; i++)
          ck.SetValue(
            globCmds[i],
            locCmds[i],
            RegistryValueKind.String
          );
      }
 
      // And the command groups, if there are any
 
      if (groups.Count > 0)
      {
        RegistryKey gk =
          rk.CreateSubKey("Groups");
 
        foreach (string grpName in groups)
          gk.SetValue(grpName, grpName, RegistryValueKind.String);
      }
 
      appk.Close();
    }
 
    private static void RemoveDemandLoadingEntries(bool currentUser)
    {
      // Choose a Registry hive based on the function input
 
      RegistryKey hive =
        (currentUser ? Registry.CurrentUser : Registry.LocalMachine);
 
      // Open the main AutoCAD (or vertical) and "Applications" keys
 
      RegistryKey ack =
        hive.OpenSubKey(
          HostApplicationServices.Current.RegistryProductRootKey
        );
      RegistryKey appk =
        ack.OpenSubKey("Applications", true);
 
      // Delete the key with the same name as this assembly
 
      appk.DeleteSubKeyTree(
        Assembly.GetExecutingAssembly().GetName().Name
      );
      appk.Close();
    }
  }
}

If you drop this code into an existing project, you should be able simply to add a call to DemandLoading.RegistryUpdate.RegisterForDemandLoading() during your IExtensionApplication’s Initialize() method or during a custom command.
Here’s an example of the Registry keys created by this code (exported from Regedit) when called from the Initialize() method of the application in this previous post:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R18.0\ACAD-8001:409\Applications\OffsetInXref]
"DESCRIPTION"="OffsetInXref"
"LOADCTRLS"=dword:0000000c
"LOADER"="C:\\Program Files\\Autodesk\\AutoCAD 2010\\OffsetInXref.dll"
"MANAGED"=dword:00000001
[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R18.0\ACAD-8001:409\Applications\OffsetInXref\Commands]
"XOFFSETLAYER"="XOFFSETLAYER"
"XOFFSETCPLAYS"="XOFFSETCPLAYS"

复制代码

You can see that our code found the commands defined by the application and created Registry entries which tell AutoCAD to load the module when one of them is chosen by the user. You’ll notice the LOADCTRLS value is c (hexadecimal for 12), which means the application will be loaded “on demand” as a specified command is invoked, but we could also adjust the code to force this to 2, which would mean the module would be loaded on AutoCAD startup (the default when no commands are found). This would actually be a good idea, in this case, as the command hooks into the OFFSET command, and we can’t demand-load a module on invocation of a built-in command.
You’ll also notice that the keys were created under R18.0\ACAD-8001:409 (the English version of AutoCAD 2010), but if the module was loaded in a different language version of an AutoCAD-based vertical product (French AutoCAD Architecture 2009, for instance) then the root key would be the one for that product. All you have to do is load the module once in the AutoCAD-based product of your choice, and it will be registered for automatic loading from then onwards.
This is a useful technique for people who want to deploy .NET modules without installers, or for people who wish applications to re-create their demand-loading keys on load (something this code currently does not do, by the way: if the application’s key is found we do not recreate the contents for the sake of efficiency… you may want to change the code to force creation of the keys should you be adding new commands regularly to your application, for instance).

雪山飞狐_lzh · 发表于 2009-6-12 08:31

使用本地化的名字注册命令（多语言支持）
June 08, 2009
Registering AutoCAD commands with localized names using .NET
While I was preparing this recent post I put together a simple project which registered localized names for commands, to make sure they were picked up and used to create the appropriate demand-loading Registry keys. It was a little tricky to do this from the current documentation, so thankfully I had access to this DevNote on the ADN site which helped a great deal (this is only available to ADN members but don’t worry if you’re not one: this post should provide equivalent information and in certain ways goes beyond the original example).
Anyway, it seemed a relevant topic to cover in its own post, so here we are today looking at this question: how to register localized command-names – possibly for multiple target languages – for your AutoCAD commands.
First of all we need to register some commands, the code for which proves to be pretty straightforward. Here’s the C# code defining our commands, which we will save in a file named Commands.cs:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
namespace LocalizedCommands
{
public class LocCmds
{
[CommandMethod(
"LOCCMDS", "HELLO", "helloCmdId", CommandFlags.Modal
)]
public void HelloCommand()
{
Application.DocumentManager.MdiActiveDocument.Editor.
WriteMessage("\nHello!");
}
[CommandMethod(
"LOCCMDS", "GOODBYE", "goodbyeCmdId", CommandFlags.Modal
)]
public void GoodbyeCommand()
{
Application.DocumentManager.MdiActiveDocument.Editor.
WriteMessage("\nGoodbye!");
}
}
}

You’ll notice straight away that we’re using a special version of the CommandMethod attribute which specifies more than the usual items (command name and flags are the most common ones). We start with the command group (“LOCCMDS”), the global names (“HELLO” and “GOODBYE”), the localized resource IDs (“helloCmdId” and “goodbyeCmdId”) and then come the flags (CommandFlags.Modal).
The localized command name is provided as a resource ID to aid localization. Let’s see how this helps… we’ll add some resources to the project for our neutral culture (US English) and for two additional cultures (French and German).
We can add resource files by right-clicking the project and selecting Add –> New Item:

From here we can use the Add New Item dialog to add new resource files with the names “Commands.resx” (which is for the neutral culture, US English), “Commands.fr-FR.resx” and “Commands.de-DE.resx” (these three files will need to be added one-by-one). It’s important that the resource files use the same base name as the .cs file (they do not have to use the class name – LocCmds – and, in fact, you may run into name collisions if you attempt to do so).

So far, so good. We should now see the resultant files in our solution explorer, and be able to open them by double-clicking them.

The files will be blank initially, and we will want to add two string resources to each, one for each of our commands, using the IDs “helloCmdId” and “goodbyeCmdId”.
When we come to edit the individual string resources, we may be presented with a warning dialog (it is safe to select Yes):

Now we can go ahead and add localized string resources for our two commands in each of the three cultures:

It should now be possible to build our application. If we take a look at the output folder, we should see sub-folders for each of our cultures:

The en-US folder will be empty, as we’ve included that as our base culture, but the other two will contain resource DLLs (also known as satellite assemblies) containing our localized strings for that target culture.
Now to see these in action. In order to fake the loading of our assembly into different language versions of AutoCAD, I put together a simple application to change the UI culture (the one used by the resource manager to choose the resources to load) of the current thread. This clearly needs to be in a separate assembly, as we want to change the culture before we use NETLOAD to load the assembly containing our localized commands.
Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using System.Threading;
using System.Globalization;
namespace CultureShift
{
public class Commands
{
private void setCulture(string culture)
{
Thread.CurrentThread.CurrentUICulture =
new CultureInfo(culture);
}
private void setNeutralCulture(string neutCult)
{
Thread.CurrentThread.CurrentUICulture =
CultureInfo.CreateSpecificCulture(neutCult);
}
[CommandMethod("SETFR")]
public void SetFrenchCulture()
{
setNeutralCulture("fr"); // or setCulture("fr-FR");
GetCulture();
}
[CommandMethod("SETDE")]
public void SetGermanCulture()
{
setNeutralCulture("de"); // or setCulture("de-DE");
GetCulture();
}
[CommandMethod("SETEN")]
public void SetEnglishCulture()
{
setNeutralCulture("en"); // or setCulture("en-US");
GetCulture();
}
[CommandMethod("GETCUL")]
public void GetCulture()
{
Application.DocumentManager.MdiActiveDocument.Editor.
WriteMessage(
"\nCurrent UI culture is {0}.",
Thread.CurrentThread.CurrentUICulture.Name
);
}
}
}

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using System.Threading;
using System.Globalization;
namespace CultureShift
{
  public class Commands
  {
    private void setCulture(string culture)
    {
      Thread.CurrentThread.CurrentUICulture =
        new CultureInfo(culture);
    }
    private void setNeutralCulture(string neutCult)
    {
      Thread.CurrentThread.CurrentUICulture =
        CultureInfo.CreateSpecificCulture(neutCult);
    }
    [CommandMethod("SETFR")]
    public void SetFrenchCulture()
    {
      setNeutralCulture("fr"); // or setCulture("fr-FR");
      GetCulture();
    }
    [CommandMethod("SETDE")]
    public void SetGermanCulture()
    {
      setNeutralCulture("de"); // or setCulture("de-DE");
      GetCulture();
    }
    [CommandMethod("SETEN")]
    public void SetEnglishCulture()
    {
      setNeutralCulture("en"); // or setCulture("en-US");
      GetCulture();
    }
    [CommandMethod("GETCUL")]
    public void GetCulture()
    {
      Application.DocumentManager.MdiActiveDocument.Editor.
        WriteMessage(
          "\nCurrent UI culture is {0}.",
          Thread.CurrentThread.CurrentUICulture.Name
        );
    }
  }
}

This code implements a number of commands to set the UI culture to US English (SETEN), French (SETFR) and German (SETDE) as well as to check the current UI culture (GETCUL). The code chooses to set the culture neutrally – which sets the language but not the location – but the end result is the same for the cultures we’ve chosen. One thing to bear in mind: this code only actually works if running from the debugger. It doesn’t crash, otherwise, but the current UI culture always ends up as “en-US”. I assume this is a threading issue, but as this is really only for testing purposes it’s a tolerable requirement to run everything from the debugger.
Here’s what happens when (launching AutoCAD from the Visual Studio 2009 debugger) we load our test code, set the current UI culture to French and then load the main application, checking which commands work and which do not:

Command: NETLOAD
Command: GETCUL
Current UI culture is en-US.
Command: SETFR
Current UI culture is fr-FR.
Command: GETCUL
Current UI culture is fr-FR.
Command: NETLOAD
Command: HELLO
Hello!
Command: GOODBYE
Goodbye!
Command: BONJOUR
Hello!
Command: AUREVOIR
Goodbye!
Command: GUTENTAG Unknown command "GUTENTAG". Press F1 for help.
Command: BYE Unknown command "BYE". Press F1 for help.

复制代码

We can see that the global and the French-localized commands have indeed worked, while the German and US ones have not.
Let’s do the same for German:

Command: NETLOAD
Command: GETCUL
Current UI culture is en-US.
Command: SETDE
Current UI culture is de-DE.
Command: GETCUL
Current UI culture is de-DE.
Command: NETLOAD
Command: HELLO
Hello!
Command: GOODBYE
Goodbye!
Command: BONJOUR Unknown command "BONJOUR". Press F1 for help.
Command: GUTENTAG
Hello!
Command: AUFWIEDERSEHEN
Goodbye!
Command: BYE Unknown command "BYE". Press F1 for help.

复制代码

And sure enough, while the German and global commands work, the others do not.
For completeness, if we just load our application – without either launching from the debugger or loading our test application to change the current UI culture – and run the commands, here’s what we see:

Command: NETLOAD
Command: HELLO
Hello!
Command: GOODBYE
Goodbye!
Command: HI
Hello!
Command: BYE
Goodbye!
Command: BONJOUR Unknown command "BONJOUR". Press F1 for help.
Command: AUREVOIR Unknown command "AUREVOIR". Press F1 for help.
Command: GUTENTAG Unknown command "GUTENTAG". Press F1 for help.
Command: AUFWIEDERSEHEN Unknown command "AUFWIEDERSEHEN". Press F1 for help.

复制代码

My assumption is that the current UI culture will be set appropriately in the different language versions of AutoCAD, and so the localized resources will be chosen correctly. If someone trying the technique for real were able to confirm, I'd certainly appreciate it. :-)

账号		自动登录	找回密码
密码			注册

[Kean专集] Kean专题(6)—Runtime

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源