Make checking properties on ExpandoObject or dynamic variables easier

[Nefcanto]

Consider this code:

dynamic person = new ExpandoObject();
var name = person.Name;

It throws this exception:

Unhandled exception. Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: 'System.Dynamic.ExpandoObject' does not contain a definition for 'Name'

So, this means that when we want to access a dynamic variable's property, we should first check for its existence.

That check is hard. Make it easier. Something like:

var name = person.Name ?? "default name"; // does not work

or

var name = has(person, "Name") ? person.Name : "default name"; // the has global function does not exist

or

var name = person.Get("Name", "default value"); // does not exist yet

[kyoyama-kazusa]

If you want to configure checking rules on dynamic objects, just make an object derive from DynamicObject.

Example (Just an example, I don't use ExpandoObject 😆)

using System;
using System.Dynamic;

dynamic d = new ResourceDictionary("ResourceFile");
Console.WriteLine((string)d.Name); // "real value"
Console.WriteLine((string)d.UnknownPropertyName); // "default value"


class ResourceDictionary(string _resourceDictionaryName) : DynamicObject
{
    public override bool TryGetMember(GetMemberBinder binder, out object? result)
    {
        if (binder.Name == "Name")
        {
            result = "real value";
            return true;
        }

        result = "default value";
        return true; // false is for failure on binding properties.
    }
}

[Nefcanto]

@SunnieShine, that's exactly why I said easier. We do have a lot of code in place. A lot of extension methods to work with ExpandoObject. For example we do have this class in our code:

public static class ExpandoObjectExtensions
{
    public static string Serialize(this ExpandoObject expandoObject)
    {
        var json = ((object)expandoObject).Serialize();
        return json;
    }

    public static T To<T>(this ExpandoObject expandoObject) where T : class, new()
    {
        var result = new T();
        IDictionary<string, object> expando = (IDictionary<string, object>)expandoObject;
        var properties = result.GetType().GetProperties();
        foreach (var property in properties)
        {
            if (expando.ContainsKey(property.Name))
            {
                property.SetValue(result, expando[property.Name]);
            }
        }
        return result;
    }

    public static dynamic CopyProperties(this ExpandoObject source, ExpandoObject target)
    {
        IDictionary<string, object> expando = (IDictionary<string, object>)source;
        foreach (var item in expando)
        {
            target.AddProperty(item.Key, item.Value);
        }
        return target;
    }

    public static object GetProperty(this ExpandoObject expandoObject, string propertyName)
    {
        var dictionary = expandoObject as IDictionary<string, object>;
        if (dictionary.ContainsKey(propertyName))
        {
            return dictionary[propertyName];
        }
        throw new ServerException($"ExpandoObject {expandoObject.GetType().FullName} does not have property {propertyName}");
    }

    public static ExpandoObject AddProperty(this ExpandoObject expandoObject, string propertyName, object propertyValue)
    {
        var dictionary = expandoObject as IDictionary<string, object>;
        if (dictionary.ContainsKey(propertyName))
        {
            dictionary[propertyName] = propertyValue;
        }
        else
        {
            dictionary.Add(propertyName, propertyValue);
        }
        return dictionary as ExpandoObject;
    }

    public static bool Has(this ExpandoObject expandoObject, string propertyName)
    {
        var dictionary = expandoObject as IDictionary<string, object>;
        if (dictionary.ContainsKey(propertyName))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public static ExpandoObject Remove(this ExpandoObject expandoObject, string field)
    {
        IDictionary<string, object> expando = (IDictionary<string, object>)expandoObject;
        expando.Remove(field);
        return expando as ExpandoObject;
    }

    public static void Log(this ExpandoObject expandoObject)
    {
        IDictionary<string, object> dictionary = expandoObject;
        foreach (var key in dictionary.Keys)
        {
            var value = dictionary[key] ?? "";
            Logger.LogInfo($"{key}: {value.ToString()}");
        }
    }
}

But I don't want to repeat that TryGetMember in any class that inherits from the DynamicObject. And in fact, I don't inherit here. I just create a dynamic variable using the dynamic something = new ExpandoObject().

Your answer is not easy.

This is easy:

dynamic person = new ExpandoObject();
var name = person.Name ?? "";

[KennethHoff]

It sounds like you're creating an architecture for a dynamic app inside a statically typed language, no wonder you have a bad time with it. I recommend either migrating immediately to a language more suited for your developers, or look into how to architecture your solutions in a more C#-friendly way.

There are definitely language-level difficulties with composition in C#, but it's perfectly suitable for creating complex systems - if designed correctly.

[Nefcanto]

@KennethHoff, the point is, systems need dynamic support when they grow. Dynamic LINQ is a good example. When you have a small system with 10 tables you can manage to repeat code for queries. When it becomes 500 tables, then it's not feasible anymore. You should make part of your system dynamic. For example the pagination which is a cross-cutting concern. You want to create a query, and then apply the pagination to return only a subset of data. Or you want to create a dynamic filtering and apply it dynamically on your LINQ queries. Right there C# breaks. Yes it has expression trees, but good luck understanding them and managing code written in them and leading a team for it. Even in React we need to make a lot of parts dynamic.

[KennethHoff]

I'm sure there's context I'm missing, but to me that sounds like the job of interfaces and generics.

[CyrusNajmabadi]

@KennethHoff, because C# sucks when it comes to creating complex systems.

There are many many thousands of companies successfully using c# for complex systems. It definitely doesn't suck for that task.

[CyrusNajmabadi]

For example the pagination which is a cross-cutting concern. You want to create a query, and then apply the pagination to return only a subset of data.

Why do you need dynamic for that?

Right there C# breaks. Yes it has expression trees, but good luck understanding them and managing code written in them and leading a team for it.

No clue why this would be a problem. ExprTrees have been around, and well understood, in c# since 3.0

Both of these areas seem like a place where you can just use EF.

[Nefcanto]

@SunnieShine, I think working with dynamic variables should become as easy as JavaScript. Because that's what it is. It's not strongly typed. We choose it for simplicity. We lose all benefits of strong typing, for the sake of simplicity. But it's syntax is not easy yet.

This is what I think we can consider easy:

dynamic person = new ExpandoObject();
person.Name = "somebody"; // statically assign properties; works;
person["SomeOtherProperty"] = "another value"; // dynamically assign properties; does not work;
var age = person.Age; // does not work; because person object does not have Age property; But we can return null here;
person.Name.Pascalize(); // calling extension methods on properties does not work; it should work; dynamic typing of the property is known;

This can be considered easy syntax.

[HaloFour]

Not that it matters much anymore, but dynamic/DLR wasn't really added to make C# a dynamic language, it was added to make it easier to bridge C# with other dynamic languages hosted on the .NET runtime. At this point there isn't really any investment in this space anymore, and the binder provided by C# hasn't been keeping up with other language capabilities. I don't think there is any interest in making C# feel like Javascript.

[CyrusNajmabadi]

In particular, regarding this point:

whether consciously and by choice, or unconsciously via good patterns that exist in JS.

We are not aping js. In particular, we do not want to take their dictionary syntax.

[Nefcanto]

In that case we can argue that:

• simplicity is the truth
• truthful technologies move towards it
• truthful technologies resemble each other

and we might argue that simplicity objectively means:

• less indentation (top-level statements)
• less biolerplate (omitting new string() {})
• more centralization (global using)
• more composability (interface default members)
• less verbosity (spread syntax)
• etc.

Any language following the truth finds ways to implement these values. Thus it might seem that they are following each other.

[yaakov-h]

Simplicity is subjective.

[Nefcanto]

@yaakov-h massive subjectivity represents objectivity.

Beauty is subjective. It's in the eyes of the beholder. But when 7 billion people consider an actress to be beautiful in their subjective minds, that represents something objective.

[CyrusNajmabadi]

@Nefcanto this digression doesn't seem to be adding much value.

People have different views around simplicity. 'go' is lauded for its simplicity, yet it takes a very different stance on most features versus what we choose here.

[TahirAhmadov]

The statement "complex systems are only possible with dynamic programming" is exactly the opposite of the truth. Static compilation reduces the number of bugs by orders of magnitude, and together with everything C# had to offer, like analyzers and tools, and following best practices, allows the creation of high quality code of any complexity.

My advice would be to engage the services of a consultant to assess the situation in detail and create a road map to eliminate dynamic code from your product line. I may be available ;)