protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment) { Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(assignment.Member.Name) + _rightBracket); Write(" = "); Visit(assignment.Expression); return(assignment); }
private Expression Evaluate(Expression e) { Type type = e.Type; if (e.NodeType == ExpressionType.Convert && AtkTypeHelper.GetNonNullableType(((UnaryExpression)e).Operand.Type) == AtkTypeHelper.GetNonNullableType(type)) { e = ((UnaryExpression)e).Operand; } if (e.NodeType == ExpressionType.Constant) { ConstantExpression constantExpression = (ConstantExpression)e; if (e.Type != type && AtkTypeHelper.GetNonNullableType(e.Type) == AtkTypeHelper.GetNonNullableType(type)) { e = Expression.Constant(constantExpression.Value, type); } return(e); } MemberExpression memberExpression = e as MemberExpression; if (memberExpression != null) { ConstantExpression expression = memberExpression.Expression as ConstantExpression; if (expression != null) { return(Expression.Constant(memberExpression.Member.GetValue(expression.Value), type)); } } if (type.IsValueType) { e = Expression.Convert(e, typeof(object)); } return(Expression.Constant(Expression.Lambda <Func <object> >(e, Array.Empty <ParameterExpression>()).Compile()(), type)); }
public static Type GetNonNullableType(Type type) { if (AtkTypeHelper.IsNullableType(type)) { return(type.GetGenericArguments()[0]); } return(type); }
public static object GetDefault(Type type) { if (type.IsValueType && !AtkTypeHelper.IsNullableType(type)) { return(Activator.CreateInstance(type)); } return((object)null); }
public static Type GetNullAssignableType(Type type) { if (AtkTypeHelper.IsNullAssignable(type)) { return(type); } return(typeof(Nullable <>).MakeGenericType(type)); }
private Expression Evaluate(System.Linq.Expressions.Expression e) { Type type = e.Type; // check for nullable converts & strip them if (e.NodeType == ExpressionType.Convert) { var u = (UnaryExpression)e; if (AtkTypeHelper.GetNonNullableType(u.Operand.Type) == AtkTypeHelper.GetNonNullableType(type)) { e = ((UnaryExpression)e).Operand; } } // if we now just have a constant, return it if (e.NodeType == ExpressionType.Constant) { var ce = (ConstantExpression)e; // if we've lost our nullable typeness add it back if (e.Type != type && AtkTypeHelper.GetNonNullableType(e.Type) == AtkTypeHelper.GetNonNullableType(type)) { e = ce = System.Linq.Expressions.Expression.Constant(ce.Value, type); } return(e); } var me = e as MemberExpression; if (me != null) { // member accesses off of constant's are common, and yet since these partial evals // are never re-used, using reflection to access the member is faster than compiling // and invoking a lambda var ce = me.Expression as ConstantExpression; if (ce != null) { return(System.Linq.Expressions.Expression.Constant(Atk.AtkExpression.AtkReflectionExtensions.GetValue(me.Member, ce.Value), type)); } } if (type.IsValueType) { e = System.Linq.Expressions.Expression.Convert(e, typeof(object)); } Expression <Func <object> > lambda = System.Linq.Expressions.Expression.Lambda <Func <object> >(e); #if NOREFEMIT Func <object> fn = ExpressionEvaluator.CreateDelegate(lambda); #else Func <object> fn = lambda.Compile(); #endif return(System.Linq.Expressions.Expression.Constant(fn(), type)); }
public static Type GetElementType(Type seqType) { Type ienumerable = AtkTypeHelper.FindIEnumerable(seqType); if (ienumerable == (Type)null) { return(seqType); } return(ienumerable.GetGenericArguments()[0]); }
protected override MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding) { Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(binding.Member.Name) + _rightBracket); Write(" = {"); WriteLine(Indentation.Inner); VisitBindingList(binding.Bindings); WriteLine(Indentation.Outer); Write("}"); return(binding); }
protected override MemberListBinding VisitMemberListBinding(MemberListBinding binding) { Write(_tableAlias + _leftbracket + AtkTypeHelper.GetColumnAlias <T>(binding.Member.Name) + _rightbracket); Write(" = {"); WriteLine(Indentation.Inner); VisitElementInitializerList(binding.Initializers); WriteLine(Indentation.Outer); Write("}"); return(binding); }
public static object GetDefault(Type type) { bool isNullable = !type.IsValueType || AtkTypeHelper.IsNullableType(type); if (!isNullable) { return(Activator.CreateInstance(type)); } return(null); }
protected override Expression VisitNewArray(NewArrayExpression na) { Write("new "); Write(GetTypeName(AtkTypeHelper.GetElementType(na.Type))); Write("[] {"); if (na.Expressions.Count > 1) { WriteLine(Indentation.Inner); } VisitExpressionList(na.Expressions); if (na.Expressions.Count > 1) { WriteLine(Indentation.Outer); } Write("}"); return(na); }
public static Type FindIEnumerable(Type seqType) { if (seqType == (Type)null || seqType == typeof(string)) { return((Type)null); } if (seqType.IsArray) { return(typeof(IEnumerable <>).MakeGenericType(seqType.GetElementType())); } if (seqType.IsGenericType) { foreach (Type genericArgument in seqType.GetGenericArguments()) { Type type = typeof(IEnumerable <>).MakeGenericType(genericArgument); if (type.IsAssignableFrom(seqType)) { return(type); } } } Type[] interfaces = seqType.GetInterfaces(); if (interfaces != null && (uint)interfaces.Length > 0U) { foreach (Type seqType1 in interfaces) { Type ienumerable = AtkTypeHelper.FindIEnumerable(seqType1); if (ienumerable != (Type)null) { return(ienumerable); } } } if (seqType.BaseType != (Type)null && seqType.BaseType != typeof(object)) { return(AtkTypeHelper.FindIEnumerable(seqType.BaseType)); } return((Type)null); }
public static bool IsNullAssignable(Type type) { return(!type.IsValueType || AtkTypeHelper.IsNullableType(type)); }
public static bool IsInteger(Type type) { AtkTypeHelper.GetNonNullableType(type); return((uint)(Type.GetTypeCode(type) - 5) <= 7U); }
public static ConstantExpression GetNullConstant(Type type) { return(Expression.Constant((object)null, AtkTypeHelper.GetNullAssignableType(type))); }
protected override Expression VisitMemberAccess(MemberExpression m) { if (m.Member.DeclaringType == typeof(string)) { Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(m.Member.Name) + _rightBracket); if (m.Member.Name == "Length") { Write("LEN("); Visit(m.Expression); Write(")"); return(m); } } else if (m.Member.DeclaringType != null && (m.Member.DeclaringType.IsGenericType && m.Member.DeclaringType.GetGenericTypeDefinition() == typeof(Nullable <>))) { if (m.Member.Name == "HasValue") { Write("("); Visit(m.Expression); Write(" IS NOT NULL)"); return(m); } } else if (m.Member.DeclaringType == typeof(DateTime) || m.Member.DeclaringType == typeof(DateTimeOffset)) { Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(m.Member.Name) + _rightBracket); switch (m.Member.Name) { case "Day": Write("DAY("); Visit(m.Expression); Write(")"); return(m); case "DayOfWeek": Write("(DATEPART(weekday, "); Visit(m.Expression); Write(") - 1)"); return(m); case "DayOfYear": Write("(DATEPART(dayofyear, "); Visit(m.Expression); Write(") - 1)"); return(m); case "Hour": Write("DATEPART(hour, "); Visit(m.Expression); Write(")"); return(m); case "Millisecond": Write("DATEPART(millisecond, "); Visit(m.Expression); Write(")"); return(m); case "Minute": Write("DATEPART(minute, "); Visit(m.Expression); Write(")"); return(m); case "Month": Write("MONTH("); Visit(m.Expression); Write(")"); return(m); case "Second": Write("DATEPART(second, "); Visit(m.Expression); Write(")"); return(m); case "Year": Write("YEAR("); Visit(m.Expression); Write(")"); return(m); } } else if (IsRight) { Write("@" + m.Member.Name); } else { Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(m.Member.Name) + _rightBracket); } return(base.VisitMemberAccess(m)); }