/// <summary> /// Creates a CallSite with the given delegate type and binder. /// </summary> /// <param name="delegateType">The CallSite delegate type.</param> /// <param name="binder">The CallSite binder.</param> /// <returns>The new CallSite.</returns> public static CallSite Create(Type delegateType, CallSiteBinder binder) { ContractUtils.RequiresNotNull(delegateType, "delegateType"); ContractUtils.RequiresNotNull(binder, "binder"); if (!delegateType.IsSubclassOf(typeof(MulticastDelegate))) throw Error.TypeMustBeDerivedFromSystemDelegate(); var ctors = s_siteCtors; if (ctors == null) { // It's okay to just set this, worst case we're just throwing away some data s_siteCtors = ctors = new CacheDict<Type, Func<CallSiteBinder, CallSite>>(100); } Func<CallSiteBinder, CallSite> ctor; MethodInfo method = null; if (!ctors.TryGetValue(delegateType, out ctor)) { method = typeof(CallSite<>).MakeGenericType(delegateType).GetMethod("Create"); if (TypeUtils.CanCache(delegateType)) { ctor = (Func<CallSiteBinder, CallSite>)method.CreateDelegate(typeof(Func<CallSiteBinder, CallSite>)); ctors.Add(delegateType, ctor); } } if (ctor != null) { return ctor(binder); } // slow path return (CallSite)method.Invoke(null, new object[] { binder }); }
public static CallSite Create(Type delegateType, CallSiteBinder binder) { Func<CallSiteBinder, CallSite> func; ContractUtils.RequiresNotNull(delegateType, "delegateType"); ContractUtils.RequiresNotNull(binder, "binder"); if (!delegateType.IsSubclassOf(typeof(Delegate))) { throw Error.TypeMustBeDerivedFromSystemDelegate(); } if (_SiteCtors == null) { _SiteCtors = new CacheDict<Type, Func<CallSiteBinder, CallSite>>(100); } MethodInfo method = null; CacheDict<Type, Func<CallSiteBinder, CallSite>> dict = _SiteCtors; lock (dict) { if (!dict.TryGetValue(delegateType, out func)) { method = typeof(CallSite<>).MakeGenericType(new Type[] { delegateType }).GetMethod("Create"); if (delegateType.CanCache()) { func = (Func<CallSiteBinder, CallSite>) Delegate.CreateDelegate(typeof(Func<CallSiteBinder, CallSite>), method); dict.Add(delegateType, func); } } } if (func != null) { return func(binder); } return (CallSite) method.Invoke(null, new object[] { binder }); }
/// <summary> /// Reduces the dynamic expression to a binder and a set of arguments to apply the operation to. /// </summary> /// <param name="binder">The binder used to perform the dynamic operation.</param> /// <param name="arguments">The arguments to apply the dynamic operation to.</param> /// <param name="argumentTypes">The types of the arguments to use for the dynamic call site. Return null to infer types.</param> protected override void ReduceDynamic(out CallSiteBinder binder, out IEnumerable<Expression> arguments, out Type[] argumentTypes) { var nodeType = OperationNodeType; switch (nodeType) { case ExpressionType.AddChecked: nodeType = ExpressionType.Add; break; case ExpressionType.MultiplyChecked: nodeType = ExpressionType.Multiply; break; case ExpressionType.SubtractChecked: nodeType = ExpressionType.Subtract; break; case ExpressionType.AndAlso: nodeType = ExpressionType.And; break; case ExpressionType.OrElse: nodeType = ExpressionType.Or; break; } binder = Binder.BinaryOperation(Flags, nodeType, Context, new[] { Left.ArgumentInfo, Right.ArgumentInfo }); arguments = new[] { Left.Expression, Right.Expression }; argumentTypes = null; }
internal static DynamicExpression Make(Type returnType, Type delegateType, CallSiteBinder binder, ReadOnlyCollection<Expression> arguments) { if (returnType == typeof(object)) { return new DynamicExpressionN(delegateType, binder, arguments); } else { return new TypedDynamicExpressionN(returnType, delegateType, binder, arguments); } }
internal static DynamicExpression Make(Type returnType, Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3) { if (returnType == typeof(object)) { return new DynamicExpression4(delegateType, binder, arg0, arg1, arg2, arg3); } else { return new TypedDynamicExpression4(returnType, delegateType, binder, arg0, arg1, arg2, arg3); } }
internal DynamicExpression4(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3) : base(delegateType, binder) { this._arg0 = arg0; this._arg1 = arg1; this._arg2 = arg2; this._arg3 = arg3; }
internal static DynamicExpression Make(System.Type returnType, System.Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2) { if (returnType == typeof(object)) { return new DynamicExpression3(delegateType, binder, arg0, arg1, arg2); } return new TypedDynamicExpression3(returnType, delegateType, binder, arg0, arg1, arg2); }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="returnType">The result type of the dynamic expression.</param> /// <param name="arguments">The arguments to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.Binder">Binder</see> and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> /// <remarks> /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the /// result will be inferred from the types of the arguments and the specified return type. /// </remarks> public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, IEnumerable<Expression> arguments) { ContractUtils.RequiresNotNull(arguments, nameof(arguments)); ContractUtils.RequiresNotNull(returnType, nameof(returnType)); var args = arguments.ToReadOnly(); ContractUtils.RequiresNotEmpty(args, nameof(args)); return MakeDynamic(binder, returnType, args); }
internal static DynamicMetaObject RewriteStrongBoxAsRef(CallSiteBinder action, DynamicMetaObject target, DynamicMetaObject[] args, bool hasRhs) { Debug.Assert(action != null && target != null && args != null); var restrictions = target.Restrictions.Merge(BindingRestrictions.Combine(args)); Expression[] argExpressions = new Expression[args.Length + 1]; Type[] signatureTypes = new Type[args.Length + 3]; // args + CallSite, target, returnType signatureTypes[0] = typeof(CallSite); //we are not restricting on target type here. argExpressions[0] = target.Expression; signatureTypes[1] = target.Expression.Type; int argsToProcess = args.Length; if (hasRhs) { DynamicMetaObject rhsArgument = args[args.Length - 1]; argExpressions[args.Length] = rhsArgument.Expression; signatureTypes[args.Length + 1] = rhsArgument.Expression.Type; argsToProcess--; } for (int i = 0; i < argsToProcess; i++) { DynamicMetaObject currArgument = args[i]; if (IsStrongBoxArg(currArgument)) { restrictions = restrictions.Merge(BindingRestrictions.GetTypeRestriction(currArgument.Expression, currArgument.LimitType)); // we have restricted this argument to LimitType so we can convert and conversion will be trivial cast. Expression boxedValueAccessor = Expression.Field( Helpers.Convert( currArgument.Expression, currArgument.LimitType ), currArgument.LimitType.GetField("Value") ); argExpressions[i + 1] = boxedValueAccessor; signatureTypes[i + 2] = boxedValueAccessor.Type.MakeByRefType(); } else { argExpressions[i + 1] = currArgument.Expression; signatureTypes[i + 2] = currArgument.Expression.Type; } } // Last signatureType is the return value signatureTypes[signatureTypes.Length - 1] = typeof(object); return new DynamicMetaObject( Expression.MakeDynamic( Expression.GetDelegateType(signatureTypes), action, argExpressions ), restrictions ); }
internal static Instruction CreateUntypedInstruction(CallSiteBinder binder, int argCount) { switch (argCount) { case 0: return DynamicInstruction<object>.Factory(binder); case 1: return DynamicInstruction<object, object>.Factory(binder); case 2: return DynamicInstruction<object, object, object>.Factory(binder); case 3: return DynamicInstruction<object, object, object, object>.Factory(binder); case 4: return DynamicInstruction<object, object, object, object, object>.Factory(binder); case 5: return DynamicInstruction<object, object, object, object, object, object>.Factory(binder); case 6: return DynamicInstruction<object, object, object, object, object, object, object>.Factory(binder); case 7: return DynamicInstruction<object, object, object, object, object, object, object, object>.Factory(binder); case 8: return DynamicInstruction<object, object, object, object, object, object, object, object, object>.Factory(binder); case 9: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object>.Factory(binder); case 10: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object, object>.Factory(binder); case 11: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object, object, object>.Factory(binder); case 12: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object, object, object, object>.Factory(binder); case 13: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object, object, object, object, object>.Factory(binder); case 14: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object, object, object, object, object, object>.Factory(binder); case 15: return DynamicInstruction<object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object>.Factory(binder); } return null; }
public static Expression MakeDynamic(Type type, CallSiteBinder binder, IEnumerable<Expression> arguments, Type[] argumentTypes) { if (argumentTypes == null) { return Expression.Dynamic(binder, type, arguments); } else { // NB: This is a trick to leverage MakeCallSiteDelegate; we should refactor it to take in an array of types. var args = argumentTypes.Map(a => (Expression)Expression.Default(a)).ToReadOnly(); var delegateType = DelegateHelpers.MakeCallSiteDelegate(args, type); return Expression.MakeDynamic(delegateType, binder, arguments); } }
public static Instruction MakeInstruction(Type delegateType, CallSiteBinder binder) { Func<CallSiteBinder, Instruction> factory; if (!_factories.TryGetValue(delegateType, out factory)) { Type instructionType = GetDynamicInstructionType(delegateType); if (instructionType == null) { return new DynamicInstructionN(delegateType, CallSite.Create(delegateType, binder)); } factory = (Func<CallSiteBinder, Instruction>)Delegate.CreateDelegate(typeof(Func<CallSiteBinder, Instruction>), instructionType.GetMethod("Factory")); _factories[delegateType] = factory; } return factory(binder); }
internal static MetaObject RewriteStrongBoxAsRef(CallSiteBinder action, MetaObject target, MetaObject[] args) { Debug.Assert(action != null && target != null && args != null); var restrictions = target.Restrictions.Merge(Restrictions.Combine(args)); Expression[] argExpressions = new Expression[args.Length + 1]; Type[] signatureTypes = new Type[args.Length + 3]; // args + CallSite, target, returnType signatureTypes[0] = typeof(CallSite); //TODO: we are not restricting on target type here, but in theory we could. //It is a tradeoff between rule reuse and higher polymorphism of the site. argExpressions[0] = target.Expression; signatureTypes[1] = target.Expression.Type; for (int i = 0; i < args.Length; i++) { MetaObject currArgument = args[i]; if (IsStrongBoxArg(currArgument)) { restrictions = restrictions.Merge(Restrictions.GetTypeRestriction(currArgument.Expression, currArgument.LimitType)); // we have restricted this argument to LimitType so we can convert and conversion will be trivial cast. Expression boxedValueAccessor = Expression.Field( Helpers.Convert( currArgument.Expression, currArgument.LimitType ), currArgument.LimitType.GetField("Value") ); argExpressions[i + 1] = boxedValueAccessor; signatureTypes[i + 2] = boxedValueAccessor.Type.MakeByRefType(); } else { argExpressions[i + 1] = currArgument.Expression; signatureTypes[i + 2] = currArgument.Expression.Type; } } // Last signatureType is the return value signatureTypes[signatureTypes.Length - 1] = typeof(object); return new MetaObject( Expression.MakeDynamic( Expression.GetDelegateType(signatureTypes), action, argExpressions ), restrictions ); }
/// <summary> /// Reduces the dynamic expression to a binder and a set of arguments to apply the operation to. /// </summary> /// <param name="binder">The binder used to perform the dynamic operation.</param> /// <param name="arguments">The arguments to apply the dynamic operation to.</param> /// <param name="argumentTypes">The types of the arguments to use for the dynamic call site. Return null to infer types.</param> protected override void ReduceDynamic(out CallSiteBinder binder, out IEnumerable<Expression> arguments, out Type[] argumentTypes) { var nodeType = OperationNodeType; switch (nodeType) { case ExpressionType.NegateChecked: nodeType = ExpressionType.Negate; break; } binder = Binder.UnaryOperation(Flags, nodeType, Context, new[] { Operand.ArgumentInfo }); arguments = new[] { Operand.Expression }; argumentTypes = null; }
private DynamicMetaObject BindGetOrInvoke(CallSiteBinder binder, DynamicMetaObject[] args, IList<ArgumentInfo> argInfos) { if (args.Any(arg => ComBinderHelpers.IsStrongBoxArg(arg))) { return ComBinderHelpers.RewriteStrongBoxAsRef(binder, this, args, false); } ComMethodDesc method; var target = _callable.DispatchComObject; var name = _callable.MemberName; if (target.TryGetMemberMethod(name, out method) || target.TryGetMemberMethodExplicit(name, out method)) { return BindComInvoke(method, args, argInfos); } return null; }
/// <summary> /// Reduces the dynamic expression to a binder and a set of arguments to apply the operation to. /// </summary> /// <param name="binder">The binder used to perform the dynamic operation.</param> /// <param name="arguments">The arguments to apply the dynamic operation to.</param> /// <param name="argumentTypes">The types of the arguments to use for the dynamic call site. Return null to infer types.</param> protected override void ReduceDynamic(out CallSiteBinder binder, out IEnumerable<Expression> arguments, out Type[] argumentTypes) { var n = Arguments.Count; var argumentInfos = new CSharpArgumentInfo[n + 1]; var expressions = new Expression[n + 1]; expressions[0] = Expression; argumentInfos[0] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null); argumentTypes = null; CopyArguments(Arguments, argumentInfos, expressions, ref argumentTypes); binder = Binder.Invoke(Flags, Context, argumentInfos); arguments = expressions; }
/// <summary> /// Reduces the dynamic expression to a binder and a set of arguments to apply the operation to. /// </summary> /// <param name="binder">The binder used to perform the dynamic operation.</param> /// <param name="arguments">The arguments to apply the dynamic operation to.</param> /// <param name="argumentTypes">The types of the arguments to use for the dynamic call site. Return null to infer types.</param> protected override void ReduceDynamic(out CallSiteBinder binder, out IEnumerable<Expression> arguments, out Type[] argumentTypes) { var n = Arguments.Count; var argumentInfos = new CSharpArgumentInfo[n + 1]; var expressions = new Expression[n + 1]; expressions[0] = Expression.Constant(Type, typeof(Type)); argumentInfos[0] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null); argumentTypes = null; CopyArguments(Arguments, argumentInfos, expressions, ref argumentTypes); binder = Binder.InvokeConstructor(Flags, Context, argumentInfos); arguments = expressions; }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="returnType">The result type of the dynamic expression.</param> /// <param name="arg0">The first argument to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.Binder">Binder</see> and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> /// <remarks> /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the /// result will be inferred from the types of the arguments and the specified return type. /// </remarks> public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0) { ContractUtils.RequiresNotNull(binder, nameof(binder)); ValidateDynamicArgument(arg0, nameof(arg0)); DelegateHelpers.TypeInfo info = DelegateHelpers.GetNextTypeInfo( returnType, DelegateHelpers.GetNextTypeInfo( arg0.Type, DelegateHelpers.NextTypeInfo(typeof(CallSite)) ) ); Type delegateType = info.DelegateType ?? info.MakeDelegateType(returnType, arg0); return DynamicExpression.Make(returnType, delegateType, binder, arg0); }
/// <summary> /// Reduces the dynamic expression to a binder and a set of arguments to apply the operation to. /// </summary> /// <param name="binder">The binder used to perform the dynamic operation.</param> /// <param name="arguments">The arguments to apply the dynamic operation to.</param> /// <param name="argumentTypes">The types of the arguments to use for the dynamic call site. Return null to infer types.</param> protected override void ReduceDynamic(out CallSiteBinder binder, out IEnumerable<Expression> arguments, out Type[] argumentTypes) { var n = Arguments.Count; var argumentInfos = new CSharpArgumentInfo[n + 1]; var expressions = new Expression[n + 1]; // NB: By-ref passing for the receiver seems to be omitted in Roslyn here; see https://github.com/dotnet/roslyn/issues/6818. // We're choosing to be consistent with that behavior until further notice. expressions[0] = Object; argumentInfos[0] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null); argumentTypes = null; CopyArguments(Arguments, argumentInfos, expressions, ref argumentTypes); binder = Binder.GetIndex(Flags, Context, argumentInfos); arguments = expressions; }
/// <summary> /// Creates a CallSite with the given delegate type and binder. /// </summary> /// <param name="delegateType">The CallSite delegate type.</param> /// <param name="binder">The CallSite binder.</param> /// <returns>The new CallSite.</returns> public static CallSite Create(Type delegateType, CallSiteBinder binder) { ContractUtils.RequiresNotNull(delegateType, "delegateType"); ContractUtils.RequiresNotNull(binder, "binder"); ContractUtils.Requires(delegateType.IsSubclassOf(typeof(Delegate)), "delegateType", Strings.TypeMustBeDerivedFromSystemDelegate); if (_SiteCtors == null) { // It's okay to just set this, worst case we're just throwing away some data _SiteCtors = new CacheDict<Type, Func<CallSiteBinder, CallSite>>(100); } Func<CallSiteBinder, CallSite> ctor; lock (_SiteCtors) { if (!_SiteCtors.TryGetValue(delegateType, out ctor)) { MethodInfo method = typeof(CallSite<>).MakeGenericType(delegateType).GetMethod("Create"); ctor = (Func<CallSiteBinder, CallSite>)Delegate.CreateDelegate(typeof(Func<CallSiteBinder, CallSite>), method); _SiteCtors.Add(delegateType, ctor); } } return ctor(binder); }
public static Instruction MakeInstruction(Type delegateType, CallSiteBinder binder) { Func<CallSiteBinder, Instruction> factory; lock (_factories) { if (!_factories.TryGetValue(delegateType, out factory)) { if (delegateType.GetMethod("Invoke").ReturnType == typeof(void)) { // TODO: We should generally support void returning binders but the only // ones that exist are delete index/member who's perf isn't that critical. return new DynamicInstructionN(delegateType, CallSite.Create(delegateType, binder), true); } Type instructionType = GetDynamicInstructionType(delegateType); if (instructionType == null) { return new DynamicInstructionN(delegateType, CallSite.Create(delegateType, binder)); } factory = (Func<CallSiteBinder, Instruction>)Delegate.CreateDelegate(typeof(Func<CallSiteBinder, Instruction>), instructionType.GetMethod("Factory")); _factories[delegateType] = factory; } } return factory(binder); }
public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2) { throw null; }
// Dev10 Bug 914027 - Changed the callsite's target parameter from dynamic to object, see comment at top for details public static CallSite<Func<CallSite, object, object>> GetMemberAccessCallSite(CallSiteBinder binder) { return CallSite<Func<CallSite, object, object>>.Create(binder); }
// only CallSite<T> derives from this internal CallSite(CallSiteBinder binder) { _binder = binder; }
private static DynamicExpression MakeDynamic(CallSiteBinder binder, Type returnType, ReadOnlyCollection<Expression> args) { ContractUtils.RequiresNotNull(binder, "binder"); for (int i = 0; i < args.Count; i++) { Expression arg = args[i]; ValidateDynamicArgument(arg); } Type delegateType = DelegateHelpers.MakeCallSiteDelegate(args, returnType); // Since we made a delegate with argument types that exactly match, // we can skip delegate and argument validation switch (args.Count) { case 1: return DynamicExpression.Make(returnType, delegateType, binder, args[0]); case 2: return DynamicExpression.Make(returnType, delegateType, binder, args[0], args[1]); case 3: return DynamicExpression.Make(returnType, delegateType, binder, args[0], args[1], args[2]); case 4: return DynamicExpression.Make(returnType, delegateType, binder, args[0], args[1], args[2], args[3]); default: return DynamicExpression.Make(returnType, delegateType, binder, args); } }
public static CallSite Create(Type delegateType, CallSiteBinder binder) { return(null); }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="returnType">The result type of the dynamic expression.</param> /// <param name="arg0">The first argument to the dynamic operation.</param> /// <param name="arg1">The second argument to the dynamic operation.</param> /// <param name="arg2">The third argument to the dynamic operation.</param> /// <param name="arg3">The fourth argument to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.Binder">Binder</see> and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> /// <remarks> /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the /// result will be inferred from the types of the arguments and the specified return type. /// </remarks> public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0, Expression arg1, Expression arg2, Expression arg3) { ContractUtils.RequiresNotNull(binder, "binder"); ValidateDynamicArgument(arg0); ValidateDynamicArgument(arg1); ValidateDynamicArgument(arg2); ValidateDynamicArgument(arg3); DelegateHelpers.TypeInfo info = DelegateHelpers.GetNextTypeInfo( returnType, DelegateHelpers.GetNextTypeInfo( arg3.Type, DelegateHelpers.GetNextTypeInfo( arg2.Type, DelegateHelpers.GetNextTypeInfo( arg1.Type, DelegateHelpers.GetNextTypeInfo( arg0.Type, DelegateHelpers.NextTypeInfo(typeof(CallSite)) ) ) ) ) ); Type delegateType = info.DelegateType; if (delegateType == null) { delegateType = info.MakeDelegateType(returnType, arg0, arg1, arg2, arg3); } return DynamicExpression.Make(returnType, delegateType, binder, arg0, arg1, arg2, arg3); }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="returnType">The result type of the dynamic expression.</param> /// <param name="arguments">The arguments to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.Binder">Binder</see> and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> /// <remarks> /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the /// result will be inferred from the types of the arguments and the specified return type. /// </remarks> public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, params Expression[] arguments) { return Dynamic(binder, returnType, (IEnumerable<Expression>)arguments); }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" /> and four arguments. /// </summary> /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="arg0">The first argument to the dynamic operation.</param> /// <param name="arg1">The second argument to the dynamic operation.</param> /// <param name="arg2">The third argument to the dynamic operation.</param> /// <param name="arg3">The fourth argument to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.DelegateType">DelegateType</see>, /// <see cref="DynamicExpression.Binder">Binder</see>, and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3) { ContractUtils.RequiresNotNull(delegateType, "delegateType"); ContractUtils.RequiresNotNull(binder, "binder"); if (!delegateType.IsSubclassOf(typeof(MulticastDelegate))) throw Error.TypeMustBeDerivedFromSystemDelegate(); var method = GetValidMethodForDynamic(delegateType); var parameters = method.GetParametersCached(); ValidateArgumentCount(method, ExpressionType.Dynamic, 5, parameters); ValidateDynamicArgument(arg0); ValidateOneArgument(method, ExpressionType.Dynamic, arg0, parameters[1]); ValidateDynamicArgument(arg1); ValidateOneArgument(method, ExpressionType.Dynamic, arg1, parameters[2]); ValidateDynamicArgument(arg2); ValidateOneArgument(method, ExpressionType.Dynamic, arg2, parameters[3]); ValidateDynamicArgument(arg3); ValidateOneArgument(method, ExpressionType.Dynamic, arg3, parameters[4]); return DynamicExpression.Make(method.GetReturnType(), delegateType, binder, arg0, arg1, arg2, arg3); }
// only CallSite<T> derives from this internal CallSite(CallSiteBinder binder) { Binder = binder; }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="arguments">The arguments to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.DelegateType">DelegateType</see>, /// <see cref="DynamicExpression.Binder">Binder</see>, and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, IEnumerable<Expression> arguments) { ContractUtils.RequiresNotNull(delegateType, "delegateType"); ContractUtils.RequiresNotNull(binder, "binder"); if (!delegateType.IsSubclassOf(typeof(MulticastDelegate))) throw Error.TypeMustBeDerivedFromSystemDelegate(); var method = GetValidMethodForDynamic(delegateType); var args = arguments.ToReadOnly(); ValidateArgumentTypes(method, ExpressionType.Dynamic, ref args); return DynamicExpression.Make(method.GetReturnType(), delegateType, binder, args); }
internal DynamicExpression(Type delegateType, CallSiteBinder binder) { Debug.Assert(delegateType.GetMethod("Invoke").GetReturnType() == typeof(object) || GetType() != typeof(DynamicExpression)); _delegateType = delegateType; _binder = binder; }
public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Collections.Generic.IEnumerable <System.Linq.Expressions.Expression> arguments) { throw null; }
public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, params System.Linq.Expressions.Expression[] arguments) { throw null; }
public static T Bind <T>(CallSiteBinder binder, CallSite <T> site, object[] args) where T : class { return(binder.BindCore(site, args)); }
public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3) { throw null; }
/// <summary> /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />. /// </summary> /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param> /// <param name="binder">The runtime binder for the dynamic operation.</param> /// <param name="arguments">The arguments to the dynamic operation.</param> /// <returns> /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the /// <see cref="DynamicExpression.DelegateType">DelegateType</see>, /// <see cref="DynamicExpression.Binder">Binder</see>, and /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values. /// </returns> public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, params Expression[] arguments) { return MakeDynamic(delegateType, binder, (IEnumerable<Expression>)arguments); }
public static System.Runtime.CompilerServices.CallSite Create(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder) { throw null; }
public static extern CallSite Create(Type delegateType, CallSiteBinder binder);