XmlSerializer.Serialize XmlSerializer.Serialize XmlSerializer.Serialize XmlSerializer.Serialize Method

Definición

Serializa un objeto en un documento XML.Serializes an object into an XML document.

Sobrecargas

Serialize(XmlWriter, Object) Serialize(XmlWriter, Object) Serialize(XmlWriter, Object)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el XmlWriter especificado.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter.

Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String)

Serializa el Object especificado y escribe el documento XML en un archivo mediante el XmlWriter especificado, así como los espacios de nombres y la codificación especificados.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter, XML namespaces, and encoding.

Serialize(XmlWriter, Object, XmlSerializerNamespaces, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String)

Serializa el objeto especificado, escribe el documento XML en un archivo utilizando el XmlWriter especificado y hace referencia a los espacios de nombres especificados y al estilo de codificación.Serializes the specified object and writes the XML document to a file using the specified XmlWriter and references the specified namespaces and encoding style.

Serialize(XmlWriter, Object, XmlSerializerNamespaces) Serialize(XmlWriter, Object, XmlSerializerNamespaces) Serialize(XmlWriter, Object, XmlSerializerNamespaces)

Serializa el objeto Object especificado, escribe el documento XML en un archivo utilizando el objeto XmlWriter especificado y hace referencia a los espacios de nombres especificados.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter and references the specified namespaces.

Serialize(TextWriter, Object, XmlSerializerNamespaces) Serialize(TextWriter, Object, XmlSerializerNamespaces) Serialize(TextWriter, Object, XmlSerializerNamespaces)

Serializa el objeto Object especificado, escribe el documento XML en un archivo utilizando el objeto TextWriter especificado y hace referencia a los espacios de nombres especificados.Serializes the specified Object and writes the XML document to a file using the specified TextWriter and references the specified namespaces.

Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el XmlSerializationWriter especificado.Serializes the specified Object and writes the XML document to a file using the specified XmlSerializationWriter.

Serialize(TextWriter, Object) Serialize(TextWriter, Object) Serialize(TextWriter, Object)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el TextWriter especificado.Serializes the specified Object and writes the XML document to a file using the specified TextWriter.

Serialize(Stream, Object) Serialize(Stream, Object) Serialize(Stream, Object)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el Stream especificado.Serializes the specified Object and writes the XML document to a file using the specified Stream.

Serialize(Stream, Object, XmlSerializerNamespaces) Serialize(Stream, Object, XmlSerializerNamespaces) Serialize(Stream, Object, XmlSerializerNamespaces)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el Stream especificado, que hace referencia a los espacios de nombres especificados.Serializes the specified Object and writes the XML document to a file using the specified Stream that references the specified namespaces.

Serialize(XmlWriter, Object) Serialize(XmlWriter, Object) Serialize(XmlWriter, Object)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el XmlWriter especificado.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter.

public:
 void Serialize(System::Xml::XmlWriter ^ xmlWriter, System::Object ^ o);
public void Serialize (System.Xml.XmlWriter xmlWriter, object o);
member this.Serialize : System.Xml.XmlWriter * obj -> unit

Parámetros

xmlWriter
XmlWriter XmlWriter XmlWriter XmlWriter

XmlWriter que se utiliza para escribir el documento XML.The XmlWriter used to write the XML document.

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

Excepciones

Se ha producido un error durante la serialización.An error occurred during serialization. La excepción original está disponible mediante la propiedad InnerException.The original exception is available using the InnerException property.

Ejemplos

El ejemplo siguiente serializa un objeto utilizando un XmlWriter.The following example serializes an object using an XmlWriter.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Xml;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class OrderedItem
{
public:
   String^ ItemName;
   String^ Description;
   Decimal UnitPrice;
   int Quantity;
   Decimal LineTotal;

   // A custom method used to calculate price per item.
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
};

void SerializeObject( String^ filename )
{
   Console::WriteLine( "Writing With XmlTextWriter" );
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );
   OrderedItem^ i = gcnew OrderedItem;
   i->ItemName = "Widget";
   i->Description = "Regular Widget";
   i->Quantity = 10;
   i->UnitPrice = (Decimal)2.30;
   i->Calculate();

   // Create an XmlTextWriter using a FileStream.
   Stream^ fs = gcnew FileStream( filename,FileMode::Create );
   XmlWriter^ writer = gcnew XmlTextWriter( fs,Encoding::Unicode );

   // Serialize using the XmlTextWriter.
   serializer->Serialize( writer, i );
   writer->Close();
}

int main()
{
   // Write a purchase order.
   SerializeObject( "simple.xml" );
}
using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

// This is the class that will be serialized.
public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
   public decimal LineTotal;
   // A custom method used to calculate price per item.
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test{
   public static void Main()
   {
      Test t = new Test();
      // Write a purchase order.
      t.SerializeObject("simple.xml");
   }
 
   private void SerializeObject(string filename)
   {
      Console.WriteLine("Writing With XmlTextWriter");
 
      XmlSerializer serializer = 
      new XmlSerializer(typeof(OrderedItem));
      OrderedItem i = new OrderedItem();
      i.ItemName = "Widget";
      i.Description = "Regular Widget";
      i.Quantity = 10;
      i.UnitPrice = (decimal) 2.30;
      i.Calculate();
      // Create an XmlTextWriter using a FileStream.
      Stream fs = new FileStream(filename, FileMode.Create);
      XmlWriter writer = 
      new XmlTextWriter(fs, Encoding.Unicode);
      // Serialize using the XmlTextWriter.
      serializer.Serialize(writer, i);
      writer.Close();
   }
}
   
Imports System
Imports System.IO
Imports System.Text
Imports System.Xml
Imports System.Xml.Serialization


' This is the class that will be serialized.
Public Class OrderedItem
    Public ItemName As String
    Public Description As String
    Public UnitPrice As Decimal
    Public Quantity As Integer
    Public LineTotal As Decimal
    
    ' A custom method used to calculate price per item.
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class


Public Class Test
    
    Public Shared Sub Main()
        Dim t As New Test()
        ' Write a purchase order.
        t.SerializeObject("simple.xml")
    End Sub
        
    Private Sub SerializeObject(ByVal filename As String)
        Console.WriteLine("Writing With XmlTextWriter")
        
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        Dim i As New OrderedItem()
        With i
            .ItemName = "Widget"
            .Description = "Regular Widget"
            .Quantity = 10
            .UnitPrice = CDec(2.3)
            .Calculate()
        End With
        ' Create an XmlTextWriter using a FileStream.
        Dim fs As New FileStream(filename, FileMode.Create)
        Dim writer As New XmlTextWriter(fs, Encoding.Unicode)
        ' Serialize using the XmlTextWriter.
        serializer.Serialize(writer, i)
        writer.Close()
    End Sub
End Class

<?xml version="1.0"?>
 <OrderedItem xmlns:inventory="http://www.cpandl.com" xmlns:money="http://www.cohowinery.com">
   <inventory:ItemName>Widget</inventory:ItemName>
   <inventory:Description>Regular Widget</inventory:Description>
   <money:UnitPrice>2.3</money:UnitPrice>
   <inventory:Quantity>10</inventory:Quantity>
   <money:LineTotal>23</money:LineTotal>
 </OrderedItem>

Comentarios

El Serialize método convierte los campos públicos y propiedades de lectura/escritura de un objeto en XML.The Serialize method converts the public fields and read/write properties of an object into XML. No convierte los métodos, indizadores, campos privados o propiedades de solo lectura.It does not convert methods, indexers, private fields, or read-only properties. Para serializar campos y propiedades de todos los de un objeto, públicos y privados, use el BinaryFormatter.To serialize all an object's fields and properties, both public and private, use the BinaryFormatter.

En el xmlWriter parámetro, especifique un objeto que se deriva de la clase abstracta XmlWriter clase.In the xmlWriter parameter, specify an object that derives from the abstract XmlWriter class. El XmlTextWriter deriva el XmlWriter.The XmlTextWriter derives from the XmlWriter.

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String)

Serializa el Object especificado y escribe el documento XML en un archivo mediante el XmlWriter especificado, así como los espacios de nombres y la codificación especificados.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter, XML namespaces, and encoding.

public:
 void Serialize(System::Xml::XmlWriter ^ xmlWriter, System::Object ^ o, System::Xml::Serialization::XmlSerializerNamespaces ^ namespaces, System::String ^ encodingStyle, System::String ^ id);
public void Serialize (System.Xml.XmlWriter xmlWriter, object o, System.Xml.Serialization.XmlSerializerNamespaces namespaces, string encodingStyle, string id);
member this.Serialize : System.Xml.XmlWriter * obj * System.Xml.Serialization.XmlSerializerNamespaces * string * string -> unit

Parámetros

xmlWriter
XmlWriter XmlWriter XmlWriter XmlWriter

XmlWriter que se utiliza para escribir el documento XML.The XmlWriter used to write the XML document.

o
Object Object Object Object

El objeto que se va a serializar.The object to serialize.

namespaces
XmlSerializerNamespaces XmlSerializerNamespaces XmlSerializerNamespaces XmlSerializerNamespaces

Instancia de XmlSerializerNamespaces que contiene los espacios de nombres y prefijos que se van a utilizar.An instance of the XmlSerializerNamespaces that contains namespaces and prefixes to use.

encodingStyle
String String String String

Codificación utilizada en el documento.The encoding used in the document.

id
String String String String

Para mensajes con codificación SOAP, base utilizada para generar los atributos de identificador.For SOAP encoded messages, the base used to generate id attributes.

Comentarios

El id parámetro proporciona la cadena base utilizada para crear identificadores de SOAP.The id parameter supplies the base string used to create SOAP ids. De forma predeterminada, estos son "id1", "id2" y así sucesivamente.By default, these are "id1", "id2" and so on. Pero si el parámetro se establece en "myBase" los valores generados es "myBaseid1", "myBaseid2" y así sucesivamente.But if the parameter is set to "myBase" the generated values are "myBaseid1", "myBaseid2" and so on. Esta funcionalidad se utiliza para crear valores de identificador único a través de todo el mensaje SOAP.This functionality is used to create unique id values across the whole SOAP message.

Serialize(XmlWriter, Object, XmlSerializerNamespaces, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String)

Serializa el objeto especificado, escribe el documento XML en un archivo utilizando el XmlWriter especificado y hace referencia a los espacios de nombres especificados y al estilo de codificación.Serializes the specified object and writes the XML document to a file using the specified XmlWriter and references the specified namespaces and encoding style.

public:
 void Serialize(System::Xml::XmlWriter ^ xmlWriter, System::Object ^ o, System::Xml::Serialization::XmlSerializerNamespaces ^ namespaces, System::String ^ encodingStyle);
public void Serialize (System.Xml.XmlWriter xmlWriter, object o, System.Xml.Serialization.XmlSerializerNamespaces namespaces, string encodingStyle);
member this.Serialize : System.Xml.XmlWriter * obj * System.Xml.Serialization.XmlSerializerNamespaces * string -> unit

Parámetros

xmlWriter
XmlWriter XmlWriter XmlWriter XmlWriter

XmlWriter que se utiliza para escribir el documento XML.The XmlWriter used to write the XML document.

o
Object Object Object Object

El objeto que se va a serializar.The object to serialize.

encodingStyle
String String String String

Estilo de codificación del XML serializado.The encoding style of the serialized XML.

Excepciones

Se ha producido un error durante la serialización.An error occurred during serialization. La excepción original está disponible mediante la propiedad InnerException.The original exception is available using the InnerException property.

Comentarios

Cuando el Serialize se invoca el método, los campos públicos y propiedades de lectura/escritura de un objeto se convierten en XML.When the Serialize method is invoked, the public fields and read/write properties of an object are converted into XML. No se serializan los métodos, indizadores, campos privados y propiedades de solo lectura.Methods, indexers, private fields, and read-only properties are not serialized. Para serializar todos los campos y propiedades, públicos y privados, use el BinaryFormatter.To serialize all fields and properties, both public and private, use the BinaryFormatter.

Use la xmlWriter parámetro para especificar un objeto que se deriva de la clase abstracta XmlWriter (clase), que está diseñado para escribir documentos XML.Use the xmlWriter parameter to specify an object that derives from the abstract XmlWriter class, which is designed to write XML documents. El XmlTextWriter deriva el XmlWriter.The XmlTextWriter derives from the XmlWriter.

Establecer el encodingStyle parámetro a "http://schemas.xmlsoap.org/soap/encoding/"para la codificación de la versión 1.1 de SOAP; de lo contrario, establézcalo en"http://www.w3.org/2001/12/soap-encoding" para la codificación de SOAP versión 1.2.Set the encodingStyle parameter to "http://schemas.xmlsoap.org/soap/encoding/" for SOAP version 1.1 encoding; otherwise, set it to "http://www.w3.org/2001/12/soap-encoding" for SOAP version 1.2 encoding.

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Serialize(XmlWriter, Object, XmlSerializerNamespaces) Serialize(XmlWriter, Object, XmlSerializerNamespaces) Serialize(XmlWriter, Object, XmlSerializerNamespaces)

Serializa el objeto Object especificado, escribe el documento XML en un archivo utilizando el objeto XmlWriter especificado y hace referencia a los espacios de nombres especificados.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter and references the specified namespaces.

public:
 void Serialize(System::Xml::XmlWriter ^ xmlWriter, System::Object ^ o, System::Xml::Serialization::XmlSerializerNamespaces ^ namespaces);
public void Serialize (System.Xml.XmlWriter xmlWriter, object o, System.Xml.Serialization.XmlSerializerNamespaces namespaces);
member this.Serialize : System.Xml.XmlWriter * obj * System.Xml.Serialization.XmlSerializerNamespaces -> unit

Parámetros

xmlWriter
XmlWriter XmlWriter XmlWriter XmlWriter

XmlWriter que se utiliza para escribir el documento XML.The XmlWriter used to write the XML document.

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

Excepciones

Se ha producido un error durante la serialización.An error occurred during serialization. La excepción original está disponible mediante la propiedad InnerException.The original exception is available using the InnerException property.

Ejemplos

El ejemplo siguiente serializa un objeto con un XmlWriter.The following example serializes an object with an XmlWriter. El ejemplo también se crea un XmlSerializerNamespaces y agrega dos espacios de nombres al objeto.The example also creates an XmlSerializerNamespaces and adds two namespaces to the object. Varias instancias de la XmlElementAttribute clase se aplican a los miembros de clase para especificar el espacio de nombres para cada elemento.Several instances of the XmlElementAttribute class are applied to the class members to specify the namespace for each element.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Xml;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class OrderedItem
{
public:

   [XmlElement(Namespace="http://www.cpandl.com")]
   String^ ItemName;

   [XmlElement(Namespace="http://www.cpandl.com")]
   String^ Description;

   [XmlElement(Namespace="http://www.cohowinery.com")]
   Decimal UnitPrice;

   [XmlElement(Namespace="http://www.cpandl.com")]
   int Quantity;

   [XmlElement(Namespace="http://www.cohowinery.com")]
   Decimal LineTotal;

   // A custom method used to calculate price per item.
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
};

void SerializeObject( String^ filename )
{
   Console::WriteLine( "Writing With XmlTextWriter" );
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );
   OrderedItem^ i = gcnew OrderedItem;
   i->ItemName = "Widget";
   i->Description = "Regular Widget";
   i->Quantity = 10;
   i->UnitPrice = (Decimal)2.30;
   i->Calculate();

   // Create an XmlSerializerNamespaces object.
   XmlSerializerNamespaces^ ns = gcnew XmlSerializerNamespaces;

   // Add two namespaces with prefixes.
   ns->Add( "inventory", "http://www.cpandl.com" );
   ns->Add( "money", "http://www.cohowinery.com" );

   // Create an XmlTextWriter using a FileStream.
   Stream^ fs = gcnew FileStream( filename,FileMode::Create );
   XmlWriter^ writer = gcnew XmlTextWriter( fs,gcnew UTF8Encoding );

   // Serialize using the XmlTextWriter.
   serializer->Serialize( writer, i, ns );
   writer->Close();
}

int main()
{
   // Write a purchase order.
   SerializeObject( "simple.xml" );
}
using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

// This is the class that will be serialized.
public class OrderedItem
{
   [XmlElement(Namespace = "http://www.cpandl.com")]
   public string ItemName;
   [XmlElement(Namespace = "http://www.cpandl.com")]
   public string Description;
   [XmlElement(Namespace="http://www.cohowinery.com")]
   public decimal UnitPrice;
   [XmlElement(Namespace = "http://www.cpandl.com")]
   public int Quantity;
   [XmlElement(Namespace="http://www.cohowinery.com")]
   public decimal LineTotal;
   // A custom method used to calculate price per item.
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test{
   public static void Main()
   {
      Test t = new Test();
   // Write a purchase order.
   t.SerializeObject("simple.xml");
   }
 
   private void SerializeObject(string filename)
   {
      Console.WriteLine("Writing With XmlTextWriter");

      XmlSerializer serializer = 
      new XmlSerializer(typeof(OrderedItem));
      OrderedItem i = new OrderedItem();
      i.ItemName = "Widget";
      i.Description = "Regular Widget";
      i.Quantity = 10;
      i.UnitPrice = (decimal) 2.30;
      i.Calculate();
 
      // Create an XmlSerializerNamespaces object.
      XmlSerializerNamespaces ns = 
      new XmlSerializerNamespaces();
      // Add two namespaces with prefixes.
      ns.Add("inventory", "http://www.cpandl.com");
      ns.Add("money", "http://www.cohowinery.com");
      // Create an XmlTextWriter using a FileStream.
      Stream fs = new FileStream(filename, FileMode.Create);
      XmlWriter writer = 
      new XmlTextWriter(fs, new UTF8Encoding());
      // Serialize using the XmlTextWriter.
      serializer.Serialize(writer, i, ns);
      writer.Close();
   }
}

Imports System
Imports System.IO
Imports System.Text
Imports System.Xml
Imports System.Xml.Serialization


' This is the class that will be serialized.
Public Class OrderedItem
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public ItemName As String
    
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public Description As String
    
    <XmlElement(Namespace := "http://www.cohowinery.com")> _
    Public UnitPrice As Decimal
    
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public Quantity As Integer
    
    <XmlElement(Namespace := "http://www.cohowinery.com")> _
    Public LineTotal As Decimal
    
    'A custom method used to calculate price per item.
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class


Public Class Test
    
    Public Shared Sub Main()
        Dim t As New Test()
        ' Write a purchase order.
        t.SerializeObject("simple.xml")
    End Sub    
    
    Private Sub SerializeObject(ByVal filename As String)
        Console.WriteLine("Writing With XmlTextWriter")
        
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        Dim i As New OrderedItem()
        With i
            .ItemName = "Widget"
            .Description = "Regular Widget"
            .Quantity = 10
            .UnitPrice = CDec(2.3)
            .Calculate()
        End With
        
        ' Create an XmlSerializerNamespaces object.
        Dim ns As New XmlSerializerNamespaces()
        ' Add two namespaces with prefixes.
        ns.Add("inventory", "http://www.cpandl.com")
        ns.Add("money", "http://www.cohowinery.com")
        ' Create an XmlTextWriter using a FileStream.
        Dim fs As New FileStream(filename, FileMode.Create)
        Dim writer As New XmlTextWriter(fs, New UTF8Encoding())
        ' Serialize using the XmlTextWriter.
        serializer.Serialize(writer, i, ns)
        writer.Close()
    End Sub
End Class

<?xml version="1.0"?>
 <OrderedItem xmlns:inventory="http://www.cpandl.com" xmlns:money="http://www.cohowinery.com">
   <inventory:ItemName>Widget</inventory:ItemName>
   <inventory:Description>Regular Widget</inventory:Description>
   <money:UnitPrice>2.3</money:UnitPrice>
   <inventory:Quantity>10</inventory:Quantity>
   <money:LineTotal>23</money:LineTotal>
 </OrderedItem>

Comentarios

Cuando el Serialize se invoca el método, los campos públicos y propiedades de lectura/escritura de un objeto se convierten en XML.When the Serialize method is invoked, the public fields and read/write properties of an object are converted into XML. No se serializan los métodos, indizadores, campos privados y propiedades de solo lectura.Methods, indexers, private fields, and read-only properties are not serialized. Para serializar todos los campos y propiedades, públicos y privados, use el BinaryFormatter.To serialize all fields and properties, both public and private, use the BinaryFormatter.

Use la xmlWriter parámetro para especificar un objeto que se deriva de la clase abstracta XmlWriter (clase), que está diseñado para escribir documentos XML.Use the xmlWriter parameter to specify an object that derives from the abstract XmlWriter class, which is designed to write XML documents. El XmlTextWriter deriva el XmlWriter.The XmlTextWriter derives from the XmlWriter.

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Serialize(TextWriter, Object, XmlSerializerNamespaces) Serialize(TextWriter, Object, XmlSerializerNamespaces) Serialize(TextWriter, Object, XmlSerializerNamespaces)

Serializa el objeto Object especificado, escribe el documento XML en un archivo utilizando el objeto TextWriter especificado y hace referencia a los espacios de nombres especificados.Serializes the specified Object and writes the XML document to a file using the specified TextWriter and references the specified namespaces.

public:
 void Serialize(System::IO::TextWriter ^ textWriter, System::Object ^ o, System::Xml::Serialization::XmlSerializerNamespaces ^ namespaces);
public void Serialize (System.IO.TextWriter textWriter, object o, System.Xml.Serialization.XmlSerializerNamespaces namespaces);
member this.Serialize : System.IO.TextWriter * obj * System.Xml.Serialization.XmlSerializerNamespaces -> unit

Parámetros

textWriter
TextWriter TextWriter TextWriter TextWriter

TextWriter que se utiliza para escribir el documento XML.The TextWriter used to write the XML document.

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

namespaces
XmlSerializerNamespaces XmlSerializerNamespaces XmlSerializerNamespaces XmlSerializerNamespaces

XmlSerializerNamespaces que contiene los espacios de nombres para el documento XML generado.The XmlSerializerNamespaces that contains namespaces for the generated XML document.

Excepciones

Se ha producido un error durante la serialización.An error occurred during serialization. La excepción original está disponible mediante la propiedad InnerException.The original exception is available using the InnerException property.

Ejemplos

El ejemplo siguiente serializa un objeto con un TextWriter.The following example serializes an object with a TextWriter. El ejemplo también se crea un XmlSerializerNamespaces de objeto y agrega dos espacios de nombres al objeto.The example also creates an XmlSerializerNamespaces object and adds two namespaces to the object. También se atribuye la clase que define el objeto serializado con XmlElementAttribute atributos para especificar el espacio de nombres para cada elemento.The class that defines the serialized object is also attributed with XmlElementAttribute attributes to specify the namespace for each element.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class OrderedItem
{
public:

   [XmlElement(Namespace="http://www.cpandl.com")]
   String^ ItemName;

   [XmlElement(Namespace="http://www.cpandl.com")]
   String^ Description;

   [XmlElement(Namespace="http://www.cohowinery.com")]
   Decimal UnitPrice;

   [XmlElement(Namespace="http://www.cpandl.com")]
   int Quantity;

   [XmlElement(Namespace="http://www.cohowinery.com")]
   Decimal LineTotal;

   // A custom method used to calculate price per item.
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
};

void SerializeObject( String^ filename )
{
   Console::WriteLine( "Writing With TextWriter" );

   // Create an XmlSerializer instance using the type.
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );
   OrderedItem^ i = gcnew OrderedItem;
   i->ItemName = "Widget";
   i->Description = "Regular Widget";
   i->Quantity = 10;
   i->UnitPrice = (Decimal)2.30;
   i->Calculate();

   // Create an XmlSerializerNamespaces object.
   XmlSerializerNamespaces^ ns = gcnew XmlSerializerNamespaces;

   // Add two namespaces with prefixes.
   ns->Add( "inventory", "http://www.cpandl.com" );
   ns->Add( "money", "http://www.cohowinery.com" );

   // Create a StreamWriter to write with.
   TextWriter^ writer = gcnew StreamWriter( filename );

   /* Serialize using the object using the TextWriter 
      and namespaces. */
   serializer->Serialize( writer, i, ns );
   writer->Close();
}

int main()
{
   // Write a purchase order.
   SerializeObject( "simple.xml" );
}
using System;
using System.IO;
using System.Xml.Serialization;

// This is the class that will be serialized.
public class OrderedItem
{
   [XmlElement(Namespace = "http://www.cpandl.com")]
   public string ItemName;
   [XmlElement(Namespace = "http://www.cpandl.com")]
   public string Description;
   [XmlElement(Namespace="http://www.cohowinery.com")]
   public decimal UnitPrice;
   [XmlElement(Namespace = "http://www.cpandl.com")]
   public int Quantity;
   [XmlElement(Namespace="http://www.cohowinery.com")]
   public decimal LineTotal;
   // A custom method used to calculate price per item.
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test{
   public static void Main(string[] args)
   {
      Test t = new Test();
      // Write a purchase order.
      t.SerializeObject("simple.xml");
   }
 
   private void SerializeObject(string filename)
   {
      Console.WriteLine("Writing With TextWriter");
      // Create an XmlSerializer instance using the type.
      XmlSerializer serializer = 
      new XmlSerializer(typeof(OrderedItem));
      OrderedItem i = new OrderedItem();
      i.ItemName = "Widget";
      i.Description = "Regular Widget";
      i.Quantity = 10;
      i.UnitPrice = (decimal) 2.30;
      i.Calculate();
 
      // Create an XmlSerializerNamespaces object.
      XmlSerializerNamespaces ns = 
      new XmlSerializerNamespaces();
      // Add two namespaces with prefixes.
      ns.Add("inventory", "http://www.cpandl.com");
      ns.Add("money", "http://www.cohowinery.com");
      // Create a StreamWriter to write with.
      TextWriter writer = new StreamWriter(filename);
      /* Serialize using the object using the TextWriter 
      and namespaces. */
      serializer.Serialize(writer, i, ns);
      writer.Close();
   }
}

Imports System
Imports System.IO
Imports System.Xml.Serialization


' This is the class that will be serialized.
Public Class OrderedItem
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public ItemName As String
    
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public Description As String
    
    <XmlElement(Namespace := "http://www.cohowinery.com")> _
    Public UnitPrice As Decimal
    
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public Quantity As Integer
    
    <XmlElement(Namespace := "http://www.cohowinery.com")> _
    Public LineTotal As Decimal
    
    'A custom method used to calculate price per item.
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class


Public Class Test
    
    Public Shared Sub Main()
        Dim t As New Test()
        ' Write a purchase order.
        t.SerializeObject("simple.xml")
    End Sub
    
    Private Sub SerializeObject(ByVal filename As String)
        Console.WriteLine("Writing With TextWriter")
        ' Create an XmlSerializer instance using the type.
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        Dim i As New OrderedItem()
        i.ItemName = "Widget"
        i.Description = "Regular Widget"
        i.Quantity = 10
        i.UnitPrice = CDec(2.3)
        i.Calculate()
        
        ' Create an XmlSerializerNamespaces object.
        Dim ns As New XmlSerializerNamespaces()
        ' Add two namespaces with prefixes.
        ns.Add("inventory", "http://www.cpandl.com")
        ns.Add("money", "http://www.cohowinery.com")
        ' Create a StreamWriter to write with.
        Dim writer As New StreamWriter(filename)
        ' Serialize using the object using the TextWriter
        ' and namespaces. 
        serializer.Serialize(writer, i, ns)
        writer.Close()
    End Sub
End Class

<?xml version="1.0"?>
 <OrderedItem xmlns:inventory="http://www.cpandl.com" xmlns:money="http://www.cohowinery.com">
   <inventory:ItemName>Widget</inventory:ItemName>
   <inventory:Description>Regular Widget</inventory:Description>
   <money:UnitPrice>2.3</money:UnitPrice>
   <inventory:Quantity>10</inventory:Quantity>
   <money:LineTotal>23</money:LineTotal>
 </OrderedItem>

Comentarios

Cuando el Serialize se invoca el método de los campos públicos y propiedades de lectura/escritura de un objeto se convierten en XML.When the Serialize method is invoked the public fields and read/write properties of an object are converted into XML. No se serializan los métodos, indizadores, campos privados y propiedades de solo lectura.Methods, indexers, private fields, and read-only properties are not serialized. Para serializar todos los campos y propiedades, públicos y privados, use el BinaryFormatter.To serialize all fields and properties, both public and private, use the BinaryFormatter.

Use la textWriter parámetro para especificar un objeto que se deriva de la clase abstracta TextWriter clase.Use the textWriter parameter to specify an object that derives from the abstract TextWriter class. Las clases que derivan de TextWriter clase incluyen:Classes that derive from TextWriter class include:

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el XmlSerializationWriter especificado.Serializes the specified Object and writes the XML document to a file using the specified XmlSerializationWriter.

protected:
 virtual void Serialize(System::Object ^ o, System::Xml::Serialization::XmlSerializationWriter ^ writer);
protected virtual void Serialize (object o, System.Xml.Serialization.XmlSerializationWriter writer);
abstract member Serialize : obj * System.Xml.Serialization.XmlSerializationWriter -> unit
override this.Serialize : obj * System.Xml.Serialization.XmlSerializationWriter -> unit
Protected Overridable Sub Serialize (o As Object, writer As XmlSerializationWriter)

Parámetros

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

writer
XmlSerializationWriter XmlSerializationWriter XmlSerializationWriter XmlSerializationWriter

XmlSerializationWriter que se utiliza para escribir el documento XML.The XmlSerializationWriter used to write the XML document.

Excepciones

Se intenta por todos los medios tener acceso al método cuando el método no se reemplaza en una clase descendiente.Any attempt is made to access the method when the method is not overridden in a descendant class.

Serialize(TextWriter, Object) Serialize(TextWriter, Object) Serialize(TextWriter, Object)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el TextWriter especificado.Serializes the specified Object and writes the XML document to a file using the specified TextWriter.

public:
 void Serialize(System::IO::TextWriter ^ textWriter, System::Object ^ o);
public void Serialize (System.IO.TextWriter textWriter, object o);
member this.Serialize : System.IO.TextWriter * obj -> unit

Parámetros

textWriter
TextWriter TextWriter TextWriter TextWriter

TextWriter que se utiliza para escribir el documento XML.The TextWriter used to write the XML document.

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

Ejemplos

El ejemplo siguiente serializa un objeto utilizando un TextWriter.The following example serializes an object using a TextWriter.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class OrderedItem
{
public:
   String^ ItemName;
   String^ Description;
   Decimal UnitPrice;
   int Quantity;
   Decimal LineTotal;

   // A custom method used to calculate price per item.
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
};

void SerializeObject( String^ filename )
{
   Console::WriteLine( "Writing With TextWriter" );
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );
   OrderedItem^ i = gcnew OrderedItem;
   i->ItemName = "Widget";
   i->Description = "Regular Widget";
   i->Quantity = 10;
   i->UnitPrice = (Decimal)2.30;
   i->Calculate();

   /* Create a StreamWriter to write with. First create a FileStream
      object, and create the StreamWriter specifying an Encoding to use. */
   FileStream^ fs = gcnew FileStream( filename,FileMode::Create );
   TextWriter^ writer = gcnew StreamWriter( fs,gcnew UTF8Encoding );

   // Serialize using the XmlTextWriter.
   serializer->Serialize( writer, i );
   writer->Close();
}

int main()
{
   // Write a purchase order.
   SerializeObject( "simple.xml" );
}
using System;
using System.IO;
using System.Text;
using System.Xml.Serialization;

// This is the class that will be serialized.
public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
   public decimal LineTotal;
   // A custom method used to calculate price per item.
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test{
   public static void Main(string[] args)
   {
      Test t = new Test();
      // Write a purchase order.
      t.SerializeObject("simple.xml");
   }
 
  private void SerializeObject(string filename)
  {
      Console.WriteLine("Writing With TextWriter");
 
      XmlSerializer serializer = 
      new XmlSerializer(typeof(OrderedItem));
      OrderedItem i = new OrderedItem();
      i.ItemName = "Widget";
      i.Description = "Regular Widget";
      i.Quantity = 10;
      i.UnitPrice = (decimal) 2.30;
      i.Calculate();
 
      /* Create a StreamWriter to write with. First create a FileStream
         object, and create the StreamWriter specifying an Encoding to use. */
      FileStream fs = new FileStream(filename, FileMode.Create);
      TextWriter writer = new StreamWriter(fs, new UTF8Encoding());
      // Serialize using the XmlTextWriter.
      serializer.Serialize(writer, i);
      writer.Close();
   }
}

Imports System
Imports System.IO
Imports System.Text
Imports System.Xml.Serialization


' This is the class that will be serialized.
Public Class OrderedItem
    Public ItemName As String
    Public Description As String
    Public UnitPrice As Decimal
    Public Quantity As Integer
    Public LineTotal As Decimal
    
    'A custom method used to calculate price per item.
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class


Public Class Test
    
    Public Shared Sub Main()
        Dim t As New Test()
        ' Write a purchase order.
        t.SerializeObject("simple.xml")
    End Sub
    
    Private Sub SerializeObject(ByVal filename As String)
        Console.WriteLine("Writing With TextWriter")
        
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        Dim i As New OrderedItem()

        With i
            .ItemName = "Widget"
            .Description = "Regular Widget"
            .Quantity = 10
            .UnitPrice = CDec(2.3)
            .Calculate()
        End With
        
        ' Create a StreamWriter to write with. First create a FileStream
        ' object, and create the StreamWriter specifying an Encoding to use. 
        Dim fs As New FileStream(filename, FileMode.Create)
        Dim writer As New StreamWriter(fs, New UTF8Encoding())
        ' Serialize using the XmlTextWriter.
        serializer.Serialize(writer, i)
        writer.Close()
    End Sub
End Class

<?xml version="1.0"?>
 <OrderedItem xmlns:inventory="http://www.cpandl.com" xmlns:money="http://www.cohowinery.com">
   <inventory:ItemName>Widget</inventory:ItemName>
   <inventory:Description>Regular Widget</inventory:Description>
   <money:UnitPrice>2.3</money:UnitPrice>
   <inventory:Quantity>10</inventory:Quantity>
   <money:LineTotal>23</money:LineTotal>
 </OrderedItem>

Comentarios

El Serialize método convierte los campos públicos y propiedades de lectura/escritura de un objeto en XML.The Serialize method converts the public fields and read/write properties of an object into XML. No convierte los métodos, indizadores, campos privados o propiedades de solo lectura.It does not convert methods, indexers, private fields, or read-only properties. Para serializar campos y propiedades de todos los de un objeto, públicos y privados, use el BinaryFormatter.To serialize all an object's fields and properties, both public and private, use the BinaryFormatter.

En el textWriter parámetro, especifique un objeto que se deriva de la clase abstracta TextWriter clase.In the textWriter parameter, specify an object that derives from the abstract TextWriter class. Las clases que derivan de TextWriter incluyen:Classes that derive from TextWriter include:

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Serialize(Stream, Object) Serialize(Stream, Object) Serialize(Stream, Object)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el Stream especificado.Serializes the specified Object and writes the XML document to a file using the specified Stream.

public:
 void Serialize(System::IO::Stream ^ stream, System::Object ^ o);
public void Serialize (System.IO.Stream stream, object o);
member this.Serialize : System.IO.Stream * obj -> unit

Parámetros

stream
Stream Stream Stream Stream

Stream que se utiliza para escribir el documento XML.The Stream used to write the XML document.

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

Excepciones

Se ha producido un error durante la serialización.An error occurred during serialization. La excepción original está disponible mediante la propiedad InnerException.The original exception is available using the InnerException property.

Ejemplos

El ejemplo siguiente serializa un objeto utilizando un Stream objeto.The following example serializes an object using a Stream object.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class OrderedItem
{
public:
   String^ ItemName;
   String^ Description;
   Decimal UnitPrice;
   int Quantity;
   Decimal LineTotal;

   // A custom method used to calculate price per item.
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
};

void SerializeObject( String^ filename )
{
   Console::WriteLine( "Writing With Stream" );
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );
   OrderedItem^ i = gcnew OrderedItem;
   i->ItemName = "Widget";
   i->Description = "Regular Widget";
   i->Quantity = 10;
   i->UnitPrice = (Decimal)2.30;
   i->Calculate();

   // Create a FileStream to write with.
   Stream^ writer = gcnew FileStream( filename,FileMode::Create );

   // Serialize the object, and close the TextWriter
   serializer->Serialize( writer, i );
   writer->Close();
}

int main()
{
   // Write a purchase order.
   SerializeObject( "simple.xml" );
}
using System;
using System.IO;
using System.Xml.Serialization;

// This is the class that will be serialized.
public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
   public decimal LineTotal;

   // A custom method used to calculate price per item.
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test{
   public static void Main(string[] args)
   {
      Test t = new Test();
      // Write a purchase order.
      t.SerializeObject("simple.xml");
   }
 
   private void SerializeObject(string filename)
   {
      Console.WriteLine("Writing With Stream");
 
      XmlSerializer serializer = 
      new XmlSerializer(typeof(OrderedItem));
      OrderedItem i = new OrderedItem();
      i.ItemName = "Widget";
      i.Description = "Regular Widget";
      i.Quantity = 10;
      i.UnitPrice = (decimal) 2.30;
      i.Calculate();
 
      // Create a FileStream to write with.
      Stream writer = new FileStream(filename, FileMode.Create);
      // Serialize the object, and close the TextWriter
      serializer.Serialize(writer, i);
      writer.Close();
   }
}

Imports System
Imports System.IO
Imports System.Xml.Serialization


' This is the class that will be serialized.
Public Class OrderedItem
    Public ItemName As String
    Public Description As String
    Public UnitPrice As Decimal
    Public Quantity As Integer
    Public LineTotal As Decimal
    
    
    ' A custom method used to calculate price per item.
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class


Public Class Test
    
    Public Shared Sub Main()
        Dim t As New Test()
        ' Write a purchase order.
        t.SerializeObject("simple.xml")
    End Sub
    
    Private Sub SerializeObject(ByVal filename As String)
        Console.WriteLine("Writing With Stream")
        
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        Dim i As New OrderedItem()

        With i
            .ItemName = "Widget"
            .Description = "Regular Widget"
            .Quantity = 10
            .UnitPrice = CDec(2.3)
            .Calculate()
        End With
        
        ' Create a FileStream to write with.
        Dim writer As New FileStream(filename, FileMode.Create)
        ' Serialize the object, and close the TextWriter
        serializer.Serialize(writer, i)
        writer.Close()
    End Sub
End Class

<?xml version="1.0"?>
 <OrderedItem xmlns:inventory="http://www.cpandl.com" xmlns:money="http://www.cohowinery.com">
   <inventory:ItemName>Widget</inventory:ItemName>
   <inventory:Description>Regular Widget</inventory:Description>
   <money:UnitPrice>2.3</money:UnitPrice>
   <inventory:Quantity>10</inventory:Quantity>
   <money:LineTotal>23</money:LineTotal>
 </OrderedItem>

Comentarios

El Serialize método convierte los campos públicos y propiedades de lectura/escritura de un objeto en XML.The Serialize method converts the public fields and read/write properties of an object into XML. No convierte los métodos, indizadores, campos privados o propiedades de solo lectura.It does not convert methods, indexers, private fields, or read-only properties. Para serializar todos los campos y propiedades de un objeto, públicos y privados, use el BinaryFormatter.To serialize all of an object's fields and properties, both public and private, use the BinaryFormatter.

En el stream parámetro, especifique un objeto que se deriva de la clase abstracta Stream clase.In the stream parameter, specify an object that derives from the abstract Stream class. Las clases que derivan de Stream incluyen:Classes that derive from Stream include:

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Serialize(Stream, Object, XmlSerializerNamespaces) Serialize(Stream, Object, XmlSerializerNamespaces) Serialize(Stream, Object, XmlSerializerNamespaces)

Serializa el Object especificado y escribe el documento XML en un archivo utilizando el Stream especificado, que hace referencia a los espacios de nombres especificados.Serializes the specified Object and writes the XML document to a file using the specified Stream that references the specified namespaces.

public:
 void Serialize(System::IO::Stream ^ stream, System::Object ^ o, System::Xml::Serialization::XmlSerializerNamespaces ^ namespaces);
public void Serialize (System.IO.Stream stream, object o, System.Xml.Serialization.XmlSerializerNamespaces namespaces);
member this.Serialize : System.IO.Stream * obj * System.Xml.Serialization.XmlSerializerNamespaces -> unit

Parámetros

stream
Stream Stream Stream Stream

Stream que se utiliza para escribir el documento XML.The Stream used to write the XML document.

o
Object Object Object Object

Object que se va a serializar.The Object to serialize.

Excepciones

Se ha producido un error durante la serialización.An error occurred during serialization. La excepción original está disponible mediante la propiedad InnerException.The original exception is available using the InnerException property.

Ejemplos

El ejemplo siguiente serializa un objeto con un Stream objeto.The following example serializes an object with a Stream object. El ejemplo también se crea un XmlSerializerNamespaces y agrega dos espacios de nombres al objeto.The example also creates an XmlSerializerNamespaces and adds two namespaces to the object. También se atribuye la clase que define el objeto serializado con XmlElementAttribute atributos para especificar el espacio de nombres para cada elemento.The class that defines the serialized object is also attributed with XmlElementAttribute attributes to specify the namespace for each element.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class OrderedItem
{
public:

   [XmlElement(Namespace="http://www.cpandl.com")]
   String^ ItemName;

   [XmlElement(Namespace="http://www.cpandl.com")]
   String^ Description;

   [XmlElement(Namespace="http://www.cohowinery.com")]
   Decimal UnitPrice;

   [XmlElement(Namespace="http://www.cpandl.com")]
   int Quantity;

   [XmlElement(Namespace="http://www.cohowinery.com")]
   Decimal LineTotal;

   // A custom method used to calculate price per item.
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
};

void SerializeObject( String^ filename )
{
   Console::WriteLine( "Writing With Stream" );
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );
   OrderedItem^ i = gcnew OrderedItem;
   i->ItemName = "Widget";
   i->Description = "Regular Widget";
   i->Quantity = 10;
   i->UnitPrice = (Decimal)2.30;
   i->Calculate();

   // Create an XmlSerializerNamespaces object.
   XmlSerializerNamespaces^ ns = gcnew XmlSerializerNamespaces;

   // Add two prefix-namespace pairs.
   ns->Add( "inventory", "http://www.cpandl.com" );
   ns->Add( "money", "http://www.cohowinery.com" );

   // Create a FileStream to write with.
   Stream^ writer = gcnew FileStream( filename,FileMode::Create );

   // Serialize the object, and close the TextWriter
   serializer->Serialize( writer, i, ns );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   Console::WriteLine( "Reading with Stream" );

   // Create an instance of the XmlSerializer.
   XmlSerializer^ serializer = gcnew XmlSerializer( OrderedItem::typeid );

   // Writing the file requires a Stream.
   Stream^ reader = gcnew FileStream( filename,FileMode::Open );

   // Declare an object variable of the type to be deserialized.
   OrderedItem^ i;

   /* Use the Deserialize method to restore the object's state 
      using data from the XML document. */
   i = dynamic_cast<OrderedItem^>(serializer->Deserialize( reader ));

   // Write out the properties of the object.
   Console::Write( "{0}\t{1}\t{2}\t{3}\t{4}", i->ItemName, i->Description, i->UnitPrice, i->Quantity, i->LineTotal );
}

int main()
{
   // Write a purchase order.
   SerializeObject( "simple.xml" );
   DeserializeObject( "simple.xml" );
}

using System;
using System.IO;
using System.Xml.Serialization;

// This is the class that will be serialized.
public class OrderedItem {
    [XmlElement(Namespace = "http://www.cpandl.com")]
    public string ItemName;
    [XmlElement(Namespace = "http://www.cpandl.com")]
    public string Description;
    [XmlElement(Namespace="http://www.cohowinery.com")]
    public decimal UnitPrice;
    [XmlElement(Namespace = "http://www.cpandl.com")]
    public int Quantity;
    [XmlElement(Namespace="http://www.cohowinery.com")]
    public decimal LineTotal;

    // A custom method used to calculate price per item.
    public void Calculate() {
        LineTotal = UnitPrice * Quantity;
    }
}
 
public class Test {
    
   public static void Main() {
        Test t = new Test();
        // Write a purchase order.
        t.SerializeObject("simple.xml");
        t.DeserializeObject("simple.xml");
   }
 
   private void SerializeObject(string filename) {
        Console.WriteLine("Writing With Stream");
 
        XmlSerializer serializer = 
            new XmlSerializer(typeof(OrderedItem));

        OrderedItem i = new OrderedItem();
        i.ItemName = "Widget";
        i.Description = "Regular Widget";
        i.Quantity = 10;
        i.UnitPrice = (decimal) 2.30;
        i.Calculate();
 
        // Create an XmlSerializerNamespaces object.
        XmlSerializerNamespaces ns = new XmlSerializerNamespaces();

        // Add two prefix-namespace pairs.
        ns.Add("inventory", "http://www.cpandl.com");
        ns.Add("money", "http://www.cohowinery.com");

        // Create a FileStream to write with.
        Stream writer = new FileStream(filename, FileMode.Create);

        // Serialize the object, and close the TextWriter
        serializer.Serialize(writer, i, ns);
        writer.Close();
    }
 
    private void DeserializeObject(string filename) {
        Console.WriteLine("Reading with Stream");
        // Create an instance of the XmlSerializer.
        XmlSerializer serializer = new XmlSerializer(typeof(OrderedItem));

        // Writing the file requires a Stream.
        Stream reader= new FileStream(filename,FileMode.Open);
          
        // Declare an object variable of the type to be deserialized.
        OrderedItem i;

        /* Use the Deserialize method to restore the object's state 
           using data from the XML document. */
        i = (OrderedItem) serializer.Deserialize(reader);

        // Write out the properties of the object.
        Console.Write(
            i.ItemName + "\t" +
            i.Description + "\t" +
            i.UnitPrice + "\t" +
            i.Quantity + "\t" +
            i.LineTotal);
    }
}

Imports System
Imports System.IO
Imports System.Xml.Serialization
Imports Microsoft.VisualBasic


' This is the class that will be serialized.
Public Class OrderedItem
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public ItemName As String
    
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public Description As String
    
    <XmlElement(Namespace := "http://www.cohowinery.com")> _
    Public UnitPrice As Decimal
    
    <XmlElement(Namespace := "http://www.cpandl.com")> _
    Public Quantity As Integer
    
    <XmlElement(Namespace := "http://www.cohowinery.com")> _
    Public LineTotal As Decimal
    
    ' A custom method used to calculate price per item.
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class

Public Class Test
        
    Public Shared Sub Main()
        Dim t As New Test()
        ' Write a purchase order.
        t.SerializeObject("simple.xml")
        t.DeserializeObject("simple.xml")
    End Sub    
    
    Private Sub SerializeObject(ByVal filename As String)
        Console.WriteLine("Writing With Stream")
        
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        
        Dim i As New OrderedItem()
        With i
            .ItemName = "Widget"
            .Description = "Regular Widget"
            .Quantity = 10
            .UnitPrice = CDec(2.3)
            .Calculate()
        End With
        
        ' Create an XmlSerializerNamespaces object.
        Dim ns As New XmlSerializerNamespaces()
        
        ' Add two prefix-namespace pairs.
        ns.Add("inventory", "http://www.cpandl.com")
        ns.Add("money", "http://www.cohowinery.com")
        
        ' Create a FileStream to write with.
        Dim writer As New FileStream(filename, FileMode.Create)
        
        ' Serialize the object, and close the TextWriter
        serializer.Serialize(writer, i, ns)
        writer.Close()
    End Sub
        
    Private Sub DeserializeObject(ByVal filename As String)
        Console.WriteLine("Reading with Stream")
        ' Create an instance of the XmlSerializer.
        Dim serializer As New XmlSerializer(GetType(OrderedItem))
        
        ' Writing the file requires a Stream.
        Dim reader As New FileStream(filename, FileMode.Open)
        
        ' Declare an object variable of the type to be deserialized.
        Dim i As OrderedItem
        
        ' Use the Deserialize method to restore the object's state
        ' using data from the XML document. 
        i = CType(serializer.Deserialize(reader), OrderedItem)
        
        ' Write out the properties of the object.
        Console.Write(i.ItemName & ControlChars.Tab & _
                      i.Description & ControlChars.Tab & _
                      i.UnitPrice & ControlChars.Tab & _
                      i.Quantity & ControlChars.Tab & _
                      i.LineTotal)
    End Sub
End Class

Comentarios

Cuando el Serialize se invoca el método, los campos públicos y propiedades de lectura/escritura de un objeto se convierten en XML.When the Serialize method is invoked, the public fields and read/write properties of an object are converted into XML. No se serializan los métodos, indizadores, campos privados y propiedades de solo lectura.Methods, indexers, private fields, and read-only properties are not serialized. Para serializar todos los campos y propiedades, públicos y privados, use el BinaryFormatter.To serialize all fields and properties, both public and private, use the BinaryFormatter.

Use la stream parámetro para especificar un objeto que se deriva de la clase abstracta Stream (clase), que está diseñado para escribir en secuencias.Use the stream parameter to specify an object that derives from the abstract Stream class, which is designed to write to streams. Las clases que derivan de la Stream clase incluyen:Classes that derive from the Stream class include:

Nota

El XmlSerializer no se puede serializar a lo siguiente: matrices de ArrayList y matrices de List<T>.The XmlSerializer cannot serialize the following: arrays of ArrayList and arrays of List<T>.

Consulte también:

Se aplica a