Proposal: Typed dynamics

[deniszykov]

Brief
Allow to specify expected type for dynamic types to IDE support (suggestions, syntax highlight) and improve performance in some cases.

Motivation
After RIP'ing remoting infrastructure in .NET Core DLR and dynamic remained the only mechanism for implementing transparent proxies to objects. Current DynamicObject features are enough to replace the RealProxy in the field, but lacking of suggestions from IDE during development somehow frustrating.

Suggestion
Allow to specify expected type for 'dynamic' types like this dynamic<T>. This will not change how dynamic is treated by compiler/runtime and would produce same IL as before except new metadata (DynamicTypeAttribute or so...).
Also when some member is invoked InvokeMemberBinder should provide suggested MemberInfo which member is invoked on expected type. This is only hint for some one who implementing IDynamicMetaObjectProvider but potentially could lead to performance boost if right type is hit (by omitting whole "binding" part). Same for other binders.

Type of dynamic should be propagated after invocations:

dynamic<string> str;
var index = str.IndexOf('a');
// index is dynamic<int>

And erased where ambiguity is involved.

Generics should be supported too, because creating a proxy almost always involve a generic method:

class Remoting
{
    public dynamic<T> Connect<T>(string address); 
}

var myRemoteService = Remoting.Connect<Service>("/service");

Breaking changes
None as I see.

Alternatives
a) Custom post-processing IL or source code for "proxy" types:

var myRemoteService = Proxy.Create<Service>();
myRemoteService.Call();

 // will be re-writed to 

var myRemoteService = new DynamicObject();
var newInvokeMember = new InvokeMemberBinder("Call", ...);
myRemoteService.BindInvokeMember(newInvokeMember, ...);

b) Dynamic proxies with overridden members like NHIbernate proxies.

[jnm2]

See #1116, and #284 and #969 linked thanks to svick.

[deniszykov]

Thanks for links. #969 and #284 looks like mine but lacking of motivation/explanation.
#1116 a little different concept.

[BhaaLseN]

.NET Core has DispatchProxy by the way if all you want is intercept calls like RealProxy does on .NET Framework (while neither are part of .NET Standard, unfortunately).

[deniszykov]

Thanks for suggestion @BhaaLseN! It looks like DispatchProxy is just another dynamically generated proxy implementation. It is support only interface types and can't intercept non-virtual calls like GetType(). Not exactly like RealProxy.

[douglasg14b]

Would this apply to a MyGenericType<T1,T2> where the generics are sorted out at runtime?

Thus far I've had to rely on dynamic, but it would be beyond helpful to have intellisense on the methods that MyGenericType has, and what their arguments are. Sans the generic types.

[deniszykov]

If you mean open generic type like dynamic<MyGenericType<,>>, I have no idea how it should be threated by intellisense and binding-wise.
If it is generic type closed on scoped generic argument (from containing method or type) then sure, why not.

void Foo<T1,T2>()
{
    dynamic<MyGenericType<T1,T2>> x = ... ;
    x.Bar();
}