ExpandoObject: add dynamic properties through type initializer

[ghost]

If there's still a significant importance of the ExpandoObject after ValueTuple syntax added to C#, I suggest to enhance ExpandoObject like this:

1. allow add dynamic properties thought type initializer like this:

dynamic T = new ExpandoObject( ){x = 1, y = 2, z = new ExpandoObject( ) { a = 3, b = 4} };

This is much better than:

dynamic T = new ExpandoObject();
T.x = 1;
T.y = 2;
T.z = new ExpandoObject();
T.z.a = 3;
T.b= 4;

2. Infer property type from initial value. Being a dynamic object doesn't mean all its properties must be objects.
3. As many others asked, Make Intilisense detect added properties and display them in auto completion list.

[HaloFour]

The C# compiler currently doesn't know anything about the ExpandoObject class. It just happens to be a type in the BCL that implements the IDynamicMetaObjectProvider interface that allows it to support custom dynamic binding. To the compiler the ExpandoObject is pretty opaque and it doesn't offer any of the required members that would allow object or collection initializers to work. You could hack it by doing the following:

public static class ExpandoObjectExtensions {
    public static void Add(this ExpandoObject target, string key, Object value) {
        dynamic d = target;
        d[key] = value;
    }
}

which would enable:

 var ex = new ExpandoObject() {
    { "a", "foo" },
    { "b", "bar" }
};

Maybe the compiler could consider the target type of the expression as dynamic and enable object/collection initializers?

I'd make separate proposals for the other ideas. Check out #1116 which I think is pretty relevant.

[ghost]

@HaloFour
I see it's C# relevant. C# compiler can convert type initializer syntax to the normal syntax when it produces IL code. C# code doen't talk to BCL directly, so you can make the imposible posible in this two step translation!

[ghost]

For examole: This is the way Tuples work. ValueTuple Class only have Item1, Item2, Item3... properties. C# converts elemnt names to these properties when it produces IL code. The side effect is that Tuple loose element names through reflection and dynamics. For this I would suggest that C# should produce new fields with the elemnt names inside a new struct inherited from ValueTuple Class. I think this would solve this problem. If this is not a proposal already!

[svick]

Infer property type from initial value. Being a dynamic object doesn't mean all its properties must be objects.

Changing ExpandoObject to do this would be a breaking change. Creating a new type that does this is something you can do yourself. The starting point could look something like this:

public class InferedExpandoObject : DynamicObject
{
    Dictionary<string, (Type t, object v)> values = new Dictionary<string, (Type, object)>();
    
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        bool found = values.TryGetValue(binder.Name, out var tuple);
        result = tuple.v;
        return found;
    }
    
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        // TODO: handle null value
        if (value == null)
            throw new NotImplementedException();
            
        Type newType;
    
        if (values.TryGetValue(binder.Name, out var tuple))
        {
            if (!tuple.t.IsAssignableFrom(value.GetType()))
                throw new InvalidOperationException();
                
            newType = tuple.t;
        }
        else
        {
            newType = value.GetType();
        }
        
        values[binder.Name] = (newType, value);
        
        return true;
    }
}

If you think such a type would be widely useful, then you should create a proposal about it in the corefx repo, since those types are part of the framework, they're not part of the language.

[HaloFour]

@MohammadHamdyGhanem

C# compiler can convert type initializer syntax to the normal syntax when it produces IL code.

The problem is that the C# compiler applies the initializers to a temporary variable of the type of the new class, as follows:

dynamic d = new ExpandoObject() { a = "a", b = "b" };

// which translates to

ExpandoObject temp = new ExpandoObject();
temp.a = "a";
temp.b = "b";
dynamic d = temp;

This is why it doesn't work. Initializers don't consider the type of the target, but I'm suggesting that maybe the compiler could in the case of a dynamic target.

For this I would suggest that C# shiuld produce new fields with the elemnt names inside a new struct inherited from ValueTuple Class.

That would be a separate proposal. It would also be impossible because structs cannot be inherited. The approach of creating a new tuple struct was suggested but the team wanted assembly unification and for the names to be ephemeral, so we ended up with the result of that decision.

@svick

If the goal is to enable object initializer syntax with objects intended to be used with dynamic then I do think that it falls into a language proposal. Your InferedExpandoObject suffers the same problem; you can't create it with an object initializer intended to assign "dynamic" properties. At best you could create such an object that has an indexer by string and treat it like JSON:

dynamic e = new IndexableExpandoObject() {
    ["a"] = "foo",
    ["b"] = "bar"
};

[ghost]

@svick
The easier way is to store properties in a dictionary like this
Dictionary <Type, Dictionary<string, object>>
This of course needs to rewrite the ExpandoObject Class!

[HaloFour]

To throw some random syntax spaghetti against the wall, how about the dynamic contextual keyword between the new keyword and the type being instantiated to tell the compiler to treat any initialization as dynamic and for the result of the expression to be dynamic as well?

var d = new dynamic ExpandoObject() {
    a = "foo",
    ["b"] = "bar"
};

// translates to
dynamic d = new ExpandoObject();
d.a = "foo";
d["b"] = "bar";

Although I can't honestly imagine that this comes up often.

[ghost]

@HaloFour
Another solution, is to add a dictionry to the ValueTuple Class and add elemnt names to it. Reflections and dynamics can use this dictionry to retrieve the names.

[yaakov-h]

What are you actually trying to achieve?

This sounds like you're programming a bunch of goop.

[svick]

@HaloFour

If the goal is to enable object initializer syntax with objects intended to be used with dynamic then I do think that it falls into a language proposal.

Yes. I was specifically talking about point 2 of the original proposal, which I think belongs to corefx. Point 1 does belong here. (And point 3 belongs to the roslyn repo, since that's not the language, just IntelliSense.)

[ghost]

@yaakov-h
I publish Arabic books about C# and VB.NET. Now I'm updating these books to 2017 version, so I have to write many small samples that cover new topics, and make notes and warnings about their usage. You can say: this is my complain and suggest season.
(I know dynamics are an old topic but I didn't cover it in my books before. I looked back to them to becuase of Tuples).

[ghost]

I will go now to complain about invoking ExpandoObject dynamic delegates in VB.NET. It reguires the Invoke method unlike C#!.. This is a rare situation where C# syntax wins!

[ghost]

By the way. I want to suggest to change the Controller.ViewBag property In ASP.NET. I think in will be easier and more efficient to declare it as a ValueTuple instead of ExpandoObject. The code will be sorter and strong typed and we will have intilisense support in razor. Or Create a new bag property of such kind, not to miss with old projects.
If it is worthy, Where can I send this proposal?

[yaakov-h]

If you want strong typing, use a strongly typed model with @model...

[ghost]

May be this proposal give a solution:
#1226
Typed Dictionary have a ToExpandoObject method.