{"id":3003,"date":"2009-10-19T14:24:00","date_gmt":"2009-10-19T14:24:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/visualstudio\/2009\/10\/19\/dynamic-in-c-4-0-creating-wrappers-with-dynamicobject\/"},"modified":"2019-02-14T15:42:19","modified_gmt":"2019-02-14T23:42:19","slug":"dynamic-in-c-4-0-creating-wrappers-with-dynamicobject","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/visualstudio\/dynamic-in-c-4-0-creating-wrappers-with-dynamicobject\/","title":{"rendered":"Dynamic in C# 4.0: Creating Wrappers with DynamicObject"},"content":{"rendered":"

In the previous post<\/a> I showed how you can use the new dynamic feature and the ExpandoObject<\/a> class to add and remove properties at run time, and how this can make your code more readable and flexible than code written with LINQ to XML syntax. <\/p>\n

But there were some obvious flaws in that example: While ExpandoObject<\/b> provided better syntax, LINQ to XML provided a lot of useful library methods that helped you to work with XML files. So, is it possible to combine those two advantages, to have better syntax and still get all those methods? The answer is yes, but you need another type from the System.Dynamic<\/b> namespace: DynamicObject<\/a>.<\/b><\/p>\n

The DynamicObject<\/b> class enables you to override operations like getting or setting a member, calling a method, or performing any binary, unary, or type conversion operation. To illustrate the issue, let\u2019s create a very simple object that overrides the \u201cget property\u201d operation, so that whenever you access a property it returns the property\u2019s name as a string. This example has no practical value.<\/p>\n

public class <\/span>SampleObject <\/span>: DynamicObject\n<\/span>{\n    public override bool <\/span>TryGetMember(\n        GetMemberBinder <\/span>binder, out object <\/span>result)\n    {\n        result = binder.Name;\n        return true<\/span>;\n    }\n}<\/pre>\n
As with ExpandoObject<\/b>, we must use the dynamic<\/b> keyword to create an instance of this class.<\/p>\n
dynamic <\/span>obj = new <\/span>SampleObject<\/span>();\nConsole<\/span>.WriteLine(obj.SampleProperty);\n\/\/Prints \"SampleProperty\".<\/span><\/pre>\n
The TryGetMember<\/b> method returns true<\/font> if the operation is successful. But the actual result of the operation must be assigned to the out parameter result<\/font>. In this example, TryGetMember<\/b> returns true<\/font>, but obj.SampleProperty<\/font> returns “SampleProperty”. <\/p>\n
Now let\u2019s move to a more complex example and create a wrapper for the XElement<\/b> object. Once again, I\u2019ll try to provide better syntax for the following LINQ to XML sample.<\/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
First of all, I need to create an analog of ExpandoObject<\/b>. I still want to be able to dynamically add and remove properties. But since I am essentially creating a wrapper for the XElement<\/b> type, I\u2019ll use XElement<\/b> instead of the dictionary to maintain the properties.<\/p>\n
public class <\/span>DynamicXMLNode <\/span>: DynamicObject\n<\/span>{\n    XElement <\/span>node;\n    public <\/span>DynamicXMLNode(XElement <\/span>node)\n    {\n        this<\/span>.node = node;\n    }\n    public <\/span>DynamicXMLNode()\n    {\n    }\n    public <\/span>DynamicXMLNode(String <\/span>name)\n    {\n        node = new <\/span>XElement<\/span>(name);\n    }\n    public override bool <\/span>TrySetMember(\n        SetMemberBinder <\/span>binder, object <\/span>value)\n    {\n        XElement <\/span>setNode = node.Element(binder.Name);\n        if <\/span>(setNode != null<\/span>)\n            setNode.SetValue(value);\n        else\n        <\/span>{\n            if <\/span>(value.GetType() == typeof<\/span>(DynamicXMLNode<\/span>))\n                node.Add(new <\/span>XElement<\/span>(binder.Name));\n            else\n                <\/span>node.Add(new <\/span>XElement<\/span>(binder.Name, value));\n        }\n        return true<\/span>;\n    }\n    public override bool <\/span>TryGetMember(
        GetMemberBinder <\/span>binder, out object <\/span>result)\n    {\n        XElement <\/span>getNode = node.Element(binder.Name);\n        if <\/span>(getNode != null<\/span>)\n        {\n            result = new <\/span>DynamicXMLNode<\/span>(getNode);\n            return true<\/span>;\n        }\n        else\n        <\/span>{\n            result = null<\/span>;\n            return false<\/span>;\n        }\n    }\n}<\/pre>\n
And here is how you can use this class.<\/p>\n
dynamic <\/span>contact = new <\/span>DynamicXMLNode<\/span>(\"Contacts\"<\/span>);\ncontact.Name = \"Patrick Hines\"<\/span>;\ncontact.Phone = \"206-555-0144\"<\/span>;\ncontact.Address = new <\/span>DynamicXMLNode<\/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
Let\u2019s look at the contact<\/font> object. When this object is created, it initializes its inner XElement<\/b>. If you set a property value, like in contact.Phone = “206-555-0144”<\/span><\/font>, the TrySetMember<\/b> method checks whether an element with the name Phone exists in its XElement<\/b>. If it does not exist, the method creates the element.<\/p>\n
The next interesting line is contact.Address = new <\/span>DynamicXMLNode<\/span>().<\/font> Basically, in this particular example this line means that I want to create a node that has subnodes. For this property, the TrySetMember<\/b> method creates an XElement<\/b> without a value.<\/p>\n
The most complex case here is a line such as contact.Address.State = “WA”<\/span>.<\/font><\/font> First, the TryGetMember<\/b> method is called for contact.Address<\/font> and returns a new DynamicXMLNode<\/b> object, which is initialized by the XElement<\/b> with the name Address. (Theoretically, I could have returned the XElement<\/b> itself, but that would make the example more complicated.) Then the TrySetMember<\/b> method is called. The method looks for the State element in contact.Address<\/font>. If it doesn\u2019t find one, it creates it.<\/p>\n
So I have successfully created the required XML structure. But TryGetMember<\/b> always returns an instance of DynamicXMLNode<\/b>. How do I get the actual value of the XML node? For example, I want the following line to work, but now it throws an exception.<\/p>\n
String <\/span>state = contact.Address.State;<\/pre>\n
<\/a><\/p>\n
I have several options here. I can modify the TryGetMember<\/b> method to return actual values for leaf nodes, for example. But let\u2019s explore another option: override type conversion. Just add the following method to the DynamicXMLNode<\/b> class.<\/p>\n
<\/a><\/p>\n
public override bool <\/span>TryConvert(\n    ConvertBinder <\/span>binder, out object <\/span>result)\n{\n    if <\/span>(binder.Type == typeof<\/span>(String<\/span>))\n    {\n        result = node.Value;\n        return true<\/span>;\n    }\n    else\n    <\/span>{\n        result = null<\/span>;\n        return false<\/span>;\n    }\n}<\/pre>\n
<\/a><\/p>\n
Now whenever I have an explicit or implicit type conversion of the DynamicXMLNode<\/b> type, the TryConvert<\/b> method is called. The method checks what type the object is converted to and, if this type is String<\/b>, the method returns the value of the inner XElement<\/b>. Otherwise, it returns false<\/b>, which means that the language should determine what to do next (in most cases it means that you\u2019re going to get a run-time exception).<\/p>\n
The last thing I\u2019m going to show is how to get access to the XElement<\/b> methods. Let\u2019s override the TryInvokeMember<\/b> method so that it will redirect all the method calls to its XElement<\/b> object. Of course, I\u2019m using the System.Reflection<\/strong> namespace here.<\/p>\n
public override bool <\/span>TryInvokeMember(\n    InvokeMemberBinder <\/span>binder, 
    object<\/span>[] args, 
    out object <\/span>result)\n{\n    Type <\/span>xmlType = typeof<\/span>(XElement<\/span>);\n    try\n    <\/span>{\n        result = xmlType.InvokeMember(\n                  binder.Name,\n                  BindingFlags.InvokeMethod |\n                  BindingFlags.Public |\n                  BindingFlags.Instance,\n                  null<\/span>, node, args);\n        return true<\/span>;\n    }\n    catch\n    <\/span>{\n        result = null<\/span>;\n        return false<\/span>;\n    }\n}<\/pre>\n
This method enables you to call XElement<\/b> methods on any node of the DynamicXMLNode<\/b> object. The most obvious drawback here is absence of IntelliSense.<\/p>\n
I\u2019m not even going to pretend that this example is a ready-to-use wrapper for the LINQ to XML library. It doesn\u2019t support attributes, doesn\u2019t allow you to create a collection of nodes (for example, multiple contacts), and it is probably missing other features. Creating a library is a difficult task, and creating a good wrapper is too. But I hope that after reading this blog post you can create a fully functioning wrapper with DynamicObject<\/b> yourself.<\/p>\n
So, if you routinely use a library with complicated syntax that crawls XML files or works with script objects, or if you are creating such a library yourself, you should probably consider writing a wrapper. Doing this might make you more productive and the syntax of your library much better.<\/p>\n
All the examples provided in this blog post work in the just released <\/a>Visual Studio 2010 Beta 2<\/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 send an e-mail to the DLR team at dlr@microsoft.com<\/a>.<\/p>\n
Documentation for DynamicObject<\/strong><\/a> is also available on MSDN (check out our new MSDN design and don\u2019t forget to take a look at the lightweight view<\/a>.) In documentation, you can read about other useful methods of this class, such as TryBinaryOperation<\/a>, TryUnaryOperation<\/a>, TrySetIndex<\/a>, and TryGetIndex<\/a>. <\/p>\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
In the previous post I showed how you can use the new dynamic feature and the ExpandoObject class to add and remove properties at run time, and how this can make your code more readable and flexible than code written with LINQ to XML syntax. But there were some obvious flaws in that example: While […]<\/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,13],"class_list":["post-3003","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-visual-studio","tag-net-framework","tag-c","tag-node-js","tag-visual-studio-2010"],"acf":[],"blog_post_summary":"
In the previous post I showed how you can use the new dynamic feature and the ExpandoObject class to add and remove properties at run time, and how this can make your code more readable and flexible than code written with LINQ to XML syntax. But there were some obvious flaws in that example: While […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts\/3003","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=3003"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts\/3003\/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=3003"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/categories?post=3003"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/tags?post=3003"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
<\/a><\/p>\n
<\/a><\/a><\/p>\n
<\/a><\/p>\n
Let\u2019s see what\u2019s going on in this example. When you call obj.SampleProperty<\/font>, the dynamic language runtime<\/a> (DLR) uses the language binder to look for a static definition of this property in the SampleObject<\/b> class. If there is no such property, the DLR calls the TryGetMember<\/b> method. This method gets information about what property it was called for through the binder<\/font> parameter. As you can see, the binder.Name<\/font> contains the actual name of the property.<\/p>\n
<\/a><\/p>\n