The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ XmlSerializer

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlSerializer.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization
  17. {
  18.    
  19.     using System.Reflection;
  20.     using System.Collections;
  21.     using System.IO;
  22.     using System.Xml.Schema;
  23.     using System;
  24.     using System.Text;
  25.     using System.Threading;
  26.     using System.Globalization;
  27.     using System.Security;
  28.     using System.Security.Permissions;
  29.     using System.Security.Policy;
  30.     using System.Xml.Serialization.Configuration;
  31.     using System.Diagnostics;
  32.     using System.CodeDom.Compiler;
  33.    
  34.     /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlDeserializationEvents"]/*' />
  35.     /// <devdoc>
  36.     /// <para>[To be supplied.]</para>
  37.     /// </devdoc>
  38.     public struct XmlDeserializationEvents
  39.     {
  40.         XmlNodeEventHandler onUnknownNode;
  41.         XmlAttributeEventHandler onUnknownAttribute;
  42.         XmlElementEventHandler onUnknownElement;
  43.         UnreferencedObjectEventHandler onUnreferencedObject;
  44.         internal object sender;
  45.        
  46.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlDeserializationEvents.OnUnknownNode"]/*' />
  47.         public XmlNodeEventHandler OnUnknownNode {
  48.             get { return onUnknownNode; }
  49.            
  50.             set { onUnknownNode = value; }
  51.         }
  52.        
  53.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlDeserializationEvents.OnUnknownAttribute"]/*' />
  54.         public XmlAttributeEventHandler OnUnknownAttribute {
  55.             get { return onUnknownAttribute; }
  56.             set { onUnknownAttribute = value; }
  57.         }
  58.        
  59.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlDeserializationEvents.OnUnknownElement"]/*' />
  60.         public XmlElementEventHandler OnUnknownElement {
  61.             get { return onUnknownElement; }
  62.             set { onUnknownElement = value; }
  63.         }
  64.        
  65.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlDeserializationEvents.OnUnreferencedObject"]/*' />
  66.         public UnreferencedObjectEventHandler OnUnreferencedObject {
  67.             get { return onUnreferencedObject; }
  68.             set { onUnreferencedObject = value; }
  69.         }
  70.     }
  71.    
  72.     /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation"]/*' />
  73.     ///<internalonly/>
  74.     /// <devdoc>
  75.     /// <para>[To be supplied.]</para>
  76.     /// </devdoc>
  77.     public abstract class XmlSerializerImplementation
  78.     {
  79.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.Reader"]/*' />
  80.         public virtual XmlSerializationReader Reader {
  81.             get {
  82.                 throw new NotSupportedException();
  83.             }
  84.         }
  85.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.Writer"]/*' />
  86.         public virtual XmlSerializationWriter Writer {
  87.             get {
  88.                 throw new NotSupportedException();
  89.             }
  90.         }
  91.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.ReadMethods"]/*' />
  92.         public virtual Hashtable ReadMethods {
  93.             get {
  94.                 throw new NotSupportedException();
  95.             }
  96.         }
  97.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.WriteMethods"]/*' />
  98.         public virtual Hashtable WriteMethods {
  99.             get {
  100.                 throw new NotSupportedException();
  101.             }
  102.         }
  103.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.TypedSerializers"]/*' />
  104.         public virtual Hashtable TypedSerializers {
  105.             get {
  106.                 throw new NotSupportedException();
  107.             }
  108.         }
  109.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.CanSerialize"]/*' />
  110.         public virtual bool CanSerialize(Type type)
  111.         {
  112.             throw new NotSupportedException();
  113.         }
  114.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializerImplementation.GetSerializer"]/*' />
  115.         public virtual XmlSerializer GetSerializer(Type type)
  116.         {
  117.             throw new NotSupportedException();
  118.         }
  119.     }
  120.    
  121.     /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer"]/*' />
  122.     /// <devdoc>
  123.     /// <para>[To be supplied.]</para>
  124.     /// </devdoc>
  125.     public class XmlSerializer
  126.     {
  127.         TempAssembly tempAssembly;
  128.         bool typedSerializer;
  129.         Type primitiveType;
  130.         XmlMapping mapping;
  131.         XmlDeserializationEvents events = new XmlDeserializationEvents();
  132.        
  133.         static TempAssemblyCache cache = new TempAssemblyCache();
  134.         static XmlSerializerNamespaces defaultNamespaces;
  135.         static XmlSerializerNamespaces DefaultNamespaces {
  136.             get {
  137.                 if (defaultNamespaces == null) {
  138.                     XmlSerializerNamespaces nss = new XmlSerializerNamespaces();
  139.                     nss.AddInternal("xsi", XmlSchema.InstanceNamespace);
  140.                     nss.AddInternal("xsd", XmlSchema.Namespace);
  141.                     if (defaultNamespaces == null) {
  142.                         defaultNamespaces = nss;
  143.                     }
  144.                 }
  145.                 return defaultNamespaces;
  146.             }
  147.         }
  148.        
  149.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer8"]/*' />
  150.         ///<internalonly/>
  151.         protected XmlSerializer()
  152.         {
  153.         }
  154.        
  155.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer"]/*' />
  156.         /// <devdoc>
  157.         /// <para>[To be supplied.]</para>
  158.         /// </devdoc>
  159.         public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace) : this(type, overrides, extraTypes, root, defaultNamespace, null, null)
  160.         {
  161.         }
  162.        
  163.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer2"]/*' />
  164.         /// <devdoc>
  165.         /// <para>[To be supplied.]</para>
  166.         /// </devdoc>
  167.         public XmlSerializer(Type type, XmlRootAttribute root) : this(type, null, new Type[0], root, null, null, null)
  168.         {
  169.         }
  170.        
  171.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer3"]/*' />
  172.         /// <devdoc>
  173.         /// <para>[To be supplied.]</para>
  174.         /// </devdoc>
  175.         public XmlSerializer(Type type, Type[] extraTypes) : this(type, null, extraTypes, null, null, null, null)
  176.         {
  177.         }
  178.        
  179.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer4"]/*' />
  180.         /// <devdoc>
  181.         /// <para>[To be supplied.]</para>
  182.         /// </devdoc>
  183.         public XmlSerializer(Type type, XmlAttributeOverrides overrides) : this(type, overrides, new Type[0], null, null, null, null)
  184.         {
  185.         }
  186.        
  187.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer5"]/*' />
  188.         /// <devdoc>
  189.         /// <para>[To be supplied.]</para>
  190.         /// </devdoc>
  191.         public XmlSerializer(XmlTypeMapping xmlTypeMapping)
  192.         {
  193.             tempAssembly = GenerateTempAssembly(xmlTypeMapping);
  194.             this.mapping = xmlTypeMapping;
  195.         }
  196.        
  197.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer6"]/*' />
  198.         /// <devdoc>
  199.         /// <para>[To be supplied.]</para>
  200.         /// </devdoc>
  201.         public XmlSerializer(Type type) : this(type, (string)null)
  202.         {
  203.         }
  204.        
  205.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer1"]/*' />
  206.         /// <devdoc>
  207.         /// <para>[To be supplied.]</para>
  208.         /// </devdoc>
  209.         public XmlSerializer(Type type, string defaultNamespace)
  210.         {
  211.             if (type == null)
  212.                 throw new ArgumentNullException("type");
  213.             this.mapping = GetKnownMapping(type, defaultNamespace);
  214.             if (this.mapping != null) {
  215.                 this.primitiveType = type;
  216.                 return;
  217.             }
  218.             tempAssembly = cache[defaultNamespace, type];
  219.             if (tempAssembly == null) {
  220.                 lock (cache) {
  221.                     tempAssembly = cache[defaultNamespace, type];
  222.                     if (tempAssembly == null) {
  223.                         XmlSerializerImplementation contract;
  224.                         Assembly assembly = TempAssembly.LoadGeneratedAssembly(type, defaultNamespace, out contract);
  225.                         if (assembly == null) {
  226.                             // need to reflect and generate new serialization assembly
  227.                             XmlReflectionImporter importer = new XmlReflectionImporter(defaultNamespace);
  228.                             this.mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
  229.                             tempAssembly = GenerateTempAssembly(this.mapping, type, defaultNamespace);
  230.                         }
  231.                         else {
  232.                             // we found the pre-generated assembly, now make sure that the assembly has the right serializer
  233.                             // try to avoid the reflection step, need to get ElementName, namespace and the Key form the type
  234.                             this.mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
  235.                             tempAssembly = new TempAssembly(new XmlMapping[] {this.mapping}, assembly, contract);
  236.                         }
  237.                     }
  238.                     cache.Add(defaultNamespace, type, tempAssembly);
  239.                 }
  240.             }
  241.             if (mapping == null) {
  242.                 mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
  243.             }
  244.         }
  245.        
  246.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer7"]/*' />
  247.         /// <devdoc>
  248.         /// <para>[To be supplied.]</para>
  249.         /// </devdoc>
  250.         [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
  251.         public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, string location, Evidence evidence)
  252.         {
  253.             if (type == null)
  254.                 throw new ArgumentNullException("type");
  255.             XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace);
  256.             for (int i = 0; i < extraTypes.Length; i++)
  257.                 importer.IncludeType(extraTypes[i]);
  258.             this.mapping = importer.ImportTypeMapping(type, root, defaultNamespace);
  259.             tempAssembly = GenerateTempAssembly(this.mapping, type, defaultNamespace, location, evidence);
  260.         }
  261.        
  262.         static internal TempAssembly GenerateTempAssembly(XmlMapping xmlMapping)
  263.         {
  264.             return GenerateTempAssembly(xmlMapping, null, null);
  265.         }
  266.        
  267.         static internal TempAssembly GenerateTempAssembly(XmlMapping xmlMapping, Type type, string defaultNamespace)
  268.         {
  269.             if (xmlMapping == null)
  270.                 throw new ArgumentNullException("xmlMapping");
  271.             return new TempAssembly(new XmlMapping[] {xmlMapping}, new Type[] {type}, defaultNamespace, null, null);
  272.         }
  273.        
  274.         static internal TempAssembly GenerateTempAssembly(XmlMapping xmlMapping, Type type, string defaultNamespace, string location, Evidence evidence)
  275.         {
  276.             return new TempAssembly(new XmlMapping[] {xmlMapping}, new Type[] {type}, defaultNamespace, location, evidence);
  277.         }
  278.        
  279.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize"]/*' />
  280.         /// <devdoc>
  281.         /// <para>[To be supplied.]</para>
  282.         /// </devdoc>
  283.         public void Serialize(TextWriter textWriter, object o)
  284.         {
  285.             Serialize(textWriter, o, null);
  286.         }
  287.        
  288.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize1"]/*' />
  289.         /// <devdoc>
  290.         /// <para>[To be supplied.]</para>
  291.         /// </devdoc>
  292.         public void Serialize(TextWriter textWriter, object o, XmlSerializerNamespaces namespaces)
  293.         {
  294.             XmlTextWriter xmlWriter = new XmlTextWriter(textWriter);
  295.             xmlWriter.Formatting = Formatting.Indented;
  296.             xmlWriter.Indentation = 2;
  297.             Serialize(xmlWriter, o, namespaces);
  298.         }
  299.        
  300.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize2"]/*' />
  301.         /// <devdoc>
  302.         /// <para>[To be supplied.]</para>
  303.         /// </devdoc>
  304.         public void Serialize(Stream stream, object o)
  305.         {
  306.             Serialize(stream, o, null);
  307.         }
  308.        
  309.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize3"]/*' />
  310.         /// <devdoc>
  311.         /// <para>[To be supplied.]</para>
  312.         /// </devdoc>
  313.         public void Serialize(Stream stream, object o, XmlSerializerNamespaces namespaces)
  314.         {
  315.             XmlTextWriter xmlWriter = new XmlTextWriter(stream, null);
  316.             xmlWriter.Formatting = Formatting.Indented;
  317.             xmlWriter.Indentation = 2;
  318.             Serialize(xmlWriter, o, namespaces);
  319.         }
  320.        
  321.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize4"]/*' />
  322.         /// <devdoc>
  323.         /// <para>[To be supplied.]</para>
  324.         /// </devdoc>
  325.         public void Serialize(XmlWriter xmlWriter, object o)
  326.         {
  327.             Serialize(xmlWriter, o, null);
  328.         }
  329.        
  330.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize5"]/*' />
  331.         /// <devdoc>
  332.         /// <para>[To be supplied.]</para>
  333.         /// </devdoc>
  334.         public void Serialize(XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces)
  335.         {
  336.             Serialize(xmlWriter, o, namespaces, null);
  337.         }
  338.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize6"]/*' />
  339.         public void Serialize(XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces, string encodingStyle)
  340.         {
  341.             Serialize(xmlWriter, o, namespaces, encodingStyle, null);
  342.         }
  343.        
  344.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize6"]/*' />
  345.         public void Serialize(XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
  346.         {
  347.             try {
  348.                 if (primitiveType != null) {
  349.                     if (encodingStyle != null && encodingStyle.Length > 0) {
  350.                         throw new InvalidOperationException(Res.GetString(Res.XmlInvalidEncodingNotEncoded1, encodingStyle));
  351.                     }
  352.                     SerializePrimitive(xmlWriter, o, namespaces);
  353.                 }
  354.                 else if (tempAssembly == null || typedSerializer) {
  355.                     XmlSerializationWriter writer = CreateWriter();
  356.                     writer.Init(xmlWriter, namespaces == null || namespaces.Count == 0 ? DefaultNamespaces : namespaces, encodingStyle, id, tempAssembly);
  357.                     try {
  358.                         Serialize(o, writer);
  359.                     }
  360.                     finally {
  361.                         writer.Dispose();
  362.                     }
  363.                 }
  364.                 else
  365.                     tempAssembly.InvokeWriter(mapping, xmlWriter, o, namespaces == null || namespaces.Count == 0 ? DefaultNamespaces : namespaces, encodingStyle, id);
  366.             }
  367.             catch (Exception e) {
  368.                 if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
  369.                     throw;
  370.                 }
  371.                 if (e is TargetInvocationException)
  372.                     e = e.InnerException;
  373.                 throw new InvalidOperationException(Res.GetString(Res.XmlGenError), e);
  374.             }
  375.             catch {
  376.                 throw new InvalidOperationException(Res.GetString(Res.XmlGenError), null);
  377.             }
  378.             xmlWriter.Flush();
  379.         }
  380.        
  381.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize"]/*' />
  382.         /// <devdoc>
  383.         /// <para>[To be supplied.]</para>
  384.         /// </devdoc>
  385.         public object Deserialize(Stream stream)
  386.         {
  387.             XmlTextReader xmlReader = new XmlTextReader(stream);
  388.             xmlReader.WhitespaceHandling = WhitespaceHandling.Significant;
  389.             xmlReader.Normalization = true;
  390.             xmlReader.XmlResolver = null;
  391.             return Deserialize(xmlReader, null);
  392.         }
  393.        
  394.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize1"]/*' />
  395.         /// <devdoc>
  396.         /// <para>[To be supplied.]</para>
  397.         /// </devdoc>
  398.         public object Deserialize(TextReader textReader)
  399.         {
  400.             XmlTextReader xmlReader = new XmlTextReader(textReader);
  401.             xmlReader.WhitespaceHandling = WhitespaceHandling.Significant;
  402.             xmlReader.Normalization = true;
  403.             xmlReader.XmlResolver = null;
  404.             return Deserialize(xmlReader, null);
  405.         }
  406.        
  407.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize2"]/*' />
  408.         /// <devdoc>
  409.         /// <para>[To be supplied.]</para>
  410.         /// </devdoc>
  411.         public object Deserialize(XmlReader xmlReader)
  412.         {
  413.             return Deserialize(xmlReader, null);
  414.         }
  415.        
  416.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize3"]/*' />
  417.         public object Deserialize(XmlReader xmlReader, XmlDeserializationEvents events)
  418.         {
  419.             return Deserialize(xmlReader, null, events);
  420.         }
  421.        
  422.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize4"]/*' />
  423.         public object Deserialize(XmlReader xmlReader, string encodingStyle)
  424.         {
  425.             return Deserialize(xmlReader, encodingStyle, this.events);
  426.         }
  427.        
  428.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize5"]/*' />
  429.         public object Deserialize(XmlReader xmlReader, string encodingStyle, XmlDeserializationEvents events)
  430.         {
  431.             events.sender = this;
  432.             try {
  433.                 if (primitiveType != null) {
  434.                     if (encodingStyle != null && encodingStyle.Length > 0) {
  435.                         throw new InvalidOperationException(Res.GetString(Res.XmlInvalidEncodingNotEncoded1, encodingStyle));
  436.                     }
  437.                     return DeserializePrimitive(xmlReader, events);
  438.                 }
  439.                 else if (tempAssembly == null || typedSerializer) {
  440.                     XmlSerializationReader reader = CreateReader();
  441.                     reader.Init(xmlReader, events, encodingStyle, tempAssembly);
  442.                     try {
  443.                         return Deserialize(reader);
  444.                     }
  445.                     finally {
  446.                         reader.Dispose();
  447.                     }
  448.                 }
  449.                 else {
  450.                     return tempAssembly.InvokeReader(mapping, xmlReader, events, encodingStyle);
  451.                 }
  452.             }
  453.             catch (Exception e) {
  454.                 if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
  455.                     throw;
  456.                 }
  457.                 if (e is TargetInvocationException)
  458.                     e = e.InnerException;
  459.                
  460.                 if (xmlReader is IXmlLineInfo) {
  461.                     IXmlLineInfo lineInfo = (IXmlLineInfo)xmlReader;
  462.                     throw new InvalidOperationException(Res.GetString(Res.XmlSerializeErrorDetails, lineInfo.LineNumber.ToString(CultureInfo.InvariantCulture), lineInfo.LinePosition.ToString(CultureInfo.InvariantCulture)), e);
  463.                 }
  464.                 else {
  465.                     throw new InvalidOperationException(Res.GetString(Res.XmlSerializeError), e);
  466.                 }
  467.             }
  468.             catch {
  469.                 if (xmlReader is IXmlLineInfo) {
  470.                     IXmlLineInfo lineInfo = (IXmlLineInfo)xmlReader;
  471.                     throw new InvalidOperationException(Res.GetString(Res.XmlSerializeErrorDetails, lineInfo.LineNumber.ToString(CultureInfo.InvariantCulture), lineInfo.LinePosition.ToString(CultureInfo.InvariantCulture)), null);
  472.                 }
  473.                 else {
  474.                     throw new InvalidOperationException(Res.GetString(Res.XmlSerializeError), (Exception)null);
  475.                 }
  476.             }
  477.         }
  478.        
  479.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.CanDeserialize"]/*' />
  480.         /// <devdoc>
  481.         /// <para>[To be supplied.]</para>
  482.         /// </devdoc>
  483.         public virtual bool CanDeserialize(XmlReader xmlReader)
  484.         {
  485.             if (primitiveType != null) {
  486.                 TypeDesc typeDesc = (TypeDesc)TypeScope.PrimtiveTypes[primitiveType];
  487.                 return xmlReader.IsStartElement(typeDesc.DataType.Name, string.Empty);
  488.             }
  489.             else if (tempAssembly != null) {
  490.                 return tempAssembly.CanRead(mapping, xmlReader);
  491.             }
  492.             else {
  493.                 return false;
  494.             }
  495.         }
  496.        
  497.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.FromMappings"]/*' />
  498.         /// <devdoc>
  499.         /// <para>[To be supplied.]</para>
  500.         /// </devdoc>
  501.         [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
  502.         public static XmlSerializer[] FromMappings(XmlMapping[] mappings)
  503.         {
  504.             return FromMappings(mappings, (Type)null);
  505.         }
  506.        
  507.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.FromMappings1"]/*' />
  508.         /// <devdoc>
  509.         /// <para>[To be supplied.]</para>
  510.         /// </devdoc>
  511.         [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
  512.         public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type)
  513.         {
  514.             if (mappings == null || mappings.Length == 0)
  515.                 return new XmlSerializer[0];
  516.             XmlSerializerImplementation contract = null;
  517.             Assembly assembly = type == null ? null : TempAssembly.LoadGeneratedAssembly(type, null, out contract);
  518.             TempAssembly tempAssembly = null;
  519.             if (assembly == null) {
  520.                 if (XmlMapping.IsShallow(mappings)) {
  521.                     return new XmlSerializer[0];
  522.                 }
  523.                 else {
  524.                     tempAssembly = new TempAssembly(mappings, new Type[] {type}, null, null, null);
  525.                     XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
  526.                     contract = tempAssembly.Contract;
  527.                     for (int i = 0; i < serializers.Length; i++) {
  528.                         serializers[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
  529.                         serializers[i].SetTempAssembly(tempAssembly, mappings[i]);
  530.                     }
  531.                     return serializers;
  532.                 }
  533.             }
  534.             else {
  535.                 XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
  536.                 for (int i = 0; i < serializers.Length; i++)
  537.                     serializers[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
  538.                 return serializers;
  539.             }
  540.         }
  541.        
  542.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.FromMappings3"]/*' />
  543.         /// <devdoc>
  544.         /// <para>[To be supplied.]</para>
  545.         /// </devdoc>
  546.         [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
  547.         public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Evidence evidence)
  548.         {
  549.             if (mappings == null || mappings.Length == 0)
  550.                 return new XmlSerializer[0];
  551.             if (XmlMapping.IsShallow(mappings)) {
  552.                 return new XmlSerializer[0];
  553.             }
  554.             TempAssembly tempAssembly = new TempAssembly(mappings, new Type[0], null, null, evidence);
  555.             XmlSerializerImplementation contract = tempAssembly.Contract;
  556.             XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
  557.             for (int i = 0; i < serializers.Length; i++) {
  558.                 serializers[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
  559.             }
  560.             return serializers;
  561.         }
  562.        
  563.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.GenerateSerializer"]/*' />
  564.         /// <devdoc>
  565.         /// <para>[To be supplied.]</para>
  566.         /// </devdoc>
  567.         [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
  568.         public static Assembly GenerateSerializer(Type[] types, XmlMapping[] mappings)
  569.         {
  570.             CompilerParameters parameters = new CompilerParameters();
  571.             parameters.TempFiles = new TempFileCollection();
  572.             parameters.GenerateInMemory = false;
  573.             parameters.IncludeDebugInformation = false;
  574.             return GenerateSerializer(types, mappings, parameters);
  575.         }
  576.        
  577.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.GenerateSerializer1"]/*' />
  578.         /// <devdoc>
  579.         /// <para>[To be supplied.]</para>
  580.         /// </devdoc>
  581.         [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
  582.         public static Assembly GenerateSerializer(Type[] types, XmlMapping[] mappings, CompilerParameters parameters)
  583.         {
  584.             if (types == null || types.Length == 0)
  585.                 return null;
  586.            
  587.             if (mappings == null)
  588.                 throw new ArgumentNullException("mappings");
  589.            
  590.             if (XmlMapping.IsShallow(mappings)) {
  591.                 throw new InvalidOperationException(Res.GetString(Res.XmlMelformMapping));
  592.             }
  593.            
  594.             Assembly assembly = null;
  595.             for (int i = 0; i < types.Length; i++) {
  596.                 Type type = types[i];
  597.                 if (DynamicAssemblies.IsTypeDynamic(type)) {
  598.                     throw new InvalidOperationException(Res.GetString(Res.XmlPregenTypeDynamic, type.FullName));
  599.                 }
  600.                 if (assembly == null)
  601.                     assembly = type.Assembly;
  602.                 else if (type.Assembly != assembly) {
  603.                     throw new ArgumentException(Res.GetString(Res.XmlPregenOrphanType, type.FullName, assembly.Location), "types");
  604.                 }
  605.             }
  606.             return TempAssembly.GenerateAssembly(mappings, types, null, null, parameters, assembly, new Hashtable());
  607.         }
  608.        
  609.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.FromTypes"]/*' />
  610.         /// <devdoc>
  611.         /// <para>[To be supplied.]</para>
  612.         /// </devdoc>
  613.         public static XmlSerializer[] FromTypes(Type[] types)
  614.         {
  615.             if (types == null)
  616.                 return new XmlSerializer[0];
  617.             XmlReflectionImporter importer = new XmlReflectionImporter();
  618.             XmlTypeMapping[] mappings = new XmlTypeMapping[types.Length];
  619.             for (int i = 0; i < types.Length; i++) {
  620.                 mappings[i] = importer.ImportTypeMapping(types[i]);
  621.             }
  622.             return FromMappings(mappings);
  623.         }
  624.        
  625.        
  626.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.GetXmlSerializerAssemblyName"]/*' />
  627.         /// <devdoc>
  628.         /// <para>[To be supplied.]</para>
  629.         /// </devdoc>
  630.         [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
  631.         public static string GetXmlSerializerAssemblyName(Type type)
  632.         {
  633.             return GetXmlSerializerAssemblyName(type, null);
  634.         }
  635.        
  636.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.GetXmlSerializerAssemblyName"]/*' />
  637.         /// <devdoc>
  638.         /// <para>[To be supplied.]</para>
  639.         /// </devdoc>
  640.         [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
  641.         public static string GetXmlSerializerAssemblyName(Type type, string defaultNamespace)
  642.         {
  643.             if (type == null) {
  644.                 throw new ArgumentNullException("type");
  645.             }
  646.             return Compiler.GetTempAssemblyName(type.Assembly.GetName(), defaultNamespace);
  647.         }
  648.        
  649.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.UnknownNode"]/*' />
  650.         /// <devdoc>
  651.         /// <para>[To be supplied.]</para>
  652.         /// </devdoc>
  653.         public event XmlNodeEventHandler UnknownNode {
  654.             add { events.OnUnknownNode += value; }
  655.             remove { events.OnUnknownNode -= value; }
  656.         }
  657.        
  658.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.UnknownAttribute"]/*' />
  659.         /// <devdoc>
  660.         /// <para>[To be supplied.]</para>
  661.         /// </devdoc>
  662.         public event XmlAttributeEventHandler UnknownAttribute {
  663.             add { events.OnUnknownAttribute += value; }
  664.             remove { events.OnUnknownAttribute -= value; }
  665.         }
  666.        
  667.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.UnknownElement"]/*' />
  668.         public event XmlElementEventHandler UnknownElement {
  669.             add { events.OnUnknownElement += value; }
  670.             remove { events.OnUnknownElement -= value; }
  671.         }
  672.        
  673.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.UnreferencedObject"]/*' />
  674.         public event UnreferencedObjectEventHandler UnreferencedObject {
  675.             add { events.OnUnreferencedObject += value; }
  676.             remove { events.OnUnreferencedObject -= value; }
  677.         }
  678.        
  679.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.CreateReader"]/*' />
  680.         ///<internalonly/>
  681.         protected virtual XmlSerializationReader CreateReader()
  682.         {
  683.             throw new NotImplementedException();
  684.         }
  685.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Deserialize4"]/*' />
  686.         ///<internalonly/>
  687.         protected virtual object Deserialize(XmlSerializationReader reader)
  688.         {
  689.             throw new NotImplementedException();
  690.         }
  691.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.CreateWriter"]/*' />
  692.         ///<internalonly/>
  693.         protected virtual XmlSerializationWriter CreateWriter()
  694.         {
  695.             throw new NotImplementedException();
  696.         }
  697.         /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.Serialize7"]/*' />
  698.         ///<internalonly/>
  699.         protected virtual void Serialize(object o, XmlSerializationWriter writer)
  700.         {
  701.             throw new NotImplementedException();
  702.         }
  703.        
  704.         internal void SetTempAssembly(TempAssembly tempAssembly, XmlMapping mapping)
  705.         {
  706.             this.tempAssembly = tempAssembly;
  707.             this.mapping = mapping;
  708.             this.typedSerializer = true;
  709.         }
  710.        
  711.         static XmlTypeMapping GetKnownMapping(Type type, string ns)
  712.         {
  713.             if (ns != null && ns != string.Empty)
  714.                 return null;
  715.             TypeDesc typeDesc = (TypeDesc)TypeScope.PrimtiveTypes[type];
  716.             if (typeDesc == null)
  717.                 return null;
  718.             ElementAccessor element = new ElementAccessor();
  719.             element.Name = typeDesc.DataType.Name;
  720.             XmlTypeMapping mapping = new XmlTypeMapping(null, element);
  721.             mapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, null));
  722.             return mapping;
  723.         }
  724.        
  725.         void SerializePrimitive(XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces)
  726.         {
  727.             XmlSerializationPrimitiveWriter writer = new XmlSerializationPrimitiveWriter();
  728.             writer.Init(xmlWriter, namespaces, null, null, null);
  729.             switch (Type.GetTypeCode(primitiveType)) {
  730.                 case TypeCode.String:
  731.                     writer.Write_string(o);
  732.                     break;
  733.                 case TypeCode.Int32:
  734.                     writer.Write_int(o);
  735.                     break;
  736.                 case TypeCode.Boolean:
  737.                     writer.Write_boolean(o);
  738.                     break;
  739.                 case TypeCode.Int16:
  740.                     writer.Write_short(o);
  741.                     break;
  742.                 case TypeCode.Int64:
  743.                     writer.Write_long(o);
  744.                     break;
  745.                 case TypeCode.Single:
  746.                     writer.Write_float(o);
  747.                     break;
  748.                 case TypeCode.Double:
  749.                     writer.Write_double(o);
  750.                     break;
  751.                 case TypeCode.Decimal:
  752.                     writer.Write_decimal(o);
  753.                     break;
  754.                 case TypeCode.DateTime:
  755.                     writer.Write_dateTime(o);
  756.                     break;
  757.                 case TypeCode.Char:
  758.                     writer.Write_char(o);
  759.                     break;
  760.                 case TypeCode.Byte:
  761.                     writer.Write_unsignedByte(o);
  762.                     break;
  763.                 case TypeCode.SByte:
  764.                     writer.Write_byte(o);
  765.                     break;
  766.                 case TypeCode.UInt16:
  767.                     writer.Write_unsignedShort(o);
  768.                     break;
  769.                 case TypeCode.UInt32:
  770.                     writer.Write_unsignedInt(o);
  771.                     break;
  772.                 case TypeCode.UInt64:
  773.                     writer.Write_unsignedLong(o);
  774.                     break;
  775.                 default:
  776.                    
  777.                     if (primitiveType == typeof(XmlQualifiedName)) {
  778.                         writer.Write_QName(o);
  779.                     }
  780.                     else if (primitiveType == typeof(byte[])) {
  781.                         writer.Write_base64Binary(o);
  782.                     }
  783.                     else if (primitiveType == typeof(Guid)) {
  784.                         writer.Write_guid(o);
  785.                     }
  786.                     else {
  787.                         throw new InvalidOperationException(Res.GetString(Res.XmlUnxpectedType, primitiveType.FullName));
  788.                     }
  789.                     break;
  790.             }
  791.         }
  792.        
  793.         object DeserializePrimitive(XmlReader xmlReader, XmlDeserializationEvents events)
  794.         {
  795.             XmlSerializationPrimitiveReader reader = new XmlSerializationPrimitiveReader();
  796.             reader.Init(xmlReader, events, null, null);
  797.             object o;
  798.             switch (Type.GetTypeCode(primitiveType)) {
  799.                 case TypeCode.String:
  800.                     o = reader.Read_string();
  801.                     break;
  802.                 case TypeCode.Int32:
  803.                     o = reader.Read_int();
  804.                     break;
  805.                 case TypeCode.Boolean:
  806.                     o = reader.Read_boolean();
  807.                     break;
  808.                 case TypeCode.Int16:
  809.                     o = reader.Read_short();
  810.                     break;
  811.                 case TypeCode.Int64:
  812.                     o = reader.Read_long();
  813.                     break;
  814.                 case TypeCode.Single:
  815.                     o = reader.Read_float();
  816.                     break;
  817.                 case TypeCode.Double:
  818.                     o = reader.Read_double();
  819.                     break;
  820.                 case TypeCode.Decimal:
  821.                     o = reader.Read_decimal();
  822.                     break;
  823.                 case TypeCode.DateTime:
  824.                     o = reader.Read_dateTime();
  825.                     break;
  826.                 case TypeCode.Char:
  827.                     o = reader.Read_char();
  828.                     break;
  829.                 case TypeCode.Byte:
  830.                     o = reader.Read_unsignedByte();
  831.                     break;
  832.                 case TypeCode.SByte:
  833.                     o = reader.Read_byte();
  834.                     break;
  835.                 case TypeCode.UInt16:
  836.                     o = reader.Read_unsignedShort();
  837.                     break;
  838.                 case TypeCode.UInt32:
  839.                     o = reader.Read_unsignedInt();
  840.                     break;
  841.                 case TypeCode.UInt64:
  842.                     o = reader.Read_unsignedLong();
  843.                     break;
  844.                 default:
  845.                    
  846.                     if (primitiveType == typeof(XmlQualifiedName)) {
  847.                         o = reader.Read_QName();
  848.                     }
  849.                     else if (primitiveType == typeof(byte[])) {
  850.                         o = reader.Read_base64Binary();
  851.                     }
  852.                     else if (primitiveType == typeof(Guid)) {
  853.                         o = reader.Read_guid();
  854.                     }
  855.                     else {
  856.                         throw new InvalidOperationException(Res.GetString(Res.XmlUnxpectedType, primitiveType.FullName));
  857.                     }
  858.                     break;
  859.             }
  860.             return o;
  861.         }
  862.     }
  863. }

Developer Fusion