mcs/class/referencesource/System.Runtime.Serialization/System/Runtime/Serialization/DataContractSerializer.cs

   1 //------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 //------------------------------------------------------------
   4
   5 namespace System.Runtime.Serialization
   6 {
   7     using System;
   8     using System.Collections;
   9     using System.Diagnostics;
  10     using System.Globalization;
  11     using System.IO;
  12     using System.Reflection;
  13     using System.Text;
  14     using System.Xml;
  15     using System.Xml.Serialization;
  16     using System.Collections.Generic;
  17     using System.Collections.ObjectModel;
  18     using System.Runtime.CompilerServices;
  19     using DataContractDictionary = System.Collections.Generic.Dictionary<System.Xml.XmlQualifiedName, DataContract>;
  20
  21     public sealed class DataContractSerializer : XmlObjectSerializer
  22     {
  23         Type rootType;
  24         DataContract rootContract; // post-surrogate
  25         bool needsContractNsAtRoot;
  26         XmlDictionaryString rootName;
  27         XmlDictionaryString rootNamespace;
  28         int maxItemsInObjectGraph;
  29         bool ignoreExtensionDataObject;
  30         bool preserveObjectReferences;
  31         IDataContractSurrogate dataContractSurrogate;
  32         ReadOnlyCollection<Type> knownTypeCollection;
  33         internal IList<Type> knownTypeList;
  34         internal DataContractDictionary knownDataContracts;
  35         DataContractResolver dataContractResolver;
  36         bool serializeReadOnlyTypes;
  37
  38         public DataContractSerializer(Type type)
  39             : this(type, (IEnumerable<Type>)null)
  40         {
  41         }
  42
  43         public DataContractSerializer(Type type, IEnumerable<Type> knownTypes)
  44             : this(type, knownTypes, int.MaxValue, false, false, null)
  45         {
  46         }
  47
  48         public DataContractSerializer(Type type,
  49             IEnumerable<Type> knownTypes,
  50             int maxItemsInObjectGraph,
  51             bool ignoreExtensionDataObject,
  52             bool preserveObjectReferences,
  53             IDataContractSurrogate dataContractSurrogate)
  54             : this(type, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, null)
  55         {
  56         }
  57
  58         public DataContractSerializer(Type type,
  59             IEnumerable<Type> knownTypes,
  60             int maxItemsInObjectGraph,
  61             bool ignoreExtensionDataObject,
  62             bool preserveObjectReferences,
  63             IDataContractSurrogate dataContractSurrogate,
  64             DataContractResolver dataContractResolver)
  65         {
  66             Initialize(type, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, dataContractResolver, false);
  67         }
  68
  69         public DataContractSerializer(Type type, string rootName, string rootNamespace)
  70             : this(type, rootName, rootNamespace, null)
  71         {
  72         }
  73
  74         public DataContractSerializer(Type type, string rootName, string rootNamespace, IEnumerable<Type> knownTypes)
  75             : this(type, rootName, rootNamespace, knownTypes, int.MaxValue, false, false, null)
  76         {
  77         }
  78
  79         public DataContractSerializer(Type type, string rootName, string rootNamespace,
  80             IEnumerable<Type> knownTypes,
  81             int maxItemsInObjectGraph,
  82             bool ignoreExtensionDataObject,
  83             bool preserveObjectReferences,
  84             IDataContractSurrogate dataContractSurrogate)
  85             : this(type, rootName, rootNamespace, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, null)
  86         {
  87         }
  88
  89         public DataContractSerializer(Type type, string rootName, string rootNamespace,
  90             IEnumerable<Type> knownTypes,
  91             int maxItemsInObjectGraph,
  92             bool ignoreExtensionDataObject,
  93             bool preserveObjectReferences,
  94             IDataContractSurrogate dataContractSurrogate,
  95             DataContractResolver dataContractResolver)
  96         {
  97             XmlDictionary dictionary = new XmlDictionary(2);
  98             Initialize(type, dictionary.Add(rootName), dictionary.Add(DataContract.GetNamespace(rootNamespace)), knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, dataContractResolver, false);
  99         }
 100
 101         public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace)
 102             : this(type, rootName, rootNamespace, null)
 103         {
 104         }
 105
 106         public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes)
 107             : this(type, rootName, rootNamespace, knownTypes, int.MaxValue, false, false, null, null)
 108         {
 109         }
 110
 111         public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace,
 112             IEnumerable<Type> knownTypes,
 113             int maxItemsInObjectGraph,
 114             bool ignoreExtensionDataObject,
 115             bool preserveObjectReferences,
 116             IDataContractSurrogate dataContractSurrogate)
 117             : this(type, rootName, rootNamespace, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, null)
 118         {
 119         }
 120
 121         public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace,
 122             IEnumerable<Type> knownTypes,
 123             int maxItemsInObjectGraph,
 124             bool ignoreExtensionDataObject,
 125             bool preserveObjectReferences,
 126             IDataContractSurrogate dataContractSurrogate,
 127             DataContractResolver dataContractResolver)
 128         {
 129             Initialize(type, rootName, rootNamespace, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, dataContractResolver, false);
 130         }
 131
 132         public DataContractSerializer(Type type, DataContractSerializerSettings settings)
 133         {
 134             if (settings == null)
 135             {
 136                 settings = new DataContractSerializerSettings();
 137             }
 138             Initialize(type, settings.RootName, settings.RootNamespace, settings.KnownTypes, settings.MaxItemsInObjectGraph, settings.IgnoreExtensionDataObject,
 139                 settings.PreserveObjectReferences, settings.DataContractSurrogate, settings.DataContractResolver, settings.SerializeReadOnlyTypes);
 140         }
 141
 142         void Initialize(Type type,
 143             IEnumerable<Type> knownTypes,
 144             int maxItemsInObjectGraph,
 145             bool ignoreExtensionDataObject,
 146             bool preserveObjectReferences,
 147             IDataContractSurrogate dataContractSurrogate,
 148             DataContractResolver dataContractResolver,
 149             bool serializeReadOnlyTypes)
 150         {
 151             CheckNull(type, "type");
 152             this.rootType = type;
 153
 154             if (knownTypes != null)
 155             {
 156                 this.knownTypeList = new List<Type>();
 157                 foreach (Type knownType in knownTypes)
 158                 {
 159                     this.knownTypeList.Add(knownType);
 160                 }
 161             }
 162
 163             if (maxItemsInObjectGraph < 0)
 164                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxItemsInObjectGraph", SR.GetString(SR.ValueMustBeNonNegative)));
 165             this.maxItemsInObjectGraph = maxItemsInObjectGraph;
 166
 167             this.ignoreExtensionDataObject = ignoreExtensionDataObject;
 168             this.preserveObjectReferences = preserveObjectReferences;
 169             this.dataContractSurrogate = dataContractSurrogate;
 170             this.dataContractResolver = dataContractResolver;
 171             this.serializeReadOnlyTypes = serializeReadOnlyTypes;
 172         }
 173
 174         void Initialize(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace,
 175             IEnumerable<Type> knownTypes,
 176             int maxItemsInObjectGraph,
 177             bool ignoreExtensionDataObject,
 178             bool preserveObjectReferences,
 179             IDataContractSurrogate dataContractSurrogate,
 180             DataContractResolver dataContractResolver,
 181             bool serializeReadOnlyTypes)
 182         {
 183             Initialize(type, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, dataContractResolver, serializeReadOnlyTypes);
 184             // validate root name and namespace are both non-null
 185             this.rootName = rootName;
 186             this.rootNamespace = rootNamespace;
 187         }
 188
 189         public ReadOnlyCollection<Type> KnownTypes
 190         {
 191             get
 192             {
 193                 if (knownTypeCollection == null)
 194                 {
 195                     if (knownTypeList != null)
 196                     {
 197                         knownTypeCollection = new ReadOnlyCollection<Type>(knownTypeList);
 198                     }
 199                     else
 200                     {
 201                         knownTypeCollection = new ReadOnlyCollection<Type>(Globals.EmptyTypeArray);
 202                     }
 203                 }
 204                 return knownTypeCollection;
 205             }
 206         }
 207
 208         internal override DataContractDictionary KnownDataContracts
 209         {
 210             get
 211             {
 212                 if (this.knownDataContracts == null && this.knownTypeList != null)
 213                 {
 214                     // This assignment may be performed concurrently and thus is a race condition.
 215                     // It's safe, however, because at worse a new (and identical) dictionary of
 216                     // data contracts will be created and re-assigned to this field.  Introduction
 217                     // of a lock here could lead to deadlocks.
 218                     this.knownDataContracts = XmlObjectSerializerContext.GetDataContractsForKnownTypes(this.knownTypeList);
 219                 }
 220                 return this.knownDataContracts;
 221             }
 222         }
 223
 224         public int MaxItemsInObjectGraph
 225         {
 226             get { return maxItemsInObjectGraph; }
 227         }
 228
 229         public IDataContractSurrogate DataContractSurrogate
 230         {
 231             get { return dataContractSurrogate; }
 232         }
 233
 234         public bool PreserveObjectReferences
 235         {
 236             get { return preserveObjectReferences; }
 237         }
 238
 239         public bool IgnoreExtensionDataObject
 240         {
 241             get { return ignoreExtensionDataObject; }
 242         }
 243
 244         public DataContractResolver DataContractResolver
 245         {
 246             get { return dataContractResolver; }
 247         }
 248
 249         public bool SerializeReadOnlyTypes
 250         {
 251             get { return serializeReadOnlyTypes; }
 252         }
 253
 254         DataContract RootContract
 255         {
 256             get
 257             {
 258                 if (rootContract == null)
 259                 {
 260                     rootContract = DataContract.GetDataContract(((dataContractSurrogate == null) ? rootType : GetSurrogatedType(dataContractSurrogate, rootType)));
 261                     needsContractNsAtRoot = CheckIfNeedsContractNsAtRoot(rootName, rootNamespace, rootContract);
 262                 }
 263                 return rootContract;
 264             }
 265         }
 266
 267         internal override void InternalWriteObject(XmlWriterDelegator writer, object graph)
 268         {
 269             InternalWriteObject(writer, graph, null);
 270         }
 271
 272         internal override void InternalWriteObject(XmlWriterDelegator writer, object graph, DataContractResolver dataContractResolver)
 273         {
 274             InternalWriteStartObject(writer, graph);
 275             InternalWriteObjectContent(writer, graph, dataContractResolver);
 276             InternalWriteEndObject(writer);
 277         }
 278
 279         public override void WriteObject(XmlWriter writer, object graph)
 280         {
 281             WriteObjectHandleExceptions(new XmlWriterDelegator(writer), graph);
 282         }
 283
 284         public override void WriteStartObject(XmlWriter writer, object graph)
 285         {
 286             WriteStartObjectHandleExceptions(new XmlWriterDelegator(writer), graph);
 287         }
 288
 289         public override void WriteObjectContent(XmlWriter writer, object graph)
 290         {
 291             WriteObjectContentHandleExceptions(new XmlWriterDelegator(writer), graph);
 292         }
 293
 294         public override void WriteEndObject(XmlWriter writer)
 295         {
 296             WriteEndObjectHandleExceptions(new XmlWriterDelegator(writer));
 297         }
 298
 299         public override void WriteStartObject(XmlDictionaryWriter writer, object graph)
 300         {
 301             WriteStartObjectHandleExceptions(new XmlWriterDelegator(writer), graph);
 302         }
 303
 304         public override void WriteObjectContent(XmlDictionaryWriter writer, object graph)
 305         {
 306             WriteObjectContentHandleExceptions(new XmlWriterDelegator(writer), graph);
 307         }
 308
 309         public override void WriteEndObject(XmlDictionaryWriter writer)
 310         {
 311             WriteEndObjectHandleExceptions(new XmlWriterDelegator(writer));
 312         }
 313
 314         public void WriteObject(XmlDictionaryWriter writer, object graph, DataContractResolver dataContractResolver)
 315         {
 316             WriteObjectHandleExceptions(new XmlWriterDelegator(writer), graph, dataContractResolver);
 317         }
 318
 319         public override object ReadObject(XmlReader reader)
 320         {
 321             return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), true /*verifyObjectName*/);
 322         }
 323
 324         public override object ReadObject(XmlReader reader, bool verifyObjectName)
 325         {
 326             return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), verifyObjectName);
 327         }
 328
 329         public override bool IsStartObject(XmlReader reader)
 330         {
 331             return IsStartObjectHandleExceptions(new XmlReaderDelegator(reader));
 332         }
 333
 334         public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName)
 335         {
 336             return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), verifyObjectName);
 337         }
 338
 339         public override bool IsStartObject(XmlDictionaryReader reader)
 340         {
 341             return IsStartObjectHandleExceptions(new XmlReaderDelegator(reader));
 342         }
 343
 344         public object ReadObject(XmlDictionaryReader reader, bool verifyObjectName, DataContractResolver dataContractResolver)
 345         {
 346             return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), verifyObjectName, dataContractResolver);
 347         }
 348
 349         internal override void InternalWriteStartObject(XmlWriterDelegator writer, object graph)
 350         {
 351             WriteRootElement(writer, RootContract, rootName, rootNamespace, needsContractNsAtRoot);
 352         }
 353
 354         internal override void InternalWriteObjectContent(XmlWriterDelegator writer, object graph)
 355         {
 356             InternalWriteObjectContent(writer, graph, null);
 357         }
 358
 359         internal void InternalWriteObjectContent(XmlWriterDelegator writer, object graph, DataContractResolver dataContractResolver)
 360         {
 361             if (MaxItemsInObjectGraph == 0)
 362                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph)));
 363
 364             DataContract contract = RootContract;
 365             Type declaredType = contract.UnderlyingType;
 366             Type graphType = (graph == null) ? declaredType : graph.GetType();
 367
 368             if (dataContractSurrogate != null)
 369                 graph = SurrogateToDataContractType(dataContractSurrogate, graph, declaredType, ref graphType);
 370
 371             if (dataContractResolver == null)
 372                 dataContractResolver = this.DataContractResolver;
 373
 374             if (graph == null)
 375             {
 376                 if (IsRootXmlAny(rootName, contract))
 377                     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.IsAnyCannotBeNull, declaredType)));
 378                 WriteNull(writer);
 379             }
 380             else
 381             {
 382                 if (declaredType == graphType)
 383                 {
 384                     if (contract.CanContainReferences)
 385                     {
 386                         XmlObjectSerializerWriteContext context = XmlObjectSerializerWriteContext.CreateContext(this, contract, dataContractResolver);
 387                         context.HandleGraphAtTopLevel(writer, graph, contract);
 388                         context.SerializeWithoutXsiType(contract, writer, graph, declaredType.TypeHandle);
 389                     }
 390                     else
 391                     {
 392                         contract.WriteXmlValue(writer, graph, null);
 393                     }
 394                 }
 395                 else
 396                 {
 397                     XmlObjectSerializerWriteContext context = null;
 398                     if (IsRootXmlAny(rootName, contract))
 399                         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.IsAnyCannotBeSerializedAsDerivedType, graphType, contract.UnderlyingType)));
 400
 401                     contract = GetDataContract(contract, declaredType, graphType);
 402                     context = XmlObjectSerializerWriteContext.CreateContext(this, RootContract, dataContractResolver);
 403                     if (contract.CanContainReferences)
 404                     {
 405                         context.HandleGraphAtTopLevel(writer, graph, contract);
 406                     }
 407                     context.OnHandleIsReference(writer, contract, graph);
 408                     context.SerializeWithXsiTypeAtTopLevel(contract, writer, graph, declaredType.TypeHandle, graphType);
 409                 }
 410             }
 411         }
 412
 413         internal static DataContract GetDataContract(DataContract declaredTypeContract, Type declaredType, Type objectType)
 414         {
 415             if (declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType))
 416             {
 417                 return declaredTypeContract;
 418             }
 419             else if (declaredType.IsArray)//Array covariance is not supported in XSD
 420             {
 421                 return declaredTypeContract;
 422             }
 423             else
 424             {
 425                 return DataContract.GetDataContract(objectType.TypeHandle, objectType, SerializationMode.SharedContract);
 426             }
 427         }
 428
 429         internal void SetDataContractSurrogate(IDataContractSurrogate adapter)
 430         {
 431             dataContractSurrogate = adapter;
 432         }
 433
 434         internal override void InternalWriteEndObject(XmlWriterDelegator writer)
 435         {
 436             if (!IsRootXmlAny(rootName, RootContract))
 437             {
 438                 writer.WriteEndElement();
 439             }
 440         }
 441
 442         internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName)
 443         {
 444             return InternalReadObject(xmlReader, verifyObjectName, null);
 445         }
 446
 447         internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName, DataContractResolver dataContractResolver)
 448         {
 449             if (MaxItemsInObjectGraph == 0)
 450                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph)));
 451
 452             if (dataContractResolver == null)
 453                 dataContractResolver = this.DataContractResolver;
 454
 455             if (verifyObjectName)
 456             {
 457                 if (!InternalIsStartObject(xmlReader))
 458                 {
 459                     XmlDictionaryString expectedName;
 460                     XmlDictionaryString expectedNs;
 461                     if (rootName == null)
 462                     {
 463                         expectedName = RootContract.TopLevelElementName;
 464                         expectedNs = RootContract.TopLevelElementNamespace;
 465                     }
 466                     else
 467                     {
 468                         expectedName = rootName;
 469                         expectedNs = rootNamespace;
 470                     }
 471                     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.GetString(SR.ExpectingElement, expectedNs, expectedName), xmlReader));
 472                 }
 473             }
 474             else if (!IsStartElement(xmlReader))
 475             {
 476                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.GetString(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader));
 477             }
 478
 479             DataContract contract = RootContract;
 480             if (contract.IsPrimitive && object.ReferenceEquals(contract.UnderlyingType, rootType) /*handle Nullable<T> differently*/)
 481             {
 482                 return contract.ReadXmlValue(xmlReader, null);
 483             }
 484
 485             if (IsRootXmlAny(rootName, contract))
 486             {
 487                 return XmlObjectSerializerReadContext.ReadRootIXmlSerializable(xmlReader, contract as XmlDataContract, false /*isMemberType*/);
 488             }
 489
 490             XmlObjectSerializerReadContext context = XmlObjectSerializerReadContext.CreateContext(this, contract, dataContractResolver);
 491             return context.InternalDeserialize(xmlReader, rootType, contract, null, null);
 492         }
 493
 494         internal override bool InternalIsStartObject(XmlReaderDelegator reader)
 495         {
 496             return IsRootElement(reader, RootContract, rootName, rootNamespace);
 497         }
 498
 499         internal override Type GetSerializeType(object graph)
 500         {
 501             return (graph == null) ? rootType : graph.GetType();
 502         }
 503
 504         internal override Type GetDeserializeType()
 505         {
 506             return rootType;
 507         }
 508
 509         internal static object SurrogateToDataContractType(IDataContractSurrogate dataContractSurrogate, object oldObj, Type surrogatedDeclaredType, ref Type objType)
 510         {
 511             object obj = DataContractSurrogateCaller.GetObjectToSerialize(dataContractSurrogate, oldObj, objType, surrogatedDeclaredType);
 512             if (obj != oldObj)
 513             {
 514                 if (obj == null)
 515                     objType = Globals.TypeOfObject;
 516                 else
 517                     objType = obj.GetType();
 518             }
 519             return obj;
 520         }
 521
 522         internal static Type GetSurrogatedType(IDataContractSurrogate dataContractSurrogate, Type type)
 523         {
 524             return DataContractSurrogateCaller.GetDataContractType(dataContractSurrogate, DataContract.UnwrapNullableType(type));
 525         }
 526
 527     }
 528
 529 }