{"id":953,"date":"2010-01-20T15:07:00","date_gmt":"2010-01-20T15:07:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2010\/01\/20\/fun-with-dynamic-objects-doug-rothaus\/"},"modified":"2024-07-05T12:42:03","modified_gmt":"2024-07-05T19:42:03","slug":"fun-with-dynamic-objects-doug-rothaus","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/fun-with-dynamic-objects-doug-rothaus\/","title":{"rendered":"Fun With Dynamic Objects (Doug Rothaus)"},"content":{"rendered":"

\n

A<\/font><\/p>\n

while back, I remember being asked if there was a simple way to expose a source XML document as an object with properties. That is, if the root XML element had a child element <\/font><Name>Doug<\/Name><\/span>, then the object would have a <\/font>Name<\/span> property that was a string and returned “Doug”. The catch was that the XML document did not conform to a specific schema. Hence, you could not simply create an object with a <\/font>Name<\/span> property, because you did not know if the source document had a <\/font><Name><\/span> element. While there are ways to expose the XML data dynamically, you couldn’t quite do what was being asked.<\/font><\/p>\n

Enter dynamic objects in Visual Basic 2010. Now, this is possible. This means that you can use the classes in the System.Dynamic<\/b> namespace to create objects that expose properties and methods dynamically at run-time and solve the original problem. In this example, we will create an object that inherits the System.Dynamic.DynamicObject<\/b> class. The DynamicObject<\/b> class has methods that you can override to provide code specific to your implementation. When VB performs a late-bound request on an object that implements the DynamicObject<\/b> class, it calls one of the methods of the DynamicObject<\/b> class to obtain the result. Consider this simple example:<\/font><\/p>\n

Imports<\/span> System.Dynamic<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Public<\/span> Class<\/span> SimpleObject<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Inherits<\/span> DynamicObject<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>Public<\/span> Overrides<\/span> Function<\/span> TryGetMember(ByVal<\/span> binder As<\/span> GetMemberBinder<\/span>, <\/p>\n

<\/span><\/p>\n

                                           <\/span>ByRef<\/span> result As<\/span> Object<\/span>) As<\/span> Boolean<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

        <\/span>If<\/span> binder.Name = “Address”<\/span> Then<\/span><\/p>\n

<\/span><\/p>\n

            <\/span>result = “Value”<\/span><\/p>\n

<\/span><\/p>\n

            <\/span>Return<\/span> True<\/span><\/p>\n

<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

        <\/span>Return<\/span> False<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>End<\/span> Function<\/span><\/p>\n

<\/span><\/p>\n

End<\/span> Class<\/p>\n

<\/span><\/span><\/p>\n

<\/span> <\/p>\n

Now consider this code that creates an instance of the object and accesses properties of that instance.<\/font><\/p>\n

Module<\/span> Module1<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>Sub<\/span> Main()<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

        <\/span>Dim<\/span> t As<\/span> Object<\/span> = New<\/span> SimpleObject<\/span>()<\/p>\n

<\/span><\/p>\n

        <\/span>Console<\/span>.WriteLine(t.Address)<\/p>\n

<\/span><\/p>\n

        <\/span>Console<\/span>.WriteLine(t.Street)<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

End<\/span> Module<\/p>\n

<\/span><\/span><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

First, in order to ensure that requests made of the dynamic object are late-bound, we need to type the variable as Object<\/b>. Then we make two late-bound requests for object properties: <\/font>Address<\/span> and <\/font>Street<\/span>. When you access the <\/font>Address<\/span> property, a call is made to the TryGetMember<\/b> method of the DynamicObject<\/b> class, which we have overridden. The GetMemberBinder<\/b> object instance that is passed to our TryGetMember<\/b> method contains the name of the requested member in its Name<\/b> property. Our small sample matches that name and returns the string “Value”. When you access the <\/font>Street<\/span> property, a call is made to the TryGetMember<\/b> method, the name does not match anything that our code supports, so the method returns False<\/b>. False<\/b> indicates an unsupported member, and an exception is thrown. <\/font><\/p>\n

To solve our initial problem of “hiding” source XML and exposing an object instead, we can use the DynamicObject<\/b> class in this same fashion. When a property is requested of our dynamic object, our code can search the XML source for a matching XML element name, and return the corresponding value as the property value. Let’s look at an example.<\/font><\/p>\n

DynamicXmlObject example<\/font><\/h2>\n

Let’s jump into the code and we’ll talk about how the object behaves as we go. We start with a class that inherits DynamicObject<\/b>. Let’s name it <\/font>DynamicXmlObject<\/span>.<\/font><\/p>\n

Imports<\/span> System.Dynamic<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Public<\/span> Class<\/span> DynamicXmlObject<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Inherits<\/span> DynamicObject<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

End<\/span> Class<\/p>\n

<\/span><\/span><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Constructors<\/font><\/h3>\n

We will add two constructors for the class. One that takes a path to an XML file as the source, and another that takes an XElement<\/b>.  <\/span>The constructor that takes an XElement<\/b> is not just for user convenience. We’ll use this later when dealing with child elements that have attributes or children. Also for this class, we won’t expose a settable property for the source XML, so we’ll “disable” the empty constructor by making it Protected<\/b>.<\/font><\/p>\n

Imports<\/span> System.Dynamic<\/p>\n

<\/span><\/p>\n

Imports<\/span> System.IO<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Public<\/span> Class<\/span> DynamicXmlObject<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Inherits<\/span> DynamicObject<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>‘ The source XML for this instance.<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Private<\/span> p_Xml As<\/span> XElement<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>‘ Create a new DynamicXmlObject with the specified source file.<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Public<\/span> Sub<\/span> New<\/span>(ByVal<\/span> filePath As<\/span> String<\/span>)<\/p>\n

<\/span><\/p>\n

        <\/span>If<\/span> Not<\/span> File<\/span>.Exists(filePath) Then<\/span><\/p>\n

<\/span><\/p>\n

            <\/span>Throw<\/span> New<\/span> Exception<\/span>(“File does not exist.”<\/span>)<\/p>\n

<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

        <\/span>p_Xml = XElement<\/span>.Load(filePath)<\/p>\n

<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>‘ Create a new DynamicXmlObject with the specified source XElement.<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Public<\/span> Sub<\/span> New<\/span>(ByVal<\/span> xml As<\/span> XElement<\/span>)<\/p>\n

<\/span><\/p>\n

        <\/span>p_Xml = xml<\/p>\n

<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>‘ Disable the empty constructor.<\/span><\/p>\n

<\/span><\/p>\n

    <\/span>Protected<\/span> Sub<\/span> New<\/span>()<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

End<\/span> Class<\/p>\n

<\/span><\/span><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Implementing GetDynamicMemberNames<\/font><\/h3>\n

This next piece of code is optional. I’ve added it so that our object supports reflection-like functionality.  <\/span>You can expose the member names of your dynamic object using the GetDynamicMemberNames<\/b> method of the DynamicObject<\/b> class. Our sample object will return all of the child element names and attribute names of the current element. I’ve added a case-insensitive Distinct<\/b> comparison so that only a single name is returned if multiple entries are found. The search looks at only the LocalName<\/b> property of the XName<\/b> for an element or attribute. XML namespaces are ignored. That is, <\/font><a:Name><\/span> and <\/font><b:Name><\/span> are considered to be duplicate element names.<\/font><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>Public<\/span> Overrides<\/span> Function<\/span> GetDynamicMemberNames() As<\/span> IEnumerable<\/span>(Of<\/span> String<\/span>)<\/p>\n

<\/span><\/p>\n

        <\/span>Dim<\/span> names = (From<\/span> e In<\/span> p_Xml.Elements() Select<\/span> e.Name.LocalName).Union(<\/p>\n

<\/span><\/p>\n

                     <\/span>From<\/span> a In<\/span> p_Xml.Attributes() Select<\/span> a.Name.LocalName)<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

        <\/span>Return<\/span> (From<\/span> n In<\/span> names <\/p>\n

<\/span><\/p>\n

             &nbsp<\/span><\/span><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

A while back, I remember being asked if there was a simple way to expose a source XML document as an object with properties. That is, if the root XML element had a child element <Name>Doug<\/Name>, then the object would have a Name property that was a string and returned “Doug”. The catch was that […]<\/p>\n","protected":false},"author":260,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[195],"tags":[59,167,185],"class_list":["post-953","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-visual-basic","tag-doug-rothaus","tag-vb2010","tag-xml"],"acf":[],"blog_post_summary":"

A while back, I remember being asked if there was a simple way to expose a source XML document as an object with properties. That is, if the root XML element had a child element <Name>Doug<\/Name>, then the object would have a Name property that was a string and returned “Doug”. The catch was that […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/953","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/260"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=953"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/953\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=953"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=953"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=953"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}