title: .NET XML Serialization error (There was an error reflecting type)
body: <p>Yes I know very generic title, but I'm going to explain now.</p>
  
  <p>Given the class definition below, can someone explain why I would be getting this exception when I invoke the Serialize() method.</p>
  
  <p>{"There was an error reflecting type 'FNM.MISMO_3_0.FOREIGN_OBJECT'."}</p>
  
  <p>{"Type of choice identifier 'ItemsElementName' is inconsistent with type of 'Items'. Please use array of System.Collections.Generic.List`1[[MISMO_3_0.ItemsChoiceType, MISMO_3_0, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]."}</p>
  
  <p>Thank you,
  Stephen</p>
  
  <pre><code>[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.0.30319.225")]
  [System.SerializableAttribute()]
  [System.Diagnostics.DebuggerStepThroughAttribute()]
  [System.ComponentModel.DesignerCategoryAttribute("code")]
  [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://www.mismo.org/residential/2009/schemas")]
  [System.Xml.Serialization.XmlRootAttribute(Namespace = "http://www.mismo.org/residential/2009/schemas", IsNullable = true)]
  public partial class FOREIGN_OBJECT
  {
  
      private List&lt;object&gt; itemsField;
  
      private List&lt;ItemsChoiceType&gt; itemsElementNameField;
  
      private MISMOresourceLink typeField;
  
      private bool typeFieldSpecified;
  
      private string roleField;
  
      private string titleField;
  
      private string labelField;
  
      private string sequenceNumberField;
  
      private static System.Xml.Serialization.XmlSerializer serializer;
  
      public FOREIGN_OBJECT()
      {
          this.itemsElementNameField = new List&lt;ItemsChoiceType&gt;();
          this.itemsField = new List&lt;object&gt;();
      }
  
      [System.Xml.Serialization.XmlElementAttribute("CharacterEncodingSetType", typeof(CharacterEncodingSetEnum), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("CharacterEncodingSetTypeOtherDescription", typeof(MISMOString), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("EXTENSION", typeof(EXTENSION), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("EmbeddedContentXML", typeof(MISMOXML), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("MIMETypeIdentifier", typeof(MISMOIdentifier), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("ObjectCreatedDatetime", typeof(MISMODatetime), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("ObjectDescription", typeof(MISMOString), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("ObjectEncodingType", typeof(ObjectEncodingEnum), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("ObjectEncodingTypeOtherDescription", typeof(MISMOString), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("ObjectName", typeof(MISMOString), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("ObjectURI", typeof(string), DataType = "anyURI", Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("OriginalCreatorDigestValue", typeof(MISMOValue), Order = 0)]
      [System.Xml.Serialization.XmlElementAttribute("REFERENCE", typeof(REFERENCE), Order = 0)]
      [System.Xml.Serialization.XmlChoiceIdentifierAttribute("ItemsElementName")]
      public List&lt;object&gt; Items
      {
          get
          {
              return this.itemsField;
          }
          set
          {
              this.itemsField = value;
          }
      }
  
      [System.Xml.Serialization.XmlElementAttribute("ItemsElementName", Order = 1)]
      [System.Xml.Serialization.XmlIgnoreAttribute()]
      public List&lt;ItemsChoiceType&gt; ItemsElementName
      {
          get
          {
              return this.itemsElementNameField;
          }
          set
          {
              this.itemsElementNameField = value;
          }
      }
  
      [System.Xml.Serialization.XmlAttributeAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://www.w3.org/1999/xlink")]
      public MISMOresourceLink type
      {
          get
          {
              return this.typeField;
          }
          set
          {
              this.typeField = value;
          }
      }
  
      [System.Xml.Serialization.XmlIgnoreAttribute()]
      public bool typeSpecified
      {
          get
          {
              return this.typeFieldSpecified;
          }
          set
          {
              this.typeFieldSpecified = value;
          }
      }
  
      [System.Xml.Serialization.XmlAttributeAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://www.w3.org/1999/xlink")]
      public string role
      {
          get
          {
              return this.roleField;
          }
          set
          {
              this.roleField = value;
          }
      }
  
      [System.Xml.Serialization.XmlAttributeAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://www.w3.org/1999/xlink")]
      public string title
      {
          get
          {
              return this.titleField;
          }
          set
          {
              this.titleField = value;
          }
      }
  
      [System.Xml.Serialization.XmlAttributeAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://www.w3.org/1999/xlink", DataType = "NMTOKEN")]
      public string label
      {
          get
          {
              return this.labelField;
          }
          set
          {
              this.labelField = value;
          }
      }
  
      [System.Xml.Serialization.XmlAttributeAttribute(DataType = "integer")]
      public string SequenceNumber
      {
          get
          {
              return this.sequenceNumberField;
          }
          set
          {
              this.sequenceNumberField = value;
          }
      }
  
      private static System.Xml.Serialization.XmlSerializer Serializer
      {
          get
          {
              if ((serializer == null))
              {
                  serializer = new System.Xml.Serialization.XmlSerializer(typeof(FOREIGN_OBJECT));
              }
              return serializer;
          }
      }
  
      #region Serialize/Deserialize
      /// &lt;summary&gt;
      /// Serializes current FOREIGN_OBJECT object into an XML document
      /// &lt;/summary&gt;
      /// &lt;returns&gt;string XML value&lt;/returns&gt;
      public virtual string Serialize(System.Text.Encoding encoding)
      {
          System.IO.StreamReader streamReader = null;
          System.IO.MemoryStream memoryStream = null;
          try
          {
              memoryStream = new System.IO.MemoryStream();
              System.Xml.XmlWriterSettings xmlWriterSettings = new System.Xml.XmlWriterSettings();
              xmlWriterSettings.Encoding = encoding;
              System.Xml.XmlWriter xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings);
              Serializer.Serialize(xmlWriter, this);
              memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
              streamReader = new System.IO.StreamReader(memoryStream);
              return streamReader.ReadToEnd();
          }
          finally
          {
              if ((streamReader != null))
              {
                  streamReader.Dispose();
              }
              if ((memoryStream != null))
              {
                  memoryStream.Dispose();
              }
          }
      }
  
      public virtual string Serialize()
      {
          return Serialize(Encoding.UTF8);
      }
  
      /// &lt;summary&gt;
      /// Deserializes workflow markup into an FOREIGN_OBJECT object
      /// &lt;/summary&gt;
      /// &lt;param name="xml"&gt;string workflow markup to deserialize&lt;/param&gt;
      /// &lt;param name="obj"&gt;Output FOREIGN_OBJECT object&lt;/param&gt;
      /// &lt;param name="exception"&gt;output Exception value if deserialize failed&lt;/param&gt;
      /// &lt;returns&gt;true if this XmlSerializer can deserialize the object; otherwise, false&lt;/returns&gt;
      public static bool Deserialize(string xml, out FOREIGN_OBJECT obj, out System.Exception exception)
      {
          exception = null;
          obj = default(FOREIGN_OBJECT);
          try
          {
              obj = Deserialize(xml);
              return true;
          }
          catch (System.Exception ex)
          {
              exception = ex;
              return false;
          }
      }
  
      public static bool Deserialize(string xml, out FOREIGN_OBJECT obj)
      {
          System.Exception exception = null;
          return Deserialize(xml, out obj, out exception);
      }
  
      public static FOREIGN_OBJECT Deserialize(string xml)
      {
          System.IO.StringReader stringReader = null;
          try
          {
              stringReader = new System.IO.StringReader(xml);
              return ((FOREIGN_OBJECT)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
          }
          finally
          {
              if ((stringReader != null))
              {
                  stringReader.Dispose();
              }
          }
      }
  
      /// &lt;summary&gt;
      /// Serializes current FOREIGN_OBJECT object into file
      /// &lt;/summary&gt;
      /// &lt;param name="fileName"&gt;full path of outupt xml file&lt;/param&gt;
      /// &lt;param name="exception"&gt;output Exception value if failed&lt;/param&gt;
      /// &lt;returns&gt;true if can serialize and save into file; otherwise, false&lt;/returns&gt;
      public virtual bool SaveToFile(string fileName, System.Text.Encoding encoding, out System.Exception exception)
      {
          exception = null;
          try
          {
              SaveToFile(fileName, encoding);
              return true;
          }
          catch (System.Exception e)
          {
              exception = e;
              return false;
          }
      }
  
      public virtual bool SaveToFile(string fileName, out System.Exception exception)
      {
          return SaveToFile(fileName, Encoding.UTF8, out exception);
      }
  
      public virtual void SaveToFile(string fileName)
      {
          SaveToFile(fileName, Encoding.UTF8);
      }
  
      public virtual void SaveToFile(string fileName, System.Text.Encoding encoding)
      {
          System.IO.StreamWriter streamWriter = null;
          try
          {
              string xmlString = Serialize(encoding);
              streamWriter = new System.IO.StreamWriter(fileName, false, Encoding.UTF8);
              streamWriter.WriteLine(xmlString);
              streamWriter.Close();
          }
          finally
          {
              if ((streamWriter != null))
              {
                  streamWriter.Dispose();
              }
          }
      }
  
      /// &lt;summary&gt;
      /// Deserializes xml markup from file into an FOREIGN_OBJECT object
      /// &lt;/summary&gt;
      /// &lt;param name="fileName"&gt;string xml file to load and deserialize&lt;/param&gt;
      /// &lt;param name="obj"&gt;Output FOREIGN_OBJECT object&lt;/param&gt;
      /// &lt;param name="exception"&gt;output Exception value if deserialize failed&lt;/param&gt;
      /// &lt;returns&gt;true if this XmlSerializer can deserialize the object; otherwise, false&lt;/returns&gt;
      public static bool LoadFromFile(string fileName, System.Text.Encoding encoding, out FOREIGN_OBJECT obj, out System.Exception exception)
      {
          exception = null;
          obj = default(FOREIGN_OBJECT);
          try
          {
              obj = LoadFromFile(fileName, encoding);
              return true;
          }
          catch (System.Exception ex)
          {
              exception = ex;
              return false;
          }
      }
  
      public static bool LoadFromFile(string fileName, out FOREIGN_OBJECT obj, out System.Exception exception)
      {
          return LoadFromFile(fileName, Encoding.UTF8, out obj, out exception);
      }
  
      public static bool LoadFromFile(string fileName, out FOREIGN_OBJECT obj)
      {
          System.Exception exception = null;
          return LoadFromFile(fileName, out obj, out exception);
      }
  
      public static FOREIGN_OBJECT LoadFromFile(string fileName)
      {
          return LoadFromFile(fileName, Encoding.UTF8);
      }
  
      public static FOREIGN_OBJECT LoadFromFile(string fileName, System.Text.Encoding encoding)
      {
          System.IO.FileStream file = null;
          System.IO.StreamReader sr = null;
          try
          {
              file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
              sr = new System.IO.StreamReader(file, encoding);
              string xmlString = sr.ReadToEnd();
              sr.Close();
              file.Close();
              return Deserialize(xmlString);
          }
          finally
          {
              if ((file != null))
              {
                  file.Dispose();
              }
              if ((sr != null))
              {
                  sr.Dispose();
              }
          }
      }
      #endregion
  
      #region Clone method
      /// &lt;summary&gt;
      /// Create a clone of this FOREIGN_OBJECT object
      /// &lt;/summary&gt;
      public virtual FOREIGN_OBJECT Clone()
      {
          return ((FOREIGN_OBJECT)(this.MemberwiseClone()));
      }
      #endregion
  }
  </code></pre>