internal void CheckIfTypeNeedsVerifcation(DataContract declaredContract, DataContract runtimeContract)
        {
            bool verifyType = true;
            CollectionDataContract collectionContract = declaredContract as CollectionDataContract;
            if (collectionContract != null && collectionContract.UnderlyingType.GetTypeInfo().IsInterface)
            {
                switch (collectionContract.Kind)
                {
                    case CollectionKind.Dictionary:
                    case CollectionKind.GenericDictionary:
                        verifyType = declaredContract.Name == runtimeContract.Name;
                        break;

                    default:
                        Type t = collectionContract.ItemType.MakeArrayType();
                        verifyType = (t != runtimeContract.UnderlyingType);
                        break;
                }
            }

            if (verifyType)
            {
                this.PushKnownTypes(declaredContract);
                VerifyType(runtimeContract);
                this.PopKnownTypes(declaredContract);
            }
        }

        void ExportDataContract(DataContract dataContract)
        {
            if (dataContract.IsBuiltInDataContract)
                return;
            else if (dataContract is XmlDataContract)
                ExportXmlDataContract((XmlDataContract)dataContract);
            else
            {
                XmlSchema schema = GetSchema(dataContract.StableName.Namespace);

                if (dataContract is ClassDataContract)
                {
                    ClassDataContract classDataContract = (ClassDataContract)dataContract;
                    if (classDataContract.IsISerializable)
                        ExportISerializableDataContract(classDataContract, schema);
                    else
                        ExportClassDataContract(classDataContract, schema);
                }
                else if (dataContract is CollectionDataContract)
                    ExportCollectionDataContract((CollectionDataContract)dataContract, schema);
                else if (dataContract is EnumDataContract)
                    ExportEnumDataContract((EnumDataContract)dataContract, schema);
                ExportTopLevelElement(dataContract, schema);
                Schemas.Reprocess(schema);
            }
        }

 internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
     : base(serializer, rootTypeDataContract, dataContractResolver)
 {
     _mode = SerializationMode.SharedContract;
     _preserveObjectReferences = serializer.PreserveObjectReferences;
     _serializationSurrogateProvider = serializer.SerializationSurrogateProvider;
 }

 public void Add(XmlQualifiedName name, DataContract dataContract)
 {
     if (!dataContract.IsBuiltInDataContract)
     {
         this.InternalAdd(name, dataContract);
     }
 }

 internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
     : base(serializer, rootTypeDataContract, dataContractResolver)
 {
     this.mode = SerializationMode.SharedContract;
     this.preserveObjectReferences = serializer.PreserveObjectReferences;
     this.dataContractSurrogate = serializer.DataContractSurrogate;
 }

 public XmlObjectSerializerWriteContextComplexJson(DataContractJsonSerializer serializer, DataContract rootTypeDataContract) : base(serializer, serializer.MaxItemsInObjectGraph, new StreamingContext(StreamingContextStates.All), serializer.IgnoreExtensionDataObject)
 {
     this.alwaysEmitXsiType = serializer.AlwaysEmitTypeInformation;
     base.rootTypeDataContract = rootTypeDataContract;
     base.serializerKnownTypeList = serializer.knownTypeList;
     base.dataContractSurrogate = serializer.DataContractSurrogate;
 }

 public XmlObjectSerializerReadContextComplexJson(DataContractJsonSerializer serializer, DataContract rootTypeDataContract)
     : base(null, int.MaxValue, new StreamingContext(), true)
 {
     this.rootTypeDataContract = rootTypeDataContract;
     this.serializerKnownTypeList = serializer.KnownTypes;
     _jsonSerializer = serializer;
 }

 internal static DataContract GetRevisedItemContract(DataContract oldItemContract)
 {
     if (((oldItemContract != null) && oldItemContract.UnderlyingType.IsGenericType) && (oldItemContract.UnderlyingType.GetGenericTypeDefinition() == Globals.TypeOfKeyValue))
     {
         return ClassDataContract.CreateClassDataContractForKeyValue(oldItemContract.UnderlyingType, oldItemContract.Namespace, new string[] { "Key", "Value" });
     }
     return oldItemContract;
 }

 static DataContract ProcessDataContract(DataContract contract, ExportContext context, MemberInfo memberNode)
 {
     if (contract is ClassDataContract)
     {
         return ProcessClassDataContract((ClassDataContract)contract, context, memberNode);
     }
     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.QueryGeneratorPathToMemberNotFound)));
 }

 public static JsonReadWriteDelegates GetGeneratedReadWriteDelegates(DataContract c)
 {
     // this method used to be rewritten by an IL transform
     // with the restructuring for multi-file, this is no longer true - instead
     // this has become a normal method
     JsonReadWriteDelegates result;
     return JsonReadWriteDelegates.GetJsonDelegates().TryGetValue(c, out result) ? result : null;
 }

 internal XmlObjectSerializerContext(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
     : this(serializer,
     serializer.MaxItemsInObjectGraph,
     new StreamingContext(StreamingContextStates.All),
     serializer.IgnoreExtensionDataObject,
     dataContractResolver)
 {
     this.rootTypeDataContract = rootTypeDataContract;
     this.serializerKnownTypeList = serializer.knownTypeList;
 }

        internal DataContract ResolveDataContractFromType(string typeName, string typeNs, DataContract memberTypeContract)
        {
            this.PushKnownTypes(this.rootTypeDataContract);
            this.PushKnownTypes(memberTypeContract);
            XmlQualifiedName qname = ParseQualifiedName(typeName);
            DataContract contract = ResolveDataContractFromKnownTypes(qname.Name, TrimNamespace(qname.Namespace), memberTypeContract);

            this.PopKnownTypes(this.rootTypeDataContract);
            this.PopKnownTypes(memberTypeContract);
            return contract;
        }

 internal static JsonReadWriteDelegates GetReadWriteDelegatesFromGeneratedAssembly(DataContract c)
 {
     JsonReadWriteDelegates result = GetGeneratedReadWriteDelegates(c);
     if (result == null)
     {
         throw new InvalidDataContractException(string.Format(SR.SerializationCodeIsMissingForType, c.UnderlyingType.ToString()));
     }
     else
     {
         return result;
     }
 }

 internal bool CheckIfNeedsContractNsAtRoot(XmlDictionaryString name, XmlDictionaryString ns, DataContract contract)
 {
     if (name == null)
     {
         return false;
     }
     if ((contract.IsBuiltInDataContract || !contract.CanContainReferences) || contract.IsISerializable)
     {
         return false;
     }
     string str = XmlDictionaryString.GetString(contract.Namespace);
     return (!string.IsNullOrEmpty(str) && !(str == XmlDictionaryString.GetString(ns)));
 }

 internal override object InternalDeserialize(XmlReaderDelegator xmlReader, Type declaredType, DataContract dataContract, string name, string ns)
 {
     if (_mode == SerializationMode.SharedContract)
     {
         //if (dataContractSurrogate == null)
         return base.InternalDeserialize(xmlReader, declaredType, dataContract, name, ns);
         //else
         //    return InternalDeserializeWithSurrogate(xmlReader, declaredType, dataContract, name, ns);
     }
     else
     {
         return InternalDeserializeInSharedTypeMode(xmlReader, -1, declaredType, name, ns);
     }
 }

        public static JsonReadWriteDelegates GetGeneratedReadWriteDelegates(DataContract c)
        {
            // this method used to be rewritten by an IL transform
            // with the restructuring for multi-file, this is no longer true - instead
            // this has become a normal method
            JsonReadWriteDelegates result;
#if NET_NATIVE
            // The c passed in could be a clone which is different from the original key,
            // We'll need to get the original key data contract from generated assembly.
            DataContract keyDc = DataContract.GetDataContractFromGeneratedAssembly(c.UnderlyingType);
            return JsonReadWriteDelegates.GetJsonDelegates().TryGetValue(keyDc, out result) ? result : null;
#else
            return JsonReadWriteDelegates.GetJsonDelegates().TryGetValue(c, out result) ? result : null;
#endif
        }

		public void WriteCollectionToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, CollectionDataContract collectionContract)
		{
			this.writer = xmlWriter;
			this.obj = obj;
			this.ctx = context;
			this.dataContract = collectionContract;

			InitArgs (collectionContract.UnderlyingType);			

			// DemandMemberAccessPermission(memberAccessFlag);
			if (collectionContract.IsReadOnlyContract)
			{
				DataContract.ThrowInvalidDataContractException (collectionContract.SerializationExceptionMessage, null);
			}

			WriteCollection (collectionContract);
		}

		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);
		}

 internal DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type type, ref Hashtable surrogateDataContracts)
 {
     DataContract contract = GetDataContractFromSurrogateSelector(this.surrogateSelector, this.Context, typeHandle, type, ref surrogateDataContracts);
     if (contract != null)
     {
         return contract;
     }
     if (this.cachedDataContract == null)
     {
         contract = DataContract.GetDataContract(typeHandle, type, SerializationMode.SharedType);
         this.cachedDataContract = contract;
         return contract;
     }
     DataContract cachedDataContract = this.cachedDataContract;
     if (cachedDataContract.UnderlyingType.TypeHandle.Equals(typeHandle))
     {
         return cachedDataContract;
     }
     return DataContract.GetDataContract(typeHandle, type, SerializationMode.SharedType);
 }

 private void HandleCollectionAssignedToObject(Type declaredType, ref DataContract dataContract, ref object obj, ref bool verifyKnownType)
 {
     if ((declaredType != dataContract.UnderlyingType) && (dataContract is CollectionDataContract))
     {
         if (verifyKnownType)
         {
             this.VerifyType(dataContract, declaredType);
             verifyKnownType = false;
         }
         if (((CollectionDataContract) dataContract).Kind == CollectionKind.Dictionary)
         {
             IDictionary dictionary = obj as IDictionary;
             Dictionary<object, object> dictionary2 = new Dictionary<object, object>();
             foreach (DictionaryEntry entry in dictionary)
             {
                 dictionary2.Add(entry.Key, entry.Value);
             }
             obj = dictionary2;
         }
         dataContract = base.GetDataContract(Globals.TypeOfIEnumerable);
     }
 }