|
public static MakeMemberAccess ( |
||
| expression | The containing object of the member. This can be null for static members. | |
| member | The member to be accessed. | |
| return | ||
private static Accessor GetAccessor <TAttribute>(Type targetType)
where TAttribute : Attribute
{
Accessor accessor;
var cache = GetCache <TAttribute>();
if (cache.TryGetValue(targetType, out accessor))
{
return(accessor);
}
var member = FindMember <TAttribute>(targetType);
if (member == null)
{
cache[targetType] = NullCallback;
return(NullCallback);
}
var targetParameter = E.Parameter(typeof(object), "target");
var accessorExpression = E.Lambda <Accessor>(
E.Convert(
E.MakeMemberAccess(
E.Convert(targetParameter, targetType),
member),
typeof(object)),
targetParameter);
accessor = accessorExpression.Compile();
cache[targetType] = accessor;
return(accessor);
}
private static IQueryable <TResult> CreateSelector <TInput, TResult>(IQueryable <TInput> input,
MemberInfo property, QueryableMonad <TInput, TResult> method)
{
var source = Expression.Parameter(typeof(TInput), "x");
Expression propertyAccessor = Expression.MakeMemberAccess(source, property);
var expression = Expression.Lambda <Func <TInput, TResult> >(propertyAccessor, source);
return(method(input, expression));
}
private static (SystemExpression, UnaryExpression) GetBodyExpressions(ParameterExpression parameter, string propertyName, object value)
{
var documentType = typeof(TQueryable);
if (propertyName.Contains("."))
{
var propertyType = documentType;
var propertyNames = propertyName.Split('.');
SystemExpression bodyLeft = parameter;
foreach (var property in propertyNames)
{
var propertyInfo = propertyType.GetProperty(property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
if (propertyInfo == null)
{
throw new ArgumentOutOfRangeException(nameof(propertyInfo), propertyName);
}
propertyType = propertyInfo.PropertyType;
bodyLeft = SystemExpression.Property(bodyLeft, property);
}
var bodyRight =
SystemExpression.Convert(
SystemExpression.Constant(GetConstantValue(value, bodyLeft.Type)),
bodyLeft.Type
);
return(bodyLeft, bodyRight);
}
else
{
var propertyInfo = documentType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
if (propertyInfo == null)
{
throw new ArgumentOutOfRangeException(nameof(propertyName), propertyName);
}
var bodyLeft = SystemExpression.MakeMemberAccess(parameter, propertyInfo);
var bodyRight =
SystemExpression.Convert(
SystemExpression.Constant(GetConstantValue(value, propertyInfo.PropertyType)),
propertyInfo.PropertyType
);
return(bodyLeft, bodyRight);
}
}
private MemberExpression MemberExpression(ExpressionType nodeType, System.Type type, JObject obj)
{
var expression = this.Prop(obj, "expression", this.Expression);
var member = this.Prop(obj, "member", this.Member);
switch (nodeType)
{
case ExpressionType.MemberAccess:
return(Expr.MakeMemberAccess(expression, member));
default:
throw new NotSupportedException();
}
}
public static Expression <Func <Sensor, bool> > CreateLambda(Property property, Func <Expr, Expr> expr)
{
var prop = typeof(Sensor)
.GetProperties().First(e => e.GetCustomAttributes(typeof(PropertyParameterAttribute), false)
.Cast <PropertyParameterAttribute>()
.Any(p => ((Property)Enum.Parse(typeof(Property), p.Name, true)) == property));
var parameter = Expr.Parameter(typeof(Sensor), "s");
var member = Expr.MakeMemberAccess(parameter, prop);
var lambda = Expr.Lambda <Func <Sensor, bool> >(
expr(member),
parameter
);
return(lambda);
}
/// <summary>
/// 创建属性表达式
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="member">属性</param>
public static MicrosoftExpression Property(this MicrosoftExpression expression, MemberInfo member)
{
return(MicrosoftExpression.MakeMemberAccess(expression, member));
}
/// <inheritdoc/>
protected override IEnumerable <Act> Query(Expression <Func <Act, bool> > query, Guid queryId, int offset, int count, out int totalResults)
{
var typeReference = Expression.MakeBinary(ExpressionType.Equal, Expression.Convert(Expression.MakeMemberAccess(query.Parameters[0], typeof(Act).GetProperty(nameof(Act.ClassConceptKey))), typeof(Guid)), Expression.Constant(ActClassKeys.Condition));
var anyRef = this.CreateConceptSetFilter(ConceptSetKeys.AdverseEventActs, query.Parameters[0]);
query = Expression.Lambda <Func <Act, bool> >(Expression.AndAlso(Expression.AndAlso(query.Body, anyRef), typeReference), query.Parameters);
return(base.Query(query, queryId, offset, count, out totalResults));
}
public override Expr MakeAccess(Expr parent)
{
return(Expr.MakeMemberAccess(parent, _memberInfo));
}
private bool TryGetOrders(ModelBindingContext bindingContext, out List <QueryOrder> queryOrders)
{
queryOrders = new List <QueryOrder>();
var sortIndex = 0;
while (true)
{
var sortFieldValue = bindingContext.ValueProvider.GetValue($"sort[{sortIndex}][field]");
if (sortFieldValue.Length == 0)
{
break;
}
if (sortFieldValue.Length != 1)
{
throw new ArgumentOutOfRangeException(nameof(sortFieldValue), sortFieldValue.Length, null);
}
var sortDirValue = bindingContext.ValueProvider.GetValue($"sort[{sortIndex}][dir]");
if (sortDirValue.Length != 0 && sortDirValue.Length != 1)
{
throw new ArgumentOutOfRangeException(nameof(sortDirValue), sortDirValue.Length, null);
}
var documentType = typeof(TQueryable);
var parameter = SystemExpression.Parameter(documentType, "queryable");
if (sortFieldValue.FirstValue.Contains("."))
{
var propertyType = documentType;
var propertyNames = sortFieldValue.FirstValue.Split('.');
SystemExpression body = parameter;
foreach (var property in propertyNames)
{
var propertyInfo = propertyType.GetProperty(property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
if (propertyInfo == null)
{
throw new ArgumentOutOfRangeException(nameof(propertyInfo), sortFieldValue.FirstValue);
}
propertyType = propertyInfo.PropertyType;
body = SystemExpression.Property(body, property);
}
var delegateType = typeof(Func <,>).MakeGenericType(documentType, propertyType);
var queryOrder = new QueryOrder
{
Expression = SystemExpression.Lambda(delegateType, body, parameter),
IsDescending = sortDirValue.Length == 1 && sortDirValue.FirstValue == "desc"
};
queryOrders.Add(queryOrder);
sortIndex++;
}
else
{
var propertyInfo = documentType.GetProperty(sortFieldValue.FirstValue, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
if (propertyInfo == null)
{
throw new ArgumentOutOfRangeException(nameof(sortFieldValue), sortFieldValue.FirstValue, null);
}
var delegateType = typeof(Func <,>).MakeGenericType(documentType, propertyInfo.PropertyType);
var body = SystemExpression.MakeMemberAccess(parameter, propertyInfo);
var queryOrder = new QueryOrder
{
Expression = SystemExpression.Lambda(delegateType, body, parameter),
IsDescending = sortDirValue.Length == 1 && sortDirValue.FirstValue == "desc"
};
queryOrders.Add(queryOrder);
sortIndex++;
}
}
return(queryOrders.Count > 0);
}
protected override Expression VisitMember(MemberExpression node) => Linearize(args => Ex.MakeMemberAccess(args[0], node.Member), node.Expression);
public Expr ToExpression() => Expr.MakeMemberAccess(DeclaringInstance.ToExpression(), Member.MemberInfo);
/// <summary>
/// Query for substance administrations that aren't immunizations
/// </summary>
/// <param name="query">The query.</param>
/// <param name="offset">The offset.</param>
/// <param name="count">The count.</param>
/// <param name="totalResults">The total results.</param>
/// <param name="queryId">The unique query state identifier</param>
/// <returns>Returns the list of models which match the given parameters.</returns>
protected override IEnumerable <SubstanceAdministration> Query(Expression <Func <SubstanceAdministration, bool> > query, Guid queryId, int offset, int count, out int totalResults)
{
var drugTherapy = Guid.Parse("7D84A057-1FCC-4054-A51F-B77D230FC6D1");
var obsoletionReference = Expression.MakeBinary(ExpressionType.Equal, Expression.Convert(Expression.MakeMemberAccess(query.Parameters[0], typeof(SubstanceAdministration).GetProperty(nameof(SubstanceAdministration.StatusConceptKey))), typeof(Guid)), Expression.Constant(StatusKeys.Completed));
var typeReference = Expression.MakeBinary(ExpressionType.Equal, Expression.Convert(Expression.MakeMemberAccess(query.Parameters[0], typeof(SubstanceAdministration).GetProperty(nameof(SubstanceAdministration.TypeConceptKey))), typeof(Guid)), Expression.Constant(drugTherapy));
query = Expression.Lambda <Func <SubstanceAdministration, bool> >(Expression.AndAlso(Expression.AndAlso(obsoletionReference, query.Body), typeReference), query.Parameters);
if (queryId == Guid.Empty)
{
return(this.m_repository.Find(query, offset, count, out totalResults));
}
return((this.m_repository as IPersistableQueryRepositoryService <SubstanceAdministration>).Find(query, offset, count, out totalResults, queryId));
}
public override TreeNode TryUnroll()
{
if (!MustUnroll)
{
return(this);
}
// Reduce begins now
var bodyExpression = new TreeNode()
{
TypeToken = Array.TypeToken.GetElementTypeToken(),
MemberToken = Array.MemberToken,
AccessExpression = Array.AccessExpression
};
// Array initializer added now and only now
bodyExpression.ReadExpression.Add(bodyExpression.TypeToken.NewArrayBounds(Expr.Constant(IterationCount - InitialValue)));
// Create N blocks of body
for (var i = 0; i < IterationCount - InitialValue; ++i)
{
var invocationNode = new TreeNode()
{
// Can't reuse this.AccessExpression because it's bound on the iterator.
AccessExpression = Expr.ArrayAccess(Array.AccessExpression, Expr.Constant(i)),
MemberToken = Array.MemberToken,
TypeToken = Array.TypeToken.GetElementTypeToken()
};
// Insert ctor if class
if (invocationNode.TypeToken.IsClass)
{
invocationNode.ReadExpression.Add(invocationNode.TypeToken.NewExpression());
}
// Insert all children
foreach (var childNode in Children)
{
var newChildNode = new TreeNode()
{
AccessExpression = Expr.MakeMemberAccess(invocationNode.AccessExpression, childNode.MemberToken.MemberInfo),
MemberToken = childNode.MemberToken,
TypeToken = childNode.TypeToken
};
// Now that we created a new block we must try to unroll it if it needs to
foreach (var subChildNode in childNode.Children)
{
newChildNode.AddChild(subChildNode.TryUnroll());
}
// If deserialization calls were found select the one corresponding to the currently unrolling iteration.
if (childNode.ReadExpression.Count > 0)
{
newChildNode.ReadExpression.Add(childNode.ReadExpression[i]);
}
invocationNode.AddChild(newChildNode);
}
bodyExpression.AddChild(invocationNode);
}
return(bodyExpression);
}
