Dynamic in C# 4.0: Introducing the ExpandoObject

Dynamic in C# 4.0: Introducing the ExpandoObject

Rate This
  • Comments 73

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 this new feature? What are the use cases? Where does dynamic dispatch work better than static typing?

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

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

Here’s a code example that I took from MSDN. (Yes, I am an MSDN writer myself, so I use MSDN a lot.)

XElement contactXML =
    new XElement("Contact",
        new XElement("Name", "Patrick Hines"),
        new XElement("Phone", "206-555-0144"),
        new XElement("Address",
            new XElement("Street1", "123 Main St"),
            new XElement("City", "Mercer Island"),
            new XElement("State", "WA"),
            new XElement("Postal", "68042")
        )
    );

Although LINQ to XML is a good technology and I really love it, those new XElement parts look a little bit annoying. This is how I can rewrite it by using ExpandoObject.

dynamic contact = new ExpandoObject();
contact.Name = "Patrick Hines";
contact.Phone = "206-555-0144";
contact.Address = new ExpandoObject();
contact.Address.Street = "123 Main St";
contact.Address.City = "Mercer Island";
contact.Address.State = "WA";
contact.Address.Postal = "68402";

Just note a couple of things. First, look at the declaration of contact.

dynamic contact = new ExpandoObject();

I didn’t write ExpandoObject contact = new ExpandoObject(), because if I did contact would be a statically-typed object of the ExpandoObject type. And of course, statically-typed variables cannot add members at run time. So I used the new dynamic keyword instead of a type declaration, and since ExpandoObject supports dynamic operations, the code works.

Second, notice that every time I needed a node to have subnodes, I simply created a new instance of ExpandoObject as a member of the contact object.

It looks like the ExpandoObject example has more code, but it’s actually easier to read. You can clearly see what subnodes each node contains, and you don’t need to deal with the parentheses and indentation. But the best part is how you can access the elements now.

This is the code you need to print the State field in LINQ to XML.

Console.WriteLine((string)contactXML.Element("Address").Element("State"));

And this is how it looks with ExpandoObject.

Console.WriteLine(contact.Address.State);

But what if you want to have several Contact nodes? Like in the following LINQ to XML example.

XElement contactsXML =
    new XElement("Contacts",
        new XElement("Contact",
            new XElement("Name", "Patrick Hines"),
            new XElement("Phone", "206-555-0144")
        ),
        new XElement("Contact",
            new XElement("Name", "Ellen Adams"),
            new XElement("Phone", "206-555-0155")
        )
    );

Just use a collection of dynamic objects.

dynamic contacts = new List<dynamic>();

contacts.Add(new ExpandoObject());
contacts[0].Name = "Patrick Hines";
contacts[0].Phone = "206-555-0144";

contacts.Add(new ExpandoObject());
contacts[1].Name = "Ellen Adams";
contacts[1].Phone = "206-555-0155";

Technically speaking, I could write dynamic contacts = new List<ExpandoObject>() 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 and not ExpandoObject, and these are two different types. (Once again, references to the ExpandoObject objects are statically-typed and do not support dynamic operations.)

Now, if you want to find all the names in your contact list, just iterate over the collection.

foreach (var c in contacts)
    Console.WriteLine(c.Name);

Again, this syntax is better than LINQ to XML version.

foreach (var c in contactsXML.Descendants("Name"))
    Console.WriteLine((string)c);

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’s find all the phone numbers for the specified name.

var phones = from c in (contacts as List<dynamic>)
             where c.Name == "Patrick Hines"
             select c.Phone;

True, the cast here doesn’t look like something strictly necessary. Certainly the compiler could have determined at run-time that contacts is List<dynamic>. But as I said, there is still some work to be done in this area.

Another thing to note is that this trick works only for the LINQ to Objects provider. To use dynamic objects in LINQ to SQL or other LINQ providers, you need to modify the providers themselves, and that’s a completely different story.

However, even with the cast, syntax is still better than in a LINQ to XML query.

var phonesXML = from c in contactsXML.Elements("Contact")
                where c.Element("Name").Value == "Patrick Hines"
                select c.Element("Phone").Value;

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.

contactsXML.Elements("Contact").Elements("Phone").Remove();

Since C# doesn’t have syntax for removing object members, you don’t have an elegant solution here. But ExpandoObject implements IDictionary<String, Object> to maintain its list of members, and you can delete a member by deleting a key-value pair.

foreach (var person in contacts)
    ((IDictionary<String, Object>)person).Remove("Phone");

There are other useful methods in LINQ to XML like Save() and Load(). For ExpandoObject you need to write such methods yourself, but probably only once. Here, casting to the IDictionary interface can help as well.

And although I’ve been comparing LINQ to XML and ExpandoObject in this post, these two approaches are not “rivals”. You can convert ExpandoObject to XElement and vice versa. For example, this is what the ExpandoObject to XElement conversion might look like.

private static XElement expandoToXML(dynamic node, String nodeName)
{
    XElement xmlNode = new XElement(nodeName);

    foreach (var property in (IDictionary<String, Object>)node)
    {

        if (property.Value.GetType() == typeof(ExpandoObject))
            xmlNode.Add(expandoToXML(property.Value, property.Key));

        else
            if (property.Value.GetType() == typeof(List<dynamic>))
                foreach (var element in (List<dynamic>)property.Value)
                    xmlNode.Add(expandoToXML(element, property.Key));
            else
                xmlNode.Add(new XElement(property.Key, property.Value));
    }
    return xmlNode;
}

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.

Of course, XML is not the only area where you can use ExpandoObject. If you heavily use reflection or work a lot with script objects, you can simplify your code with ExpandoObject. On the other hand, ExpandoObject is not the only useful class that the DLR provides. The DynamicObject 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’s a topic for another blog post.

One more thing to note is that libraries that look up members by name might someday adopt the DLR and implement the IDynamicMetaObjectProvider interface. (This interface actually provides all the “magic” – or dynamic dispatch – for ExpandoObject and the dynamic feature in general.) For example, if LINQ to XML implements this interface, you would be able to write dynamic contacts = new XmlElement() instead of dynamic contacts = new ExpandoObject() and perform the same operations that I have shown in the examples for the ExpandoObject type.

All the examples provided in this blog post work in Visual Studio 2010 Beta 1. 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. You can also write an e-mail to the DLR team at dlr@microsoft.com.

Update:

See how you can improve this example in my next post: Dynamic in C# 4.0: Creating Wrappers with DynamicObject.

Leave a Comment
  • Please add 6 and 8 and type the answer here:
  • Post
  • @sagi: Yes, its already there (technically) as long as ExpandoObject has a this[string index] field. IDictionary inherits from ICollection, so IDictionary classes must implement that.

  • Wow, this is going to make for a lot of heavy, unoptimised code. This is great for making C# a RAD language, like VB6, where one could simply turn off Option Explicit (if it was ever on in the first place) and throw variables into the mix on the fly. Great for prototyping, great for PoC, great for those little one-off apps & tools.

    The only thing concerning me is that that sort of "cavalier code" is probably going to make its way into low level layers/domains & backends in larger systems, because now it can do so fairly unannounced. Previously the blocker to this was the simple unsuitability of VB6, VBScript & JavaScript for services & class libraries, which forced anyone who seriously wanted to make a windows service or extended stored proc look at more strict languages.

    Still, that makes more work for us real coders to step in and optimise things that seem to be running surprisingly slow, or eating quite a lot of memory. And work means pay. So bring it on :)

  • Bravo Alexandra.!Ai articole super tari

  • Interesting use of the dynamic keyword, although I would advise against its usage.

    It's very hard to catch errors with this sort of coding style and its also a very lazy and sloppy way to code.

    Typos won't be picked up during compile time because you can just declare anything anywhere.

  • I find this kind of dynamic coding very interesting. I have a coment about the naming, though.

    Correct me if I am wrong, but I had the impression that the term "expando" was short for saying "expandable object", meaning an object that can be dynamically expanded/extended. That would mean that "ExpandoObject" would actually mean "ExpandableObjectObject", which makes no sense.

    I think it should be named either just "Expando" or "ExpandableObject"; I think the latter is clearer.

  • Vince: Another concern if you have the potential for sloppy programmers to "infect" a small and seemingly innocuous method in a large & complex back-end. A "fix" to a malfunctioning, if otherwise well-written method could be hastily rewritten with an ExpandoObject by someone with a lack of time or experience, and your typo could cause a property to go unread, passing "reasonably assuming" unit tests in a local class neighbourhood but having a seriously detrimental effect in another part of the system.

    Tools such as ReSharper would undoubtedly be invaluable, though their use would still be no guarantee of code cleanliness.

  • Simon,

    If you feel that this method is really necessary for ExpandoObject, you can post your suggestion at https://connect.microsoft.com/VisualStudio

    However, by "syntax for removing object members" I meant that some dynamic languages have special language keywords for deleting members. Someting like "delete sampleObject.SampleProperty". C# doesn't have such a syntax.

  • This week on Channel 9, Dan and Brian reunite to go through the week's top developer news including:

    C# FAQ - Using the ExpandoObject with Dynamic C#

    http://channel9.msdn.com/shows/this+week+on+channel+9/twc9-sql-azure-mvc-2-new-channel-9-content/

  • This is great...

    As the ExpandoObject is doing this dynamic stuff by implementing  the IDictionary interface, so all of the dynamically added properties - and methods as well-  will just belong to THIS object.

    so I wonder if there is any workaround to add these to the declaring type itself, i.e any instance of type ExpandoObject will have this dynamically added method

    This would be very useful for methods, just like we do in JavaScript using the prototype

  • This must be a grand microsoft joke, really what a waste of my time.  Since something is not easily made type safe at compile time we just fake it?  lol.

  • Anwer,

    I think DynamicObject can help you here. This is another class from System.Dynamic namespace. With DynamicObject you can define what actually happens when you call a method or a property of an object. I am planning a blog post about DynamicObject and I hope it will answer a lot of questions asked here.

  • Anwer, I'd be curious if Extentions would help you here:

    namespace ExpandoObjectExtentions

    {

    public static class ExpandoObjectExtentions

    {

    public static void MyGlobalExpandoMethod(this ExpandoObject eo, string a)

    {

    Console.WriteLine("Called MyGlobalExpandoMethod. {0}",a);

    }

    }

    }

    -----------------------------------------------------------------

    using ExpandoObjectExtentions;

    dynamic d = new ExpandoObject();

    d.MyGlobalExpandoMethod("Hi");

  • Why do you believe this is difficult to read?

    myObject.GetProperty("Address")

    I feel that the exapander implementation of the above is deceiving.  The exapander may make the code look prettier (more readable), but in terms of maintainability (where readability is imporatant), I woulld perfer the GetProperty route.  

    With GetProperty, developers know by looking at the source code what properties myObject really exposes.  This is important so the dev can glance at the code and get a feel for where their breaking points are, and perform bounds/null checking/handling rather than assuming b/c its a prop that it will always exist.

  • Can I use a syntax like:

    dynamic contact = new ExpandoObject

    {

    Name = "Bethoven",

    Phone = "123-356-7899",

    Address = new ExpandoObject

    {

    Street = "123 Main St",

    City = "Redmond",

    State = "WA",

    ...

    }

    }

  • @ Eric

    It might be not that difficult if you are getting or setting a single property. But in case of hierarchical objects that operate with both numerical and textual data... Or, for example, how about this one?

    Scriptobj.PropeSetProperty("Count", ((int)GetProperty("Count")) + 1);

    Isn't this one look much easier to read?

    scriptobj.Count += 1;

    @George

    No, this syntax is used for anonymous types.  

    var contact = new { Name = "Patrick", Address = new { City = "Redmond" } };

    The difference is that in this case we actually create a static type, only this type has no name. With ExpandoObject, we in fact don't create any properties. We simply "overload" operations that get and set properties and make them search in a dictionary instead of a static type definition. Both approaches have their own pros and cons.

Page 2 of 5 (73 items) 12345