XmlSerializer.Serialize Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Xml.Serialization

Zestaw:: System.Xml.XmlSerializer.dll

Zestaw:: System.Xml.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Serializuje obiekt w dokumencie XML.

Przeciążenia

Serialize(XmlWriter, Object)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego XmlWriterelementu .
Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonych XmlWriterprzestrzeni nazw XML i kodowania.
Serialize(XmlWriter, Object, XmlSerializerNamespaces, String)	Serializuje określony obiekt i zapisuje dokument XML w pliku przy użyciu określonego i odwołuje się do określonych XmlWriter przestrzeni nazw i stylu kodowania.
Serialize(XmlWriter, Object, XmlSerializerNamespaces)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego XmlWriter i odwołuje się do określonych przestrzeni nazw.
Serialize(TextWriter, Object, XmlSerializerNamespaces)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego TextWriter i odwołuje się do określonych przestrzeni nazw.
Serialize(Object, XmlSerializationWriter)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego XmlSerializationWriterelementu .
Serialize(TextWriter, Object)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego TextWriterelementu .
Serialize(Stream, Object)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego Streamelementu .
Serialize(Stream, Object, XmlSerializerNamespaces)	Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego, Stream który odwołuje się do określonych przestrzeni nazw.

Serialize(XmlWriter, Object)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego XmlWriterelementu .

public:
 void Serialize(System::Xml::XmlWriter ^ xmlWriter, System::Object ^ o);

public void Serialize (System.Xml.XmlWriter xmlWriter, object o);

public void Serialize (System.Xml.XmlWriter xmlWriter, object? o);

member this.Serialize : System.Xml.XmlWriter * obj -> unit

Public Sub Serialize (xmlWriter As XmlWriter, o As Object)

Parametry

xmlWriter: XmlWriter

Używany XmlWriter do pisania dokumentu XML.

o: Object

Element Object do serializacji.

Wyjątki

InvalidOperationException

Wystąpił błąd podczas serializacji. Oryginalny wyjątek jest dostępny przy użyciu InnerException właściwości .

Przykłady

Poniższy przykład serializuje obiekt przy użyciu klasy 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 OrderedItem4
{
    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 Test4
{
    public static void Main()
    {
        Test4 t = new();
        // Write a purchase order.
        t.SerializeObject("simple.xml");
    }

    private void SerializeObject(string filename)
    {
        Console.WriteLine("Writing With XmlTextWriter");

        XmlSerializer serializer = new(typeof(OrderedItem4));
        OrderedItem4 i = new()
        {
            ItemName = "Widget",
            Description = "Regular Widget",
            Quantity = 10,
            UnitPrice = (decimal)2.30
        };
        i.Calculate();
        // Create an XmlTextWriter using a FileStream.
        Stream fs = new FileStream(filename, FileMode.Create);
        XmlTextWriter writer = new(fs, Encoding.Unicode);
        // Serialize using the XmlTextWriter.
        serializer.Serialize(writer, i);
        writer.Close();
    }
}

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>

Uwagi

Metoda Serialize konwertuje pola publiczne i właściwości odczytu/zapisu obiektu na xml. Nie konwertuje metod, indeksatorów, pól prywatnych ani właściwości tylko do odczytu.

W parametrze xmlWriter określ obiekt pochodzący z klasy abstrakcyjnej XmlWriter . Element XmlTextWriter pochodzi z elementu XmlWriter.

Uwaga

Nie XmlSerializer można serializować następujących elementów: tablic i ArrayList tablic .List<T>

Zobacz też

Dotyczy

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

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonych XmlWriterprzestrzeni nazw XML i kodowania.

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);

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

Public Sub Serialize (xmlWriter As XmlWriter, o As Object, namespaces As XmlSerializerNamespaces, encodingStyle As String, id As String)

Parametry

xmlWriter: XmlWriter

Używany XmlWriter do pisania dokumentu XML.

o: Object

Obiekt do serializacji.

namespaces: XmlSerializerNamespaces

Wystąpienie, XmlSerializerNamespaces które zawiera przestrzenie nazw i prefiksy do użycia.

encodingStyle: String

Kodowanie używane w dokumencie.

id: String

W przypadku komunikatów zakodowanych za pomocą protokołu SOAP baza używana do generowania atrybutów identyfikatorów.

Uwagi

Parametr id dostarcza ciąg podstawowy używany do tworzenia identyfikatorów protokołu SOAP. Domyślnie są to "id1", "id2" itd. Jeśli jednak parametr ma wartość "myBase", wygenerowane wartości to "myBaseid1", "myBaseid2" itd. Ta funkcja służy do tworzenia unikatowych wartości identyfikatorów w całej wiadomości SOAP.

Dotyczy

Serialize(XmlWriter, Object, XmlSerializerNamespaces, String)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony obiekt i zapisuje dokument XML w pliku przy użyciu określonego i odwołuje się do określonych XmlWriter przestrzeni nazw i stylu kodowania.

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);

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

Public Sub Serialize (xmlWriter As XmlWriter, o As Object, namespaces As XmlSerializerNamespaces, encodingStyle As String)

Parametry

xmlWriter: XmlWriter

Używany XmlWriter do pisania dokumentu XML.

o: Object

Obiekt do serializacji.

namespaces: XmlSerializerNamespaces

Obiekt XmlSerializerNamespaces , do których odwołuje się obiekt.

encodingStyle: String

Styl kodowania serializowanego kodu XML.

Wyjątki

InvalidOperationException

Wystąpił błąd podczas serializacji. Oryginalny wyjątek jest dostępny przy użyciu InnerException właściwości .

Uwagi

Serialize Po wywołaniu metody pola publiczne i właściwości odczytu/zapisu obiektu są konwertowane na kod XML. Metody, indeksatory, pola prywatne i właściwości tylko do odczytu nie są serializowane.

Użyj parametru xmlWriter , aby określić obiekt pochodzący z klasy abstrakcyjnej XmlWriter , który jest przeznaczony do pisania dokumentów XML. Element XmlTextWriter pochodzi z elementu XmlWriter.

encodingStyle Ustaw parametr na "http://schemas.xmlsoap.org/soap/encoding/" dla kodowania SOAP w wersji 1.1; w przeciwnym razie ustaw wartość "http://www.w3.org/2001/12/soap-encoding" dla kodowania SOAP w wersji 1.2.

Uwaga

Nie XmlSerializer można serializować następujących elementów: tablic i ArrayList tablic .List<T>

Zobacz też

Dotyczy

Serialize(XmlWriter, Object, XmlSerializerNamespaces)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego XmlWriter i odwołuje się do określonych przestrzeni nazw.

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);

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

Public Sub Serialize (xmlWriter As XmlWriter, o As Object, namespaces As XmlSerializerNamespaces)

Parametry

xmlWriter: XmlWriter

Używany XmlWriter do pisania dokumentu XML.

o: Object

Element Object do serializacji.

namespaces: XmlSerializerNamespaces

Obiekt XmlSerializerNamespaces , do których odwołuje się obiekt.

Wyjątki

InvalidOperationException

Wystąpił błąd podczas serializacji. Oryginalny wyjątek jest dostępny przy użyciu InnerException właściwości .

Przykłady

Poniższy przykład serializuje obiekt z obiektem XmlWriter. W przykładzie jest również tworzony obiekt XmlSerializerNamespaces i dodaje do obiektu dwie przestrzenie nazw. Do składowych klasy stosuje się kilka wystąpień XmlElementAttribute klasy, aby określić przestrzeń nazw dla każdego elementu.

#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 OrderedItem5
{
    [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 Test5
{
    public static void Main()
    {
        Test5 t = new();
        // Write a purchase order.
        t.SerializeObject("simple.xml");
    }

    private void SerializeObject(string filename)
    {
        Console.WriteLine("Writing With XmlTextWriter");

        XmlSerializer serializer = new(typeof(OrderedItem5));
        OrderedItem5 i = new()
        {
            ItemName = "Widget",
            Description = "Regular Widget",
            Quantity = 10,
            UnitPrice = (decimal)2.30
        };
        i.Calculate();

        // Create an XmlSerializerNamespaces object.
        XmlSerializerNamespaces ns = new();

        // 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);
        XmlTextWriter writer = new(fs, new UTF8Encoding());

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

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>

Uwagi

Uwaga

Nie XmlSerializer można serializować następujących elementów: tablic i ArrayList tablic .List<T>

Zobacz też

Dotyczy

Serialize(TextWriter, Object, XmlSerializerNamespaces)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego TextWriter elementu i odwołuje się do określonych przestrzeni nazw.

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);

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

Public Sub Serialize (textWriter As TextWriter, o As Object, namespaces As XmlSerializerNamespaces)

Parametry

textWriter: TextWriter

Używany TextWriter do pisania dokumentu XML.

o: Object

Element Object do serializacji.

namespaces: XmlSerializerNamespaces

Element XmlSerializerNamespaces zawierający przestrzenie nazw wygenerowanego dokumentu XML.

Wyjątki

InvalidOperationException

Wystąpił błąd podczas serializacji. Oryginalny wyjątek jest dostępny przy użyciu InnerException właściwości .

Przykłady

Poniższy przykład serializuje obiekt z obiektem TextWriter. Przykład tworzy XmlSerializerNamespaces również obiekt i dodaje do obiektu dwie przestrzenie nazw. Klasa definiująca serializowany obiekt jest również przypisywana atrybutom XmlElementAttribute w celu określenia przestrzeni nazw dla każdego elementu.

#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 OrderedItem1
{
    [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 Test1
{
    public static void Main(string[] args)
    {
        Test1 t = new();
        // 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(typeof(OrderedItem1));
        OrderedItem1 i = new()
        {
            ItemName = "Widget",
            Description = "Regular Widget",
            Quantity = 10,
            UnitPrice = (decimal)2.30
        };
        i.Calculate();

        // Create an XmlSerializerNamespaces object.
        XmlSerializerNamespaces ns = new();
        // 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.
        StreamWriter writer = new(filename);
        /* Serialize using the object using the TextWriter
        and namespaces. */
        serializer.Serialize(writer, i, ns);
        writer.Close();
    }
}

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>

Uwagi

Serialize Gdy metoda jest wywoływana w polach publicznych, a właściwości odczytu/zapisu obiektu są konwertowane na kod XML. Metody, indeksatory, pola prywatne i właściwości tylko do odczytu nie są serializowane.

Użyj parametru , textWriter aby określić obiekt pochodzący z klasy abstrakcyjnej TextWriter . Klasy pochodzące z TextWriter klasy obejmują:

Uwaga

Nie XmlSerializer można serializować następujących: tablice ArrayList i tablice .List<T>

Zobacz też

Dotyczy

Serialize(Object, XmlSerializationWriter)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego XmlSerializationWriterelementu .

protected:
 virtual void Serialize(System::Object ^ o, System::Xml::Serialization::XmlSerializationWriter ^ writer);

protected virtual void Serialize (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)

Parametry

o: Object

Element Object do serializacji.

writer: XmlSerializationWriter

Element XmlSerializationWriter używany do zapisywania dokumentu XML.

Wyjątki

NotImplementedException

Każda próba uzyskania dostępu do metody jest podejmowana, gdy metoda nie jest zastępowana w klasie potomnej.

Dotyczy

Serialize(TextWriter, Object)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego TextWriterelementu .

public:
 void Serialize(System::IO::TextWriter ^ textWriter, System::Object ^ o);

public void Serialize (System.IO.TextWriter textWriter, object o);

public void Serialize (System.IO.TextWriter textWriter, object? o);

member this.Serialize : System.IO.TextWriter * obj -> unit

Public Sub Serialize (textWriter As TextWriter, o As Object)

Parametry

textWriter: TextWriter

Element TextWriter używany do zapisywania dokumentu XML.

o: Object

Element Object do serializacji.

Przykłady

Poniższy przykład serializuje obiekt przy użyciu klasy 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();
        // Write a purchase order.
        t.SerializeObject("simple.xml");
    }

    private void SerializeObject(string filename)
    {
        Console.WriteLine("Writing With TextWriter");

        XmlSerializer serializer = new(typeof(OrderedItem));
        OrderedItem i = new()
        {
            ItemName = "Widget",
            Description = "Regular Widget",
            Quantity = 10,
            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(filename, FileMode.Create);
        StreamWriter writer = new(fs, new UTF8Encoding());
        // Serialize using the XmlTextWriter.
        serializer.Serialize(writer, i);
        writer.Close();
    }
}

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>

Uwagi

Metoda Serialize konwertuje pola publiczne i właściwości odczytu/zapisu obiektu na xml. Nie konwertuje metod, indeksatorów, pól prywatnych ani właściwości tylko do odczytu.

W parametrze textWriter określ obiekt pochodzący z klasy abstrakcyjnej TextWriter . Klasy pochodzące z TextWriter klasy obejmują:

Uwaga

Nie XmlSerializer można serializować następujących: tablice ArrayList i tablice .List<T>

Zobacz też

Dotyczy

Serialize(Stream, Object)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML w pliku przy użyciu określonego Streamelementu .

public:
 void Serialize(System::IO::Stream ^ stream, System::Object ^ o);

public void Serialize (System.IO.Stream stream, object o);

public void Serialize (System.IO.Stream stream, object? o);

member this.Serialize : System.IO.Stream * obj -> unit

Public Sub Serialize (stream As Stream, o As Object)

Parametry

stream: Stream

Element Stream używany do zapisywania dokumentu XML.

o: Object

Element Object do serializacji.

Wyjątki

InvalidOperationException

Wystąpił błąd podczas serializacji. Oryginalny wyjątek jest dostępny przy użyciu InnerException właściwości .

Przykłady

Poniższy przykład serializuje obiekt przy użyciu Stream obiektu.

#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 OrderedItem2
{
    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 Test2
{
    public static void Main(string[] args)
    {
        Test2 t = new();
        // Write a purchase order.
        t.SerializeObject("simple.xml");
    }

    private void SerializeObject(string filename)
    {
        Console.WriteLine("Writing With Stream");

        XmlSerializer serializer = new(typeof(OrderedItem2));
        OrderedItem2 i = new()
        {
            ItemName = "Widget",
            Description = "Regular Widget",
            Quantity = 10,
            UnitPrice = (decimal)2.30
        };
        i.Calculate();

        // Create a FileStream to write with.
        FileStream writer = new(filename, FileMode.Create);
        // Serialize the object, and close the TextWriter
        serializer.Serialize(writer, i);
        writer.Close();
    }
}

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>

Uwagi

Metoda Serialize konwertuje pola publiczne i właściwości odczytu/zapisu obiektu na xml. Nie konwertuje metod, indeksatorów, pól prywatnych ani właściwości tylko do odczytu.

W parametrze stream określ obiekt pochodzący z klasy abstrakcyjnej Stream . Klasy pochodzące z Stream klasy obejmują:

Uwaga

Nie XmlSerializer można serializować następujących: tablice ArrayList i tablice .List<T>

Zobacz też

Dotyczy

Serialize(Stream, Object, XmlSerializerNamespaces)

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Źródło:: XmlSerializer.cs

Serializuje określony Object i zapisuje dokument XML do pliku przy użyciu określonego Stream , który odwołuje się do określonych przestrzeni nazw.

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);

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

Public Sub Serialize (stream As Stream, o As Object, namespaces As XmlSerializerNamespaces)

Parametry

stream: Stream

Element Stream używany do zapisywania dokumentu XML.

o: Object

Element Object do serializacji.

namespaces: XmlSerializerNamespaces

Obiekt XmlSerializerNamespaces , do których odwołuje się obiekt .

Wyjątki

InvalidOperationException

Wystąpił błąd podczas serializacji. Oryginalny wyjątek jest dostępny przy użyciu InnerException właściwości .

Przykłady

Poniższy przykład serializuje obiekt z obiektem Stream . W przykładzie utworzono również element XmlSerializerNamespaces i dodano do obiektu dwie przestrzenie nazw. Klasa definiująca serializowany obiekt jest również przypisywana atrybutom XmlElementAttribute w celu określenia przestrzeni nazw dla każdego elementu.

#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 OrderedItem3
{
    [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 Test3
{
    public static void Main()
    {
        Test3 t = new();
        // 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(typeof(OrderedItem3));

        OrderedItem3 i = new()
        {
            ItemName = "Widget",
            Description = "Regular Widget",
            Quantity = 10,
            UnitPrice = (decimal)2.30
        };
        i.Calculate();

        // Create an XmlSerializerNamespaces object.
        XmlSerializerNamespaces ns = new();

        // 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.
        FileStream writer = new(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(typeof(OrderedItem3));

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

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

        /* Use the Deserialize method to restore the object's state
           using data from the XML document. */
        i = (OrderedItem3)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.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")
        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

Uwagi

Po wywołaniu Serialize metody pola publiczne i właściwości odczytu/zapisu obiektu są konwertowane na kod XML. Metody, indeksatory, pola prywatne i właściwości tylko do odczytu nie są serializowane.

Użyj parametru stream , aby określić obiekt pochodzący z klasy abstrakcyjnej Stream , który jest przeznaczony do zapisywania w strumieniach. Klasy pochodzące z Stream klasy to:

Uwaga

Nie XmlSerializer można serializować następujących: tablice ArrayList i tablice .List<T>

Zobacz też

Dotyczy

Udostępnij za pośrednictwem

XmlSerializer.Serialize Metoda

Definicja

Przeciążenia

Serialize(XmlWriter, Object)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

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

Parametry

Uwagi

Dotyczy

Serialize(XmlWriter, Object, XmlSerializerNamespaces, String)

Parametry

Wyjątki

Uwagi

Zobacz też

Dotyczy

Serialize(XmlWriter, Object, XmlSerializerNamespaces)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Serialize(TextWriter, Object, XmlSerializerNamespaces)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Serialize(Object, XmlSerializationWriter)

Parametry

Wyjątki

Dotyczy

Serialize(TextWriter, Object)

Parametry

Przykłady

Uwagi

Zobacz też

Dotyczy

Serialize(Stream, Object)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Serialize(Stream, Object, XmlSerializerNamespaces)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Dodatkowe zasoby