Dynamic .NET

雪山飞狐_lzh

Dynamic .NET in AutoCAD 2013
Another really interesting, developer-oriented feature in AutoCAD 2013 is something we’ve been calling “Dynamic .NET”. I don’t know whether that’s official branding, or not – I suspect not – but it’s the moniker we’ve been using to describe this capability internally and to ADN members.
The capability is based on an addition to .NET in version 4.0: to complement (or perhaps just as part of) the integration of the Dynamic Language Runtime into the core .NET Framework, various interfaces – including IDynamicMetaObjectProvider – were provided to developers to let their objects participate in “dynamic” operations.
Providers of APIs therefore now have the option to make certain classes dynamic – for instance, having them implement the IDynamicMetaObjectProvider interface – which means they can effectively be scripted, without binding properties and methods at compile-time. This implements a concept known as duck typing, and is at the core of many scripting language implementations. You may also hear it referred to as late binding: take a look at this excellent post by Eric Lippert if you’d like to get a better understanding of what that term means.
So what have we actually done with AutoCAD 2013? We have made Autodesk.AutoCAD.DatabaseServices.ObjectId support dynamic operations: you can declare an ObjectId using the dynamic keyword in C#, and you can then choose to access any of the properties or methods exposed by the object possessing that ID directly from the ObjectId itself. The ObjectId then takes care of the open & close operations implicitly, so there’s no need to mess around with transactions, etc.
If you’re interested in more background to this, I suggest taking a look at Albert Szilvasy’s class from AU 2009, where he gave us a hint of what was to come (although it was far from being a certainty, at that time – we have since found it to be a popular option via our annual API wishlist surveys).
OK, so what does this mean, in practice? Here’s some statically-typed C# code that iterates through the layer table and prefixes all layers (other than layer “0”) with a string:
public static void ChangeLayerNames()
{
  Database db = HostApplicationServices.WorkingDatabase;

  using (Transaction tr = db.TransactionManager.StartTransaction())
  {
    LayerTable lt =
      (LayerTable)tr.GetObject(
        db.LayerTableId, OpenMode.ForRead
      );

    foreach (ObjectId ltrId in lt)
    {
      LayerTableRecord ltr =
        (LayerTableRecord)tr.GetObject(ltrId, OpenMode.ForRead);

      if (ltr.Name != "0")
      {
        ltr.UpgradeOpen();
        ltr.Name = "First Floor " + ltr.Name;
      }
    }
    tr.Commit();
  }
}
Here’s how the code could look if using dynamic types. I’ve done my best not to exaggerate the differences in numbers of lines by using different conventions in the two implementations, but I did have to add more line breaks in the above code to have it fit the width of this blog.
public static void ChangeLayerNamesDynamically()
{
  dynamic layers =
    HostApplicationServices.WorkingDatabase.LayerTableId;

  foreach (dynamic l in layers)
    if (l.Name != "0")
      l.Name = "First Floor " + l.Name;
}
Something that needs to be stressed: as the properties and methods are effectively being determined and then accessed/called at run-time, there is no IntelliSense available when coding dynamically (something Python and Ruby developers are used to, but we statically-typed .NET developers are probably less so). It would not be impossible to implement, but it would be very difficult: aside from types being inferred at the time code is being written (I’ll use the term develop-time, although I haven’t seen it used before), there would need to be some work done to effectively populate the list of properties & methods, which would typically mean opening the object and reflecting over its protocol… not at all straightforward to implement, as far as I can tell, especially when you don’t actually have AutoCAD running to help with accessing the objects.
A lack of IntelliSense does mean this style of coding it likely to be less accessible to novice coders, unless a more integrated REPL environment becomes available (as this is something that tends to balance out the lack of other develop-time tooling when scripting – just as people have found with the ability to execute fragments of AutoLISP at AutoCAD’s command-line, over the years).
I can see a couple of ways a REPL might end up being implemented. One would be to host the DLR and (say) the IronPython scripting engine (just as Albert showed during his above-mentioned AU class, as I did at my own AU 2009 class, and we’ve seen previously on this blog). Another would be to wait for the fruits of the future .NET Framework feature codenamed Roslyn, which enables Compiler as a Service for .NET  code, as this seems it would be a likely way to execute C# and VB.NET in a more dynamic way.
But that’s all for the future, and is very much my own speculation, at this stage.
One question that has come up in relation to “Dynamic .NET” in AutoCAD is around performance: as we’re effectively opening and closing an object every time we execute a method (and we may actually open and close an object twice – once for read, once for write – when we read one of its properties, modify it and store it back), isn’t there a performance impact? I admit I haven’t performed extensive benchmarking of this, and there is likely to be some overhead if dealing with lots of properties and methods. But in terms of getting something working quickly – which you can then tune for performance later, as needed – this is likely to be a valuable tool for developers, irrespective of the performance impact (which I’d hope to be modest).
And it really comes into its own when used in combination with LINQ. Here’s some code that Stephen Preston put together to test out some of the possibilities with LINQ (I’ve included the CLN and CLN2 commands – shown above – for completeness).

2. using Autodesk.AutoCAD.Runtime;
   
3. using Autodesk.AutoCAD.ApplicationServices;
   
4. using Autodesk.AutoCAD.DatabaseServices;
   
5. using Autodesk.AutoCAD.Geometry;
   
6. using Autodesk.AutoCAD.EditorInput;
   
7. using System.Collections.Generic;
   
8. using System.Linq;
   
9. 
   
10. namespace DynamicTyping
    
11. {
    
12.   public class Commands
    
13.   {
    
14.     [CommandMethod("CLN")]
    
15.     public static void ChangeLayerNames()
    
16.     {
    
17.       Database db = HostApplicationServices.WorkingDatabase;
    
18. 
    
19.       using (
    
20.         Transaction tr = db.TransactionManager.StartTransaction()
    
21.       )
    
22.       {
    
23.         LayerTable lt =
    
24.           (LayerTable)tr.GetObject(
    
25.             db.LayerTableId, OpenMode.ForRead
    
26.           );
    
27. 
    
28.         foreach (ObjectId ltrId in lt)
    
29.         {
    
30.           LayerTableRecord ltr =
    
31.             (LayerTableRecord)tr.GetObject(ltrId, OpenMode.ForRead);
    
32. 
    
33.           if (ltr.Name != "0")
    
34.           {
    
35.             ltr.UpgradeOpen();
    
36.             ltr.Name = "First Floor " + ltr.Name;
    
37.           }
    
38.         }
    
39. 
    
40.         tr.Commit();
    
41.       }
    
42.     }
    
43. 
    
44.     [CommandMethod("CLN2")]
    
45.     public static void ChangeLayerNamesDynamically()
    
46.     {
    
47.       dynamic layers =
    
48.         HostApplicationServices.WorkingDatabase.LayerTableId;
    
49. 
    
50.       foreach (dynamic l in layers)
    
51.         if (l.Name != "0")
    
52.           l.Name = "First Floor " + l.Name;
    
53.     }
    
54. 
    
55.     // Adds a custom dictionary in the extension dictionary of
    
56.     // selected objects. Uses dynamic capabilities, but not LINQ.
    
57. 
    
58.     [CommandMethod("AddMyDict")]
    
59.     public void AddMyDict()
    
60.     {
    
61.       Document doc = Application.DocumentManager.MdiActiveDocument;
    
62.       Database db = doc.Database;
    
63.       Editor ed = doc.Editor;
    
64. 
    
65.       PromptSelectionResult res = ed.GetSelection();
    
66. 
    
67.       if (res.Status != PromptStatus.OK)
    
68.         return;
    
69. 
    
70.       foreach (dynamic ent in res.Value.GetObjectIds())
    
71.       {
    
72.         dynamic dictId = ent.ExtensionDictionary;
    
73.         if (dictId == ObjectId.Null)
    
74.         {
    
75.           ent.CreateExtensionDictionary();
    
76.           dictId = ent.ExtensionDictionary();
    
77.         }
    
78.         if (!dictId.Contains("MyDict"))
    
79.           dictId.SetAt("MyDict", new DBDictionary());
    
80.       }
    
81.     }
    
82. 
    
83.     // Adds a custom dictionary in the extension dictionary of
    
84.     // selected objects, but this time using dynamic capabilities
    
85.     // with LINQ. Conceptually simpler, but with some performance
    
86.     // overhead, as we're using two queries: one to get entities
    
87.     // without extension dictionaries (and then add them) and the
    
88.     // other to get entities with extension dictionaries.
    
89. 
    
90.     [CommandMethod("AddMyDict2")]
    
91.     public void AddMyDict2()
    
92.     {
    
93.       PromptSelectionResult res =
    
94.         Application.DocumentManager.MdiActiveDocument.Editor.
    
95.           GetSelection();
    
96. 
    
97.       if (res.Status != PromptStatus.OK)
    
98.         return;
    
99. 
    
100.       // Query for ents in selset without ExtensionDictionaries
     
101. 
     
102.       var noExtDicts =
     
103.         from ent in res.Value.GetObjectIds().Cast<dynamic>()
     
104.           where ent.ExtensionDictionary == ObjectId.Null
     
105.           select ent;
     
106. 
     
107.       // Add extension dictionaries
     
108. 
     
109.       foreach (dynamic ent in noExtDicts)
     
110.         ent.CreateExtensionDictionary();
     
111. 
     
112.       // Now we've added the ext dicts, we add our dict to each
     
113. 
     
114.       var noMyDicts =
     
115.         from ent in res.Value.GetObjectIds().Cast<dynamic>()
     
116.           where !ent.ExtensionDictionary.Contains("MyDict")
     
117.           select ent.ExtensionDictionary;
     
118. 
     
119.       foreach (dynamic dict in noMyDicts)
     
120.         dict.SetAt("MyDict", new DBDictionary());
     
121.     }
     
122. 
     
123.     // Access various bits of information using LINQ
     
124. 
     
125.     [CommandMethod("IUL")]
     
126.     public void InfoUsingLINQ()
     
127.     {
     
128.       Document doc = Application.DocumentManager.MdiActiveDocument;
     
129.       Database db = doc.Database;
     
130.       Editor ed = doc.Editor;
     
131. 
     
132.       dynamic bt = db.BlockTableId;
     
133. 
     
134.       // Dynamic .NET loop iteration
     
135. 
     
136.       ed.WriteMessage("\n*** BlockTableRecords in this DWG ***");
     
137.       foreach (dynamic btr in bt)
     
138.         ed.WriteMessage("\n" + btr.Name);
     
139. 
     
140.       // LINQ query - returns startpoints of all lines
     
141. 
     
142.       ed.WriteMessage(
     
143.         "\n\n*** StartPoints of Lines in ModelSpace ***"
     
144.       );
     
145. 
     
146.       dynamic ms = SymbolUtilityServices.GetBlockModelSpaceId(db);
     
147.       var lineStartPoints =
     
148.         from ent in (IEnumerable<dynamic>)ms
     
149.           where ent.IsKindOf(typeof(Line))
     
150.           select ent.StartPoint;
     
151. 
     
152.       foreach (Point3d start in lineStartPoints)
     
153.         ed.WriteMessage("\n" + start.ToString());
     
154. 
     
155.       // LINQ query - all entities on layer '0'
     
156. 
     
157.       ed.WriteMessage("\n\n*** Entities on Layer 0 ***");
     
158. 
     
159.       var entsOnLayer0 =
     
160.         from ent in (IEnumerable<dynamic>)ms
     
161.           where ent.Layer == "0"
     
162.           select ent;
     
163. 
     
164.       foreach (dynamic e in entsOnLayer0)
     
165.         ed.WriteMessage(
     
166.           "\nHandle=" + e.Handle.ToString() + ", ObjectId=" +
     
167.           ((ObjectId)e).ToString() + ", Class=" + e.ToString()
     
168.         );
     
169.       ed.WriteMessage("\n\n");
     
170. 
     
171.       // Using LINQ with selection sets
     
172. 
     
173.       PromptSelectionResult res = ed.GetSelection();
     
174.       if (res.Status != PromptStatus.OK)
     
175.         return;
     
176. 
     
177.       // Select all entities in selection set that have an object
     
178.       // called "MyDict" in their extension dictionary
     
179. 
     
180.       var extDicts =
     
181.         from ent in res.Value.GetObjectIds().Cast<dynamic>()
     
182.           where ent.ExtensionDictionary != ObjectId.Null &&
     
183.             ent.ExtensionDictionary.Contains("MyDict")
     
184.           select ent.ExtensionDictionary.Item("MyDict");
     
185. 
     
186.       // Erase our dictionary
     
187. 
     
188.       foreach (dynamic myDict in extDicts)
     
189.         myDict.Erase();
     
190.     }
     
191.   }
     
192. }

using Autodesk.AutoCAD.Runtime;<br /> using Autodesk.AutoCAD.ApplicationServices;<br /> using Autodesk.AutoCAD.DatabaseServices;<br /> using Autodesk.AutoCAD.Geometry;<br /> using Autodesk.AutoCAD.EditorInput;<br /> using System.Collections.Generic;<br /> using System.Linq;<br /> <br /> namespace DynamicTyping<br /> {<br />   public class Commands<br />   {<br />     [CommandMethod("CLN")]<br />     public static void ChangeLayerNames()<br />     {<br />       Database db = HostApplicationServices.WorkingDatabase;<br /> <br />       using (<br />         Transaction tr = db.TransactionManager.StartTransaction()<br />       )<br />       {<br />         LayerTable lt =<br />           (LayerTable)tr.GetObject(<br />             db.LayerTableId, OpenMode.ForRead<br />           );<br /> <br />         foreach (ObjectId ltrId in lt)<br />         {<br />           LayerTableRecord ltr =<br />             (LayerTableRecord)tr.GetObject(ltrId, OpenMode.ForRead);<br /> <br />           if (ltr.Name != "0")<br />           {<br />             ltr.UpgradeOpen();<br />             ltr.Name = "First Floor " + ltr.Name;<br />           }<br />         }<br /> <br />         tr.Commit();<br />       }<br />     }<br /> <br />     [CommandMethod("CLN2")]<br />     public static void ChangeLayerNamesDynamically()<br />     {<br />       dynamic layers =<br />         HostApplicationServices.WorkingDatabase.LayerTableId;<br /> <br />       foreach (dynamic l in layers)<br />         if (l.Name != "0")<br />           l.Name = "First Floor " + l.Name;<br />     }<br /> <br />     // Adds a custom dictionary in the extension dictionary of<br />     // selected objects. Uses dynamic capabilities, but not LINQ.<br /> <br />     [CommandMethod("AddMyDict")]<br />     public void AddMyDict()<br />     {<br />       Document doc = Application.DocumentManager.MdiActiveDocument;<br />       Database db = doc.Database;<br />       Editor ed = doc.Editor;<br /> <br />       PromptSelectionResult res = ed.GetSelection();<br /> <br />       if (res.Status != PromptStatus.OK)<br />         return;<br /> <br />       foreach (dynamic ent in res.Value.GetObjectIds())<br />       {<br />         dynamic dictId = ent.ExtensionDictionary;<br />         if (dictId == ObjectId.Null)<br />         {<br />           ent.CreateExtensionDictionary();<br />           dictId = ent.ExtensionDictionary();<br />         }<br />         if (!dictId.Contains("MyDict"))<br />           dictId.SetAt("MyDict", new DBDictionary());<br />       }<br />     }<br /> <br />     // Adds a custom dictionary in the extension dictionary of<br />     // selected objects, but this time using dynamic capabilities<br />     // with LINQ. Conceptually simpler, but with some performance<br />     // overhead, as we're using two queries: one to get entities<br />     // without extension dictionaries (and then add them) and the<br />     // other to get entities with extension dictionaries.<br /> <br />     [CommandMethod("AddMyDict2")]<br />     public void AddMyDict2()<br />     {<br />       PromptSelectionResult res =<br />         Application.DocumentManager.MdiActiveDocument.Editor.<br />           GetSelection();<br /> <br />       if (res.Status != PromptStatus.OK)<br />         return;<br /> <br />       // Query for ents in selset without ExtensionDictionaries<br /> <br />       var noExtDicts =<br />         from ent in res.Value.GetObjectIds().Cast<dynamic>()<br />           where ent.ExtensionDictionary == ObjectId.Null<br />           select ent;<br /> <br />       // Add extension dictionaries<br /> <br />       foreach (dynamic ent in noExtDicts)<br />         ent.CreateExtensionDictionary();<br /> <br />       // Now we've added the ext dicts, we add our dict to each<br /> <br />       var noMyDicts =<br />         from ent in res.Value.GetObjectIds().Cast<dynamic>()<br />           where !ent.ExtensionDictionary.Contains("MyDict")<br />           select ent.ExtensionDictionary;<br /> <br />       foreach (dynamic dict in noMyDicts)<br />         dict.SetAt("MyDict", new DBDictionary());<br />     }<br /> <br />     // Access various bits of information using LINQ<br /> <br />     [CommandMethod("IUL")]<br />     public void InfoUsingLINQ()<br />     {<br />       Document doc = Application.DocumentManager.MdiActiveDocument;<br />       Database db = doc.Database;<br />       Editor ed = doc.Editor;<br /> <br />       dynamic bt = db.BlockTableId;<br /> <br />       // Dynamic .NET loop iteration<br /> <br />       ed.WriteMessage("\n*** BlockTableRecords in this DWG ***");<br />       foreach (dynamic btr in bt)<br />         ed.WriteMessage("\n" + btr.Name);<br /> <br />       // LINQ query - returns startpoints of all lines<br /> <br />       ed.WriteMessage(<br />         "\n\n*** StartPoints of Lines in ModelSpace ***"<br />       );<br /> <br />       dynamic ms = SymbolUtilityServices.GetBlockModelSpaceId(db);<br />       var lineStartPoints =<br />         from ent in (IEnumerable<dynamic>)ms<br />           where ent.IsKindOf(typeof(Line))<br />           select ent.StartPoint;<br /> <br />       foreach (Point3d start in lineStartPoints)<br />         ed.WriteMessage("\n" + start.ToString());<br /> <br />       // LINQ query - all entities on layer '0'<br /> <br />       ed.WriteMessage("\n\n*** Entities on Layer 0 ***");<br /> <br />       var entsOnLayer0 =<br />         from ent in (IEnumerable<dynamic>)ms<br />           where ent.Layer == "0"<br />           select ent;<br /> <br />       foreach (dynamic e in entsOnLayer0)<br />         ed.WriteMessage(<br />           "\nHandle=" + e.Handle.ToString() + ", ObjectId=" +<br />           ((ObjectId)e).ToString() + ", Class=" + e.ToString()<br />         );<br />       ed.WriteMessage("\n\n");<br /> <br />       // Using LINQ with selection sets<br /> <br />       PromptSelectionResult res = ed.GetSelection();<br />       if (res.Status != PromptStatus.OK)<br />         return;<br /> <br />       // Select all entities in selection set that have an object<br />       // called "MyDict" in their extension dictionary<br /> <br />       var extDicts =<br />         from ent in res.Value.GetObjectIds().Cast<dynamic>()<br />           where ent.ExtensionDictionary != ObjectId.Null &&<br />             ent.ExtensionDictionary.Contains("MyDict")<br />           select ent.ExtensionDictionary.Item("MyDict");<br /> <br />       // Erase our dictionary<br /> <br />       foreach (dynamic myDict in extDicts)<br />         myDict.Erase();<br />     }<br />   }<br /> }

You’ll see that certain operations become very straightforward when combining Dynamic .NET and LINQ. This could well be the “sweet spot” of the dynamic capability – it certainly makes LINQ a more natural choice when accessing various types of data in AutoCAD drawings.
That’s it for today’s post. Next time we’ll summarize the remaining API enhancements coming in AutoCAD 2013, before looking at the migration steps needed for .NET applications.

chopin

AutoCAD.NET API对.NET框架的动态语言运行时的支持

single-yu

飞狐老大的帖子，一定要支持！

河伯

ObjectId对动态语言的支持，就是VB.NET早先的后期绑定。
实际使用起来并不方便，IDE没有智能提示，属性方法都要是手动输入。
本来DBObject可以直接实现的功能，非要绕弯用ObjectId实现，好像为动态而动态，不知道Autodesk怎么想的。

雪山飞狐_lzh

只是看起来很Cool而已 呵呵

pucx

很好很强大

huaxiamengqing

飞狐哥哥又回来了！

魔子幻灭

为什么谈VB.NET的这么少呢？