/// <summary>
/// 获取字段或属性成员的 <see cref="ColumnAttribute"/>
/// </summary>
/// <param name="member">字段或属性成员</param>
/// <param name="reflectedType">调用字段或属性成员的实际类型</param>
/// <returns></returns>
public static ColumnAttribute GetColumnAttribute(MemberInfo member, Type reflectedType)
{
if (member == null)
{
return(null);
}
if (reflectedType == null)
{
reflectedType = member.ReflectedType ?? member.DeclaringType;
}
ColumnAttribute column = null;
if (!TypeUtils.IsAnonymousType(reflectedType) && !TypeUtils.IsPrimitiveType(reflectedType))
{
var typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo(reflectedType);
var m = typeRuntime.GetMember(member.Name);
if (m != null && m is FieldAccessorBase)
{
column = (m as FieldAccessorBase).Column;
}
}
return(column);
}
/// <summary>
/// 访问字段或者属性表达式，如 g.Key.CompanyName、g.Max(a)
/// </summary>
/// <param name="node">字段或者成员表达式</param>
/// <returns></returns>
protected override Expression VisitMember(MemberExpression node)
{
// 例： g.Max(b=>b.xxxx)
bool byElementSelector = false;
if (_groupBy != null && _groupBy.Expressions.Length == 2)
{
//group new { ClientId2 = a.RizClientId, b.RizAccountId } by new { ClientId = a.RizClientId, b.RizAccountId } into g
//select new
//{
// Max = g.Max(b => b.RizAccountId)
//};
var exp = _groupBy.Expressions[1];
if (exp.NodeType == ExpressionType.Lambda)
{
exp = (exp as LambdaExpression).Body;
}
byElementSelector = node.Expression.Type == exp.Type && TypeUtils.IsAnonymousType(exp.Type);
}
if (node == null)
{
return(node);
}
else if (_groupBy == null || !node.IsGrouping())
{
if (!byElementSelector)
{
return(base.VisitMember(node));
}
else
{
LambdaExpression elmentSelector = _groupBy.Expressions[1] as LambdaExpression;
NewExpression newExpression = elmentSelector.Body as NewExpression;
int index = newExpression.Members.IndexOf(x => x.Name == node.Member.Name);
var exp = newExpression.Arguments[index];
return(this.Visit(exp));
}
}
else
{
string memberName = node.Member.Name;
// Group By 解析 CompanyName = g.Key.Name
LambdaExpression keySelector = _groupBy.Expressions[0] as LambdaExpression;
Expression exp = null;
Expression body = keySelector.Body;
if (body.NodeType == ExpressionType.MemberAccess)
{
// group xx by a.CompanyName
exp = body;
//
//
//
//
}
else if (body.NodeType == ExpressionType.New)
{
// group xx by new { Name = a.CompanyName }
NewExpression newExpression = body as NewExpression;
int index = newExpression.Members.IndexOf(x => x.Name == memberName);
exp = newExpression.Arguments[index];
}
else if (body.NodeType == ExpressionType.MemberInit)
{
// group xx by new App { Name = a.CompanyName }
MemberInitExpression initExpression = body as MemberInitExpression;
int index = initExpression.Bindings.IndexOf(x => x.Member.Name == memberName);
exp = ((MemberAssignment)initExpression.Bindings[index]).Expression;
}
return(this.Visit(exp));
}
}
/// <summary>
/// 初始化 <see cref="TypeRuntimeInfo"/> 类的新实例
/// </summary>
/// <param name="type">类型声明</param>
/// <param name="includePrivates">包含私有成员</param>
internal TypeRuntimeInfo(Type type, bool includePrivates)
{
_type = type;
_isAnonymousType = TypeUtils.IsAnonymousType(_type);
_includePrivates = includePrivates;
}
