mcs/class/System.XML/System.Xml.Serialization/XmlSerializer.cs

   1 //
   2 // XmlSerializer.cs:
   3 //
   4 // Author:
   5 //   Lluis Sanchez Gual (lluis@ximian.com)
   6 //
   7 // (C) 2002, 2003 Ximian, Inc.  http://www.ximian.com
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.IO;
  13 using System.Reflection;
  14 using System.Xml;
  15 using System.Xml.Schema;
  16 using System.Text;
  17
  18 namespace System.Xml.Serialization
  19 {
  20
  21         public class XmlSerializer
  22         {
  23
  24 #region Fields
  25
  26                 XmlTypeMapping typeMapping;
  27
  28 #endregion // Fields
  29
  30 #region Constructors
  31
  32                 protected XmlSerializer ()
  33                 {
  34                 }
  35
  36                 public XmlSerializer (Type type)
  37                         : this (type, null, null, null, null)
  38                 {
  39                 }
  40
  41                 public XmlSerializer (XmlTypeMapping xmlTypeMapping)
  42                 {
  43                         typeMapping = xmlTypeMapping;
  44                 }
  45
  46                 public XmlSerializer (Type type, string defaultNamespace)
  47                         : this (type, null, null, null, defaultNamespace)
  48                 {
  49                 }
  50
  51                 public XmlSerializer (Type type, Type[] extraTypes)
  52                         : this (type, null, extraTypes, null, null)
  53                 {
  54                 }
  55
  56                 public XmlSerializer (Type type, XmlAttributeOverrides overrides)
  57                         : this (type, overrides, null, null, null)
  58                 {
  59                 }
  60
  61                 public XmlSerializer (Type type, XmlRootAttribute root)
  62                         : this (type, null, null, root, null)
  63                 {
  64                 }
  65
  66                 public XmlSerializer (Type type,
  67                         XmlAttributeOverrides overrides,
  68                         Type [] extraTypes,
  69                         XmlRootAttribute root,
  70                         string defaultNamespace)
  71                 {
  72                         if (type == null)
  73                                 throw new ArgumentNullException ("type");
  74
  75                         XmlReflectionImporter importer = new XmlReflectionImporter (overrides, defaultNamespace);
  76
  77                         if (extraTypes != null) \r
  78                         {
  79                                 foreach (Type intype in extraTypes)
  80                                         importer.IncludeType (intype);
  81                         }
  82
  83                         typeMapping = importer.ImportTypeMapping (type, root, defaultNamespace);
  84                 }
  85
  86 #endregion // Constructors
  87
  88 #region Events
  89
  90                 private XmlAttributeEventHandler onUnknownAttribute;
  91                 private XmlElementEventHandler onUnknownElement;
  92                 private XmlNodeEventHandler onUnknownNode;
  93                 private UnreferencedObjectEventHandler onUnreferencedObject;
  94
  95                 public event XmlAttributeEventHandler UnknownAttribute
  96                 {
  97                         add { onUnknownAttribute += value; } remove { onUnknownAttribute -= value; }
  98                 }
  99
 100                 public event XmlElementEventHandler UnknownElement
 101                 {
 102                         add { onUnknownElement += value; } remove { onUnknownElement -= value; }
 103                 }
 104
 105                 public event XmlNodeEventHandler UnknownNode
 106                 {
 107                         add { onUnknownNode += value; } remove { onUnknownNode -= value; }
 108                 }
 109
 110                 public event UnreferencedObjectEventHandler UnreferencedObject
 111                 {
 112                         add { onUnreferencedObject += value; } remove { onUnreferencedObject -= value; }
 113                 }
 114
 115
 116                 internal virtual void OnUnknownAttribute (XmlAttributeEventArgs e)
 117                 {
 118                         if (onUnknownAttribute != null) onUnknownAttribute(this, e);
 119                 }
 120
 121                 internal virtual void OnUnknownElement (XmlElementEventArgs e)
 122                 {
 123                         if (onUnknownElement != null) onUnknownElement(this, e);
 124                 }
 125
 126                 internal virtual void OnUnknownNode (XmlNodeEventArgs e)
 127                 {
 128                         if (onUnknownNode != null) onUnknownNode(this, e);
 129                 }
 130
 131                 internal virtual void OnUnreferencedObject (UnreferencedObjectEventArgs e)
 132                 {
 133                         if (onUnreferencedObject != null) onUnreferencedObject(this, e);
 134                 }
 135
 136
 137 #endregion // Events
 138
 139 #region Methods
 140
 141                 [MonoTODO ("Implement.")]
 142                 public virtual bool CanDeserialize (XmlReader xmlReader)
 143                 {
 144                         xmlReader.MoveToContent ();
 145                         return typeMapping.ElementName == xmlReader.LocalName;
 146                 }
 147
 148                 protected virtual XmlSerializationReader CreateReader ()
 149                 {
 150                         return new XmlSerializationReaderInterpreter (typeMapping);
 151                 }
 152
 153                 protected virtual XmlSerializationWriter CreateWriter ()
 154                 {
 155                         return new XmlSerializationWriterInterpreter (typeMapping);
 156                 }
 157
 158                 public object Deserialize (Stream stream)
 159                 {
 160                         XmlTextReader xmlReader = new XmlTextReader(stream);
 161                         return Deserialize(xmlReader);
 162                 }
 163
 164                 public object Deserialize (TextReader textReader)
 165                 {
 166                         XmlTextReader xmlReader = new XmlTextReader(textReader);
 167                         return Deserialize(xmlReader);
 168                 }
 169
 170                 public object Deserialize (XmlReader xmlReader)
 171                 {
 172                         XmlSerializationReader xsReader = CreateReader ();
 173                         xsReader.Initialize (xmlReader, this);
 174                         return Deserialize (xsReader);
 175                 }
 176
 177                 protected virtual object Deserialize (XmlSerializationReader reader)
 178                 {
 179                         return reader.ReadObject ();
 180                 }
 181
 182                 public static XmlSerializer [] FromMappings (XmlMapping [] mappings)
 183                 {
 184                         XmlSerializer [] sers = new XmlSerializer [mappings.Length];
 185                         for (int n=0; n<mappings.Length; n++)
 186                         {
 187                                 XmlTypeMapping map = mappings[n] as XmlTypeMapping;
 188                                 if (map == null) throw new NotSupportedException ("Unsupported mapping type");
 189                                 sers[n] = new XmlSerializer (map);
 190                         }
 191                         return sers;
 192                 }
 193
 194                 public static XmlSerializer [] FromTypes (Type [] mappings)
 195                 {
 196                         XmlSerializer [] sers = new XmlSerializer [mappings.Length];
 197                         for (int n=0; n<mappings.Length; n++)
 198                                 sers[n] = new XmlSerializer (mappings[n]);
 199                         return sers;
 200                 }
 201
 202                 protected virtual void Serialize (object o, XmlSerializationWriter writer)
 203                 {
 204                         writer.WriteObject (o);
 205                 }
 206
 207                 public void Serialize (Stream stream, object o)
 208                 {
 209                         XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
 210                         xmlWriter.Formatting = Formatting.Indented;
 211                         Serialize (xmlWriter, o, null);
 212                 }
 213
 214                 public void Serialize (TextWriter textWriter, object o)
 215                 {
 216                         XmlTextWriter xmlWriter = new XmlTextWriter (textWriter);
 217                         xmlWriter.Formatting = Formatting.Indented;
 218                         Serialize (xmlWriter, o, null);
 219                 }
 220
 221                 public void Serialize (XmlWriter xmlWriter, object o)
 222                 {
 223                         Serialize (xmlWriter, o, null);
 224                 }
 225
 226                 public void Serialize (Stream stream, object o, XmlSerializerNamespaces namespaces)
 227                 {
 228                         XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
 229                         xmlWriter.Formatting = Formatting.Indented;
 230                         Serialize (xmlWriter, o, namespaces);
 231                 }
 232
 233                 public void Serialize (TextWriter textWriter, object o, XmlSerializerNamespaces namespaces)
 234                 {
 235                         XmlTextWriter xmlWriter = new XmlTextWriter (textWriter);
 236                         xmlWriter.Formatting = Formatting.Indented;
 237                         Serialize (xmlWriter, o, namespaces);
 238                         xmlWriter.Flush();
 239                 }
 240
 241                 public void Serialize (XmlWriter writer, object o, XmlSerializerNamespaces namespaces)
 242                 {
 243                         writer.WriteStartDocument ();
 244                         XmlSerializationWriter xsWriter = CreateWriter ();
 245                         xsWriter.Initialize (writer);
 246                         Serialize (o, xsWriter);
 247                         writer.WriteEndDocument();
 248                         writer.Flush ();
 249                 }
 250 #endregion // Methods
 251         }
 252 }