XmlSerializer XmlSerializer XmlSerializer XmlSerializer Class

정의

XML 문서로 개체를 serialize하고 XML 문서에서 개체를 deserialize합니다.Serializes and deserializes objects into and from XML documents. XmlSerializer를 사용하면 개체가 XML로 인코딩되는 방식을 제어할 수 있습니다.The XmlSerializer enables you to control how objects are encoded into XML.

public ref class XmlSerializer
public class XmlSerializer
type XmlSerializer = class
Public Class XmlSerializer
상속
XmlSerializerXmlSerializerXmlSerializerXmlSerializer

예제

다음 예제에서는 두 가지 주요 클래스를 포함 합니다. PurchaseOrderTest합니다.The following example contains two main classes: PurchaseOrder and Test. PurchaseOrder 단일 구매에 대 한 정보를 포함 하는 클래스입니다.The PurchaseOrder class contains information about a single purchase. Test 구매 주문을 만들고 만든된 구매 주문을 읽는 메서드를 포함 하는 클래스입니다.The Test class contains the methods that create the purchase order, and that read the created purchase order.

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

using namespace System;
using namespace System::Xml;
using namespace System::Xml::Serialization;
using namespace System::IO;
ref class Address;
ref class OrderedItem;

/* The XmlRootAttribute allows you to set an alternate name 
   (PurchaseOrder) of the XML element, the element namespace; by 
   default, the XmlSerializer uses the class name. The attribute 
   also allows you to set the XML namespace for the element.  Lastly,
   the attribute sets the IsNullable property, which specifies whether 
   the xsi:null attribute appears if the class instance is set to 
   a null reference. */

[XmlRootAttribute("PurchaseOrder",Namespace="http://www.cpandl.com",
IsNullable=false)]
public ref class PurchaseOrder
{
public:
   Address^ ShipTo;
   String^ OrderDate;

   /* The XmlArrayAttribute changes the XML element name
       from the default of "OrderedItems" to "Items". */

   [XmlArrayAttribute("Items")]
   array<OrderedItem^>^OrderedItems;
   Decimal SubTotal;
   Decimal ShipCost;
   Decimal TotalCost;
};

public ref class Address
{
public:

   /* The XmlAttribute instructs the XmlSerializer to serialize the Name
         field as an XML attribute instead of an XML element (the default
         behavior). */

   [XmlAttributeAttribute]
   String^ Name;
   String^ Line1;

   /* Setting the IsNullable property to false instructs the 
         XmlSerializer that the XML attribute will not appear if 
         the City field is set to a null reference. */

   [XmlElementAttribute(IsNullable=false)]
   String^ City;
   String^ State;
   String^ Zip;
};

public ref class OrderedItem
{
public:
   String^ ItemName;
   String^ Description;
   Decimal UnitPrice;
   int Quantity;
   Decimal LineTotal;

   /* Calculate is a custom method that calculates the price per item,
         and stores the value in a field. */
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }

};

public ref class Test
{
public:
   static void main()
   {
      // Read and write purchase orders.
      Test^ t = gcnew Test;
      t->CreatePO( "po.xml" );
      t->ReadPO( "po.xml" );
   }

private:
   void CreatePO( String^ filename )
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to serialize.
      XmlSerializer^ serializer = gcnew XmlSerializer( PurchaseOrder::typeid );
      TextWriter^ writer = gcnew StreamWriter( filename );
      PurchaseOrder^ po = gcnew PurchaseOrder;

      // Create an address to ship and bill to.
      Address^ billAddress = gcnew Address;
      billAddress->Name = "Teresa Atkinson";
      billAddress->Line1 = "1 Main St.";
      billAddress->City = "AnyTown";
      billAddress->State = "WA";
      billAddress->Zip = "00000";

      // Set ShipTo and BillTo to the same addressee.
      po->ShipTo = billAddress;
      po->OrderDate = System::DateTime::Now.ToLongDateString();

      // Create an OrderedItem object.
      OrderedItem^ i1 = gcnew OrderedItem;
      i1->ItemName = "Widget S";
      i1->Description = "Small widget";
      i1->UnitPrice = (Decimal)5.23;
      i1->Quantity = 3;
      i1->Calculate();

      // Insert the item into the array.
      array<OrderedItem^>^items = {i1};
      po->OrderedItems = items;

      // Calculate the total cost.
      Decimal subTotal = Decimal(0);
      System::Collections::IEnumerator^ myEnum = items->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         OrderedItem^ oi = safe_cast<OrderedItem^>(myEnum->Current);
         subTotal = subTotal + oi->LineTotal;
      }

      po->SubTotal = subTotal;
      po->ShipCost = (Decimal)12.51;
      po->TotalCost = po->SubTotal + po->ShipCost;

      // Serialize the purchase order, and close the TextWriter.
      serializer->Serialize( writer, po );
      writer->Close();
   }

protected:
   void ReadPO( String^ filename )
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to be deserialized.
      XmlSerializer^ serializer = gcnew XmlSerializer( PurchaseOrder::typeid );

      /* If the XML document has been altered with unknown 
            nodes or attributes, handle them with the 
            UnknownNode and UnknownAttribute events.*/
      serializer->UnknownNode += gcnew XmlNodeEventHandler( this, &Test::serializer_UnknownNode );
      serializer->UnknownAttribute += gcnew XmlAttributeEventHandler( this, &Test::serializer_UnknownAttribute );

      // A FileStream is needed to read the XML document.
      FileStream^ fs = gcnew FileStream( filename,FileMode::Open );

      // Declare an object variable of the type to be deserialized.
      PurchaseOrder^ po;

      /* Use the Deserialize method to restore the object's state with
            data from the XML document. */
      po = dynamic_cast<PurchaseOrder^>(serializer->Deserialize( fs ));

      // Read the order date.
      Console::WriteLine( "OrderDate: {0}", po->OrderDate );

      // Read the shipping address.
      Address^ shipTo = po->ShipTo;
      ReadAddress( shipTo, "Ship To:" );

      // Read the list of ordered items.
      array<OrderedItem^>^items = po->OrderedItems;
      Console::WriteLine( "Items to be shipped:" );
      System::Collections::IEnumerator^ myEnum1 = items->GetEnumerator();
      while ( myEnum1->MoveNext() )
      {
         OrderedItem^ oi = safe_cast<OrderedItem^>(myEnum1->Current);
         Console::WriteLine( "\t{0}\t{1}\t{2}\t{3}\t{4}", oi->ItemName, oi->Description, oi->UnitPrice, oi->Quantity, oi->LineTotal );
      }

      Console::WriteLine( "\t\t\t\t\t Subtotal\t{0}", po->SubTotal );
      Console::WriteLine( "\t\t\t\t\t Shipping\t{0}", po->ShipCost );
      Console::WriteLine( "\t\t\t\t\t Total\t\t{0}", po->TotalCost );
   }

   void ReadAddress( Address^ a, String^ label )
   {
      // Read the fields of the Address object.
      Console::WriteLine( label );
      Console::WriteLine( "\t{0}", a->Name );
      Console::WriteLine( "\t{0}", a->Line1 );
      Console::WriteLine( "\t{0}", a->City );
      Console::WriteLine( "\t{0}", a->State );
      Console::WriteLine( "\t{0}", a->Zip );
      Console::WriteLine();
   }

private:
   void serializer_UnknownNode( Object^ /*sender*/, XmlNodeEventArgs^ e )
   {
      Console::WriteLine( "Unknown Node:{0}\t{1}", e->Name, e->Text );
   }

   void serializer_UnknownAttribute( Object^ /*sender*/, XmlAttributeEventArgs^ e )
   {
      System::Xml::XmlAttribute^ attr = e->Attr;
      Console::WriteLine( "Unknown attribute {0}='{1}'", attr->Name, attr->Value );
   }
};

int main()
{
   Test::main();
}
using System;
using System.Xml;
using System.Xml.Serialization;
using System.IO;

/* The XmlRootAttribute allows you to set an alternate name 
   (PurchaseOrder) of the XML element, the element namespace; by 
   default, the XmlSerializer uses the class name. The attribute 
   also allows you to set the XML namespace for the element.  Lastly,
   the attribute sets the IsNullable property, which specifies whether 
   the xsi:null attribute appears if the class instance is set to 
   a null reference. */
[XmlRootAttribute("PurchaseOrder", Namespace="http://www.cpandl.com", 
IsNullable = false)]
public class PurchaseOrder
{
   public Address ShipTo;
   public string OrderDate; 
   /* The XmlArrayAttribute changes the XML element name
    from the default of "OrderedItems" to "Items". */
   [XmlArrayAttribute("Items")]
   public OrderedItem[] OrderedItems;
   public decimal SubTotal;
   public decimal ShipCost;
   public decimal TotalCost;   
}
 
public class Address
{
   /* The XmlAttribute instructs the XmlSerializer to serialize the Name
      field as an XML attribute instead of an XML element (the default
      behavior). */
   [XmlAttribute]
   public string Name;
   public string Line1;

   /* Setting the IsNullable property to false instructs the 
      XmlSerializer that the XML attribute will not appear if 
      the City field is set to a null reference. */
   [XmlElementAttribute(IsNullable = false)]
   public string City;
   public string State;
   public string Zip;
}
 
public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
   public decimal LineTotal;

   /* Calculate is a custom method that calculates the price per item,
      and stores the value in a field. */
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test
{
   public static void Main()
   {
      // Read and write purchase orders.
      Test t = new Test();
      t.CreatePO("po.xml");
      t.ReadPO("po.xml");
   }

   private void CreatePO(string filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to serialize.
      XmlSerializer serializer = 
      new XmlSerializer(typeof(PurchaseOrder));
      TextWriter writer = new StreamWriter(filename);
      PurchaseOrder po=new PurchaseOrder();
       
      // Create an address to ship and bill to.
      Address billAddress = new Address();
      billAddress.Name = "Teresa Atkinson";
      billAddress.Line1 = "1 Main St.";
      billAddress.City = "AnyTown";
      billAddress.State = "WA";
      billAddress.Zip = "00000";
      // Set ShipTo and BillTo to the same addressee.
      po.ShipTo = billAddress;
      po.OrderDate = System.DateTime.Now.ToLongDateString();
 
      // Create an OrderedItem object.
      OrderedItem i1 = new OrderedItem();
      i1.ItemName = "Widget S";
      i1.Description = "Small widget";
      i1.UnitPrice = (decimal) 5.23;
      i1.Quantity = 3;
      i1.Calculate();
 
      // Insert the item into the array.
      OrderedItem [] items = {i1};
      po.OrderedItems = items;
      // Calculate the total cost.
      decimal subTotal = new decimal();
      foreach(OrderedItem oi in items)
      {
         subTotal += oi.LineTotal;
      }
      po.SubTotal = subTotal;
      po.ShipCost = (decimal) 12.51; 
      po.TotalCost = po.SubTotal + po.ShipCost; 
      // Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po);
      writer.Close();
   }
 
   protected void ReadPO(string filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to be deserialized.
      XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder));
      /* If the XML document has been altered with unknown 
      nodes or attributes, handle them with the 
      UnknownNode and UnknownAttribute events.*/
      serializer.UnknownNode+= new 
      XmlNodeEventHandler(serializer_UnknownNode);
      serializer.UnknownAttribute+= new 
      XmlAttributeEventHandler(serializer_UnknownAttribute);
   
      // A FileStream is needed to read the XML document.
      FileStream fs = new FileStream(filename, FileMode.Open);
      // Declare an object variable of the type to be deserialized.
      PurchaseOrder po;
      /* Use the Deserialize method to restore the object's state with
      data from the XML document. */
      po = (PurchaseOrder) serializer.Deserialize(fs);
      // Read the order date.
      Console.WriteLine ("OrderDate: " + po.OrderDate);
  
      // Read the shipping address.
      Address shipTo = po.ShipTo;
      ReadAddress(shipTo, "Ship To:");
      // Read the list of ordered items.
      OrderedItem [] items = po.OrderedItems;
      Console.WriteLine("Items to be shipped:");
      foreach(OrderedItem oi in items)
      {
         Console.WriteLine("\t"+
         oi.ItemName + "\t" + 
         oi.Description + "\t" +
         oi.UnitPrice + "\t" +
         oi.Quantity + "\t" +
         oi.LineTotal);
      }
      // Read the subtotal, shipping cost, and total cost.
      Console.WriteLine("\t\t\t\t\t Subtotal\t" + po.SubTotal);
      Console.WriteLine("\t\t\t\t\t Shipping\t" + po.ShipCost); 
      Console.WriteLine("\t\t\t\t\t Total\t\t" + po.TotalCost);
   }
 
   protected void ReadAddress(Address a, string label)
   {
      // Read the fields of the Address object.
      Console.WriteLine(label);
      Console.WriteLine("\t"+ a.Name );
      Console.WriteLine("\t" + a.Line1);
      Console.WriteLine("\t" + a.City);
      Console.WriteLine("\t" + a.State);
      Console.WriteLine("\t" + a.Zip );
      Console.WriteLine();
   }

   private void serializer_UnknownNode
   (object sender, XmlNodeEventArgs e)
   {
      Console.WriteLine("Unknown Node:" +   e.Name + "\t" + e.Text);
   }

   private void serializer_UnknownAttribute
   (object sender, XmlAttributeEventArgs e)
   {
      System.Xml.XmlAttribute attr = e.Attr;
      Console.WriteLine("Unknown attribute " + 
      attr.Name + "='" + attr.Value + "'");
   }
}
Imports System.Xml
Imports System.Xml.Serialization
Imports System.IO

' The XmlRootAttribute allows you to set an alternate name
' (PurchaseOrder) of the XML element, the element namespace; by
' default, the XmlSerializer uses the class name. The attribute
' also allows you to set the XML namespace for the element.  Lastly,
' the attribute sets the IsNullable property, which specifies whether
' the xsi:null attribute appears if the class instance is set to
' a null reference. 
<XmlRootAttribute("PurchaseOrder", _
 Namespace := "http://www.cpandl.com", IsNullable := False)> _
Public Class PurchaseOrder
    
    Public ShipTo As Address
    Public OrderDate As String
    ' The XmlArrayAttribute changes the XML element name
    ' from the default of "OrderedItems" to "Items". 
    <XmlArrayAttribute("Items")> _
    Public OrderedItems() As OrderedItem
    Public SubTotal As Decimal
    Public ShipCost As Decimal
    Public TotalCost As Decimal
End Class


Public Class Address
    ' The XmlAttribute instructs the XmlSerializer to serialize the Name
    ' field as an XML attribute instead of an XML element (the default
    ' behavior). 
    <XmlAttribute()> _
    Public Name As String
    Public Line1 As String
    
    ' Setting the IsNullable property to false instructs the
    ' XmlSerializer that the XML attribute will not appear if
    ' the City field is set to a null reference. 
    <XmlElementAttribute(IsNullable := False)> _
    Public City As String
    Public State As String
    Public Zip As String
End Class


Public Class OrderedItem
    Public ItemName As String
    Public Description As String
    Public UnitPrice As Decimal
    Public Quantity As Integer
    Public LineTotal As Decimal
    
    
    ' Calculate is a custom method that calculates the price per item,
    ' and stores the value in a field. 
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub
End Class


Public Class Test
    
   Public Shared Sub Main()
      ' Read and write purchase orders.
      Dim t As New Test()
      t.CreatePO("po.xml")
      t.ReadPO("po.xml")
   End Sub
    
   Private Sub CreatePO(filename As String)
      ' Create an instance of the XmlSerializer class;
      ' specify the type of object to serialize.
      Dim serializer As New XmlSerializer(GetType(PurchaseOrder))
      Dim writer As New StreamWriter(filename)
      Dim po As New PurchaseOrder()
        
      ' Create an address to ship and bill to.
      Dim billAddress As New Address()
      billAddress.Name = "Teresa Atkinson"
      billAddress.Line1 = "1 Main St."
      billAddress.City = "AnyTown"
      billAddress.State = "WA"
      billAddress.Zip = "00000"
      ' Set ShipTo and BillTo to the same addressee.
      po.ShipTo = billAddress
      po.OrderDate = System.DateTime.Now.ToLongDateString()
        
      ' Create an OrderedItem object.
      Dim i1 As New OrderedItem()
      i1.ItemName = "Widget S"
      i1.Description = "Small widget"
      i1.UnitPrice = CDec(5.23)
      i1.Quantity = 3
      i1.Calculate()
        
      ' Insert the item into the array.
      Dim items(0) As OrderedItem
      items(0) = i1
      po.OrderedItems = items
      ' Calculate the total cost.
      Dim subTotal As New Decimal()
      Dim oi As OrderedItem
      For Each oi In  items
         subTotal += oi.LineTotal
      Next oi
      po.SubTotal = subTotal
      po.ShipCost = CDec(12.51)
      po.TotalCost = po.SubTotal + po.ShipCost
      ' Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po)
      writer.Close()
   End Sub
    
   Protected Sub ReadPO(filename As String)
      ' Create an instance of the XmlSerializer class;
      ' specify the type of object to be deserialized.
      Dim serializer As New XmlSerializer(GetType(PurchaseOrder))
      ' If the XML document has been altered with unknown
      ' nodes or attributes, handle them with the
      ' UnknownNode and UnknownAttribute events.
      AddHandler serializer.UnknownNode, AddressOf serializer_UnknownNode
      AddHandler serializer.UnknownAttribute, AddressOf serializer_UnknownAttribute
      
      ' A FileStream is needed to read the XML document.
      Dim fs As New FileStream(filename, FileMode.Open)
      ' Declare an object variable of the type to be deserialized.
      Dim po As PurchaseOrder
      ' Use the Deserialize method to restore the object's state with
      ' data from the XML document. 
      po = CType(serializer.Deserialize(fs), PurchaseOrder)
      ' Read the order date.
      Console.WriteLine(("OrderDate: " & po.OrderDate))
        
      ' Read the shipping address.
      Dim shipTo As Address = po.ShipTo
      ReadAddress(shipTo, "Ship To:")
      ' Read the list of ordered items.
      Dim items As OrderedItem() = po.OrderedItems
      Console.WriteLine("Items to be shipped:")
      Dim oi As OrderedItem
      For Each oi In  items
         Console.WriteLine((ControlChars.Tab & oi.ItemName & ControlChars.Tab & _
         oi.Description & ControlChars.Tab & oi.UnitPrice & ControlChars.Tab & _
         oi.Quantity & ControlChars.Tab & oi.LineTotal))
      Next oi
      ' Read the subtotal, shipping cost, and total cost.
      Console.WriteLine(( New String(ControlChars.Tab, 5) & _
      " Subtotal"  & ControlChars.Tab & po.SubTotal))
      Console.WriteLine(New String(ControlChars.Tab, 5) & _
      " Shipping" & ControlChars.Tab & po.ShipCost )
      Console.WriteLine( New String(ControlChars.Tab, 5) & _
      " Total" &  New String(ControlChars.Tab, 2) & po.TotalCost)
    End Sub
    
    Protected Sub ReadAddress(a As Address, label As String)
      ' Read the fields of the Address object.
      Console.WriteLine(label)
      Console.WriteLine(ControlChars.Tab & a.Name)
      Console.WriteLine(ControlChars.Tab & a.Line1)
      Console.WriteLine(ControlChars.Tab & a.City)
      Console.WriteLine(ControlChars.Tab & a.State)
      Console.WriteLine(ControlChars.Tab & a.Zip)
      Console.WriteLine()
    End Sub
        
    Private Sub serializer_UnknownNode(sender As Object, e As XmlNodeEventArgs)
        Console.WriteLine(("Unknown Node:" & e.Name & ControlChars.Tab & e.Text))
    End Sub
    
    
    Private Sub serializer_UnknownAttribute(sender As Object, e As XmlAttributeEventArgs)
        Dim attr As System.Xml.XmlAttribute = e.Attr
        Console.WriteLine(("Unknown attribute " & attr.Name & "='" & attr.Value & "'"))
    End Sub
End Class

설명

XML serialization은 개체의 public 속성 및 필드를 저장이나 전송을 위해 직렬 형식(이 경우 XML)으로 변환하는 프로세스입니다.XML serialization is the process of converting an object's public properties and fields to a serial format (in this case, XML) for storage or transport. Deserialization은 XML 출력에서 원래 상태로 개체를 다시 만듭니다.Deserialization re-creates the object in its original state from the XML output. Serialization 스트림 또는 버퍼 개체의 상태를 저장 하는 방법으로 생각할 수 있습니다.You can think of serialization as a way of saving the state of an object into a stream or buffer. 예를 들어 ASP.NET에서는 XmlSerializer XML 웹 서비스 메시지를 인코딩하는 클래스입니다.For example, ASP.NET uses the XmlSerializer class to encode XML Web service messages.

개체 내의 데이터는 클래스, 필드, 속성, 기본 형식, 배열 및 XmlElement 또는 XmlAttribute 개체 형태로 포함된 XML과 같은 프로그래밍 언어 구조를 통하여 설명됩니다.The data in your objects is described using programming language constructs like classes, fields, properties, primitive types, arrays, and even embedded XML in the form of XmlElement or XmlAttribute objects. 주석이 지정 된 특성 또는 사용 하 여 사용자 고유의 클래스를 만드는 옵션이 있습니다 합니다 XML 스키마 정의 도구 (Xsd.exe) 에서 기존 XML 스키마 정의 (XSD) 문서에 기반한 클래스를 생성 합니다.You have the option of creating your own classes, annotated with attributes, or using the XML Schema Definition Tool (Xsd.exe) to generate the classes based on an existing XML Schema definition (XSD) document. XML 스키마에 있는 경우에 강력한 스키마로 형식화 되어 serialize 될 때 스키마를 준수 하는 특성으로 주석이 지정 된 된 클래스 집합을 생성 하기 위해 Xsd.exe를 실행할 수 있습니다.If you have an XML Schema, you can run the Xsd.exe to produce a set of classes that are strongly typed to the schema and annotated with attributes to adhere to the schema when serialized.

개체 및 XML 간에 데이터를 전송 하려면 XML 스키마는 프로그래밍 언어 구문을 프로그래밍 언어 구문에 XML 스키마 매핑이 필요 합니다.To transfer data between objects and XML requires a mapping from the programming language constructs to XML schema and from the XML schema to the programming language constructs. XmlSerializer Xsd.exe와 같은 관련된 도구는 이러한 두 기술 모두 디자인 타임 및 런타임 간의 브리지를 제공 합니다.The XmlSerializer and related tools like Xsd.exe provide the bridge between these two technologies at both design time and runtime. 디자인 타임에 사용 하 여 Xsd.exe를 사용자 지정 클래스에서 XML 스키마 문서 (.xsd)를 생성 하거나 지정된 된 스키마에서 클래스를 생성 합니다.At design time, use the Xsd.exe to produce an XML schema document (.xsd) from your custom classes or to produce classes from a given schema. 두 경우 모두에서 클래스를 지시 하는 사용자 지정 특성으로 주석이 지정 된 된 XmlSerializer XML 스키마 시스템 및 공용 언어 런타임 간에 매핑하는 방법.In either case, the classes are annotated with custom attributes to instruct the XmlSerializer how to map between the XML schema system and the common language runtime. 런타임 시 클래스의 인스턴스 지정된 된 스키마를 따르는 XML 문서로 serialize 할 수 있습니다.At runtime, instances of the classes can be serialized into XML documents that follow the given schema. 마찬가지로, 다음 XML 문서 런타임 개체로 deserialize 할 수 있습니다.Likewise, these XML documents can be deserialized into runtime objects. 디자인 타임 또는 런타임 XML 스키마가 며, 필요 하지 않습니다는 참고 합니다.Note that the XML schema is optional, and not required at design time or runtime.

생성 된 XML을 제어합니다.Controlling Generated XML

생성된 된 XML을 제어 하려면 특수 한 특성 클래스 및 멤버에 적용할 수 있습니다.To control the generated XML, you can apply special attributes to classes and members. 예를 들어, 다른 XML 요소 이름을 지정 하려면 적용을 XmlElementAttribute 를 공용 필드 또는 속성 집합에는 ElementName 속성입니다.For example, to specify a different XML element name, apply an XmlElementAttribute to a public field or property, and set the ElementName property. 비슷한 특성의 전체 목록은 참조 하세요 는 XML Serialization을 제어 특성합니다.For a complete list of similar attributes, see Attributes That Control XML Serialization. 구현할 수도 있습니다는 IXmlSerializable XML 출력을 제어 하는 인터페이스입니다.You can also implement the IXmlSerializable interface to control the XML output.

생성 된 XML이 wwpn (Simple Object Access Protocol) 1.1의 w3c(world Wide Consortium 문서 5를 준수 해야 하는 경우를 사용 XmlSerializer XmlTypeMapping하 여를 생성 해야 합니다.If the XML generated must conform to section 5 of the World Wide Consortium document, Simple Object Access Protocol (SOAP) 1.1, you must construct the XmlSerializer with an XmlTypeMapping. 컨트롤은 인코딩된 SOAP XML을 위해에 나열 된 특성을 사용 하 여 는 인코딩된 SOAP Serialization을 제어 특성합니다.To further control the encoded SOAP XML, use the attributes listed in Attributes That Control Encoded SOAP Serialization.

사용 하 여는 XmlSerializer 강력한 형식의 클래스를 사용 하 여 작업을 활용 하 고 XML의 유연성을 아직 수 있습니다.With the XmlSerializer you can take advantage of working with strongly typed classes and still have the flexibility of XML. 필드 또는 형식의 속성을 사용 하 여 XmlElement, XmlAttribute 또는 XmlNode 에서 강력한 형식의 클래스를 직접 XML 개체로 XML 문서 부분을 읽을 수 있습니다.Using fields or properties of type XmlElement, XmlAttribute or XmlNode in your strongly typed classes, you can read parts of the XML document directly into XML objects.

확장 가능한 XML 스키마를 사용 하 여 작업 하는 경우 사용할 수도 있습니다는 XmlAnyElementAttributeXmlAnyAttributeAttribute 특성을 serialize 및 deserialize 요소 또는 원래 스키마에 없는 특성입니다.If you work with extensible XML schemas, you can also use the XmlAnyElementAttribute and XmlAnyAttributeAttribute attributes to serialize and deserialize elements or attributes that are not found in the original schema. 개체를 사용 하려면 적용를 XmlAnyElementAttribute 배열을 반환 하는 필드를 XmlElement 개체 또는 적용을 XmlAnyAttributeAttribute 배열을 반환 하는 필드를 XmlAttribute 개체.To use the objects, apply an XmlAnyElementAttribute to a field that returns an array of XmlElement objects, or apply an XmlAnyAttributeAttribute to a field that returns an array of XmlAttribute objects.

속성 또는 필드가 복잡한 개체(예: 배열 또는 클래스 인스턴스)를 반환하는 경우 XmlSerializer는 그 개체를 주 XML 문서 내의 중첩된 요소로 변환합니다.If a property or field returns a complex object (such as an array or a class instance), the XmlSerializer converts it to an element nested within the main XML document. 예를 들어, 다음 코드에서 첫 번째 클래스는 둘째 클래스의 인스턴스를 반환 합니다.For example, the first class in the following code returns an instance of the second class.

Public Class MyClass  
    Public MyObjectProperty As MyObject  
End Class  
  
Public Class MyObject  
    Public ObjectName As String  
End Class  
public class MyClass  
{  
    public MyObject MyObjectProperty;  
}  
public class MyObject  
{  
    public string ObjectName;  
}  

serialize 된 XML 출력은 다음과 같습니다.The serialized, XML output looks like this:

<MyClass>  
  <MyObjectProperty>  
  <ObjectName>My String</ObjectName>  
  </MyObjectProperty>  
</MyClass>  

스키마 옵션에 있는 요소를 포함 하는 경우 (minOccurs = '0'), 또는 스키마에서 기본 값에 포함 된 경우 두 가지 옵션이 있습니다.If a schema includes an element that is optional (minOccurs = '0'), or if the schema includes a default value, you have two options. 사용 하는 한 가지 방법은 System.ComponentModel.DefaultValueAttribute 다음 코드와 같이 기본값을 지정 합니다.One option is to use System.ComponentModel.DefaultValueAttribute to specify the default value, as shown in the following code.

Public Class PurchaseOrder  
    <System.ComponentModel.DefaultValueAttribute ("2002")> _  
    Public Year As String  
End Class  
public class PurchaseOrder  
{  
    [System.ComponentModel.DefaultValueAttribute ("2002")]  
    public string Year;  
}  

인식 하는 부울 필드를 만들려면 특별 한 패턴을 사용 하는 또 다른 방법은 합니다 XmlSerializer를 적용 하는 XmlIgnoreAttribute 필드에 합니다.Another option is to use a special pattern to create a Boolean field recognized by the XmlSerializer, and to apply the XmlIgnoreAttribute to the field. 패턴의 형태로 만들어집니다 propertyNameSpecified합니다.The pattern is created in the form of propertyNameSpecified. 예를 들어, "MyFirstNameSpecified" 라는 필드는 만들어야 하는 "MyFirstName" 라는 필드가 있는지는 지시 된 XmlSerializer "MyFirstName" 이라는 XML 요소를 생성할지 여부를 합니다.For example, if there is a field named "MyFirstName" you would also create a field named "MyFirstNameSpecified" that instructs the XmlSerializer whether to generate the XML element named "MyFirstName". 다음 예제에서 이를 확인할 수 있습니다.This is shown in the following example.

Public Class OptionalOrder  
    ' This field's value should not be serialized   
    ' if it is uninitialized.  
    Public FirstOrder As String  
  
    ' Use the XmlIgnoreAttribute to ignore the   
    ' special field named "FirstOrderSpecified".  
    <System.Xml.Serialization.XmlIgnoreAttribute> _  
    Public FirstOrderSpecified As Boolean  
End Class  
public class OptionalOrder  
{  
    // This field should not be serialized   
    // if it is uninitialized.  
    public string FirstOrder;  
  
    // Use the XmlIgnoreAttribute to ignore the   
    // special field named "FirstOrderSpecified".  
    [System.Xml.Serialization.XmlIgnoreAttribute]  
    public bool FirstOrderSpecified;  
}  

기본 Serialization 재정의Overriding Default Serialization

적절 한 특성 중 하나를 만들고 인스턴스에 추가 하 여 개체 및 해당 필드와 속성 집합의 serialization을 재정의할 수도 있습니다는 XmlAttributes 클래스입니다.You can also override the serialization of any set of objects and their fields and properties by creating one of the appropriate attributes, and adding it to an instance of the XmlAttributes class. 용도 이러한 방식으로 serialization을 재정의 합니다: 제어 하 고 원본;에 액세스할 수 없는 경우에 DLL에 있는 개체의 serialization을 보강할 수 먼저 둘째, serializable 클래스의 집합을 만들 수 있지만 여러 가지 방법으로 개체를 직렬화 할.Overriding serialization in this way has two uses: first, you can control and augment the serialization of objects found in a DLL, even if you do not have access to the source; second, you can create one set of serializable classes, but serialize the objects in multiple ways. 자세한 XmlAttributeOverrides 내용은 클래스 및 방법: 파생 클래스의 Serialization을 제어 합니다.For more details, see the XmlAttributeOverrides class and How to: Control Serialization of Derived Classes.

개체를 serialize 하려면 호출을 Serialize 메서드.To serialize an object, call the Serialize method. 개체를 deserialize 하려면 호출을 Deserialize 메서드.To deserialize an object, call the Deserialize method.

XML 네임 스페이스에 XML 문서를 추가 하려면 참조 XmlSerializerNamespaces합니다.To add XML namespaces to an XML document, see XmlSerializerNamespaces.

참고

합니다 XmlSerializer 특별 한 처리를 구현 하는 클래스에 제공 IEnumerable 또는 ICollection합니다.The XmlSerializer gives special treatment to classes that implement IEnumerable or ICollection. IEnumerable을 구현하는 클래스는 단일 매개 변수를 취하는 공용 Add 메서드를 구현해야 합니다.A class that implements IEnumerable must implement a public Add method that takes a single parameter. 합니다 Add 메서드의 매개 변수에서 반환 된 동일한 형식 이어야 합니다는 Current 속성에서 반환 되는 값을 GetEnumerator, 또는 해당 형식의 자료 중 하나입니다.The Add method's parameter must be of the same type as is returned from the Current property on the value returned from GetEnumerator, or one of that type's bases. 구현 하는 클래스 ICollection (같은 CollectionBase) 외에 IEnumerable 공용 있어야 합니다. Item 인덱싱된 정수를 사용 하는 속성 (C# 인덱서) 및 공용 있어야 Count integer 형식의 속성입니다.A class that implements ICollection (such as CollectionBase) in addition to IEnumerable must have a public Item indexed property (indexer in C#) that takes an integer, and it must have a public Count property of type integer. 매개 변수를 합니다 Add 메서드는 반환 된 동일한 형식 이어야 합니다는 Item 속성 또는 해당 형식의 자료 중 하나입니다.The parameter to the Add method must be the same type as is returned from the Item property, or one of that type's bases. 구현 하는 클래스 ICollection, serialize 되는 값이 검색에서 인덱싱된 Item 속성을 호출 하 여 GetEnumerator합니다.For classes that implement ICollection, values to be serialized are retrieved from the indexed Item property, not by calling GetEnumerator.

개체를 deserialize 하려면 (TEMP 환경 변수로 정의)은 임시 디렉터리에 쓸 수 있는 권한이 있어야 합니다.You must have permission to write to the temporary directory (as defined by the TEMP environment variable) to deserialize an object.

동적으로 생성 된 어셈블리Dynamically Generated Assemblies

성능을 향상 시키려면 XML serialization 인프라는 동적으로 지정 된 형식만 serialize 및 deserialize 하는 어셈블리를 생성 합니다.To increase performance, the XML serialization infrastructure dynamically generates assemblies to serialize and deserialize specified types. 인프라를 찾아 해당 어셈블리를 다시 사용 합니다.The infrastructure finds and reuses those assemblies. 이 동작에는 다음 생성자를 사용 하는 경우에 발생 합니다.This behavior occurs only when using the following constructors:

XmlSerializer.XmlSerializer(Type)

XmlSerializer.XmlSerializer(Type, String)

다른 생성자를 사용 하면 동일한 어셈블리의 여러 버전의 생성 되어이 언로드되지 않으므로 메모리 누수 및 성능 저하는 결과입니다.If you use any of the other constructors, multiple versions of the same assembly are generated and never unloaded, which results in a memory leak and poor performance. 가장 쉬운 방법은 앞에서 언급 한 두 명의 생성자 중 하나를 사용 하는 것입니다.The easiest solution is to use one of the previously mentioned two constructors. 어셈블리를 캐시 해야 하는 고, 그렇지는 Hashtable다음 예제에서와 같이 합니다.Otherwise, you must cache the assemblies in a Hashtable, as shown in the following example.

Hashtable serializers = new Hashtable();  
  
// Use the constructor that takes a type and XmlRootAttribute.  
XmlSerializer s = new XmlSerializer(typeof(MyClass), myRoot);  
  
// Implement a method named GenerateKey that creates unique keys   
// for each instance of the XmlSerializer. The code should take   
// into account all parameters passed to the XmlSerializer   
// constructor.  
object key = GenerateKey(typeof(MyClass), myRoot);  
  
// Check the local cache for a matching serializer.  
XmlSerializer ser = (XmlSerializer)serializers[key];  
if (ser == null)   
{  
    ser = new XmlSerializer(typeof(MyClass), myRoot);  
    // Cache the serializer.  
    serializers[key] = ser;  
}

// Use the serializer to serialize or deserialize.
Dim serializers As New Hashtable()  
  
' Use the constructor that takes a type and XmlRootAttribute.  
Dim s As New XmlSerializer(GetType([MyClass]), myRoot)  
  
' Implement a method named GenerateKey that creates unique keys   
' for each instance of the XmlSerializer. The code should take   
' into account all parameters passed to the XmlSerializer   
' constructor.  
Dim key As Object = GenerateKey(GetType([MyClass]), myRoot)  
  
' Check the local cache for a matching serializer.  
Dim ser As XmlSerializer = CType(serializers(key), XmlSerializer)  
  
If ser Is Nothing Then  
    ser = New XmlSerializer(GetType([MyClass]), myRoot)  
    ' Cache the serializer.  
    serializers(key) = ser  
End If  

' Use the serializer to serialize or deserialize.

ArrayList 및 List 제네릭의 serializationSerialization of ArrayList and Generic List

XmlSerializer serialize 하거나 다음을 deserialize 할 수 없습니다.The XmlSerializer cannot serialize or deserialize the following:

Unsigned 열거의 serializationSerialization of Enumerations of Unsigned Long

다음 XmlSerializer 조건에 해당 하는 경우 열거형을 serialize 하기 위해를 인스턴스화할 수 없습니다. 열거형이 부호 없는 long 형식 (ulong 의 C#경우) 이며 열거형에 9223372036854775807 보다 큰 값을 가진 멤버가 포함 되어 있습니다.The XmlSerializer cannot be instantiated to serialize an enumeration if the following conditions are true: The enumeration is of type unsigned long (ulong in C#) and the enumeration contains any member with a value larger than 9,223,372,036,854,775,807. 예를 들어, 다음 직렬화 할 수 없습니다.For example, the following cannot be serialized.

public enum LargeNumbers: ulong  
{  
    a = 9223372036854775808  
}  
// At runtime, the following code will fail.  
xmlSerializer mySerializer=new XmlSerializer(typeof(LargeNumbers));  

개체 직렬화 더 이상 사용 되지 않는 특성으로 표시 됩니다.Objects marked with the Obsolete Attribute no longer serialized

.NET Framework 3.5.NET Framework 3.5XmlSerializer 클래스가 더 이상으로 표시 되는 개체를 serialize [Obsolete]합니다.In the .NET Framework 3.5.NET Framework 3.5 the XmlSerializer class no longer serializes objects that are marked as [Obsolete].

생성자

XmlSerializer() XmlSerializer() XmlSerializer() XmlSerializer()

XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class.

XmlSerializer(Type) XmlSerializer(Type) XmlSerializer(Type) XmlSerializer(Type)

지정된 형식의 개체를 XML 문서로 serialize하고 XML 문서를 지정된 형식의 개체로 deserialize할 수 있는 XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML documents, and deserialize XML documents into objects of the specified type.

XmlSerializer(Type, String) XmlSerializer(Type, String) XmlSerializer(Type, String) XmlSerializer(Type, String)

지정된 형식의 개체를 XML 문서로 serialize하고 XML 문서를 지정된 형식의 개체로 deserialize할 수 있는 XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML documents, and deserialize XML documents into objects of the specified type. 모든 XML 요소의 기본 네임스페이스를 지정합니다.Specifies the default namespace for all the XML elements.

XmlSerializer(Type, Type[]) XmlSerializer(Type, Type[]) XmlSerializer(Type, Type[]) XmlSerializer(Type, Type[])

지정된 형식의 개체를 XML 문서로 serialize하고 XML 문서를 지정된 형식의 개체로 deserialize할 수 있는 XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML documents, and deserialize XML documents into object of a specified type. 필드 또는 속성이 배열을 반환하는 경우 extraTypes 매개 변수는 배열에 삽입될 수 있는 개체를 지정합니다.If a property or field returns an array, the extraTypes parameter specifies objects that can be inserted into the array.

XmlSerializer(Type, XmlAttributeOverrides) XmlSerializer(Type, XmlAttributeOverrides) XmlSerializer(Type, XmlAttributeOverrides) XmlSerializer(Type, XmlAttributeOverrides)

지정된 형식의 개체를 XML 문서로 serialize하고 XML 문서를 지정된 형식의 개체로 deserialize할 수 있는 XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML documents, and deserialize XML documents into objects of the specified type. serialize되는 각 개체는 클래스의 인스턴스를 포함할 수 있으며, 이 오버로드는 다른 클래스로 재정의할 수 있습니다.Each object to be serialized can itself contain instances of classes, which this overload can override with other classes.

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

XmlSerializer 형식의 개체를 XML 문서 인스턴스로 serialize하고 XML 문서 인스턴스를 Object 형식의 개체로 deserialize할 수 있는 Object 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of type Object into XML document instances, and deserialize XML document instances into objects of type Object. serialize되는 각 개체는 클래스의 인스턴스를 포함할 수 있으며, 이 오버로드에서 그 클래스를 다른 클래스로 재정의합니다.Each object to be serialized can itself contain instances of classes, which this overload overrides with other classes. 또한 이 오버로드는 모든 XML 요소의 기본 네임스페이스 및 XML 루트 요소로 사용할 클래스를 지정합니다.This overload also specifies the default namespace for all the XML elements and the class to use as the XML root element.

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

XmlSerializer 형식의 개체를 XML 문서 인스턴스로 serialize하고 XML 문서 인스턴스를 Object 형식의 개체로 deserialize할 수 있는 Object 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of type Object into XML document instances, and deserialize XML document instances into objects of type Object. serialize되는 각 개체는 클래스의 인스턴스를 포함할 수 있으며, 이 오버로드에서 그 클래스를 다른 클래스로 재정의합니다.Each object to be serialized can itself contain instances of classes, which this overload overrides with other classes. 또한 이 오버로드는 모든 XML 요소의 기본 네임스페이스 및 XML 루트 요소로 사용할 클래스를 지정합니다.This overload also specifies the default namespace for all the XML elements and the class to use as the XML root element.

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

지정된 형식의 개체를 XML 문서 인스턴스로 serialize하고 XML 문서 인스턴스를 지정된 형식의 개체로 deserialize할 수 있는 XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML document instances, and deserialize XML document instances into objects of the specified type. 이 오버로드를 통해 serialization 또는 deserialization 작업 동안 발생할 수 있는 다른 형식뿐 아니라 모든 XML 요소에 대한 기본 네임스페이스, XML 루트 요소로 사용할 클래스, 클래스의 위치 및 액세스하는 데 필요한 자격 증명을 제공할 수 있습니다.This overload allows you to supply other types that can be encountered during a serialization or deserialization operation, as well as a default namespace for all XML elements, the class to use as the XML root element, its location, and credentials required for access.

XmlSerializer(Type, XmlRootAttribute) XmlSerializer(Type, XmlRootAttribute) XmlSerializer(Type, XmlRootAttribute) XmlSerializer(Type, XmlRootAttribute)

지정된 형식의 개체를 XML 문서로 serialize하고 XML 문서를 지정된 형식의 개체로 deserialize할 수 있는 XmlSerializer 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML documents, and deserialize an XML document into object of the specified type. 또한 XML 루트 요소로 사용할 클래스를 지정합니다.It also specifies the class to use as the XML root element.

XmlSerializer(XmlTypeMapping) XmlSerializer(XmlTypeMapping) XmlSerializer(XmlTypeMapping) XmlSerializer(XmlTypeMapping)

특정 형식을 다른 형식에 매핑하는 개체를 사용하여 XmlSerializer 클래스의 인스턴스를 초기화합니다.Initializes an instance of the XmlSerializer class using an object that maps one type to another.

메서드

CanDeserialize(XmlReader) CanDeserialize(XmlReader) CanDeserialize(XmlReader) CanDeserialize(XmlReader)

XmlSerializer가 지정된 XML 문서를 deserialize할 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether this XmlSerializer can deserialize a specified XML document.

CreateReader() CreateReader() CreateReader() CreateReader()

serialize할 XML 문서를 읽는 데 사용되는 개체를 반환합니다.Returns an object used to read the XML document to be serialized.

CreateWriter() CreateWriter() CreateWriter() CreateWriter()

파생 클래스에서 재정의되는 경우 개체를 serialize하는 데 사용되는 작성기를 반환합니다.When overridden in a derived class, returns a writer used to serialize the object.

Deserialize(Stream) Deserialize(Stream) Deserialize(Stream) Deserialize(Stream)

지정된 Stream에 포함된 XML 문서를 deserialize합니다.Deserializes the XML document contained by the specified Stream.

Deserialize(TextReader) Deserialize(TextReader) Deserialize(TextReader) Deserialize(TextReader)

지정된 TextReader에 포함된 XML 문서를 deserialize합니다.Deserializes the XML document contained by the specified TextReader.

Deserialize(XmlReader) Deserialize(XmlReader) Deserialize(XmlReader) Deserialize(XmlReader)

지정된 XmlReader에 포함된 XML 문서를 deserialize합니다.Deserializes the XML document contained by the specified XmlReader.

Deserialize(XmlReader, String) Deserialize(XmlReader, String) Deserialize(XmlReader, String) Deserialize(XmlReader, String)

지정된 XmlReader에 포함된 XML 문서와 인코딩 스타일을 deserialize합니다.Deserializes the XML document contained by the specified XmlReader and encoding style.

Deserialize(XmlReader, String, XmlDeserializationEvents) Deserialize(XmlReader, String, XmlDeserializationEvents) Deserialize(XmlReader, String, XmlDeserializationEvents) Deserialize(XmlReader, String, XmlDeserializationEvents)

지정된 XmlReader에 포함된 데이터를 사용하여 개체를 deserialize합니다.Deserializes the object using the data contained by the specified XmlReader.

Deserialize(XmlReader, XmlDeserializationEvents) Deserialize(XmlReader, XmlDeserializationEvents) Deserialize(XmlReader, XmlDeserializationEvents) Deserialize(XmlReader, XmlDeserializationEvents)

지정된 XmlReader에 포함된 XML 문서를 deserialize하고 deserialization을 수행하는 동안 발생하는 이벤트를 재정의할 수 있도록 합니다.Deserializes an XML document contained by the specified XmlReader and allows the overriding of events that occur during deserialization.

Deserialize(XmlSerializationReader) Deserialize(XmlSerializationReader) Deserialize(XmlSerializationReader) Deserialize(XmlSerializationReader)

지정된 XmlSerializationReader에 포함된 XML 문서를 deserialize합니다.Deserializes the XML document contained by the specified XmlSerializationReader.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(Inherited from Object)
FromMappings(XmlMapping[]) FromMappings(XmlMapping[]) FromMappings(XmlMapping[]) FromMappings(XmlMapping[])

XmlSerializer 개체의 배열에서 만들어진 XmlTypeMapping 개체의 배열을 반환합니다.Returns an array of XmlSerializer objects created from an array of XmlTypeMapping objects.

FromMappings(XmlMapping[], Evidence) FromMappings(XmlMapping[], Evidence) FromMappings(XmlMapping[], Evidence) FromMappings(XmlMapping[], Evidence)

XML 형식 간의 매핑에 따라 생성되는 XmlSerializer 클래스의 인스턴스를 반환합니다.Returns an instance of the XmlSerializer class created from mappings of one XML type to another.

FromMappings(XmlMapping[], Type) FromMappings(XmlMapping[], Type) FromMappings(XmlMapping[], Type) FromMappings(XmlMapping[], Type)

지정된 매핑에 따라 XmlSerializer 클래스의 인스턴스를 반환합니다.Returns an instance of the XmlSerializer class from the specified mappings.

FromTypes(Type[]) FromTypes(Type[]) FromTypes(Type[]) FromTypes(Type[])

형식 배열에서 만든 XmlSerializer 개체의 배열을 반환합니다.Returns an array of XmlSerializer objects created from an array of types.

GenerateSerializer(Type[], XmlMapping[]) GenerateSerializer(Type[], XmlMapping[]) GenerateSerializer(Type[], XmlMapping[]) GenerateSerializer(Type[], XmlMapping[])

지정된 매핑을 사용하여 하나 이상의 지정된 형식을 serialize 또는 deserialize하는 데 사용되는 사용자 지정 serializer가 포함된 어셈블리를 반환합니다.Returns an assembly that contains custom-made serializers used to serialize or deserialize the specified type or types, using the specified mappings.

GenerateSerializer(Type[], XmlMapping[], CompilerParameters) GenerateSerializer(Type[], XmlMapping[], CompilerParameters) GenerateSerializer(Type[], XmlMapping[], CompilerParameters) GenerateSerializer(Type[], XmlMapping[], CompilerParameters)

지정된 매핑과 컴파일러 설정 및 옵션을 사용하여 하나 이상의 지정된 형식을 serialize 또는 deserialize하는 데 사용되는 사용자 지정 serializer가 포함된 어셈블리를 반환합니다.Returns an assembly that contains custom-made serializers used to serialize or deserialize the specified type or types, using the specified mappings and compiler settings and options.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
GetXmlSerializerAssemblyName(Type) GetXmlSerializerAssemblyName(Type) GetXmlSerializerAssemblyName(Type) GetXmlSerializerAssemblyName(Type)

지정된 형식을 serialize 또는 deserialize하기 위해 특별히 생성된 하나 또는 여러 버전의 XmlSerializer가 포함된 어셈블리의 이름을 반환합니다.Returns the name of the assembly that contains one or more versions of the XmlSerializer especially created to serialize or deserialize the specified type.

GetXmlSerializerAssemblyName(Type, String) GetXmlSerializerAssemblyName(Type, String) GetXmlSerializerAssemblyName(Type, String) GetXmlSerializerAssemblyName(Type, String)

지정된 네임스페이스의 지정된 형식에 대한 serializer가 포함된 어셈블리의 이름을 반환합니다.Returns the name of the assembly that contains the serializer for the specified type in the specified namespace.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter) Serialize(Object, XmlSerializationWriter)

지정된 Object를 serialize하고 지정된 XmlSerializationWriter을 사용하여 XML 문서를 파일에 씁니다.Serializes the specified Object and writes the XML document to a file using the specified XmlSerializationWriter.

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

지정된 Object를 serialize하고 지정된 Stream을 사용하여 XML 문서를 파일에 씁니다.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) Serialize(Stream, Object, XmlSerializerNamespaces)

지정된 Object를 serialize하고 지정된 네임스페이스를 참조하는 지정된 Stream을 사용하여 XML 문서를 파일에 씁니다.Serializes the specified Object and writes the XML document to a file using the specified Stream that references the specified namespaces.

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

지정된 Object를 serialize하고 지정된 TextWriter을 사용하여 XML 문서를 파일에 씁니다.Serializes the specified Object and writes the XML document to a file using the specified TextWriter.

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

지정된 Object를 serialize하고 지정된 TextWriter를 사용하여 XML 문서를 파일에 쓰며 지정된 네임스페이스를 참조합니다.Serializes the specified Object and writes the XML document to a file using the specified TextWriter and references the specified namespaces.

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

지정된 Object를 serialize하고 지정된 XmlWriter을 사용하여 XML 문서를 파일에 씁니다.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter.

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

지정된 Object를 serialize하고 지정된 XmlWriter를 사용하여 XML 문서를 파일에 쓰며 지정된 네임스페이스를 참조합니다.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter and references the specified namespaces.

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

지정된 개체를 serialize하고 지정된 XmlWriter를 사용하여 XML 문서를 파일에 쓰며 지정된 네임스페이스 및 인코딩 스타일을 참조합니다.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, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String) Serialize(XmlWriter, Object, XmlSerializerNamespaces, String, String)

지정된 Object를 serialize하고 지정된 XmlWriter, XML 네임스페이스 및 인코딩을 사용하여 XML 문서를 파일에 씁니다.Serializes the specified Object and writes the XML document to a file using the specified XmlWriter, XML namespaces, and encoding.

ToString() ToString() ToString() ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(Inherited from Object)

이벤트

UnknownAttribute UnknownAttribute UnknownAttribute UnknownAttribute

XmlSerializer가 deserialization을 수행하는 동안 알 수 없는 형식의 XML 특성이 나타날 때 발생합니다.Occurs when the XmlSerializer encounters an XML attribute of unknown type during deserialization.

UnknownElement UnknownElement UnknownElement UnknownElement

XmlSerializer가 deserialization을 수행하는 동안 알 수 없는 형식의 XML 요소를 발견하면 발생합니다.Occurs when the XmlSerializer encounters an XML element of unknown type during deserialization.

UnknownNode UnknownNode UnknownNode UnknownNode

XmlSerializer가 deserialization을 수행하는 동안 알 수 없는 형식의 XML 노드가 나타날 때 발생합니다.Occurs when the XmlSerializer encounters an XML node of unknown type during deserialization.

UnreferencedObject UnreferencedObject UnreferencedObject UnreferencedObject

SOAP로 인코딩된 XML 스트림의 deserialization을 수행하는 동안 XmlSerializer가 사용되지 않았거나 참조되지 않은 인식할 수 있는 형식을 발견하면 발생합니다.Occurs during deserialization of a SOAP-encoded XML stream, when the XmlSerializer encounters a recognized type that is not used or is unreferenced.

적용 대상

스레드 보안

이 형식은 스레드로부터 안전합니다.This type is thread safe.

추가 정보