private void DemandSerializationFormatterPermission(ClassDataContract classContract)
 {
     if (!classContract.HasDataContract && !classContract.IsNonAttributedType)
     {
         this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.DemandSerializationFormatterPermissionMethod);
     }
 }

        public static object ConvertDictionaryToClassDataContract(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, XmlObjectSerializerReadContextComplexJson context)
        {
            if (deserialzedValue == null)
            {
                return null;
            }

            if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
            {
                var tuple = deserialzedValue["DateTime"] as Tuple<DateTime, string>;
                DateTimeOffset dto = new DateTimeOffset(tuple != null ? tuple.Item1 : (DateTime)deserialzedValue["DateTime"]);
                return dto.ToOffset(new TimeSpan(0, (int)deserialzedValue["OffsetMinutes"], 0));
            }

            object serverTypeStringValue;
            if (deserialzedValue.TryGetValue(JsonGlobals.ServerTypeString, out serverTypeStringValue))
            {
                dataContract = ResolveDataContractFromTypeInformation(serverTypeStringValue.ToString(), dataContract, context);
            }

            object o = CreateInstance(dataContract);

            CheckDuplicateNames(dataContract);
            DataContractJsonSerializer.InvokeOnDeserializing(o, dataContract, context);
            ReadClassDataContractMembers(serializer, dataContract, deserialzedValue, o, context);
            DataContractJsonSerializer.InvokeOnDeserialized(o, dataContract, context);
            if (dataContract.IsKeyValuePairAdapter)
            {
                return dataContract.GetKeyValuePairMethodInfo.Invoke(o, Array.Empty<Type>());
            }
            return o;
        }

 private void CreateObject(ClassDataContract classContract)
 {
     Type typeOfValueType = this.objectType = classContract.UnderlyingType;
     if (typeOfValueType.IsValueType && !classContract.IsNonAttributedType)
     {
         typeOfValueType = Globals.TypeOfValueType;
     }
     this.objectLocal = this.ilg.DeclareLocal(typeOfValueType, "objectDeserialized");
     if (classContract.UnderlyingType == Globals.TypeOfDBNull)
     {
         this.ilg.LoadMember(Globals.TypeOfDBNull.GetField("Value"));
         this.ilg.Stloc(this.objectLocal);
     }
     else if (classContract.IsNonAttributedType)
     {
         if (typeOfValueType.IsValueType)
         {
             this.ilg.Ldloca(this.objectLocal);
             this.ilg.InitObj(typeOfValueType);
         }
         else
         {
             this.ilg.New(classContract.GetNonAttributedTypeConstructor());
             this.ilg.Stloc(this.objectLocal);
         }
     }
     else
     {
         this.ilg.Call(null, XmlFormatGeneratorStatics.GetUninitializedObjectMethod, DataContract.GetIdForInitialization(classContract));
         this.ilg.ConvertValue(Globals.TypeOfObject, typeOfValueType);
         this.ilg.Stloc(this.objectLocal);
     }
 }

 private void AddClassDataContract(ClassDataContract classDataContract)
 {
     if (classDataContract.BaseContract != null)
     {
         this.Add(classDataContract.BaseContract.StableName, classDataContract.BaseContract);
     }
     if (!classDataContract.IsISerializable && (classDataContract.Members != null))
     {
         for (int i = 0; i < classDataContract.Members.Count; i++)
         {
             DataMember dataMember = classDataContract.Members[i];
             DataContract memberTypeDataContract = this.GetMemberTypeDataContract(dataMember);
             if ((this.dataContractSurrogate != null) && (dataMember.MemberInfo != null))
             {
                 object obj2 = DataContractSurrogateCaller.GetCustomDataToExport(this.dataContractSurrogate, dataMember.MemberInfo, memberTypeDataContract.UnderlyingType);
                 if (obj2 != null)
                 {
                     this.SurrogateDataTable.Add(dataMember, obj2);
                 }
             }
             this.Add(memberTypeDataContract.StableName, memberTypeDataContract);
         }
     }
     this.AddKnownDataContracts(classDataContract.KnownDataContracts);
 }

 internal XmlFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
 {
     if (_useReflection)
     {
         return new ReflectionXmlFormatWriter().ReflectionWriteClass;
     }
     else
     {
         _ilg = new CodeGenerator();
         bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null);
         try
         {
             _ilg.BeginMethod("Write" + classContract.StableName.Name + "ToXml", Globals.TypeOfXmlFormatClassWriterDelegate, memberAccessFlag);
         }
         catch (SecurityException securityException)
         {
             if (memberAccessFlag)
             {
                 classContract.RequiresMemberAccessForWrite(securityException);
             }
             else
             {
                 throw;
             }
         }
         InitArgs(classContract.UnderlyingType);
         WriteClass(classContract);
         return (XmlFormatClassWriterDelegate)_ilg.EndMethod();
     }
 }

            public JsonFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract)
            {
                _ilg = new CodeGenerator();
                bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null);
                try
                {
                    BeginMethod(_ilg, "Read" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "FromJson", typeof(JsonFormatClassReaderDelegate), memberAccessFlag);
                }
                catch (SecurityException securityException)
                {
                    if (memberAccessFlag)
                    {
                        classContract.RequiresMemberAccessForRead(securityException);
                    }
                    else
                    {
                        throw;
                    }
                }
                InitArgs();
                CreateObject(classContract);
                _ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, _objectLocal);
                InvokeOnDeserializing(classContract);
                if (classContract.IsISerializable)
                    ReadISerializable(classContract);
                else
                    ReadClass(classContract);

                if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType))
                {
                    _ilg.Call(_objectLocal, JsonFormatGeneratorStatics.OnDeserializationMethod, null);
                }

                InvokeOnDeserialized(classContract);
                if (!InvokeFactoryMethod(classContract))
                {
                    _ilg.Load(_objectLocal);
                    // Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
                    // DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
                    // on DateTimeOffset; which does not work in partial trust.

                    if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
                    {
                        _ilg.ConvertValue(_objectLocal.LocalType, Globals.TypeOfDateTimeOffsetAdapter);
                        _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetMethod);
                        _ilg.ConvertValue(Globals.TypeOfDateTimeOffset, _ilg.CurrentMethod.ReturnType);
                    }
                    //Copy the KeyValuePairAdapter<K,T> to a KeyValuePair<K,T>. 
                    else if (classContract.IsKeyValuePairAdapter)
                    {
                        _ilg.Call(classContract.GetKeyValuePairMethodInfo);
                        _ilg.ConvertValue(Globals.TypeOfKeyValuePair.MakeGenericType(classContract.KeyValuePairGenericArguments), _ilg.CurrentMethod.ReturnType);
                    }
                    else
                    {
                        _ilg.ConvertValue(_objectLocal.LocalType, _ilg.CurrentMethod.ReturnType);
                    }
                }
                return (JsonFormatClassReaderDelegate)_ilg.EndMethod();
            }

        internal int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract)
        {
            int memberCount = (classContract.BaseContract == null) ? 0 :
                ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract);

            Type classType = classContract.UnadaptedClassType;
            XmlDictionaryString[] memberNames = classContract.MemberNames;
            XmlDictionaryString ns = classContract.Namespace;
            context.IncrementItemCount(classContract.Members.Count);
            for (int i = 0; i < classContract.Members.Count; i++, memberCount++)
            {
                DataMember member = classContract.Members[i];
                Type memberType = member.MemberType;
                if (member.IsGetOnlyCollection)
                {
                    context.StoreIsGetOnlyCollection();
                }
                bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract);
                MemberInfo memberInfo = member.MemberInfo;
                object memberValue = ReflectionGetMemberValue(obj, memberInfo);
                if (writeXsiType || !ReflectionTryWritePrimitive(xmlWriter, context, memberType, memberValue, member.MemberInfo, null /*arrayItemIndex*/, ns, memberNames[i] /*nameLocal*/, i + _childElementIndex))
                {
                    ReflectionWriteStartElement(memberType, ns, ns.Value, member.Name, 0);
                    if (classContract.ChildElementNamespaces[i + _childElementIndex] != null)
                    {
                        var nsChildElement = classContract.ChildElementNamespaces[i + _childElementIndex];
                        _arg0XmlWriter.WriteNamespaceDecl(nsChildElement);
                    }
                    ReflectionWriteValue(memberType, memberValue, writeXsiType);
                    ReflectionWriteEndElement();
                }
            }

            return 0;
        }

 public void ReflectionWriteClass(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, XmlDictionaryString[] memberNames)
 {
     InvokeOnSerializing(obj, context, classContract);
     obj = ResolveAdapterType(obj, classContract);
     ReflectionWriteMembers(xmlWriter, obj, context, classContract, classContract, 0 /*childElementIndex*/, memberNames);
     InvokeOnSerialized(obj, context, classContract);
 }

 static DataContract ProcessClassDataContract(ClassDataContract contract, ExportContext context, MemberInfo memberNode)
 {
     string prefix = context.SetNamespace(contract.Namespace.Value);
     foreach (DataMember member in GetDataMembers(contract))
     {
         if (member.MemberInfo.Name == memberNode.Name && member.MemberInfo.DeclaringType.IsAssignableFrom(memberNode.DeclaringType))
         {
             context.WriteChildToContext(member, prefix);
             return member.MemberTypeContract;
         }
     }
     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.QueryGeneratorPathToMemberNotFound)));
 }

 private static void CheckDuplicateNames(ClassDataContract dataContract)
 {
     if (dataContract.MemberNames != null)
     {
         Dictionary<string, object> memberTable = new Dictionary<string, object>();
         for (int i = 0; i < dataContract.MemberNames.Length; i++)
         {
             if (memberTable.ContainsKey(dataContract.MemberNames[i].Value))
             {
                 throw new SerializationException(SR.Format(SR.JsonDuplicateMemberInInput, dataContract.MemberNames[i].Value));
             }
             memberTable.Add(dataContract.MemberNames[i].Value, null);
         }
     }
 }

        private static void ReadClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, object newInstance, XmlObjectSerializerReadContextComplexJson context)
        {
            if (dataContract.BaseContract != null)
            {
                ReadClassDataContractMembers(serializer, dataContract.BaseContract, deserialzedValue, newInstance, context);
            }
            for (int i = 0; i < dataContract.Members.Count; i++)
            {
                DataMember member = dataContract.Members[i];
                object currentMemberValue;
                if (deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name), out currentMemberValue) ||
                    dataContract.IsKeyValuePairAdapter && deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name.ToLowerInvariant()), out currentMemberValue))
                {
                    if (member.MemberType.GetTypeInfo().IsPrimitive || currentMemberValue == null)
                    {
                        SetMemberValue(newInstance, serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context), dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
                    }
                    else
                    {
                        context.PushKnownTypes(dataContract);
                        object subMemberValue = serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context);
                        Type declaredType = (member.MemberType.GetTypeInfo().IsGenericType && member.MemberType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
                            ? Nullable.GetUnderlyingType(member.MemberType)
                            : member.MemberType;

                        if (!(declaredType == Globals.TypeOfObject && subMemberValue.GetType() == Globals.TypeOfObjectArray) && declaredType != subMemberValue.GetType())
                        {
                            DataContract memberValueContract = DataContract.GetDataContract(subMemberValue.GetType());
                            context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract);
                        }

                        if (member.IsGetOnlyCollection)
                        {
                            PopulateReadOnlyCollection(newInstance, member, (IEnumerable)subMemberValue);
                        }
                        else
                        {
                            SetMemberValue(newInstance, subMemberValue, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
                        }
                        context.PopKnownTypes(dataContract);
                    }
                }
                else if (member.IsRequired)
                {
                    XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(dataContract.MemberNames[i].Value, dataContract.UnderlyingType);
                }
            }
        }

        private void ReflectionInitArgs(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract)
        {
            if (obj.GetType() == typeof(DateTimeOffset))
            {
                obj = DateTimeOffsetAdapter.GetDateTimeOffsetAdapter((DateTimeOffset)obj);
            }
            else if (obj.GetType().GetTypeInfo().IsGenericType && obj.GetType().GetGenericTypeDefinition() == typeof(KeyValuePair<,>))
            {
                obj = classContract.KeyValuePairAdapterConstructorInfo.Invoke(new object[] { obj });
            }

            _arg0XmlWriter = xmlWriter;
            _arg1Object = obj;
            _arg2Context = context;
            _arg3ClassDataContract = classContract;
        }

 private static DataContract ProcessClassDataContract(ClassDataContract contract, ExportContext context, MemberInfo memberNode)
 {
     string prefix = context.SetNamespace(contract.Namespace.Value);
     if (contract.Members != null)
     {
         foreach (DataMember member in contract.Members)
         {
             if (member.MemberInfo == memberNode)
             {
                 context.WriteChildToContext(member, prefix);
                 return member.MemberTypeContract;
             }
         }
     }
     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("QueryGeneratorPathToMemberNotFound")));
 }

 static IEnumerable<DataMember> GetDataMembers(ClassDataContract contract)
 {
     if (contract.BaseContract != null)
     {
         foreach (DataMember baseClassMember in GetDataMembers(contract.BaseContract))
         {
             yield return baseClassMember;
         }
     }
     if (contract.Members != null)
     {
         foreach (DataMember member in contract.Members)
         {
             yield return member;
         }
     }
 }

        internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
        {
            try
            {
                if (TD.DCJsonGenWriterStartIsEnabled())
                {
                    TD.DCJsonGenWriterStart("Class", classContract.UnderlyingType.FullName);
                }

                return helper.GenerateClassWriter(classContract);
            }
            finally
            {
                if (TD.DCJsonGenWriterStopIsEnabled())
                {
                    TD.DCJsonGenWriterStop();
                }
            }
        }

		public void WriteToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract dataContract)
		{
			this.writer = xmlWriter;
			this.obj = obj;
			this.ctx = context;
			this.dataContract = dataContract;

			InitArgs (classContract.UnderlyingType);

			// DemandSerializationFormatterPermission (classContract) - irrelevant
			// DemandMemberAccessPermission (memberAccessFlag) - irrelevant

			if (classContract.IsReadOnlyContract)
			{
				DataContract.ThrowInvalidDataContractException (classContract.SerializationExceptionMessage, null);
			}

			WriteClass (classContract);
		}

        public XmlFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract)
        {
            try
            {
                if (TD.DCGenReaderStartIsEnabled())
                {
                    TD.DCGenReaderStart("Class", classContract.UnderlyingType.FullName);
                }

                return helper.GenerateClassReader(classContract);
            }
            finally
            {
                if (TD.DCGenReaderStopIsEnabled())
                {
                    TD.DCGenReaderStop();
                }
            }
        }

            internal XmlFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
            {
                if (DataContractSerializer.Option == SerializationOption.ReflectionOnly)
                {
                    return new ReflectionXmlFormatWriter().ReflectionWriteClass;
                }
#if NET_NATIVE
                else if (DataContractSerializer.Option == SerializationOption.ReflectionAsBackup)
                {
                    return new ReflectionXmlFormatWriter().ReflectionWriteClass;
                }
#endif
                else
                {
#if USE_REFEMIT || NET_NATIVE
                    throw new InvalidOperationException("Cannot generate class writer");
#else
                    _ilg = new CodeGenerator();
                    bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null);
                    try
                    {
                        _ilg.BeginMethod("Write" + classContract.StableName.Name + "ToXml", Globals.TypeOfXmlFormatClassWriterDelegate, memberAccessFlag);
                    }
                    catch (SecurityException securityException)
                    {
                        if (memberAccessFlag)
                        {
                            classContract.RequiresMemberAccessForWrite(securityException);
                        }
                        else
                        {
                            throw;
                        }
                    }
                    InitArgs(classContract.UnderlyingType);
                    WriteClass(classContract);
                    return (XmlFormatClassWriterDelegate)_ilg.EndMethod();
#endif
                }
            }

 internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
 {
     this.ilg = new CodeGenerator();
     bool allowPrivateMemberAccess = classContract.RequiresMemberAccessForWrite(null);
     try
     {
         this.BeginMethod(this.ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), allowPrivateMemberAccess);
     }
     catch (SecurityException exception)
     {
         if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission)))
         {
             throw;
         }
         classContract.RequiresMemberAccessForWrite(exception);
     }
     this.InitArgs(classContract.UnderlyingType);
     this.memberNamesArg = this.ilg.GetArg(4);
     this.DemandSerializationFormatterPermission(classContract);
     this.DemandMemberAccessPermission(allowPrivateMemberAccess);
     this.WriteClass(classContract);
     return (JsonFormatClassWriterDelegate) this.ilg.EndMethod();
 }

 private bool CheckIfMemberHasConflict(DataMember member, ClassDataContract classContract, ClassDataContract derivedMostClassContract)
 {
     if (this.CheckIfConflictingMembersHaveDifferentTypes(member))
     {
         return true;
     }
     string name = member.Name;
     string str2 = classContract.StableName.Namespace;
     for (ClassDataContract contract = derivedMostClassContract; (contract != null) && (contract != classContract); contract = contract.BaseContract)
     {
         if (str2 == contract.StableName.Namespace)
         {
             List<DataMember> members = contract.Members;
             for (int i = 0; i < members.Count; i++)
             {
                 if (name == members[i].Name)
                 {
                     return this.CheckIfConflictingMembersHaveDifferentTypes(members[i]);
                 }
             }
         }
     }
     return false;
 }