|
public static MemberInit ( |
||
| newExpression | A |
|
| return | ||
public void MemberInit_no_bindings()
{
var expression =
LinqExpression.MemberInit(
LinqExpression.New(
typeof(SampleClass)));
ShouldRoundrip(expression);
}
public void MemberInit_bind()
{
var expression =
LinqExpression.MemberInit(
LinqExpression.New(
typeof(SampleClass)),
LinqExpression.Bind(
typeof(SampleClass).GetField(nameof(SampleClass.InstanceField)),
LinqExpression.Constant(string.Empty)));
ShouldRoundrip(expression);
}
public void MemberInit_list_bind()
{
var expression =
LinqExpression.MemberInit(
LinqExpression.New(
typeof(SampleClass)),
LinqExpression.ListBind(
typeof(SampleClass).GetProperty(nameof(SampleClass.ListProperty)),
LinqExpression.ElementInit(
typeof(List <long>).GetMethod("Add"),
LinqExpression.Constant(0L))));
ShouldRoundrip(expression);
}
public Expression CreateInitExpression()
{
List <MemberBinding> bindings = new List <MemberBinding>();
var modelType = ((PropertyInfo)ModelProperty.Member).PropertyType;
var responseType = ResponseProperty.PropertyType;
var props = responseType.GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(x => x.CanWrite);
foreach (var p in props)
{
IncludeTree include;
Expression bind = null;
if (!Includes.TryGetValue(p.Name, out include))
{
NavigationPropertyAttribute navAttr = p.GetCustomAttribute <NavigationPropertyAttribute>();
if (navAttr != null)
{
var navModelProp = Expression.Property(ModelProperty, modelType.GetProperty(navAttr.NavigationProperty));
var navProp = Expression.Property(navModelProp, ((PropertyInfo)navModelProp.Member).PropertyType.GetProperty(navAttr.Property));
bind = navProp;
}
else if (IsMappeable(p))
{
bind = Expression.Property(ModelProperty, modelType.GetProperty(p.Name));
}
}
else
{
bind = include.CreateInitExpression();
}
if (bind != null)
{
bindings.Add(Expression.Bind(p, bind));
}
}
NewExpression newResponse = Expression.New(responseType);
MemberInitExpression initExpression = Expression.MemberInit(newResponse, bindings);
return(initExpression);
}
private static Expression CreateValueExpression(DataType value, Expression result)
{
Expression FromString(string str)
{
return(result is MemberExpression me
? (Expression)Expression.MemberInit(
Expression.New(me.Type.GetConstructor(Array.Empty <Type>())),
Expression.Bind(
me.Type.GetProperty("ObjectValue"),
Expression.Constant(str)))
: Expression.Constant(value));
}
return(value switch
{
Code code => FromString(code.Value),
FhirString str => FromString(str.Value),
_ => Expression.Constant(value)
});
public static System.Linq.Expressions.Expression <Func <object[], object> > CreateComplexExpression(string p = null)
{
var stateParamExpr = SysExpr.Parameter(typeof(object[]), p);
var expr = SysExpr.Lambda <Func <object[], object> >(
SysExpr.MemberInit(
SysExpr.New(_ctorOfA,
SysExpr.New(_ctorOfB),
SysExpr.Convert(SysExpr.ArrayIndex(stateParamExpr, SysExpr.Constant(11)), typeof(string)),
SysExpr.NewArrayInit(typeof(ID),
SysExpr.New(_ctorOfD1),
SysExpr.New(_ctorOfD2))),
SysExpr.Bind(_propAProp,
SysExpr.New(_ctorOfP,
SysExpr.New(_ctorOfB))),
SysExpr.Bind(_fieldABop,
SysExpr.New(_ctorOfB))),
stateParamExpr);
return(expr);
}
private static Func <TIn, TOut> GetFunc()
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
List <MemberBinding> memberBindingList = new List <MemberBinding>();
foreach (var item in typeof(TOut).GetProperties())
{
if (!item.CanWrite)
{
continue;
}
MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
MemberBinding memberBinding = Expression.Bind(item, property);
memberBindingList.Add(memberBinding);
}
MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
Expression <Func <TIn, TOut> > lambda = Expression.Lambda <Func <TIn, TOut> >(memberInitExpression, new ParameterExpression[] { parameterExpression });
return(lambda.Compile());
}
public Expression <Func <T, TResponse> > Select <TResponse>(string include = null)
{
List <MemberBinding> bindings = new List <MemberBinding>();
foreach (var p in ResponseType.GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(x => x.CanWrite))
{
NavigationPropertyAttribute navAttr = p.GetCustomAttribute <NavigationPropertyAttribute>();
if (navAttr != null)
{
bindings.Add(Expression.Bind(p, Expression.Property(Expression.Property(Parameter, navAttr.NavigationProperty), navAttr.Property)));
}
else if (IncludeTree.IsMappeable(p))
{
bindings.Add(Expression.Bind(p, Expression.Property(Parameter, p.Name)));
}
}
if (!string.IsNullOrWhiteSpace(include))
{
var incTrees = IncludeTree.Build(include, ResponseType, ModelType, Parameter);
foreach (var item in incTrees)
{
bindings.Add(Expression.Bind(item.ResponseProperty, item.CreateInitExpression()));
}
}
MemberInitExpression initExpression = Expression.MemberInit(Expression.New(typeof(TResponse)), bindings);
Expression current = Parameter;
while (current != null && !(current is ParameterExpression))
{
current = ((MemberExpression)current).Expression;
}
return(Expression.Lambda <Func <T, TResponse> >(initExpression, (ParameterExpression)current));
}
/// <inheritdoc /> protected override Expression VisitMemberInit(MemberInitExpression init) => Expression.MemberInit(VisitNew(init.NewExpression), VisitBindingList(init.Bindings));
public override SysExpr ToExpression() => SysExpr.MemberInit(NewExpression.ToNewExpression(), Bindings.Map(b => b.ToMemberBinding()));
public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, MemberBinding[] bindings) => Expression.MemberBind(propertyAccessor, bindings); // NB: Used for properties.
public static MemberInitExpression MemberInit(NewExpression newExpression, MemberBinding[] bindings) => Expression.MemberInit(newExpression, bindings);
