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); }
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); }
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 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)); }
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); }
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)); }
Dlr getDlr() { var aToken = childs.Dequeue(); var asig = aToken as Operator; if (asig != null && asig.type == OperatorType.OpenParenthesis) { return(getDlr()); } var a = aToken as Value; if (childs.count == 0) { return(a.value); } var op = childs.Dequeue() as Operator; if (op.type == OperatorType.CloseParenthesis) { return(Dlr.Constant(a.value)); } var b = getValue(); switch (op.type) { case OperatorType.Add: return(Dlr.Add(Dlr.Constant(a.value), Dlr.Constant(b))); case OperatorType.Subtract: return(Dlr.Subtract(Dlr.Constant(a.value), Dlr.Constant(b))); case OperatorType.Divide: return(Dlr.Divide(Dlr.Constant(a.value), Dlr.Constant(b))); case OperatorType.Multiply: return(Dlr.Multiply(Dlr.Constant(a.value), Dlr.Constant(b))); } return(Dlr.Empty()); }
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(); } }
private static Func <object> GetCommandExecutionProviderConstructor(CommandExecutionProviderKey key) { Func <object> constructor; if (!CompiledConstructors.TryGetValue(key, out constructor)) { var executionProviderType = typeof(CommandExecutionProvider <>).MakeGenericType(key.TargetType); var executionProviderCtor = executionProviderType.GetConstructor(new[] { typeof(Type), typeof(string), typeof(string) }); var executionProviderCtorParamaters = new Expression[] { Expression.Constant(key.TargetType), Expression.Constant(key.CanExecuteMethodName, typeof(string)), Expression.Constant(key.ExecutedMethodName, typeof(string)) }; Debug.Assert(executionProviderCtor != null, "executionProviderCtor != null"); var executionProviderCtorExpression = Expression.New( executionProviderCtor, executionProviderCtorParamaters); constructor = Expression.Lambda <Func <object> >(executionProviderCtorExpression).Compile(); } return(constructor); }
Expr Logical(DynamicMetaObject left, DynamicMetaObject right) { // Assign left operand to a temp variable for single evaluation var tempLeft = Expr.Variable(left.LimitType); var compareExpr = (Expr)tempLeft; Expr ifExpr = null; switch (Operation) { case ExprType.AndAlso: if (left.LimitType != typeof(bool)) { compareExpr = Expr.Equal(tempLeft, Expr.Constant(null)); } ifExpr = Expr.IfThenElse(compareExpr, right.Expression, tempLeft); break; case ExprType.OrElse: if (left.LimitType != typeof(bool)) { compareExpr = Expr.NotEqual(tempLeft, Expr.Constant(null)); } ifExpr = Expr.IfThenElse(compareExpr, tempLeft, right.Expression); break; } return (Expr.Block( new[] { tempLeft }, Expr.Assign(tempLeft, left.Expression), ifExpr)); }
public static Expr UnaryMinus(Context context, DynamicMetaObject target) { return(Expr.Invoke( Expr.Constant((Func <Context, object, object>)LuaOps.UnaryMinusMetamethod), Expr.Constant(context, typeof(Context)), Expr.Convert(target.Expression, typeof(object)))); }
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); }
static GlyphRunFormatter() { var refType = typeof(CharacterBufferReference); _textFormattingMode = typeof(GlyphRun).GetField("_textFormattingMode", BindingFlags.NonPublic | BindingFlags.Instance); { var property = refType.GetProperty("CharacterBuffer", BindingFlags.NonPublic | BindingFlags.Instance); var param0 = Expr.Parameter(refType); var expr = Expr.Convert(Expr.Property(param0, property), typeof(IList <char>)); var lambda = Expr.Lambda <Func <CharacterBufferReference, IList <char> > >(expr, param0); getCharBuf = lambda.Compile(); } { var property = refType.GetProperty("OffsetToFirstChar", BindingFlags.NonPublic | BindingFlags.Instance); var param0 = Expr.Parameter(refType); var expr = Expr.Property(param0, property); var lambda = Expr.Lambda <Func <CharacterBufferReference, int> >(expr, param0); getCharOffset = lambda.Compile(); } { var ctor = typeof(TextBounds).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0]; var param0 = Expr.Parameter(typeof(Rect)); var expr = Expr.New(ctor, param0, Expr.Constant(FlowDirection.LeftToRight), Expr.Constant(null, typeof(IList <TextRunBounds>))); var lambda = Expr.Lambda <Func <Rect, TextBounds> >(expr, param0); makeBounds = lambda.Compile(); } }
public override (Expression, ExpressionConversionResult) Convert(ArrayExpression node, ExpressionConverterContext expressionConverterContext, ExpressionConverterScope expressionConverterScope, bool allowTerminal, params Type[] genericArguments) { if (expressionConverterScope.TargetType == typeof(JArray)) { var code = expressionConverterContext.Source.Substring(node.Range.Start, node.Range.End - node.Range.Start + 1); using (var reader = new StringReader(code)) { var @object = JsonSerializer.Deserialize(reader, expressionConverterScope.TargetType); return(Expression.Constant(@object), DefaultResult); } } var targetType = expressionConverterScope.TargetType != null?expressionConverterScope.TargetType.GetEnumerableUnderlyingType() : null; var itemScope = new ExpressionConverterScope(expressionConverterScope, targetType); var elementsExpressions = node.Elements.Select((element, index) => { var itemExpression = expressionConverterContext.ExpressionConverterResolver.Convert(element, expressionConverterContext, itemScope, allowTerminal); if (index == 0 && targetType == null) { targetType = itemExpression.Type; } if (itemExpression.Type != targetType && targetType != null) { itemExpression = Expression.Convert(itemExpression, targetType); } return(itemExpression); }).ToArray(); return(Expression.NewArrayInit(targetType, elementsExpressions), DefaultResult); }
public static Expr Index(Context context, DynamicMetaObject target, DynamicMetaObject[] indexes) { return(Expr.Invoke( Expr.Constant((Func <Context, object, object, object>)LuaOps.IndexMetamethod), Expr.Constant(context, typeof(Context)), Expr.Convert(target.Expression, typeof(object)), Expr.Convert(indexes[0].Expression, typeof(object)))); }
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 )); }
Expr NotOp(DynamicMetaObject target) { if (target.LimitType == typeof(bool)) { return(Expr.MakeUnary(Operation, target.Expression, null)); } return(Expr.Equal(target.Expression, Expr.Constant(null))); }
public static Expr BinaryOp(Context context, ExprType operation, DynamicMetaObject left, DynamicMetaObject right) { return(Expr.Invoke( Expr.Constant((Func <Context, ExprType, object, object, object>)LuaOps.BinaryOpMetamethod), Expr.Constant(context, typeof(Context)), Expr.Constant(operation), Expr.Convert(left.Expression, typeof(object)), Expr.Convert(right.Expression, typeof(object)))); }
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))); }
public override MSAst TransformCore(ScriptGenerator generator) { if (Kind == LiteralKind.Null) { return(MSAst.Default(typeof(object))); } return(MSAst.Constant( _value, Type)); }
public static Expr Call(Context context, DynamicMetaObject target, DynamicMetaObject[] args) { var expression = Expr.Invoke( Expr.Constant((Func <Context, object, object[], object>)LuaOps.CallMetamethod), Expr.Constant(context, typeof(Context)), Expr.Convert(target.Expression, typeof(object)), Expr.NewArrayInit( typeof(object), args.Select(arg => Expr.Convert(arg.Expression, typeof(object))))); return(expression); }
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)); }
protected override LExpression GetExpressionTreeIfPossible(LExpression contextExpression, LExpression evalContext) { if (type == null) { lock (this) { type = TypeResolutionUtils.ResolveType(getText()); } } return(LExpression.Constant(type, typeof(Type))); }
/// <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)); }
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); }
Function ParseFunc(Expression def, bool has_self = false) { string name = def[0].Value; var ps = ParseParameters(def[1].Subset, omitFirstParameter: has_self); /* write IL */ LocalBuilder loc = Local; Local = new LocalBuilder(); var IL = new List <Exp>(); ret.Push(Exp.Label(typeof(Object))); // load parameters var arg = Exp.Parameter(typeof(Args), "arg"); if (has_self) { var self = Exp.Variable(typeof(Object), "self"); Local.Add(self); IL.Add(Exp.Assign(self, Exp.Field(arg, "self"))); } ParamInfo pi; for (int i = 0; i < ps.Info.Length; i++) { pi = ps.Info[i]; var p = Exp.Variable(typeof(Object), pi.Name.str); Local.Add(p); IL.Add(Exp.Assign(p, Exp.Property(arg, "Item", Exp.Constant(i)))); } PushBlock(def.Body, IL); // add the return label target IL.Add(Exp.Label(ret.Pop(), NoneExp)); var body = Exp.Block(Local.Variables, IL); Local = loc; var func = Exp.Lambda <Func <Args, Object> >(body, arg).Compile(); return(new Function { Name = name, Parameters = ps, handler = func }); }
public void ListBind() { var expected = LinqExpression.MemberInit( LinqExpression.New( typeof(SampleClass)), LinqExpression.ListBind( typeof(SampleClass).GetProperty(nameof(SampleClass.ListProperty)), LinqExpression.ElementInit( typeof(List <long>).GetMethod("Add"), LinqExpression.Constant(0L)))); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :memberInitNewExpression [ :newType _:C3 ; ] ; :memberInitBindings ( [ :bindMember [ :memberType _:C3 ; :memberName ""ListProperty"" ; ] ; :listBindInitializers ( [ :elementInitAddMethod [ :memberType [ :typeName ""System.Collections.Generic.List`1[System.Int64]"" ; ] ; :memberName ""Add"" ; ] ; :elementInitArguments ( [ :constantValue 0 ; ] ) ; ] ) ; ] ) ; . _:C3 :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; . "; ShouldBe(actual, expected); }
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 MemberBind() { var expected = LinqExpression.MemberInit( LinqExpression.New( typeof(SampleClass)), LinqExpression.MemberBind( typeof(SampleClass).GetField(nameof(SampleClass.ComplexField)), LinqExpression.Bind( typeof(SampleClass).GetField(nameof(SampleClass.InstanceField)), LinqExpression.Constant( string.Empty)))); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :memberInitNewExpression [ :newType _:C3 ; ] ; :memberInitBindings ( [ :bindMember [ a :Member ; :memberType _:C3 ; :memberName ""ComplexField"" ; ] ; :memberBindBindings ( [ :bindMember [ :memberType _:C3 ; :memberName ""InstanceField"" ; ] ; :bindExpression [ :constantValue """" ; ] ; ] ) ; ] ) ; . _:C3 a :Type ; :typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ; . "; ShouldBe(actual, expected); }
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)); }