private HqlTreeNode VisitTypeBinaryExpression(TypeBinaryExpression expression)
{
return(BuildOfType(expression.Expression, expression.TypeOperand));
}
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
this.expressions.Add(node);
return(base.VisitTypeBinary(node));
}
protected override Expression VisitTypeIs(TypeBinaryExpression expression)
{
this.hashCode ^= expression.TypeOperand.GetHashCode();
return(base.VisitTypeIs(expression));
}
/// <summary>
/// Creates a <see cref="TypeBinaryExpression"/>.
/// </summary>
/// <param name="expression"><see cref="TypeBinaryExpression"/> to visit.</param>
/// <returns>Returns a <see cref="TypeBinaryExpression"/>.</returns>
/// <seealso cref="ExpressionVisitor.VisitTypeBinaryExpression"/>
protected override object VisitTypeBinaryExpression(TypeBinaryExpression expression)
{
return(Expression.TypeIs(VisitExpression(expression.Expression), expression.TypeOperand));
}
private int VisitTypeIs(TypeBinaryExpression tb)
{
return(CalculateHashCode(tb.Expression) ^ tb.TypeOperand.GetHashCode());
}
protected override Expression MakeTypeBinary(TypeBinaryExpression node, Expression expression) => throw new NotImplementedException();
// TypeBinaryExpression
protected internal virtual bool Walk(TypeBinaryExpression node) { return true; }
private Expression Rewrite(Expression expression, ReadOnlyCollection <ParameterExpression> lambdaParameters)
{
Func <Expression, Expression> selector = null;
Func <ElementInit, ElementInit> func2 = null;
Func <MemberBinding, MemberBinding> func3 = null;
Func <Expression, Expression> func4 = null;
Func <Expression, Expression> func5 = null;
Func <Expression, Expression> func6 = null;
Func <Expression, Expression> func7 = null;
Func <Expression, Expression> func8 = null;
if (expression == null)
{
return(null);
}
switch (expression.NodeType)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
case ExpressionType.And:
case ExpressionType.AndAlso:
case ExpressionType.Coalesce:
case ExpressionType.Divide:
case ExpressionType.Equal:
case ExpressionType.ExclusiveOr:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LeftShift:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.Modulo:
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
case ExpressionType.NotEqual:
case ExpressionType.Or:
case ExpressionType.OrElse:
case ExpressionType.Power:
case ExpressionType.RightShift:
case ExpressionType.Subtract:
case ExpressionType.SubtractChecked:
{
BinaryExpression expression2 = (BinaryExpression)expression;
return(Expression.MakeBinary(expression2.NodeType, this.Rewrite(expression2.Left, lambdaParameters), this.Rewrite(expression2.Right, lambdaParameters), expression2.IsLiftedToNull, expression2.Method, (LambdaExpression)this.Rewrite(expression2.Conversion, lambdaParameters)));
}
case ExpressionType.ArrayLength:
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.Not:
case ExpressionType.Quote:
case ExpressionType.TypeAs:
{
UnaryExpression expression17 = (UnaryExpression)expression;
return(Expression.MakeUnary(expression17.NodeType, this.Rewrite(expression17.Operand, lambdaParameters), expression17.Type, expression17.Method));
}
case ExpressionType.ArrayIndex:
{
MethodCallExpression expression10 = expression as MethodCallExpression;
if (expression10 == null)
{
BinaryExpression expression11 = (BinaryExpression)expression;
return(Expression.ArrayIndex(this.Rewrite(expression11.Left, lambdaParameters), this.Rewrite(expression11.Right, lambdaParameters)));
}
if (func4 == null)
{
func4 = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.ArrayIndex(this.Rewrite(expression10.Object, lambdaParameters), expression10.Arguments.Select <Expression, Expression>(func4)));
}
case ExpressionType.Call:
{
MethodCallExpression expression12 = (MethodCallExpression)expression;
if (func5 == null)
{
func5 = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.Call(this.Rewrite(expression12.Object, lambdaParameters), expression12.Method, expression12.Arguments.Select <Expression, Expression>(func5)));
}
case ExpressionType.Conditional:
{
ConditionalExpression expression3 = (ConditionalExpression)expression;
return(Expression.Condition(this.Rewrite(expression3.Test, lambdaParameters), this.Rewrite(expression3.IfTrue, lambdaParameters), this.Rewrite(expression3.IfFalse, lambdaParameters)));
}
case ExpressionType.Constant:
return(expression);
case ExpressionType.Invoke:
{
InvocationExpression expression4 = (InvocationExpression)expression;
if (selector == null)
{
selector = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.Invoke(this.Rewrite(expression4.Expression, lambdaParameters), expression4.Arguments.Select <Expression, Expression>(selector)));
}
case ExpressionType.Lambda:
{
LambdaExpression expression5 = (LambdaExpression)expression;
return(Expression.Lambda(expression5.Type, this.Rewrite(expression5.Body, expression5.Parameters), expression5.Parameters));
}
case ExpressionType.ListInit:
{
ListInitExpression expression6 = (ListInitExpression)expression;
if (func2 == null)
{
func2 = ei => Expression.ElementInit(ei.AddMethod, (IEnumerable <Expression>)(from arg in ei.Arguments select this.Rewrite(arg, lambdaParameters)));
}
return(Expression.ListInit((NewExpression)this.Rewrite(expression6.NewExpression, lambdaParameters), expression6.Initializers.Select <ElementInit, ElementInit>(func2)));
}
case ExpressionType.MemberAccess:
{
MemberExpression expression8 = (MemberExpression)expression;
return(Expression.MakeMemberAccess(this.Rewrite(expression8.Expression, lambdaParameters), expression8.Member));
}
case ExpressionType.MemberInit:
{
MemberInitExpression expression9 = (MemberInitExpression)expression;
if (func3 == null)
{
func3 = b => this.Rewrite(b, lambdaParameters);
}
return(Expression.MemberInit((NewExpression)this.Rewrite(expression9.NewExpression, lambdaParameters), expression9.Bindings.Select <MemberBinding, MemberBinding>(func3)));
}
case ExpressionType.UnaryPlus:
{
UnaryExpression expression18 = (UnaryExpression)expression;
return(Expression.UnaryPlus(this.Rewrite(expression18.Operand, lambdaParameters), expression18.Method));
}
case ExpressionType.New:
{
NewExpression expression15 = (NewExpression)expression;
if (expression15.Constructor != null)
{
if (func8 == null)
{
func8 = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.New(expression15.Constructor, expression15.Arguments.Select <Expression, Expression>(func8)));
}
return(expression);
}
case ExpressionType.NewArrayInit:
{
NewArrayExpression expression13 = (NewArrayExpression)expression;
if (func6 == null)
{
func6 = e => this.Rewrite(e, lambdaParameters);
}
return(Expression.NewArrayInit(expression13.Type.GetElementType(), expression13.Expressions.Select <Expression, Expression>(func6)));
}
case ExpressionType.NewArrayBounds:
{
NewArrayExpression expression14 = (NewArrayExpression)expression;
if (func7 == null)
{
func7 = e => this.Rewrite(e, lambdaParameters);
}
return(Expression.NewArrayBounds(expression14.Type.GetElementType(), expression14.Expressions.Select <Expression, Expression>(func7)));
}
case ExpressionType.Parameter:
{
ParameterExpression expression7 = (ParameterExpression)expression;
if ((lambdaParameters == null) || !lambdaParameters.Contains(expression7))
{
string name = expression7.Name;
for (LocationReferenceEnvironment environment = this.environment; environment != null; environment = environment.Parent)
{
foreach (LocationReference reference in environment.GetLocationReferences())
{
if (string.Equals(reference.Name, name, StringComparison.OrdinalIgnoreCase))
{
LocationReference reference3;
LocationReference locationReference = reference;
if (this.metadata.HasValue && this.metadata.Value.TryGetInlinedLocationReference(reference, out reference3))
{
locationReference = reference3;
}
return(ExpressionUtilities.CreateIdentifierExpression(locationReference));
}
}
}
return(expression7);
}
return(expression7);
}
case ExpressionType.TypeIs:
{
TypeBinaryExpression expression16 = (TypeBinaryExpression)expression;
return(Expression.TypeIs(this.Rewrite(expression16.Expression, lambdaParameters), expression16.TypeOperand));
}
case ExpressionType.Assign:
{
BinaryExpression expression22 = (BinaryExpression)expression;
return(Expression.Assign(this.Rewrite(expression22.Left, lambdaParameters), this.Rewrite(expression22.Right, lambdaParameters)));
}
case ExpressionType.Block:
{
BlockExpression expression19 = (BlockExpression)expression;
List <ParameterExpression> list = new List <ParameterExpression>();
foreach (ParameterExpression expression20 in expression19.Variables)
{
list.Add((ParameterExpression)this.Rewrite(expression20, lambdaParameters));
}
List <Expression> list2 = new List <Expression>();
foreach (Expression expression21 in expression19.Expressions)
{
list2.Add(this.Rewrite(expression21, lambdaParameters));
}
return(Expression.Block((IEnumerable <ParameterExpression>)list, (IEnumerable <Expression>)list2));
}
}
return(expression);
}
/// <summary> /// Visit a <see cref="TypeBinaryExpression"/>. /// </summary> /// <param name="expression"><see cref="TypeBinaryExpression"/> to visit.</param> /// <returns>Returns the result of the visit.</returns> protected abstract object VisitTypeBinaryExpression(TypeBinaryExpression expression);
private Expression UpdateTypeEqual(TypeBinaryExpression exp, Expression result)
{
if (exp.Expression != result) {
return Expression.TypeEqual(result, exp.TypeOperand);
}
return exp;
}
protected virtual bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b)
{
return a.TypeOperand == b.TypeOperand
&& this.Compare(a.Expression, b.Expression);
}
protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
{
Expression expr = this.Visit(b.Expression);
return this.UpdateTypeIs(b, expr, b.TypeOperand);
}
protected virtual Expression VisitTypeEqual(TypeBinaryExpression exp)
{
var result = this.Visit(exp.Expression);
return UpdateTypeEqual(exp, result);
}
protected TypeBinaryExpression UpdateTypeIs(TypeBinaryExpression b, Expression expression, Type typeOperand)
{
if (expression != b.Expression || typeOperand != b.TypeOperand)
{
return Expression.TypeIs(expression, typeOperand);
}
return b;
}
protected override Expression VisitTypeBinary(TypeBinaryExpression b)
{
return(MakeDirtyMeta(b.Type, null, Visit(b.Expression)));
}
static void FindTypeReferences(Expression expression, HashSet <Type> typeReferences)
{
if (expression == null)
{
return;
}
switch (expression.NodeType)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
case ExpressionType.And:
case ExpressionType.AndAlso:
case ExpressionType.Coalesce:
case ExpressionType.Divide:
case ExpressionType.Equal:
case ExpressionType.ExclusiveOr:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LeftShift:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.Modulo:
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
case ExpressionType.NotEqual:
case ExpressionType.Or:
case ExpressionType.OrElse:
case ExpressionType.Power:
case ExpressionType.RightShift:
case ExpressionType.Subtract:
case ExpressionType.SubtractChecked:
BinaryExpression binaryExpression = (BinaryExpression)expression;
FindTypeReferences(binaryExpression.Left, typeReferences);
FindTypeReferences(binaryExpression.Right, typeReferences);
return;
case ExpressionType.Conditional:
ConditionalExpression conditional = (ConditionalExpression)expression;
FindTypeReferences(conditional.Test, typeReferences);
FindTypeReferences(conditional.IfTrue, typeReferences);
FindTypeReferences(conditional.IfFalse, typeReferences);
return;
case ExpressionType.Constant:
ConstantExpression constantExpr = (ConstantExpression)expression;
if (constantExpr.Value is Type)
{
EnsureTypeReferenced((Type)constantExpr.Value, true, typeReferences);
}
else if (constantExpr.Value != null)
{
EnsureTypeReferenced(constantExpr.Value.GetType(), true, typeReferences);
}
return;
case ExpressionType.Invoke:
InvocationExpression invocation = (InvocationExpression)expression;
FindTypeReferences(invocation.Expression, typeReferences);
for (int i = 0; i < invocation.Arguments.Count; i++)
{
FindTypeReferences(invocation.Arguments[i], typeReferences);
}
return;
case ExpressionType.Lambda:
LambdaExpression lambda = (LambdaExpression)expression;
FindTypeReferences(lambda.Body, typeReferences);
for (int i = 0; i < lambda.Parameters.Count; i++)
{
FindTypeReferences(lambda.Parameters[i], typeReferences);
}
return;
case ExpressionType.ListInit:
ListInitExpression listInit = (ListInitExpression)expression;
FindTypeReferences(listInit.NewExpression, typeReferences);
for (int i = 0; i < listInit.Initializers.Count; i++)
{
ReadOnlyCollection <Expression> arguments = listInit.Initializers[i].Arguments;
for (int argumentIndex = 0; argumentIndex < arguments.Count; argumentIndex++)
{
FindTypeReferences(arguments[argumentIndex], typeReferences);
}
}
return;
case ExpressionType.Parameter:
ParameterExpression paramExpr = (ParameterExpression)expression;
EnsureTypeReferenced(paramExpr.Type, false, typeReferences);
return;
case ExpressionType.MemberAccess:
MemberExpression memberExpression = (MemberExpression)expression;
if (memberExpression.Expression == null)
{
EnsureTypeReferenced(memberExpression.Member.DeclaringType, true, typeReferences);
}
else
{
FindTypeReferences(memberExpression.Expression, typeReferences);
}
EnsureTypeReferenced(memberExpression.Type, false, typeReferences);
return;
case ExpressionType.MemberInit:
MemberInitExpression memberInit = (MemberInitExpression)expression;
FindTypeReferences(memberInit.NewExpression, typeReferences);
ReadOnlyCollection <MemberBinding> bindings = memberInit.Bindings;
for (int i = 0; i < bindings.Count; i++)
{
FindTypeReferences(bindings[i], typeReferences);
}
return;
case ExpressionType.ArrayIndex:
// ArrayIndex can be a MethodCallExpression or a BinaryExpression
MethodCallExpression arrayIndex = expression as MethodCallExpression;
if (arrayIndex != null)
{
FindTypeReferences(arrayIndex.Object, typeReferences);
ReadOnlyCollection <Expression> arguments = arrayIndex.Arguments;
for (int i = 0; i < arguments.Count; i++)
{
FindTypeReferences(arguments[i], typeReferences);
}
return;
}
BinaryExpression alternateIndex = (BinaryExpression)expression;
FindTypeReferences(alternateIndex.Left, typeReferences);
FindTypeReferences(alternateIndex.Right, typeReferences);
return;
case ExpressionType.Call:
MethodCallExpression methodCall = (MethodCallExpression)expression;
MethodInfo method = methodCall.Method;
EnsureTypeReferenced(methodCall.Type, false, typeReferences);
if (methodCall.Object != null)
{
FindTypeReferences(methodCall.Object, typeReferences);
}
else
{
EnsureTypeReferenced(method.DeclaringType, true, typeReferences);
}
if (method.IsGenericMethod && !method.IsGenericMethodDefinition && !method.ContainsGenericParameters)
{
// closed generic method
Type[] typeArgs = method.GetGenericArguments();
for (int i = 1; i < typeArgs.Length; ++i)
{
EnsureTypeReferenced(typeArgs[i], true, typeReferences);
}
}
ParameterInfo[] parameters = method.GetParameters();
if (parameters != null)
{
foreach (ParameterInfo parameter in parameters)
{
EnsureTypeReferenced(parameter.ParameterType, false, typeReferences);
}
}
ReadOnlyCollection <Expression> callArguments = methodCall.Arguments;
for (int i = 0; i < callArguments.Count; i++)
{
FindTypeReferences(callArguments[i], typeReferences);
}
return;
case ExpressionType.NewArrayInit:
NewArrayExpression newArray = (NewArrayExpression)expression;
EnsureTypeReferenced(newArray.Type.GetElementType(), true, typeReferences);
ReadOnlyCollection <Expression> expressions = newArray.Expressions;
for (int i = 0; i < expressions.Count; i++)
{
FindTypeReferences(expressions[i], typeReferences);
}
return;
case ExpressionType.NewArrayBounds:
NewArrayExpression newArrayBounds = (NewArrayExpression)expression;
EnsureTypeReferenced(newArrayBounds.Type.GetElementType(), true, typeReferences);
ReadOnlyCollection <Expression> boundExpressions = newArrayBounds.Expressions;
for (int i = 0; i < boundExpressions.Count; i++)
{
FindTypeReferences(boundExpressions[i], typeReferences);
}
return;
case ExpressionType.New:
NewExpression newExpression = (NewExpression)expression;
if (newExpression.Constructor != null)
{
EnsureTypeReferenced(newExpression.Constructor.DeclaringType, true, typeReferences);
}
else
{
// if no constructors defined (e.g. structs), the simply use the type
EnsureTypeReferenced(newExpression.Type, true, typeReferences);
}
ReadOnlyCollection <Expression> ctorArguments = newExpression.Arguments;
for (int i = 0; i < ctorArguments.Count; i++)
{
FindTypeReferences(ctorArguments[i], typeReferences);
}
return;
case ExpressionType.TypeIs:
TypeBinaryExpression typeBinary = (TypeBinaryExpression)expression;
FindTypeReferences(typeBinary.Expression, typeReferences);
EnsureTypeReferenced(typeBinary.TypeOperand, true, typeReferences);
return;
case ExpressionType.TypeAs:
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
UnaryExpression unary = (UnaryExpression)expression;
FindTypeReferences(unary.Operand, typeReferences);
EnsureTypeReferenced(unary.Type, true, typeReferences);
return;
case ExpressionType.ArrayLength:
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.Not:
case ExpressionType.Quote:
case ExpressionType.UnaryPlus:
UnaryExpression unaryExpression = (UnaryExpression)expression;
FindTypeReferences(unaryExpression.Operand, typeReferences);
return;
// Expression Tree V2.0 types. This is due to the hosted VB compiler generating ET V2.0 nodes
case ExpressionType.Block:
BlockExpression block = (BlockExpression)expression;
ReadOnlyCollection <ParameterExpression> variables = block.Variables;
for (int i = 0; i < variables.Count; i++)
{
FindTypeReferences(variables[i], typeReferences);
}
ReadOnlyCollection <Expression> blockExpressions = block.Expressions;
for (int i = 0; i < blockExpressions.Count; i++)
{
FindTypeReferences(blockExpressions[i], typeReferences);
}
return;
case ExpressionType.Assign:
BinaryExpression assign = (BinaryExpression)expression;
FindTypeReferences(assign.Left, typeReferences);
FindTypeReferences(assign.Right, typeReferences);
return;
}
Fx.Assert("Don't understand expression type " + expression.NodeType);
return;
}
private bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b) => a.TypeOperand == b.TypeOperand && Compare(a.Expression, b.Expression);
private HqlTreeNode VisitTypeBinaryExpression(TypeBinaryExpression expression)
{
return(_hqlTreeBuilder.Equality(
_hqlTreeBuilder.Dot(Visit(expression.Expression).AsExpression(), _hqlTreeBuilder.Class()),
_hqlTreeBuilder.Ident(expression.TypeOperand.FullName)));
}
private static bool Check(TypeBinaryExpression node, object value) {
// allow constant TypeIs expressions to be optimized away
if (value is bool && ((bool)value) == true) {
return node.TypeOperand.IsAssignableFrom(node.Expression.Type);
}
return false;
}
internal override Expression VisitTypeIs(TypeBinaryExpression b)
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjectionToEntity, this.type, b.ToString()));
}
protected override Expression VisitTypeIs(TypeBinaryExpression b)
{
Accumulate(b.TypeOperand);
return base.VisitTypeIs(b);
}
public virtual EditableTypeBinaryExpression Edit(TypeBinaryExpression expression)
{
}
//Edited for .NET Core
private void Write(Expression exp)
{
ExpressionType nodeType = exp.NodeType;
switch (nodeType)
{
case ExpressionType.AndAlso:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
break;
case ExpressionType.ArrayLength:
case ExpressionType.ArrayIndex:
case ExpressionType.Coalesce:
case ExpressionType.Conditional:
case ExpressionType.Divide:
case ExpressionType.ExclusiveOr:
case ExpressionType.Invoke:
case ExpressionType.Lambda:
case ExpressionType.LeftShift:
case ExpressionType.ListInit:
goto IL_71A;
case ExpressionType.Call:
{
MethodCallExpression methodCallExpression = (MethodCallExpression)exp;
bool flag = false;
if (methodCallExpression.Object == null)
{
flag = true;
this.m_writer.WriteStartElement("ExpressionStaticMethod");
string serverTypeId = ConditionalExpressionToXmlConverter.GetServerTypeId(methodCallExpression.Method.DeclaringType);
if (string.IsNullOrEmpty(serverTypeId))
{
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
this.m_writer.WriteAttributeString("TypeId", serverTypeId);
this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(methodCallExpression.Method));
}
else
{
this.m_writer.WriteStartElement("ExpressionMethod");
this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(methodCallExpression.Method));
this.Write(methodCallExpression.Object);
}
this.m_writer.WriteStartElement("Parameters");
foreach (Expression current in methodCallExpression.Arguments)
{
if (flag)
{
flag = false;
}
else
{
this.Write(current);
}
}
this.m_writer.WriteEndElement();
this.m_writer.WriteEndElement();
return;
}
case ExpressionType.Constant:
{
ConstantExpression constantExpression = (ConstantExpression)exp;
object value = constantExpression.Value;
//Edited for .NET Core
//if (value == null || value is ClientObject || value is ClientValueObject || value.GetType().IsPrimitive || value.GetType().IsEnum || value.GetType() == typeof(Guid) || value.GetType() == typeof(DateTime) || value.GetType() == typeof(string))
if (value == null || value is ClientObject || value is ClientValueObject || value.GetType().GetTypeInfo().IsPrimitive || value.GetType().GetTypeInfo().IsEnum || value.GetType() == typeof(Guid) || value.GetType() == typeof(DateTime) || value.GetType() == typeof(string))
{
this.m_writer.WriteStartElement("ExpressionConstant");
DataConvert.WriteValueToXmlElement(this.m_writer, value, this.m_serializationContext);
this.m_writer.WriteEndElement();
return;
}
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
{
UnaryExpression unaryExpression = (UnaryExpression)exp;
string value2 = null;
string value3 = null;
DataConvert.GetTypeNameOrTypeId(unaryExpression.Type, out value2, out value3);
if (!string.IsNullOrEmpty(value2))
{
this.m_writer.WriteStartElement("ExpressionConvert");
this.m_writer.WriteAttributeString("Type", value2);
this.Write(unaryExpression.Operand);
this.m_writer.WriteEndElement();
return;
}
if (string.IsNullOrEmpty(value3))
{
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
if (this.m_serializationContext.Context.RequestSchemaVersion >= ClientSchemaVersions.Version15)
{
this.m_writer.WriteStartElement("ExpressionConvert");
this.m_writer.WriteAttributeString("TypeId", value3);
this.Write(unaryExpression.Operand);
this.m_writer.WriteEndElement();
return;
}
this.Write(unaryExpression.Operand);
return;
}
case ExpressionType.Equal:
goto IL_D7;
case ExpressionType.MemberAccess:
{
MemberExpression memberExpression = (MemberExpression)exp;
if (!(memberExpression.Member is PropertyInfo))
{
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
if (ConditionalExpressionToXmlConverter.IsClientResultValueExpression(memberExpression))
{
this.Write(memberExpression.Expression);
return;
}
if (ConditionalExpressionToXmlConverter.IsServerObjectIsNullValue(memberExpression))
{
this.Write(memberExpression.Expression);
return;
}
if (memberExpression.Expression != null)
{
this.m_writer.WriteStartElement("ExpressionProperty");
this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(memberExpression.Member));
this.Write(memberExpression.Expression);
this.m_writer.WriteEndElement();
return;
}
this.m_writer.WriteStartElement("ExpressionStaticProperty");
string serverTypeId2 = ConditionalExpressionToXmlConverter.GetServerTypeId(memberExpression.Member.DeclaringType);
if (string.IsNullOrEmpty(serverTypeId2))
{
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
this.m_writer.WriteAttributeString("TypeId", serverTypeId2);
this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(memberExpression.Member));
this.m_writer.WriteEndElement();
return;
}
default:
switch (nodeType)
{
case ExpressionType.Not:
{
this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]);
UnaryExpression unaryExpression2 = (UnaryExpression)exp;
this.Write(unaryExpression2.Operand);
this.m_writer.WriteEndElement();
return;
}
case ExpressionType.NotEqual:
goto IL_D7;
case ExpressionType.Or:
goto IL_71A;
case ExpressionType.OrElse:
break;
case ExpressionType.Parameter:
{
ParameterExpression parameterExpression = (ParameterExpression)exp;
this.m_writer.WriteStartElement("ExpressionParameter");
this.m_writer.WriteAttributeString("Name", parameterExpression.Name);
this.m_writer.WriteEndElement();
return;
}
default:
{
if (nodeType != ExpressionType.TypeIs)
{
goto IL_71A;
}
TypeBinaryExpression typeBinaryExpression = (TypeBinaryExpression)exp;
string value4 = null;
string value5 = null;
DataConvert.GetTypeNameOrTypeId(typeBinaryExpression.TypeOperand, out value4, out value5);
if (string.IsNullOrEmpty(value4) && string.IsNullOrEmpty(value5))
{
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
this.m_writer.WriteStartElement("ExpressionTypeIs");
if (!string.IsNullOrEmpty(value4))
{
this.m_writer.WriteAttributeString("Type", value4);
}
if (!string.IsNullOrEmpty(value5))
{
this.m_writer.WriteAttributeString("TypeId", value5);
}
this.Write(typeBinaryExpression.Expression);
this.m_writer.WriteEndElement();
return;
}
}
break;
}
BinaryExpression binaryExpression = (BinaryExpression)exp;
this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]);
this.Write(binaryExpression.Left);
this.Write(binaryExpression.Right);
this.m_writer.WriteEndElement();
return;
IL_D7:
BinaryExpression binaryExpression2 = (BinaryExpression)exp;
if (ConditionalExpressionToXmlConverter.IsNullExpression(binaryExpression2.Left) || ConditionalExpressionToXmlConverter.IsNullExpression(binaryExpression2.Right) || (ConditionalExpressionToXmlConverter.IsSupportedEqualType(binaryExpression2.Right.Type) && ConditionalExpressionToXmlConverter.IsSupportedEqualType(binaryExpression2.Left.Type)))
{
this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]);
this.Write(binaryExpression2.Left);
this.Write(binaryExpression2.Right);
this.m_writer.WriteEndElement();
return;
}
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
IL_71A:
throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
{
this.m_condition.ToString()
}));
}
private void TraverseTypeBinaryExpression(TypeBinaryExpression typeBinaryExpression)
{
TraverseExpression(typeBinaryExpression.Expression);
}
internal override Expression VisitTypeIs(TypeBinaryExpression b)
{
throw new NotSupportedException(Strings.ALinq_TypeBinaryNotSupported);
}
/// <summary>Visits the children of the <see cref="T:System.Linq.Expressions.TypeBinaryExpression"></see>.</summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
_box.Put(node.TypeOperand.GUID.ToByteArray());
return(base.VisitTypeBinary(node));
}
protected virtual void VisitTypeIs(TypeBinaryExpression type)
{
Visit(type.Expression);
}
bool IEvaluatableExpressionFilter.IsEvaluatableTypeBinary(TypeBinaryExpression node) => true;
public void VisitTypeIs(TypeBinaryExpression b)
{
Visit(b.Expression);
}
protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
{
var expr = Visit(b.Expression);
return(UpdateTypeIs(b, expr, b.TypeOperand));
}
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
return(base.VisitTypeBinary(node));
}
/// <summary>
/// Visit type-is expression
/// </summary>
protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
{
Expression expr = this.Visit(b.Expression);
return(expr != b.Expression ? Expression.TypeIs(expr, b.TypeOperand) : b);
}
protected override Expression VisitTypeBinary(TypeBinaryExpression b)
{
throw InvalidSqlExpression(b);
}
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
throw new NotSupportedException(string.Format(Resources.EX_PROCESS_NODE_NOT_SUPPORT, node.GetType().Name));
}
protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
{
Expression expr = this.Visit(b.Expression);
return(this.UpdateTypeIs(b, expr, b.TypeOperand));
}
protected virtual bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b)
{
return(a.TypeOperand == b.TypeOperand &&
Compare(a.Expression, b.Expression));
}
/// <summary>
/// If the result of a TypeBinaryExpression is known statically, this
/// returns the result, otherwise it returns null, meaning we'll need
/// to perform the IsInst instruction at runtime.
///
/// The result of this function must be equivalent to IsInst, or
/// null.
/// </summary>
internal static AnalyzeTypeIsResult AnalyzeTypeIs(TypeBinaryExpression typeIs)
{
return AnalyzeTypeIs(typeIs.Expression, typeIs.TypeOperand);
}
protected override Expression VisitTypeBinaryExpression(TypeBinaryExpression expression)
{
return(expression);
}
public TypeBinaryExpressionProxy(TypeBinaryExpression node) {
_node = node;
}
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
Out(node.ToString());
return(node);
}
protected internal virtual void PostWalk(TypeBinaryExpression node) { }
protected override Expression VisitTypeEqual(TypeBinaryExpression exp)
{
Accumulate(exp.TypeOperand);
return base.VisitTypeEqual(exp);
}
