private static bool IsNullExpression(Expression exp)
 {
     if (exp.NodeType == ExpressionType.Constant)
     {
         ConstantExpression constantExpression = (ConstantExpression)exp;
         return(constantExpression.Value == null);
     }
     if (exp.NodeType == ExpressionType.Convert || exp.NodeType == ExpressionType.ConvertChecked)
     {
         UnaryExpression unaryExpression = (UnaryExpression)exp;
         return(ConditionalExpressionToXmlConverter.IsNullExpression(unaryExpression.Operand));
     }
     return(false);
 }
        //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()
            }));
        }