C# Serialization.DataContract类代码示例

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