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