public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
{
// First try COM binding.
if (ComBinder.TryBindInvokeMember(this, target, args, out var result))
{
return(result);
}
// Defer if any object has no value so that we evaluate their Expressions and nest a
// CallSite for the InvokeMember.
if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[args.Length + 1];
deferArgs[0] = target;
args.CopyTo(deferArgs.AsSpan(1));
return(Defer(deferArgs));
}
// Find our own binding. Could consider allowing invoking static members from an instance.
var members = target.LimitType.GetMember(Name, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);
if (members.Length == 1 && (members[0] is PropertyInfo || members[0] is FieldInfo))
{
// NEED TO TEST, should check for delegate value too
// var mem = members[0];
throw new NotImplementedException();
//return new DynamicMetaObject(
// Expression.Dynamic(
// new SymplInvokeBinder(new CallInfo(args.Length)),
// typeof(object),
// args.Select(a => a.Expression).AddFirst(
// Expression.MakeMemberAccess(this.Expression, mem)));
// Don't test for eventinfos since we do nothing with them now.
}
else
{
// Get MethodInfos with param types that work for args. This works except for value
// args that need to pass to reftype params. We could detect that to be smarter and
// then explicitly StrongBox the args.
var res = Array.FindAll(members, meth => meth is MethodInfo m && m.GetParameters().Length == args.Length && RuntimeHelpers.ParametersMatchArguments(m.GetParameters(), args));
// False below means generate a type restriction on the MO. We are looking at the
// members targetMO's Type.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(target, args, false);
if (res.Length == 0)
{
return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, restrictions,
typeof(MissingMemberException), $"Can't bind member invoke -- {args}"));
}
// restrictions and conversion must be done consistently.
var callArgs = RuntimeHelpers.ConvertArguments(args, ((MethodInfo)res[0]).GetParameters());
return(new DynamicMetaObject(RuntimeHelpers.EnsureObjectResult(Expression.Call(Expression.Convert(target.Expression, target.LimitType), (MethodInfo)res[0], callArgs)), restrictions));
// Could hve tried just letting expression.Call factory do the work, but if there is more
// than one applicable method using just assignablefrom, expression.Call throws. It does
// not pick a "most applicable" method or any method.
}
}
public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
{
// Defer if any object has no value so that we evaluate their Expressions and nest a
// CallSite for the InvokeMember.
if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[args.Length + 1];
deferArgs[0] = target;
args.CopyTo(deferArgs.AsSpan(1));
return(Defer(deferArgs));
}
// Make sure target actually contains a Type.
if (!typeof(Type).IsAssignableFrom(target.LimitType))
{
return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, BindingRestrictions.Empty,
typeof(InvalidOperationException),
$"Type object must be used when creating instance -- {args}"));
}
var type = target.Value as Type;
Debug.Assert(type is not null);
var constructors = type.GetConstructors();
// Get constructors with right arg counts.
var res = Array.FindAll(constructors, c => c.GetParameters().Length == args.Length && RuntimeHelpers.ParametersMatchArguments(c.GetParameters(), args));
// We generate an instance restriction on the target since it is a Type and the
// constructor is associate with the actual Type instance.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(target, args, true);
if (res.Length == 0)
{
return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, restrictions,
typeof(MissingMemberException),
$"Can't bind create instance -- {args}"));
}
var ctorArgs = RuntimeHelpers.ConvertArguments(args, res[0].GetParameters());
return(new DynamicMetaObject(
// Creating an object, so don't need EnsureObjectResult.
Expression.New(res[0], ctorArgs), restrictions));
}
public override DynamicMetaObject FallbackGetIndex(
DynamicMetaObject target, DynamicMetaObject[] indexes,
DynamicMetaObject errorSuggestion)
{
#if !SILVERLIGHT
// First try COM binding.
DynamicMetaObject result;
if (ComBinder.TryBindGetIndex(this, target, indexes, out result))
{
return(result);
}
#endif
// Defer if any object has no value so that we evaulate their
// Expressions and nest a CallSite for the InvokeMember.
if (!target.HasValue || indexes.Any((a) => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[indexes.Length + 1];
for (int i = 0; i < indexes.Length; i++)
{
deferArgs[i + 1] = indexes[i];
}
deferArgs[0] = target;
return(Defer(deferArgs));
}
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
target, indexes, false);
if (target.HasValue && target.Value == null)
{
return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target,
indexes,
restrictions,
typeof(NullReferenceException),
"Object reference not set to an instance of an object."));
}
var indexingExpr = RuntimeHelpers.EnsureObjectResult(
RuntimeHelpers.GetIndexingExpression(target,
indexes));
return(new DynamicMetaObject(indexingExpr, restrictions));
}
public override DynamicMetaObject FallbackGetIndex(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
{
// First try COM binding.
if (ComBinder.TryBindGetIndex(this, target, args, out var result))
{
return(result);
}
// Defer if any object has no value so that we evaulate their Expressions and nest a
// CallSite for the InvokeMember.
if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[args.Length + 1];
deferArgs[0] = target;
args.CopyTo(deferArgs.AsSpan(1));
return(Defer(deferArgs));
}
// Give good error for Cons.
if (target.LimitType == typeof(Cons))
{
if (args.Length != 1)
{
return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, BindingRestrictions.Empty,
typeof(InvalidOperationException),
$"Indexing list takes single index. Got {args.Length}"));
}
}
// Find our own binding.
// Conversions created in GetIndexExpression must be consistent with restrictions made in GetTargetArgsRestrictions.
var indexingExpr = RuntimeHelpers.EnsureObjectResult(RuntimeHelpers.GetIndexingExpression(target, args));
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(target, args, false);
return(new DynamicMetaObject(indexingExpr, restrictions));
}
public override DynamicMetaObject BindCreateInstance(
CreateInstanceBinder binder, DynamicMetaObject[] args)
{
var constructors = ReflType.GetConstructors();
var ctors = constructors.
Where(c => c.GetParameters().Length == args.Length);
List <ConstructorInfo> res = new List <ConstructorInfo>();
foreach (var c in ctors)
{
if (RuntimeHelpers.ParametersMatchArguments(c.GetParameters(),
args))
{
res.Add(c);
}
}
if (res.Count == 0)
{
// Binders won't know what to do with TypeModels, so pass the
// RuntimeType they represent. The binder might not be Sympl's.
return(binder.FallbackCreateInstance(
RuntimeHelpers.GetRuntimeTypeMoFromModel(this),
args));
}
// For create instance of a TypeModel, we can create a instance
// restriction on the MO, hence the true arg.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
this, args, true);
var ctorArgs =
RuntimeHelpers.ConvertArguments(
args, res[0].GetParameters());
return(new DynamicMetaObject(
// Creating an object, so don't need EnsureObjectResult.
Expression.New(res[0], ctorArgs),
restrictions));
}
// Because we don't ComboBind over several MOs and operations, and no one
// is falling back to this function with MOs that have no values, we
// don't need to check HasValue. If we did check, and HasValue == False,
// then would defer to new InvokeMemberBinder.Defer().
//
public override DynamicMetaObject BindInvokeMember(
InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var flags = BindingFlags.IgnoreCase | BindingFlags.Static |
BindingFlags.Public;
var members = ReflType.GetMember(binder.Name, flags);
if ((members.Length == 1) && (members[0] is PropertyInfo ||
members[0] is FieldInfo))
{
// NEED TO TEST, should check for delegate value too
var mem = members[0];
throw new NotImplementedException();
//return new DynamicMetaObject(
// Expression.Dynamic(
// new SymplInvokeBinder(new CallInfo(args.Length)),
// typeof(object),
// args.Select(a => a.Expression).AddFirst(
// Expression.MakeMemberAccess(this.Expression, mem)));
// Don't test for eventinfos since we do nothing with them now.
}
else
{
// Get MethodInfos with right arg counts.
var mi_mems = members.
Select(m => m as MethodInfo).
Where(m => m is MethodInfo &&
((MethodInfo)m).GetParameters().Length ==
args.Length);
// Get MethodInfos with param types that work for args. This works
// for except for value args that need to pass to reftype params.
// We could detect that to be smarter and then explicitly StrongBox
// the args.
List <MethodInfo> res = new List <MethodInfo>();
foreach (var mem in mi_mems)
{
if (RuntimeHelpers.ParametersMatchArguments(
mem.GetParameters(), args))
{
res.Add(mem);
}
}
if (res.Count == 0)
{
// Sometimes when binding members on TypeModels the member
// is an intance member since the Type is an instance of Type.
// We fallback to the binder with the Type instance to see if
// it binds. The SymplInvokeMemberBinder does handle this.
var typeMO = RuntimeHelpers.GetRuntimeTypeMoFromModel(this);
var result = binder.FallbackInvokeMember(typeMO, args, null);
return(result);
}
// True below means generate an instance restriction on the MO.
// We are only looking at the members defined in this Type instance.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
this, args, true);
// restrictions and conversion must be done consistently.
var callArgs =
RuntimeHelpers.ConvertArguments(
args, res[0].GetParameters());
return(new DynamicMetaObject(
RuntimeHelpers.EnsureObjectResult(
Expression.Call(res[0], callArgs)),
restrictions));
// Could hve tried just letting Expr.Call factory do the work,
// but if there is more than one applicable method using just
// assignablefrom, Expr.Call throws. It does not pick a "most
// applicable" method or any method.
}
}
public override DynamicMetaObject FallbackCreateInstance(
DynamicMetaObject target,
DynamicMetaObject[] args,
DynamicMetaObject errorSuggestion)
{
// Defer if any object has no value so that we evaulate their
// Expressions and nest a CallSite for the InvokeMember.
if (!target.HasValue || args.Any((a) => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[args.Length + 1];
for (int i = 0; i < args.Length; i++)
{
deferArgs[i + 1] = args[i];
}
deferArgs[0] = target;
return(Defer(deferArgs));
}
// Make sure target actually contains a Type.
if (!typeof(Type).IsAssignableFrom(target.LimitType))
{
return(errorSuggestion ??
RuntimeHelpers.CreateThrow(
target, args, BindingRestrictions.Empty,
typeof(InvalidOperationException),
"Type object must be used when creating instance -- " +
args.ToString()));
}
var type = target.Value as Type;
Debug.Assert(type != null);
var constructors = type.GetConstructors();
// Get constructors with right arg counts.
var ctors = constructors.
Where(c => c.GetParameters().Length == args.Length);
List <ConstructorInfo> res = new List <ConstructorInfo>();
foreach (var c in ctors)
{
if (RuntimeHelpers.ParametersMatchArguments(c.GetParameters(),
args))
{
res.Add(c);
}
}
// We generate an instance restriction on the target since it is a
// Type and the constructor is associate with the actual Type instance.
var restrictions =
RuntimeHelpers.GetTargetArgsRestrictions(
target, args, true);
if (res.Count == 0)
{
return(errorSuggestion ??
RuntimeHelpers.CreateThrow(
target, args, restrictions,
typeof(MissingMemberException),
"Can't bind create instance -- " + args.ToString()));
}
var ctorArgs =
RuntimeHelpers.ConvertArguments(
args, res[0].GetParameters());
return(new DynamicMetaObject(
// Creating an object, so don't need EnsureObjectResult.
Expression.New(res[0], ctorArgs),
restrictions));
}
public override DynamicMetaObject FallbackInvokeMember(
DynamicMetaObject targetMO, DynamicMetaObject[] args,
DynamicMetaObject errorSuggestion)
{
#if !NETSTANDARD
// First try COM binding.
DynamicMetaObject result;
if (ComBinder.TryBindInvokeMember(this, targetMO, args, out result))
{
return(result);
}
#endif
// Defer if any object has no value so that we evaulate their
// Expressions and nest a CallSite for the InvokeMember.
if (!targetMO.HasValue || args.Any((a) => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[args.Length + 1];
for (int i = 0; i < args.Length; i++)
{
deferArgs[i + 1] = args[i];
}
deferArgs[0] = targetMO;
return(Defer(deferArgs));
}
// Find our own binding.
// Could consider allowing invoking static members from an instance.
var flags = BindingFlags.IgnoreCase | BindingFlags.Instance |
BindingFlags.Public;
var members = targetMO.LimitType.GetMember(this.Name, flags);
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
targetMO, args, false);
// Assigned a Null
if (targetMO.HasValue && targetMO.Value == null)
{
return(RuntimeHelpers.CreateThrow(targetMO,
args,
restrictions,
typeof(NullReferenceException),
"Object reference not set to an instance of an object."));
}
if ((members.Length == 1) && (members[0] is PropertyInfo ||
members[0] is FieldInfo))
{
// NEED TO TEST, should check for delegate value too
var mem = members[0];
var target = new DynamicMetaObject(
RuntimeHelpers.EnsureObjectResult(
Expression.MakeMemberAccess(
Expression.Convert(targetMO.Expression,
members[0].DeclaringType),
members[0])),
// Don't need restriction test for name since this
// rule is only used where binder is used, which is
// only used in sites with this binder.Name.
BindingRestrictions.GetTypeRestriction(targetMO.Expression,
targetMO.LimitType));
//If no arguments, to allow scenario like Request.QueryString()
if (args == null || args.Length == 0)
{
return(target);
}
return(new DynamicMetaObject(
RuntimeHelpers.GetIndexingExpression(target, args),
restrictions
));
// Don't test for eventinfos since we do nothing with them now.
}
else
{
bool isExtension = false;
// Get MethodInfos with right arg counts.
var mi_mems = members.
Select(m => m as MethodInfo).
Where(m => m is MethodInfo &&
((MethodInfo)m).GetParameters().Length ==
args.Length);
// Get MethodInfos with param types that work for args. This works
// except for value args that need to pass to reftype params.
// We could detect that to be smarter and then explicitly StrongBox
// the args.
List <MethodInfo> res = new List <MethodInfo>();
foreach (var mem in mi_mems)
{
if (RuntimeHelpers.ParametersMatchArguments(
mem.GetParameters(), args))
{
res.Add(mem);
}
}
List <DynamicMetaObject> argList = new List <DynamicMetaObject>(args);
//Try extension methods if no methods found
if (res.Count == 0)
{
isExtension = true;
argList.Insert(0, targetMO);
res = RuntimeHelpers.GetExtensionMethods(this.Name, targetMO, argList.ToArray());
}
// False below means generate a type restriction on the MO.
// We are looking at the members targetMO's Type.
if (res.Count == 0)
{
return(errorSuggestion ??
RuntimeHelpers.CreateThrow(
targetMO, args, restrictions,
typeof(MissingMemberException),
string.Format("Can't bind member invoke {0}.{1}({2})", targetMO.RuntimeType.Name, this.Name, args.ToString())));
}
//If more than one results found, attempt overload resolution
MethodInfo mi = null;
if (res.Count > 1)
{
mi = RuntimeHelpers.ResolveOverload(res, argList.ToArray());
}
else
{
mi = res[0];
}
// restrictions and conversion must be done consistently.
var callArgs = RuntimeHelpers.ConvertArguments(
argList.ToArray(), mi.GetParameters());
if (isExtension)
{
return(new DynamicMetaObject(
RuntimeHelpers.EnsureObjectResult(
Expression.Call(
null,
mi, callArgs)),
restrictions));
}
else
{
return(new DynamicMetaObject(
RuntimeHelpers.EnsureObjectResult(
Expression.Call(
Expression.Convert(targetMO.Expression,
targetMO.LimitType),
mi, callArgs)),
restrictions));
}
// Could hve tried just letting Expr.Call factory do the work,
// but if there is more than one applicable method using just
// assignablefrom, Expr.Call throws. It does not pick a "most
// applicable" method or any method.
}
}
public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject targetMO, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
// Defer if any object has no value so that we evaulate their
// Expressions and nest a CallSite for the InvokeMember.
if (!targetMO.HasValue || args.Any(a => !a.HasValue))
{
var deferArgs = new DynamicMetaObject[args.Length + 1];
for (int i = 0; i < args.Length; i++)
{
deferArgs[i + 1] = args[i];
}
deferArgs[0] = targetMO;
return(Defer(deferArgs));
}
// Find our own binding.
// Could consider allowing invoking static members from an instance.
const BindingFlags flags = BindingFlags.IgnoreCase | BindingFlags.Instance |
BindingFlags.Public;
var members = targetMO.LimitType.GetMember(Name, flags);
if ((members.Length == 1) && (members[0] is PropertyInfo ||
members[0] is FieldInfo))
{
// NEED TO TEST, should check for delegate value too
throw new NotImplementedException();
}
// Get MethodInfos with right arg counts.
var miMems = members.
Select(m => m as MethodInfo).
Where(m => m.GetParameters().Length == args.Length);
// Get MethodInfos with param types that work for args. This works
// except for value args that need to pass to reftype params.
// We could detect that to be smarter and then explicitly StrongBox
// the args.
var res = new List <MethodInfo>();
foreach (var mem in miMems)
{
if (RuntimeHelpers.ParametersMatchArguments(
mem.GetParameters(), args))
{
res.Add(mem);
}
}
// False below means generate a type restriction on the MO.
// We are looking at the members targetMO's Type.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
targetMO, args, false);
if (res.Count == 0)
{
return(errorSuggestion ??
RuntimeHelpers.CreateThrow(
targetMO, args, restrictions,
typeof(MissingMemberException),
"Can't bind member invoke -- " + args.ToString()));
}
// restrictions and conversion must be done consistently.
var callArgs = RuntimeHelpers.ConvertArguments(
args, res[0].GetParameters());
return(new DynamicMetaObject(
RuntimeHelpers.EnsureObjectResult(
Expression.Call(
Expression.Convert(targetMO.Expression,
targetMO.LimitType),
res[0], callArgs)),
restrictions));
// Could hve tried just letting Expr.Call factory do the work,
// but if there is more than one applicable method using just
// assignablefrom, Expr.Call throws. It does not pick a "most
// applicable" method or any method.
}