protected override LinqExpression BuildLinqExpression() { var leftOperandExpression = LeftNode.GetEvaluationLinqExpression(); var rightOperandExpression = RightNode.GetEvaluationLinqExpression(); var variableLeft = LinqExpression.Variable(typeof(object)); var variableEvaluatedResult = LinqExpression.Variable(typeof(object)); return(LinqExpression.Block( typeof(object), new[] { variableLeft, variableEvaluatedResult }, LinqExpressionHelper.ExpressionCallThrowIfCancellationRequested, LinqExpression.Assign(variableLeft, leftOperandExpression), LinqExpression.IfThen( LinqExpression.Not( LinqExpression.Call( LinqExpression.Constant(Operator), LinqExpressionHelper.MethodInfoBinaryOperatorEvaluateLhs, LinqExpressionHelper.ExpressionParameterContext, variableLeft, variableEvaluatedResult)), LinqExpression.Assign( variableEvaluatedResult, LinqExpression.Call( LinqExpression.Constant(Operator), LinqExpressionHelper.MethodInfoBinaryOperatorEvaluate, LinqExpressionHelper.ExpressionParameterContext, variableLeft, rightOperandExpression))), variableEvaluatedResult)); }
private static System.Linq.Expressions.LambdaExpression Evaluate(this Expression expression, IQueryable <Representation> representations) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } if (representations == null) { throw new ArgumentNullException(nameof(representations)); } var representationParameter = LinqExpression.Parameter(typeof(Representation), "rp"); var resourceAttrParameterExpr = LinqExpression.Parameter(typeof(RepresentationAttribute), "ra"); var representationAttributesProperty = LinqExpression.Property(representationParameter, "Attributes"); var result = expression.Evaluate(representationParameter); if (result == null) { return(null); } var whereMethod = GetWhereMethod <Representation>(); var equalLambda = LinqExpression.Lambda <Func <Representation, bool> >(result, representationParameter); var whereExpr = LinqExpression.Call(whereMethod, LinqExpression.Constant(representations), equalLambda); var finalSelectArg = LinqExpression.Parameter(typeof(IQueryable <Representation>), "f"); var finalSelectRequestBody = LinqExpression.Lambda(whereExpr, new System.Linq.Expressions.ParameterExpression[] { finalSelectArg }); return(finalSelectRequestBody); }
public Updater(Type type) { var props = from p in type.GetProperties() let bas = p.GetCustomAttributes(typeof(BrowsableAttribute), true) let b = bas.FirstOrDefault() as BrowsableAttribute where p.CanWrite && (b == null || b.Browsable) select p; var convert = typeof(Updater).GetMethod("FromString", BindingFlags.Static | BindingFlags.NonPublic); foreach (var p in props) { var instance = X.Parameter(typeof(object)); var value = X.Parameter(typeof(string)); var lambda = X.Lambda <Action <object, string> >( X.Assign( X.Property( X.Convert(instance, type), p ), X.Convert( X.Call(convert, value, X.Constant(p.PropertyType)), p.PropertyType ) ), instance, value); cache[p.Name] = lambda.Compile(); } }
/// <summary> /// Produces the entity factory delegate and sets the /// </summary> /// <param name="elementType">Type of the element.</param> private void ProduceEntityFactoryDelegate(Type elementType) { if (typeof(IEntityCore).IsAssignableFrom(elementType) && (_callGetEntityFactoryDelegate == null)) { lock (_semaphore) { if (_callGetEntityFactoryDelegate == null) { // create the delegate for invoking the entity factory factory. string rootNamespace = elementType.FullName.Substring(0, elementType.FullName.Length - (elementType.Name.Length + ".EntityClasses".Length) - 1); string generalEntityFactoryFactoryTypeName = rootNamespace + ".FactoryClasses.EntityFactoryFactory"; Type generalEntityFactoryFactoryType = elementType.Assembly.GetType(generalEntityFactoryFactoryTypeName); if (generalEntityFactoryFactoryType == null) { return; } var methodInfo = generalEntityFactoryFactoryType.GetMethod("GetFactory", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(Type) }, null); if (methodInfo == null) { return; } var parameter = LinqExpression.Parameter(typeof(Type), "p"); var methodCallExpression = LinqExpression.Call(methodInfo, parameter); var lambda = LinqExpression.Lambda(methodCallExpression, parameter); _callGetEntityFactoryDelegate = lambda.Compile(); } } } }
static Action <string, string> MakeNewProjectDialogMethod() { var newProjInfoType = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypesOrNone()).FirstOrDefault(t => t.Name == "VSNEWPROJECTDLGINFO"); var sDialogService = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsDialogService)); var rawDialogService = (SVsDialogService)sDialogService; var hierarchyArg = Expression.Parameter(typeof(string), "hierarchy"); var nameArg = Expression.Parameter(typeof(string), "name"); var newProjInfoVar = Expression.Variable(newProjInfoType, "newProjInfo"); var locVar = Expression.Variable(typeof(string), "locVar"); var expr = Expression.Lambda <Action <string, string> >( Expression.Block( new[] { newProjInfoVar, locVar }, Expression.Assign(newProjInfoVar, Expression.New(newProjInfoType)), Expression.Assign(Expression.Field(newProjInfoVar, newProjInfoType.GetField("pwzExpand")), hierarchyArg), Expression.Assign(Expression.Field(newProjInfoVar, newProjInfoType.GetField("pwzSelect")), nameArg), Expression.Call(Expression.Constant(rawDialogService, typeof(SVsDialogService)), rawDialogService.GetType().GetMethod("InvokeDialog"), newProjInfoVar, locVar) ), new[] { hierarchyArg, nameArg } ); var compiledExpr = expr.Compile(); return(compiledExpr); }
public void Default() { var expected = LinqExpression.Call( LinqExpression.New( typeof(SampleClass)), nameof(SampleClass.InstanceMethod), Array.Empty <Type>(), Array.Empty <LinqExpression>()); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :callInstance [ :newType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; ] ; :callMethodName ""InstanceMethod"" ; . "; ShouldBe(actual, expected); }
protected override LExpression GetExpressionTreeIfPossible(LExpression contextExpression, LExpression evalContext) { // TODO: dodanie char + char daje inta...! var leftExpression = GetExpressionTreeIfPossible(Left, contextExpression, evalContext); var rightExpression = GetExpressionTreeIfPossible(Right, contextExpression, evalContext); if (leftExpression != null && rightExpression != null) { var exp = CreateBinaryExpressionForAllNumericTypesForNotNullChildren( leftExpression, rightExpression, LExpression.Add); if (exp != null) { return(exp); } // one of exp is a string expression - we use Concat if (leftExpression.Type == typeof(string) || rightExpression.Type == typeof(string)) { return(LExpression.Call( StrConcatObjObjMethodInfo, leftExpression, rightExpression)); } } return(null); }
public static Expression Call(ProcedureCall call) { if (ReferenceEquals(call, null)) { throw new ArgumentNullException(nameof(call)); } var services = Services.Instance; var procedure = services.GetProcedureSignature(call); if (!procedure.HasReturnType) { throw new InvalidOperationException( "Cannot use a procedure that does not return a value."); } var arguments = services.GetArguments(procedure, call.Arguments); var servicesExpr = LinqExpression.Constant(services); var executeCallMethod = typeof(Services).GetMethod( "ExecuteCall", new[] { typeof(Scanner.ProcedureSignature), typeof(object[]) }); var procedureExpr = LinqExpression.Constant(procedure); var argumentsExpr = LinqExpression.Constant(arguments); var result = LinqExpression.Call( servicesExpr, executeCallMethod, new[] { procedureExpr, argumentsExpr }); var value = LinqExpression.Convert( LinqExpression.Property(result, "Value"), procedure.ReturnType); return(new Expression(value)); }
static void mapMethod(string typeName, MethodInfo method, Data data, string customName = null) { if (!method.IsStatic) { return; } if (mapType == ExpressionMode) { var args = method.GetParameters(); var pars = new List <System.Linq.Expressions.ParameterExpression>(); foreach (var arg in args) { pars.Add(Dlr.Parameter(arg.ParameterType)); } var prs = pars.ToArray(); var invoke = Dlr.Lambda(Dlr.Call(method, prs), prs).Compile(); string finalName = customName ?? method.Name; data.set(typeName + '.' + finalName, invoke); } else if (mapType == ReflectionMode) { var invoke = (Action <string>)((args) => method.Invoke(null, new object[] { args })); data.set(typeName + '.' + method.Name, invoke); } }
static LayoutHelper() { var getDpiMethod = typeof(Visual).GetMethod("GetDpi", BindingFlags.NonPublic | BindingFlags.Instance); if (getDpiMethod != null) { var dpiScaleXProperty = getDpiMethod.ReturnType.GetProperty("DpiScaleX"); var visualParam = Expression.Parameter(typeof(Visual)); var lambda = Expression.Lambda <Func <Visual, double> >( Expression.Property( Expression.Call(visualParam, getDpiMethod), dpiScaleXProperty), visualParam); GetDpiXDelegate = lambda.Compile(); return; } var feDpiScaleXProperty = typeof(FrameworkElement).GetProperty( "DpiScaleX", BindingFlags.NonPublic | BindingFlags.Static); if (feDpiScaleXProperty != null) { var lambda = Expression.Lambda <Func <Visual, double> >( Expression.Property(null, feDpiScaleXProperty), Expression.Parameter(typeof(Visual))); GetDpiXDelegate = lambda.Compile(); return; } GetDpiXDelegate = _ => 1.0; }
public void Method_TypeArguments_Arguments() { var expected = LinqExpression.Call( typeof(SampleClass).GetMethod(nameof(SampleClass.GenericStaticMethodWithArgument)).MakeGenericMethod(typeof(object)), LinqExpression.Constant(0L)); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :callMethod [ :memberType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; :memberName ""GenericStaticMethodWithArgument"" ; :methodTypeArguments ( [ :typeName ""System.Object"" ] ) ; ] ; :callArguments ( [ :constantValue 0; ] ) ; . "; ShouldBe(actual, expected); }
public void Default_Arguments() { var expected = LinqExpression.Call( LinqExpression.New( typeof(SampleClass)), nameof(SampleClass.InstanceMethodWithArgument), Array.Empty <Type>(), new[] { LinqExpression.Constant(0L), }); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :callInstance [ :newType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; ] ; :callMethodName ""InstanceMethodWithArgument"" ; :callArguments ( [ :constantValue 0; ] ) ; . "; ShouldBe(actual, expected); }
public void Default_TypeArguments() { var expected = LinqExpression.Call( LinqExpression.New( typeof(SampleClass)), nameof(SampleClass.GenericInstanceMethod), new[] { typeof(object), }, Array.Empty <LinqExpression>()); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :callInstance [ :newType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; ] ; :callMethodName ""GenericInstanceMethod"" ; :callTypeArguments ( [ :typeName ""System.Object"" ; ] ) ; . "; ShouldBe(actual, expected); }
public void Should_support_method_call_expression() { var src = RemoteItems; var result = (int)src.Provider.Execute(Expression.Call(typeof(Queryable), nameof(Queryable.Count), new[] { src.ElementType }, new[] { src.Expression })); result.ShouldBe(1); }
public void Method_Instance_TypeArguments() { var expected = LinqExpression.Call( LinqExpression.New( typeof(SampleClass)), typeof(SampleClass).GetMethod(nameof(SampleClass.GenericInstanceMethod)).MakeGenericMethod(typeof(object))); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :callInstance [ :newType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; ] ; :callMethod [ :memberType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; :memberName ""GenericInstanceMethod"" ; :methodTypeArguments ( [ :typeName ""System.Object"" ] ) ; ] ; . "; ShouldBe(actual, expected); }
public void Method_Instance_Arguments() { var expected = LinqExpression.Call( LinqExpression.New( typeof(SampleClass)), typeof(SampleClass).GetMethod(nameof(SampleClass.InstanceMethodWithArgument)), LinqExpression.Constant(0L)); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :callInstance [ :newType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; ] ; :callMethod [ :memberType [ :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; ] ; :memberName ""InstanceMethodWithArgument"" ; ] ; :callArguments ( [ :constantValue 0; ] ) ; . "; ShouldBe(actual, expected); }
internal Expression JitOverCall(bool forAssign) { return(Expression.Call( Expression.Constant(this), GetType().GetMethod(forAssign ? "EvaluateForWrite" : "Evaluate", BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(Context) }, null), JITHelpers.ContextParameter )); }
public override MSAst TransformCore(ScriptGenerator generator) { var instanceExpression = MethodGroup.InstanceExpression; return(MSAst.Call( (instanceExpression != null) ? instanceExpression.Transform(generator) : null, (MethodInfo)MethodGroup, _arguments.Select(o => o.Value.Transform(generator)))); }
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) { var expression = Expr.Call( Expr.Convert(Expression, typeof(LuaTable)), MemberInfos.LuaTableGetValue, Expr.Constant(binder.Name)); return(new DynamicMetaObject(expression, RuntimeHelpers.MergeTypeRestrictions(this))); }
protected override LExpression GetExpressionTreeIfPossible( LExpression contextExpression, LExpression evalContext) { if (arrayType == null) { lock (this) { if (arrayType == null) { arrayType = TypeResolutionUtils.ResolveType(getText()); } } } AST rankRoot = getFirstChild(); int dimensions = rankRoot.getNumberOfChildren(); if (dimensions > 0) { int i = 0; AST rankNode = rankRoot.getFirstChild(); var args = new List <LExpression>(); while (rankNode != null) { args.Add(GetExpressionTreeIfPossible((BaseNode)rankNode, contextExpression, evalContext)); rankNode = rankNode.getNextSibling(); } return(LExpression.NewArrayBounds(arrayType, args)); } AST valuesRoot = getFirstChild().getNextSibling(); if (valuesRoot != null) { var arrayExpression = GetExpressionTreeIfPossible((BaseNode)valuesRoot, contextExpression, evalContext); var arrayExpressonType = arrayExpression.Type; if (arrayExpressonType.IsGenericType && arrayExpressonType.GetGenericTypeDefinition() == typeof(List <>)) { // typed List var toArrayListMi = arrayExpressonType.GetMethod("ToArray"); return(LExpression.Call(arrayExpression, toArrayListMi)); } // TODO: to mo¿e byæ te¿ ArrayList z Objectami... póki co tego nie obs³ugujemy... chyba? // jeœli lista, to super prosto... bo ToArrayJest ju¿ zrobione //var result = LExpression.NewArrayInit(arrayExpression.Type, arra) // ArrayList values = (ArrayList)GetValue(((BaseNode)valuesRoot), context, evalContext); // return values.ToArray(arrayType); return(null); } return(null); }
protected override LExpression GetExpressionTreeIfPossible(LExpression contextExpression, LExpression evalContext) { var node = getFirstChild(); var arguments = new List <LExpression>(); var argumentsTypes = new List <Type>(); while (node != null) { //if (node.getFirstChild() is LambdaExpressionNode) //{ // argList.Add((BaseNode)node.getFirstChild()); //} //else if (node is NamedArgumentNode) //{ // namedArgs.Add(node.getText(), node); //} //else var arg = GetExpressionTreeIfPossible((BaseNode)node, contextExpression, evalContext); if (arg == null) { return(null); } arguments.Add(arg); argumentsTypes.Add(arg.Type); node = node.getNextSibling(); } // TODO: mo¿e pobranie arraya? tylko trzeba przetestowaæ, czy nie stracimy typu!.. .bo jak przez object, to syf! if (contextExpression.Type.IsArray) { return(LExpression.ArrayIndex( contextExpression, arguments)); } var indexerPropertyName = GetIndexerPropertyName(contextExpression.Type); var methodName = "get_" + indexerPropertyName; var methodInfo = contextExpression.Type.GetMethod( methodName, BINDING_FLAGS | BindingFlags.FlattenHierarchy, null, argumentsTypes.ToArray(), null); if (methodInfo == null) { return(null); } return(LExpression.Call(contextExpression, methodInfo, arguments)); }
public static IQueryable <T> OrderByField <T>(IQueryable <T> q, string SortField, bool Ascending) { var param = Expression.Parameter(typeof(T), "p"); var prop = Expression.Property(param, SortField); var exp = Expression.Lambda(prop, param); var method = Ascending ? "OrderBy" : "OrderByDescending"; var types = new[] { q.ElementType, exp.Body.Type }; var mce = Expression.Call(typeof(Queryable), method, types, q.Expression, exp); return(q.Provider.CreateQuery <T>(mce)); }
public static IQueryable <T> OrderByField <T>(this IQueryable <T> query, string field, bool ascending) { var param = E.Parameter(typeof(T), "par"); var prop = E.Property(param, field); var lambda = E.Lambda(prop, param); string method = ascending ? "OrderBy" : "OrderByDescending"; Type[] types = new Type[] { query.ElementType, lambda.Body.Type }; var mce = E.Call(typeof(Queryable), method, types, query.Expression, lambda); return(query.Provider.CreateQuery <T>(mce)); }
/// <summary> /// 获取日期常量表达式 /// </summary> /// <param name="value">日期值</param> /// <param name="targetType">目标类型</param> public static MicrosoftExpression CreateDateTimeExpression(object value, Type targetType) { var parse = typeof(DateTime).GetMethod("Parse", new[] { typeof(string) }); if (parse == null) { return(null); } var parseExpression = MicrosoftExpression.Call(parse, MicrosoftExpression.Constant(value.SafeString())); return(MicrosoftExpression.Convert(parseExpression, targetType)); }
private static Delegate CreateDelegate(EventInfo eventInfo, Action action) { var handlerType = eventInfo.EventHandlerType; var parameters = handlerType.GetMethod("Invoke").GetParameters() .Select(x => Expression.Parameter(x.ParameterType, x.Name)) .ToArray(); var body = Expression.Call(Expression.Constant(action), action.GetType().GetMethod("Invoke")); var lambda = Expression.Lambda(body, parameters); return(Delegate.CreateDelegate(handlerType, lambda.Compile(), "Invoke", false)); }
public static System.Linq.Expressions.LambdaExpression EvaluateSelection(this Filter filter, IQueryable <Representation> representations, IQueryable <RepresentationAttribute> representationAttributes) { if (filter == null) { throw new ArgumentNullException(nameof(filter)); } if (filter.Expression == null) { throw new ArgumentNullException(nameof(filter.Expression)); } if (representations == null) { throw new ArgumentNullException(nameof(representations)); } if (representationAttributes == null) { throw new ArgumentNullException(nameof(representationAttributes)); } var attrExpression = filter.Expression as AttributeExpression; if (attrExpression == null) { throw new ArgumentException("The filter is not a selector"); } var representationParameter = LinqExpression.Parameter(typeof(Representation), "rp"); var representationAttributeParameter = LinqExpression.Parameter(typeof(RepresentationAttribute), "ra"); var enumerableType = typeof(Queryable); var enumerableMethods = enumerableType.GetMethods(); var outerArg = LinqExpression.Parameter(typeof(Representation), "x"); var innerArg = LinqExpression.Parameter(typeof(RepresentationAttribute), "y"); var outerProperty = LinqExpression.Property(outerArg, "Id"); var innerProperty = LinqExpression.Property(innerArg, "RepresentationId"); var outerLambda = LinqExpression.Lambda(outerProperty, new System.Linq.Expressions.ParameterExpression[] { outerArg }); var innerLambda = LinqExpression.Lambda(innerProperty, new System.Linq.Expressions.ParameterExpression[] { innerArg }); var resultSelector = LinqExpression.Lambda(innerArg, new System.Linq.Expressions.ParameterExpression[] { outerArg, innerArg }); var joinMethod = enumerableMethods.Where(m => m.Name == "Join" && m.IsGenericMethodDefinition).Where(m => m.GetParameters().ToList().Count == 5).First(); var joinGenericMethod = joinMethod.MakeGenericMethod(typeof(Representation), typeof(RepresentationAttribute), typeof(string), typeof(RepresentationAttribute)); var join = LinqExpression.Call(joinGenericMethod, LinqExpression.Constant(representations), LinqExpression.Constant(representationAttributes), outerLambda, innerLambda, resultSelector); // add join. var result = attrExpression.Path.EvaluateSelection(join); var finalSelectArg = LinqExpression.Parameter(typeof(IQueryable <Representation>), "f"); var finalSelectRequestBody = LinqExpression.Lambda(result, new System.Linq.Expressions.ParameterExpression[] { finalSelectArg }); return(finalSelectRequestBody); }
static DependencyPropertyHelper() { MethodInfo fromNameMethod = typeof(DependencyProperty).GetMethod("FromName", BindingFlags.Static | BindingFlags.NonPublic) ?? throw new InvalidOperationException($"Failed to find FromName method"); var nameParameter = Expression.Parameter(typeof(string)); var ownerTypeParameter = Expression.Parameter(typeof(Type)); var call = Expression.Call(fromNameMethod, nameParameter, ownerTypeParameter); var fromName = Expression.Lambda <Func <string, Type, DependencyProperty> >(call, nameParameter, ownerTypeParameter); FromName = fromName.Compile(); }
public CommandExecutionProvider(Type targetType, string canExecuteMethodName, string executedMethodName) { TargetType = targetType; CanExecuteMethodName = canExecuteMethodName; ExecutedMethodName = executedMethodName; var targetParameter = Expression.Parameter(targetType); var paramParamater = Expression.Parameter(typeof(object)); var canExecuteMethodInfo = GetMethodInfo(CanExecuteMethodName); if (canExecuteMethodInfo != null && canExecuteMethodInfo.ReturnType == typeof(bool)) { if (canExecuteMethodInfo.GetParameters().Length == 0) { _canExecute = Expression.Lambda <Func <TTarget, bool> >(Expression.Call(targetParameter, canExecuteMethodInfo), targetParameter).Compile(); } else { _canExecuteWithParam = Expression.Lambda <Func <TTarget, object, bool> >(Expression.Call(targetParameter, canExecuteMethodInfo, paramParamater), targetParameter, paramParamater).Compile(); } } if (_canExecute == null && this._canExecuteWithParam == null) { _canExecute = Expression.Lambda <Func <TTarget, bool> >(Expression.Constant(true), targetParameter).Compile(); //throw new Exception(string.Format( // "Method {0} on type {1} does not have a valid method signature. The method must have one of the following signatures: 'public bool CanExecute()' or 'public bool CanExecute(object parameter)'", // CanExecuteMethodName, typeof(TTarget))); } var executedMethodInfo = GetMethodInfo(ExecutedMethodName); if (executedMethodInfo != null && (executedMethodInfo.ReturnType == typeof(void) || executedMethodInfo.ReturnType == typeof(Task))) { if (executedMethodInfo.GetParameters().Length == 0) { _executed = Expression.Lambda <Action <TTarget> >(Expression.Call(targetParameter, executedMethodInfo), targetParameter).Compile(); } else { _executedWithParam = Expression.Lambda <Action <TTarget, object> >(Expression.Call(targetParameter, executedMethodInfo, paramParamater), targetParameter, paramParamater).Compile(); } } if (_executed == null && _executedWithParam == null) { throw new Exception(string.Format( "Method {0} on type {1} does not have a valid method signature. The method must have one of the following signatures: 'public void " + executedMethodName + "()' or 'public void " + executedMethodName + "(object parameter)'", ExecutedMethodName, typeof(TTarget))); } }
public void Query_Where_Enum_AgainstDifferentEnumType_ManualExpression() { var lambda = BaseExpressionTest.CreateLambda(Property.Status, s => { var retry = Expr.Constant(RetryMode.Retry); var methodInfo = typeof(object).GetMethod(nameof(Equals), System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public); var method = Expr.Call(methodInfo, Expr.Convert(retry, typeof(object)), Expr.Convert(s, typeof(object))); return(method); }); ExecuteFilter(lambda, string.Empty, s => Assert.AreEqual(0, s.Count)); }
private static NodeVisitFunction BuildMethodVisitor(MethodInfo method, out Type parameterType) { var declaringtype = method.DeclaringType; if (declaringtype == null) { throw new InvalidOperationException(string.Format("No declaring type for method [{0}]", method.Name)); } // Throws an exception if parammeters.Count != 1 if (method.GetParameters().Length != 1) { throw new InvalidOperationException( string.Format("Invalid number of parameters [{0}] for visit method [{1}] for type [{2}]. One parameter is expected", method.GetParameters().Length, method.Name, declaringtype.FullName)); } parameterType = method.GetParameters()[0].ParameterType; if (!parameterType.IsInterface && !typeof(Node).IsAssignableFrom(parameterType)) { throw new InvalidOperationException( string.Format("Invalid type parameter [{0}] for visit method [{1}] for type [{2}]. Parameter must inherit from Node", parameterType, method.Name, declaringtype.FullName)); } var thisParameter = LinqExpression.Parameter(typeof(VisitorBase), "this"); var nodeParameter = LinqExpression.Parameter(typeof(object), "node"); var thisCastVariable = LinqExpression.Variable(declaringtype, "thisCast"); var statements = new List <LinqExpression> { LinqExpression.Assign(thisCastVariable, LinqExpression.Convert(thisParameter, declaringtype)) }; var callVisitMethod = LinqExpression.Call(thisCastVariable, method, LinqExpression.Convert(nodeParameter, parameterType)); if (typeof(void) == method.ReturnType) { statements.Add(callVisitMethod); statements.Add(nodeParameter); } else { statements.Add(callVisitMethod); } var block = LinqExpression.Block(new[] { thisCastVariable }, statements); var lambda = LinqExpression.Lambda <NodeVisitFunction>(block, thisParameter, nodeParameter); return(lambda.Compile()); }