//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 static bool CanBeEvaluated(Expression exp)
        {
            if (exp == null)
            {
                return(true);
            }
            bool result = true;

            if (exp.NodeType == ExpressionType.MemberAccess)
            {
                MemberExpression memberExpression = (MemberExpression)exp;
                //Edited for .NET Core
                //bool flag = Attribute.IsDefined(memberExpression.Member, typeof(RemoteAttribute)) || Attribute.IsDefined(memberExpression.Member, typeof(PseudoRemoteAttribute));
                bool flag = false;
                if (flag)
                {
                    result = false;
                }
                else if (ConditionalExpressionToXmlConverter.IsClientResultValueExpression(memberExpression) || ConditionalExpressionToXmlConverter.IsServerObjectIsNullValue(memberExpression))
                {
                    result = false;
                }
            }
            else if (exp.NodeType == ExpressionType.Call)
            {
                MethodCallExpression methodCallExpression = (MethodCallExpression)exp;
                //Edited for .NET Core
                //bool flag2 = Attribute.IsDefined(methodCallExpression.Method, typeof(RemoteAttribute)) || Attribute.IsDefined(methodCallExpression.Method, typeof(PseudoRemoteAttribute));
                bool flag2 = false;
                if (flag2)
                {
                    result = false;
                }
            }
            else if (exp.NodeType == ExpressionType.Parameter)
            {
                result = false;
            }
            return(result);
        }