{"id":3013,"date":"2009-09-30T16:49:00","date_gmt":"2009-09-30T16:49:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/visualstudio\/2009\/09\/30\/dynamic-in-c-4-0-introducing-the-expandoobject\/"},"modified":"2019-02-14T15:42:20","modified_gmt":"2019-02-14T23:42:20","slug":"dynamic-in-c-4-0-introducing-the-expandoobject","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/visualstudio\/dynamic-in-c-4-0-introducing-the-expandoobject\/","title":{"rendered":"Dynamic in C# 4.0: Introducing the ExpandoObject"},"content":{"rendered":"

You have probably already heard about the new dynamic feature in C# 4.0 and how it is used to support COM interop. If you haven’t, I strongly recommend reading the following MSDN articles: Using Type dynamic<\/a> and How to: Access Office Interop Objects by Using Visual C# 2010 Features<\/a>.<\/p>\n

Well, where else can you use this new feature? What are the use cases? Where does dynamic dispatch work better than static typing?<\/p>\n

The quick answer is that whenever you see syntax like myobject.GetProperty(“Address”)<\/font>, you have a use case for dynamic objects. First of all, the above syntax is difficult to read. Second, you don\u2019t have any IntelliSense support for the property name, and if the \u201cAddress\u201d property doesn\u2019t exist you get a run-time exception. So why not create a dynamic object that calls the property as myobject.Address<\/font>? You still get the run-time exception, and you still don’t get IntelliSense, but at least the syntax is much better.<\/p>\n

In fact, it<\/a><\/a>\u2019s not just better syntax. You also get flexibility. To demonstrate this flexibility, let\u2019s move to ExpandoObject<\/a><\/font>, which is a part of the new dynamic language runtime (DLR)<\/a>. ExpandoObject <\/font>instances can add and remove members at run time. Where can you use such an object? XML is a good candidate here.<\/p>\n

Here\u2019s a code example that I took from MSDN<\/a>. (Yes, I am an MSDN writer myself, so I use MSDN a lot.)<\/p>\n

XElement <\/span>contactXML =\n    new <\/span>XElement<\/span>(\"Contact\"<\/span>,\n        new <\/span>XElement<\/span>(\"Name\"<\/span>, \"Patrick Hines\"<\/span>),\n        new <\/span>XElement<\/span>(\"Phone\"<\/span>, \"206-555-0144\"<\/span>),\n        new <\/span>XElement<\/span>(\"Address\"<\/span>,\n            new <\/span>XElement<\/span>(\"Street1\"<\/span>, \"123 Main St\"<\/span>),\n            new <\/span>XElement<\/span>(\"City\"<\/span>, \"Mercer Island\"<\/span>),\n            new <\/span>XElement<\/span>(\"State\"<\/span>, \"WA\"<\/span>),\n            new <\/span>XElement<\/span>(\"Postal\"<\/span>, \"68042\"<\/span>)\n        )\n    );<\/pre>\n
<\/a><\/p>\n
Although LINQ to XML is a good technology and I really love it, those new <\/span>XElement<\/span> parts look a little bit annoying. This is how I can rewrite it by using ExpandoObject<\/font>.<\/p>\n
dynamic <\/span>contact = new <\/span>ExpandoObject<\/span>();\ncontact.Name = \"Patrick Hines\"<\/span>;\ncontact.Phone = \"206-555-0144\"<\/span>;\ncontact.Address = new <\/span>ExpandoObject<\/span>();\ncontact.Address.Street = \"123 Main St\"<\/span>;\ncontact.Address.City = \"Mercer Island\"<\/span>;\ncontact.Address.State = \"WA\"<\/span>;\ncontact.Address.Postal = \"68402\"<\/span>;<\/pre>\n
Just note a couple of things. First, look at the declaration of contact<\/font>.<\/p>\n
dynamic <\/span>contact = new <\/span>ExpandoObject<\/span>();<\/p>\n
I didn\u2019t write ExpandoObject <\/span>contact = new <\/span>ExpandoObject<\/span>(), because if I did contact<\/font> would be a statically-typed object of the ExpandoObject<\/font> type. And of course, statically-typed variables cannot add members at run time. So I used the new dynamic<\/font> keyword instead of a type declaration, and since ExpandoObject<\/font> supports dynamic operations, the code works.<\/p>\n
Second, notice that every time I needed a node to have subnodes, I simply created a new instance of ExpandoObject<\/font> as a member of the contact<\/font> object.<\/p>\n
It looks like the ExpandoObject<\/font> example has more code, but it\u2019s actually easier to read. You can clearly see what subnodes each node contains, and you don\u2019t need to deal with the parentheses and indentation. But the best part is how you can access the elements now.<\/p>\n
This is the code you need to print the State field in LINQ to XML. <\/p>\n
Console<\/span>.WriteLine((string<\/span>)contactXML.Element(\"Address\"<\/span>).Element(\"State\"<\/span>));<\/pre>\n
And this is how it looks with ExpandoObject<\/font>.<\/p>\n
Console<\/span>.WriteLine(contact.Address.State);<\/pre>\n
<\/a>But what if you want to have several Contact nodes? Like in the following LINQ to XML example.<\/p>\n
XElement <\/span>contactsXML =\n    new <\/span>XElement<\/span>(\"Contacts\"<\/span>,\n        new <\/span>XElement<\/span>(\"Contact\"<\/span>,\n            new <\/span>XElement<\/span>(\"Name\"<\/span>, \"Patrick Hines\"<\/span>),\n            new <\/span>XElement<\/span>(\"Phone\"<\/span>, \"206-555-0144\"<\/span>)\n        ),\n        new <\/span>XElement<\/span>(\"Contact\"<\/span>,\n            new <\/span>XElement<\/span>(\"Name\"<\/span>, \"Ellen Adams\"<\/span>),\n            new <\/span>XElement<\/span>(\"Phone\"<\/span>, \"206-555-0155\"<\/span>)\n        )\n    );<\/pre>\n
<\/a><\/p>\n
Just use a collection of dynamic objects. <\/p>\n
dynamic <\/span>contacts = new <\/span>List<\/span><dynamic<\/span>>();\ncontacts.Add(new <\/span>ExpandoObject<\/span>());\ncontacts[0].Name = \"Patrick Hines\"<\/span>;\ncontacts[0].Phone = \"206-555-0144\"<\/span>;\ncontacts.Add(new <\/span>ExpandoObject<\/span>());\ncontacts[1].Name = \"Ellen Adams\"<\/span>;\ncontacts[1].Phone = \"206-555-0155\"<\/span>;<\/pre>\n
<\/a><\/p>\n
Technically speaking, I could write dynamic <\/span>contacts = new <\/span>List<\/span><ExpandoObject<\/span>>() and the example would work. However, there are some situations where this could cause problems, because the actual type of the list elements should be dynamic<\/font> and not ExpandoObject<\/font>, and these are two different types. (Once again, references to the ExpandoObject<\/font> objects are statically-typed and do not support dynamic operations.)<\/p>\n
Now, if you want to find all the names in your contact list, just iterate over the collection. <\/p>\n
foreach <\/span>(var <\/span>c in <\/span>contacts)\n    Console<\/span>.WriteLine(c.Name);<\/pre>\n
Again, this syntax is better than LINQ to XML version. <\/p>\n
foreach <\/span>(var <\/span>c in <\/span>contactsXML.Descendants(\"Name\"<\/span>))\n    Console<\/span>.WriteLine((string<\/span>)c);<\/pre>\n
<\/a>So far, so good. But one of the main advantages of LINQ to XML is, well, LINQ. How would you query dynamic objects? Although there is still a lot to be done in this particular area, you can query dynamic objects. For example, let\u2019s find all the phone numbers for the specified name.<\/p>\n
var <\/span>phones = from <\/span>c in <\/span>(contacts as <\/span>List<\/span><dynamic<\/span>>)\n             where <\/span>c.Name == \"Patrick Hines\"\n             <\/span>select <\/span>c.Phone;<\/pre>\n
True, the cast here doesn\u2019t look like something strictly necessary. Certainly the compiler could have determined at run-time that contacts<\/font> is List<\/span><dynamic<\/span>>. But as I said, there is still some work to be done in this area.<\/p>\n
Another thing to note is that this trick works only for the LINQ to Objects<\/a> provider. To use dynamic objects in LINQ to SQL or other LINQ providers, you need to modify the providers themselves, and that\u2019s a completely different story.<\/p>\n
However, even with the cast, syntax is still better than in a LINQ to XML query. <\/p>\n
var <\/span>phonesXML = from <\/span>c in <\/span>contactsXML.Elements(\"Contact\"<\/span>)\n                where <\/span>c.Element(\"Name\"<\/span>).Value == \"Patrick Hines\"\n                <\/span>select <\/span>c.Element(\"Phone\"<\/span>).Value;<\/pre>\n
<\/a>Sure, there are some things that look better in LINQ to XML. For example, if you want to delete a phone number for all the contacts, you can write just one line of code in LINQ to XML.<\/p>\n
contactsXML.Elements(\"Contact\"<\/span>).Elements(\"Phone\"<\/span>).Remove();<\/pre>\n
<\/a><\/p>\n
Since C# doesn\u2019t have syntax for removing object members, you don\u2019t have an elegant solution here. But ExpandoObject<\/font> implements IDictionary<\/span><String<\/span>, Object<\/span>> to maintain its list of members, and you can delete a member by deleting a key-value pair. <\/p>\n
foreach <\/span>(var <\/span>person in <\/span>contacts)\n    ((IDictionary<\/span><String<\/span>, Object<\/span>>)person).Remove(\"Phone\"<\/span>);<\/pre>\n
There are other useful methods in LINQ to XML like Save()<\/font> and Load()<\/font>. For ExpandoObject<\/font> you need to write such methods yourself, but probably only once. Here, casting to the IDictionary<\/font> interface can help as well.<\/p>\n
And although I\u2019ve been comparing LINQ to XML and ExpandoObject<\/font> in this post, these two approaches are not \u201crivals\u201d. You can convert ExpandoObject<\/font> to XElement<\/font> and vice versa. For example, this is what the ExpandoObject<\/font> to XElement<\/font> conversion might look like. <\/p>\n
private static <\/span>XElement <\/span>expandoToXML(dynamic <\/span>node, String <\/span>nodeName)\n{\n    XElement <\/span>xmlNode = new <\/span>XElement<\/span>(nodeName);\n    foreach <\/span>(var <\/span>property in <\/span>(IDictionary<\/span><String<\/span>, Object<\/span>>)node)\n    {\n        if <\/span>(property.Value.GetType() == typeof<\/span>(ExpandoObject<\/span>))\n            xmlNode.Add(expandoToXML(property.Value, property.Key));\n        else\n            if <\/span>(property.Value.GetType() == typeof<\/span>(List<\/span><dynamic<\/span>>))\n                foreach <\/span>(var <\/span>element in <\/span>(List<\/span><dynamic<\/span>>)property.Value)\n                    xmlNode.Add(expandoToXML(element, property.Key));\n            else\n                <\/span>xmlNode.Add(new <\/span>XElement<\/span>(property.Key, property.Value));\n    }\n    return <\/span>xmlNode;\n}<\/pre>\n
This little trick might help you access all the LINQ to XML functions when you need them but at the same time use more convenient syntax when creating and modifying XML trees.<\/p>\n
Of course, XML is not the only area where you can use ExpandoObject<\/font>. If you heavily use reflection or work a lot with script objects, you can simplify your code with ExpandoObject<\/font>. On the other hand, ExpandoObject<\/font> is not the only useful class that the DLR provides. The DynamicObject<\/a><\/font> class, for example, enables you to take more control over dynamic operations and define what actually happens when you access a member or invoke a method. But that\u2019s a topic for another blog post.<\/p>\n
One more thing to note is that libraries that look up members by name might someday adopt the DLR and implement the IDynamicMetaObjectProvider<\/font> interface. (This interface actually provides all the \u201cmagic\u201d \u2013 or dynamic dispatch \u2013 for ExpandoObject<\/font> and the dynamic feature in general.) For example, if LINQ to XML implements this interface, you would be able to write dynamic <\/span>contacts = new <\/span>XmlElement() instead of dynamic <\/span>contacts = new <\/span>ExpandoObject() and perform the same operations that I have shown in the examples for the ExpandoObject<\/font> type.<\/p>\n
All the examples provided in this blog post work in Visual Studio 2010 Beta 1<\/a>. If you have any comments or suggestions, you are welcome to post them here or contact the DLR team at http:\/\/www.codeplex.com\/dlr<\/a>. You can also write an e-mail to the DLR team at dlr@microsoft.com<\/a>.<\/p>\n
Update:<\/strong><\/p>\n
See how you can improve this example in my next post: Dynamic in C# 4.0: Creating Wrappers with DynamicObject<\/font><\/a>.<\/span><\/p>\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
You have probably already heard about the new dynamic feature in C# 4.0 and how it is used to support COM interop. If you haven’t, I strongly recommend reading the following MSDN articles: Using Type dynamic and How to: Access Office Interop Objects by Using Visual C# 2010 Features. Well, where else can you use […]<\/p>\n","protected":false},"author":13,"featured_media":255385,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[155],"tags":[3,1383,185,357,13],"class_list":["post-3013","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-visual-studio","tag-net-framework","tag-c","tag-node-js","tag-sql","tag-visual-studio-2010"],"acf":[],"blog_post_summary":"
You have probably already heard about the new dynamic feature in C# 4.0 and how it is used to support COM interop. If you haven’t, I strongly recommend reading the following MSDN articles: Using Type dynamic and How to: Access Office Interop Objects by Using Visual C# 2010 Features. Well, where else can you use […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts\/3013","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/users\/13"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/comments?post=3013"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts\/3013\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/media\/255385"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/media?parent=3013"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/categories?post=3013"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/tags?post=3013"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
<\/a><\/p>\n
<\/a><\/p>\n
<\/a><\/a><\/p>\n