Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Costruttore XmlSerializer (Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String)

 

Data di pubblicazione: ottobre 2016

Inizializza una nuova istanza di XmlSerializer classe in grado di serializzare gli oggetti di tipo Object istanze di documento in XML e deserializzare le istanze di documento XML in oggetti di tipo Object. Ogni oggetto da serializzare può contenere istanze di classi, che esegue l'override di questo overload con altre classi. Questo overload specifica anche lo spazio dei nomi predefinito per tutti gli elementi XML e la classe da utilizzare come l'elemento radice XML.

Spazio dei nomi:   System.Xml.Serialization
Assembly:  System.Xml (in System.Xml.dll)

public XmlSerializer(
	Type type,
	XmlAttributeOverrides overrides,
	Type[] extraTypes,
	XmlRootAttribute root,
	string defaultNamespace
)

Parametri

type
Type: System.Type

Il tipo dell'oggetto da questo XmlSerializer può essere serializzato.

overrides
Type: System.Xml.Serialization.XmlAttributeOverrides

Un XmlAttributeOverrides che estende o sostituisce il comportamento della classe specificata nel type parametro.

extraTypes
Type: System.Type[]

Oggetto Type matrice di altri tipi di oggetti da serializzare.

root
Type: System.Xml.Serialization.XmlRootAttribute

Un XmlRootAttribute che definisce le proprietà dell'elemento radice XML.

defaultNamespace
Type: System.String

Spazio dei nomi predefinito di tutti gli elementi XML nel documento XML.

Il overrides parametro consente la creazione di un XmlSerializer che serializza una classe che estende o esegue l'override del comportamento di una classe base. Ad esempio, nel caso di una DLL, è possibile creare una classe che eredita o estende una classe contenuta nella DLL. Per serializzare tale classe, è necessario utilizzare un'istanza di XmlAttributeOverrides classe durante la costruzione di XmlSerializer. Per informazioni dettagliate, vedere XmlAttributeOverrides.

Per impostazione predefinita, se una proprietà pubblica o un campo restituisce un oggetto o una matrice di oggetti, i tipi di oggetti vengono serializzati automaticamente. Tuttavia, se una classe contiene un campo o proprietà che restituisce una matrice di tipo Object, qualsiasi oggetto può essere inserito in una matrice. In tal caso, il XmlSerializer deve prevedere tutti i tipi di oggetto possibili che vengono inseriti le Object matrice. A tale scopo, utilizzare il extraTypes parametro per specificare i tipi di oggetti aggiuntivi da serializzare o deserializzare.

L'elemento radice di un documento XML racchiude tutti gli altri elementi. Per impostazione predefinita, l'oggetto specificato dal type parametro venga serializzato come elemento radice. Proprietà, ad esempio il nome dell'elemento XML dell'elemento radice vengono prelevate i type oggetto. Tuttavia, il root parametro consente di sostituire le informazioni dell'oggetto predefinito specificando un XmlRootAttribute; l'oggetto consente di impostare un altro spazio dei nomi, nome dell'elemento e così via.

Utilizzare il defaultName parametro per specificare lo spazio dei nomi predefinito di tutti gli elementi XML generati dal XmlSerializer.

Nell'esempio seguente viene serializzata un'istanza di una classe definita in una DLL e a tale scopo, esegue l'override dei membri pubblici presenti nella classe. Nell'esempio specifica anche una matrice di tipi aggiuntivi, lo spazio dei nomi predefinito per tutti gli elementi XML e la classe da utilizzare che fornisce le informazioni di elemento radice XML. Nell'esempio si presuppone che sia stato compilato il codice all'inizio in una DLL denominata HighSchool.

// Beginning of the HighSchool.dll 

namespace HighSchool
{
   public class Student
   {
      public string Name;
      public int ID;
   }

   public class MyClass
   {
      public Student[] Students;
   }
}

namespace College
   {
   using System;
   using System.IO;
   using System.Xml;
   using System.Xml.Serialization; 
   using HighSchool;

    public class Graduate:HighSchool.Student
    {
       public Graduate(){}
       // Add a new field named University.
       public string University;
       // Use extra types to use this field.
       public object[]Info;
    }

    public class Address
    {
       public string City;
    }

    public class Phone
    {
       public string Number;
    }

   public class Run
   {
      public static void Main()
      {
         Run test = new Run();
         test.WriteOverriddenAttributes("College.xml");
         test.ReadOverriddenAttributes("College.xml");
      }

      private void WriteOverriddenAttributes(string filename)
      {
         // Writing the file requires a TextWriter.
         TextWriter myStreamWriter = new StreamWriter(filename);
         // Create an XMLAttributeOverrides class.
         XmlAttributeOverrides attrOverrides = 
         new XmlAttributeOverrides();
         // Create the XmlAttributes class.
         XmlAttributes attrs = new XmlAttributes();
         /* Override the Student class. "Alumni" is the name
         of the overriding element in the XML output. */

         XmlElementAttribute attr = 
         new XmlElementAttribute("Alumni", typeof(Graduate));
         /* Add the XmlElementAttribute to the collection of
         elements in the XmlAttributes object. */
         attrs.XmlElements.Add(attr);
         /* Add the XmlAttributes to the XmlAttributeOverrides. 
         "Students" is the name being overridden. */
         attrOverrides.Add(typeof(HighSchool.MyClass), 
         "Students", attrs);

         // Create array of extra types.
         Type [] extraTypes = new Type[2];
         extraTypes[0]=typeof(Address);
         extraTypes[1]=typeof(Phone);

         // Create an XmlRootAttribute.
         XmlRootAttribute root = new XmlRootAttribute("Graduates");

         /* Create the XmlSerializer with the 
         XmlAttributeOverrides object. */
         XmlSerializer mySerializer = new XmlSerializer
         (typeof(HighSchool.MyClass), attrOverrides, extraTypes,
         root, "http://www.microsoft.com");

         MyClass myClass= new MyClass();

         Graduate g1 = new Graduate();
         g1.Name = "Jacki";
         g1.ID = 1;
         g1.University = "Alma";

         Graduate g2 = new Graduate();
         g2.Name = "Megan";
         g2.ID = 2;
         g2.University = "CM";

         Student[] myArray = {g1,g2};

         myClass.Students = myArray;

         // Create extra information.
         Address a1 = new Address();
         a1.City = "Ionia";
         Address a2 = new Address();
         a2.City = "Stamford";
         Phone p1 = new Phone();
         p1.Number = "555-0101";
         Phone p2 = new Phone();
         p2.Number = "555-0100";

         Object[]o1 = new Object[2]{a1, p1};
         Object[]o2 = new Object[2]{a2,p2};

         g1.Info = o1;
         g2.Info = o2;
         mySerializer.Serialize(myStreamWriter,myClass);
         myStreamWriter.Close();
      }

      private void ReadOverriddenAttributes(string filename)
      {
         /* The majority of the code here is the same as that in the
         WriteOverriddenAttributes method. Because the XML being read
         doesn't conform to the schema defined by the DLL, the
         XMLAttributesOverrides must be used to create an 
         XmlSerializer instance to read the XML document.*/

         XmlAttributeOverrides attrOverrides = new 
         XmlAttributeOverrides();
         XmlAttributes attrs = new XmlAttributes();
         XmlElementAttribute attr = 
         new XmlElementAttribute("Alumni", typeof(Graduate));
         attrs.XmlElements.Add(attr);
         attrOverrides.Add(typeof(HighSchool.MyClass), 
         "Students", attrs);

         Type [] extraTypes = new Type[2];
         extraTypes[0] = typeof(Address);
         extraTypes[1] = typeof(Phone);

         XmlRootAttribute root = new XmlRootAttribute("Graduates");

         XmlSerializer readSerializer = new XmlSerializer
         (typeof(HighSchool.MyClass), attrOverrides, extraTypes,
         root, "http://www.microsoft.com");

         // A FileStream object is required to read the file. 
         FileStream fs = new FileStream(filename, FileMode.Open);

         MyClass myClass;
         myClass = (MyClass) readSerializer.Deserialize(fs);

         /* Here is the difference between reading and writing an 
         XML document: You must declare an object of the derived 
         type (Graduate) and cast the Student instance to it.*/
         Graduate g;
         Address a;
         Phone p;
         foreach(Graduate grad in myClass.Students)
         {
            g = (Graduate) grad;
            Console.Write(g.Name + "\t");
            Console.Write(g.ID + "\t");
            Console.Write(g.University + "\n");
            a = (Address) g.Info[0];
            Console.WriteLine(a.City);
            p = (Phone) g.Info[1];
            Console.WriteLine(p.Number);
         }
      }
   }
}

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: