XmlElementAttribute 클래스

아티클
08/21/2007

공용 필드 또는 속성을 포함하는 개체를 XmlSerializer가 serialize하거나 deserialize할 때 해당 필드나 속성이 XML 요소를 나타냄을 의미합니다.

네임스페이스: System.Xml.Serialization
어셈블리: System.Xml(system.xml.dll)

구문

‘선언
<AttributeUsageAttribute(AttributeTargets.Property Or AttributeTargets.Field Or AttributeTargets.Parameter Or AttributeTargets.ReturnValue, AllowMultiple:=True)> _
Public Class XmlElementAttribute
    Inherits Attribute
‘사용 방법
Dim instance As XmlElementAttribute

[AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue, AllowMultiple=true)] 
public class XmlElementAttribute : Attribute

[AttributeUsageAttribute(AttributeTargets::Property|AttributeTargets::Field|AttributeTargets::Parameter|AttributeTargets::ReturnValue, AllowMultiple=true)] 
public ref class XmlElementAttribute : public Attribute

/** @attribute AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue, AllowMultiple=true) */ 
public class XmlElementAttribute extends Attribute

AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue, AllowMultiple=true) 
public class XmlElementAttribute extends Attribute

설명

XmlSerializer가 개체를 serialize 및 deserialize하는 방식을 제어하는 특성 패밀리에 속한 XmlElementAttribute입니다. 유사한 특성에 대한 전체 목록은 XML Serialization을 제어하는 특성을 참조하십시오.

일반적으로 XML 문서에는 세 부분(여는 태그, 닫는 태그 및 태그 간 데이터)으로 구성되는 XML 요소가 포함됩니다. XML 태크는 중첩될 수 있으므로 태그 간 데이터도 XML 요소가 될 수 있습니다. 이와 같이, 하나의 요소가 다른 요소를 포함할 수 있기 때문에 문서에는 데이터의 계층 구조가 존재합니다. XML 요소는 특성을 포함할 수도 있습니다.

공용 필드 또는 공용 읽기/쓰기 속성에 XmlElementAttribute를 적용하여 요소 이름 및 네임스페이스 같은 XML 요소의 특성을 제어합니다.

개체의 배열을 반환하는 필드에 XmlElementAttribute를 여러 번 적용할 수 있는데, 이렇게 함으로써 Type 속성을 통해, 배열에 삽입될 수 있는 다양한 형식을 지정할 수 있습니다. 예를 들어, 다음 C# 코드에서 배열은 문자열과 정수를 모두 허용합니다.

 public class Things{
    [XmlElement(DataType = typeof(string)),
    XmlElement(DataType = typeof(int))]
    public object[] StringsAndInts;
 }

이에 대한 XML은 다음과 유사합니다.

 <Things>
    <string>Hello</string>
    <int>999</int>
    <string>World</string>
 </Things>

ElementName 속성 값을 지정하지 않고 XmlElementAttribute를 여러 번 적용하면 요소에는 허용된 개체의 형식 이름이 지정됩니다.

배열을 반환하는 필드 또는 속성에 XmlElementAttribute를 적용하면 배열의 항목은 XML 요소의 시퀀스로 인코딩됩니다.

이와는 반대로 이러한 필드나 속성에 XmlElementAttribute를 적용하지 않으면 배열의 항목은 해당 필드 또는 속성과 같은 이름의 요소 밑에 중첩된 요소의 시퀀스로 인코딩됩니다. XmlArrayAttribute 및 XmlArrayItemAttribute를 사용하여 배열이 serialize되는 방법을 제어할 수 있습니다.

Type 속성을 설정하여 원본 필드 또는 속성 즉, XmlElementAttribute이 적용된 필드 또는 속성의 형식에서 파생된 형식을 지정할 수 있습니다.

필드 또는 속성이 ArrayList를 반환하는 경우, 해당 멤버에 XmlElementAttribute의 여러 인스턴스를 적용할 수 있습니다. 각 인스턴스에 대해 Type 속성을 배열에 삽입할 수 있는 개체의 형식으로 설정합니다.

특성 사용에 대한 자세한 내용은 특성을 사용하여 메타데이터 확장을 참조하십시오.

참고

긴 XmlElementAttribute 대신 XmlElement라는 단어를 코드에서 사용할 수 있습니다.

예제

다음 예제에서는 Group 클래스를 serialize하고 그 클래스의 일부 멤버에 XmlElementAttribute를 적용합니다. Employees라는 이름의 필드는 Employee 개체의 배열을 반환합니다. 이 경우, XmlElementAttribute는 결과 XML이 중첩되지 않도록 지정하며, 이것은 배열의 항목에 대한 기본값입니다.

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


Public Class Group
    ' Set the element name and namespace of the XML element.
    <XmlElement(ElementName := "Members", _
     Namespace := "http://www.cpandl.com")> _    
    Public Employees() As Employee
    
    <XmlElement(DataType := "double", _
     ElementName := "Building")> _
    Public GroupID As Double
    
    <XmlElement(DataType := "hexBinary")> _
    Public HexBytes() As Byte
    
    <XmlElement(DataType := "boolean")> _
    Public IsActive As Boolean
    
    <XmlElement(GetType(Manager))> _
    Public Manager As Employee
    
    <XmlElement(GetType(Integer), _
        ElementName := "ObjectNumber"), _
     XmlElement(GetType(String), _
        ElementName := "ObjectString")> _
    Public ExtraInfo As ArrayList
End Class

Public Class Employee
    Public Name As String
End Class

Public Class Manager
    Inherits Employee
    Public Level As Integer
End Class

Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeObject("FirstDoc.xml")
        test.DeserializeObject("FirstDoc.xml")
    End Sub
    
    Public Sub SerializeObject(filename As String)
        ' Create the XmlSerializer.
        Dim s As New XmlSerializer(GetType(Group))
        
        ' To write the file, a TextWriter is required.
        Dim writer As New StreamWriter(filename)
        
        ' Create an instance of the group to serialize, and set
        ' its properties. 
        Dim group As New Group()
        group.GroupID = 10.089f
        group.IsActive = False
        
        group.HexBytes = New Byte() {Convert.ToByte(100)}
        
        Dim x As New Employee()
        Dim y As New Employee()
        
        x.Name = "Jack"
        y.Name = "Jill"
        
        group.Employees = New Employee() {x, y}
        
        Dim mgr As New Manager()
        mgr.Name = "Sara"
        mgr.Level = 4
        group.Manager = mgr
        
        ' Add a number and a string to the
        ' ArrayList returned by the ExtraInfo property. 
        group.ExtraInfo = New ArrayList()
        group.ExtraInfo.Add(42)
        group.ExtraInfo.Add("Answer")
        
        ' Serialize the object, and close the TextWriter.      
        s.Serialize(writer, group)
        writer.Close()
    End Sub    
    
    Public Sub DeserializeObject(filename As String)
        Dim fs As New FileStream(filename, FileMode.Open)
        Dim x As New XmlSerializer(GetType(Group))
        Dim g As Group = CType(x.Deserialize(fs), Group)
        Console.WriteLine(g.Manager.Name)
        Console.WriteLine(g.GroupID)
        Console.WriteLine(g.HexBytes(0))

        Dim e As Employee
        For Each e In g.Employees
            Console.WriteLine(e.Name)
        Next e
    End Sub
End Class

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

public class Group
{
   /* Set the element name and namespace of the XML element.
   By applying an XmlElementAttribute to an array,  you instruct
   the XmlSerializer to serialize the array as a series of XML
   elements, instead of a nested set of elements. */
   
   [XmlElement(
   ElementName = "Members",
   Namespace = "http://www.cpandl.com")]
   public Employee[] Employees;
      
   [XmlElement(DataType = "double",
   ElementName = "Building")]
   public double GroupID;

   [XmlElement(DataType = "hexBinary")]
   public byte [] HexBytes;


   [XmlElement(DataType = "boolean")]
   public bool IsActive;

   [XmlElement(Type = typeof(Manager))]
   public Employee Manager;

   [XmlElement(typeof(int),
   ElementName = "ObjectNumber"),
   XmlElement(typeof(string),
   ElementName = "ObjectString")]
   public ArrayList ExtraInfo;
}   

public class Employee
{
   public string Name;
}

public class Manager:Employee{
   public int Level;
}

public class Run
{
    public static void Main()
    {
       Run test = new Run();
       test.SerializeObject("FirstDoc.xml");
       test.DeserializeObject("FirstDoc.xml");
    }


   public void SerializeObject(string filename)
   {
      // Create the XmlSerializer.
      XmlSerializer s = new XmlSerializer(typeof(Group));

      // To write the file, a TextWriter is required.
      TextWriter writer = new StreamWriter(filename);

      /* Create an instance of the group to serialize, and set
         its properties. */
      Group group = new Group();
      group.GroupID = 10.089f;
      group.IsActive = false;
      
      group.HexBytes = new byte[1]{Convert.ToByte(100)};

      Employee x = new Employee();
      Employee y = new Employee();

      x.Name = "Jack";
      y.Name = "Jill";
      
      group.Employees = new Employee[2]{x,y};

      Manager mgr = new Manager();
      mgr.Name = "Sara";
      mgr.Level = 4;
      group.Manager = mgr;

      /* Add a number and a string to the 
      ArrayList returned by the ExtraInfo property. */
      group.ExtraInfo = new ArrayList();
      group.ExtraInfo.Add(42);
      group.ExtraInfo.Add("Answer");

      // Serialize the object, and close the TextWriter.      
      s.Serialize(writer, group);
      writer.Close();
   }

   public void DeserializeObject(string filename)
   {
      FileStream fs = new FileStream(filename, FileMode.Open);
      XmlSerializer x = new XmlSerializer(typeof(Group));
      Group g = (Group) x.Deserialize(fs);
      Console.WriteLine(g.Manager.Name);
      Console.WriteLine(g.GroupID);
      Console.WriteLine(g.HexBytes[0]);
      foreach(Employee e in g.Employees)
      {
         Console.WriteLine(e.Name);
      }
   }
}

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

using namespace System;
using namespace System::Collections;
using namespace System::IO;
using namespace System::Xml::Serialization;
public ref class Employee
{
public:
   String^ Name;
};

public ref class Manager: public Employee
{
public:
   int Level;
};

public ref class Group
{
public:

   /* Set the element name and namespace of the XML element.
      By applying an XmlElementAttribute to an array,  you instruct
      the XmlSerializer to serialize the array as a series of XML
      elements, instead of a nested set of elements. */

   [XmlElement(
   ElementName="Members",
   Namespace="http://www.cpandl.com")]
   array<Employee^>^Employees;

   [XmlElement(DataType="snippet1>",
   ElementName="Building")]
   double GroupID;

   [XmlElement(DataType="hexBinary")]
   array<Byte>^HexBytes;

   [XmlElement(DataType="boolean")]
   bool IsActive;

   [XmlElement(Type=::Manager::typeid)]
   Employee^ Manager;

   [XmlElement(Int32::typeid,
   ElementName="ObjectNumber"),
   XmlElement(String::typeid,
   ElementName="ObjectString")]
   ArrayList^ ExtraInfo;
};

void SerializeObject( String^ filename )
{
   // Create the XmlSerializer.
   XmlSerializer^ s = gcnew XmlSerializer( Group::typeid );

   // To write the file, a TextWriter is required.
   TextWriter^ writer = gcnew StreamWriter( filename );

   /* Create an instance of the group to serialize, and set
      its properties. */
   Group^ group = gcnew Group;
   group->GroupID = 10.089f;
   group->IsActive = false;
   array<Byte>^temp0 = {Convert::ToByte( 100 )};
   group->HexBytes = temp0;
   Employee^ x = gcnew Employee;
   Employee^ y = gcnew Employee;
   x->Name = "Jack";
   y->Name = "Jill";
   array<Employee^>^temp1 = {x,y};
   group->Employees = temp1;
   Manager^ mgr = gcnew Manager;
   mgr->Name = "Sara";
   mgr->Level = 4;
   group->Manager = mgr;

   /* Add a number and a string to the 
      ArrayList returned by the ExtraInfo property. */
   group->ExtraInfo = gcnew ArrayList;
   group->ExtraInfo->Add( 42 );
   group->ExtraInfo->Add( "Answer" );

   // Serialize the object, and close the TextWriter.      
   s->Serialize( writer, group );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
   XmlSerializer^ x = gcnew XmlSerializer( Group::typeid );
   Group^ g = dynamic_cast<Group^>(x->Deserialize( fs ));
   Console::WriteLine( g->Manager->Name );
   Console::WriteLine( g->GroupID );
   Console::WriteLine( g->HexBytes[ 0 ] );
   IEnumerator^ myEnum = g->Employees->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Employee^ e = safe_cast<Employee^>(myEnum->Current);
      Console::WriteLine( e->Name );
   }
}

int main()
{
   SerializeObject( "FirstDoc.xml" );
   DeserializeObject( "FirstDoc.xml" );
}

import System.*;
import System.Collections.*;
import System.IO.*;
import System.Xml.Serialization.*;

public class Group
{
    /* Set the element name and namespace of the XML element.
       By applying an XmlElementAttribute to an array,  you instruct
       the XmlSerializer to serialize the array as a series of XML
       elements, instead of a nested set of elements. */
   
    /** @attribute XmlElement(ElementName = "Members",
        Namespace = "http://www.cpandl.com")
     */
    public Employee employees[];   
    /** @attribute XmlElement(DataType = "double", ElementName = "Building")
     */
    public double groupID;   
    /** @attribute XmlElement(DataType = "hexBinary")
     */
    public ubyte hexBytes[];   
    /** @attribute XmlElement(DataType = "boolean")
     */
    public boolean isActive;   
    /** @attribute XmlElement(Type = Manager.class)
     */
    public Employee manager;   
    /** @attribute XmlElement(int.class, ElementName = "ObjectNumber")
        @attribute XmlElement(String.class, ElementName = "ObjectString")
     */
    public ArrayList extraInfo;
} //Group

public class Employee
{
    public String name;
} //Employee

public class Manager extends Employee
{
    public int level;
} //Manager

public class Run
{
    public static void main(String[] args)
    {
        Run test = new Run();
        test.SerializeObject("FirstDoc.xml");
        test.DeserializeObject("FirstDoc.xml");
    } //main

    public void SerializeObject(String fileName)
    {
        // Create the XmlSerializer.
        XmlSerializer s = new XmlSerializer(Group.class.ToType());

        // To write the file, a TextWriter is required.
        TextWriter writer = new StreamWriter(fileName);

        /* Create an instance of the group to serialize, and set
           its properties. */
        Group group = new Group();
        group.groupID = 10.089f;
        group.isActive = false;
        group.hexBytes = new ubyte[] { Convert.ToByte(100) };

        Employee x = new Employee();
        Employee y = new Employee();

        x.name = "Jack";
        y.name = "Jill";
        group.employees = new Employee[] { x, y };

        Manager mgr = new Manager();
        mgr.name = "Sara";
        mgr.level = 4;
        group.manager = mgr;

        /* Add a number and a string to the 
           ArrayList returned by the ExtraInfo property. */
        group.extraInfo = new ArrayList();
        group.extraInfo.Add((Int32)42);
        group.extraInfo.Add("Answer");

        // Serialize the object, and close the TextWriter.      
        s.Serialize(writer, group);
        writer.Close();
    } //SerializeObject

    public void DeserializeObject(String fileName)
    {
        FileStream fs = new FileStream(fileName, FileMode.Open);
        XmlSerializer x = new XmlSerializer(Group.class.ToType());
        Group g = (Group)x.Deserialize(fs);

        Console.WriteLine(g.manager.name);
        Console.WriteLine(g.groupID);
        Console.WriteLine(g.hexBytes.get_Item(0));
        for (int iCtr = 0; iCtr < g.employees.length; iCtr++) {
            Employee e = g.employees[iCtr];
            Console.WriteLine(e.name);
        }
    } //DeserializeObject
} //Run

상속 계층 구조

System.Object
System.Attribute
System.Xml.Serialization.XmlElementAttribute

스레드로부터의 안전성

이 형식의 모든 public static(Visual Basic의 경우 Shared) 멤버는 스레드로부터 안전합니다. 인터페이스 멤버는 스레드로부터 안전하지 않습니다.

플랫폼

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework에서 모든 플래폼의 모든 버전을 지원하지는 않습니다. 지원되는 버전의 목록은 시스템 요구 사항을 참조하십시오.

버전 정보

.NET Framework

2.0, 1.1, 1.0에서 지원

.NET Compact Framework

2.0, 1.0에서 지원

참고 항목

참조

XmlElementAttribute 멤버
System.Xml.Serialization 네임스페이스
XmlArrayAttribute 클래스
XmlAttributeOverrides 클래스
XmlAttributes 클래스
XmlElementAttributes
XmlAttributes.XmlElements 속성
XmlRootAttribute
XmlSerializer
XmlAttributes 클래스

기타 리소스

XML Serialization 소개
방법: XML 스트림의 대체 요소 이름 지정
특성을 사용하여 XML Serialization 제어
XML Serialization 예
XML 스키마 정의 도구(Xsd.exe)

다음을 통해 공유