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());
}