<xsd:schema
    targetNamespace="urn:xyzzy"
       xmlns:target="urn:xyzzy"
       xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
   > 
     <xsd:element name="bob" type="xsd:double" />
   </xsd:schema>

<ns:bob xmlns:ns="urn:xyzzy">33</ns:bob>

<ns:bob xmlns:ns="urn:xyzzy">33.0000</ns:bob>
<ns:bob xmlns:ns="urn:xyzzy">3.3e1</ns:bob>

<xsd:schema 
    targetNamespace="uuid:048b2fa1-d557-473f-ba4c-acee78fe3f7d" 
    xmlns:target="uuid:048b2fa1-d557-473f-ba4c-acee78fe3f7d" 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
>
    <xsd:complexType name="Person">
      <xsd:sequence>
        <xsd:choice>
          <xsd:element name="name" type="xsd:string"
                       xsi:nillable="true" />
          <xsd:element name="id" type="xsd:string" />
        </xsd:choice>
        <xsd:any processContents="lax"/>
      </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="AgedPerson">
      <xsd:complexContent mixed="false">
        <xsd:extension base="target:Person">
          <xsd:choice>
            <xsd:element name="age" type="xsd:double" />
            <xsd:element name="timeOnEarth" type="xsd:double" />
          </xsd:choice>
        </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
    <xsd:element name="don" type="target:Person" />
  </xsd:schema>

<ns:don
    xmlns:ns="uuid:048b2fa1-d557-473f-ba4c-
              acee78fe3f7d" 
>
    <name>Don Box</name>
    <niceStuffForDon/>  
</ns:don>

<ns:don
    xmlns:ns="uuid:048b2fa1-d557-473f-ba4c-acee78fe3f7d" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:type="ns:AgedPerson" 
>
    <name>Don Box</name>
    <niceStuffForDon/>  
    <age>26</age>
</ns:don>

<ns:don
    xmlns:ns="uuid:048b2fa1-d557-473f-ba4c-acee78fe3f7d" 
>
    <name />
    <niceStuffForDon/>  
</ns:don>

<ns:don
    xmlns:ns="uuid:048b2fa1-d557-473f-ba4c-acee78fe3f7d" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>
    <name xsi:nil="true" />
    <niceStuffForDon/>  
</ns:don>

using System;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;

class som
{
  static readonly XmlQualifiedName xsd_string 
    = new XmlQualifiedName("string", XmlSchema.Namespace);
  static readonly XmlQualifiedName xsd_double 
    = new XmlQualifiedName("double", XmlSchema.Namespace);

  static void Main()
  {
    string targetNS = "uuid:048b2fa1-d557-473f-ba4c-acee78fe3f7d";

    XmlSchema schema = new XmlSchema();
    schema.TargetNamespace = targetNS;

// <xsd:element name="name" type="xsd:string" nillable="true" />
    XmlSchemaElement elem = new XmlSchemaElement();
    elem.Name = "name";
    elem.SchemaTypeName = xsd_string;
    elem.IsNillable = true;

// <xsd:element name="id" type="xsd:string" />
    XmlSchemaElement elem2 = new XmlSchemaElement();
    elem2.Name = "id";
    elem2.SchemaTypeName = xsd_string;

// <xsd:choice><xsd:element/><xsd:element/><xsd:choice>
    XmlSchemaChoice choice = new XmlSchemaChoice();
    choice.Items.Add(elem);
    choice.Items.Add(elem2);
 
// <xsd:sequence><xsd:choice/><xsd:any/></xsd:sequence>
    XmlSchemaSequence seq = new XmlSchemaSequence();
    seq.Items.Add(choice);
    seq.Items.Add(new XmlSchemaAny());

// <xsd:complexType><xsd:sequence/></xsd:complexType>
    XmlSchemaComplexType type = new XmlSchemaComplexType();
    type.Particle = seq;
    type.Name = "Person";
    schema.Items.Add(type);

// <xsd:element name="age" type="xsd:double" />
    elem = new XmlSchemaElement();
    elem.Name = "age";
    elem.SchemaTypeName = xsd_double;

// <xsd:element name="timeOnEarth" type="xsd:double" />
    elem2 = new XmlSchemaElement();
    elem2.Name = "timeOnEarth";
    elem2.SchemaTypeName = xsd_double; 

// <xsd:choice><xsd:element/><xsd:element/><xsd:choice>
    choice = new XmlSchemaChoice();
    choice.Items.Add(elem);
    choice.Items.Add(elem);

// <xsd:extension><xsd:choice/></xsd:extension>
    XmlSchemaComplexContentExtension content = new  
    XmlSchemaComplexContentExtension();
    content.Particle = choice;
    content.BaseTypeName = new XmlQualifiedName("Person", targetNS);

// <xsd:complexContent><xsd:extension/></xsd:complexContent>
    XmlSchemaComplexContent model = new XmlSchemaComplexContent();
    model.Content = content;

// <xsd:complexType><xsd:complexContent/></xsd:complexType>
    type = new XmlSchemaComplexType();
    type.ContentModel = model;
    type.Name = "AgedPerson";
    schema.Items.Add(type);

// <xsd:element />
    elem = new XmlSchemaElement();
    elem.Name = "don";
    elem.SchemaTypeName = new XmlQualifiedName("Person", targetNS);
    schema.Items.Add(elem);

// compile and spit out to stdout
    schema.Compile(null);
    XmlTextWriter writer = new XmlTextWriter(Console.Out);
    writer.Formatting = Formatting.Indented;
    schema.Write(writer);
  }
}

그림?4는 그림?2에서 보았던 스키마를 만들기 위해 필요한 C# 코드를 나타냅니다. 그 스키마가 이미 존재한다고 가정 하에(일반적인 경우), 우리는 다음과 같이 네 줄로 간단히 쓸 수 있습니다.

XmlReader reader 
          = new XmlTextReader("http://foo.com/don.xsd");
XmlSchema schema = XmlSchema.Load(reader, null);
schema.Compile(null);
reader.Close();

namespace System.Xml.Serialization {
    public class XmlSerializer {
// primary constructor
      public XmlSerializer(Type clrType);

// primary serialize/deserialize methods
      public void Serialize(XmlWriter writer, object obj);
      public object Deserialize(XmlReader reader);

// overloaded serialize/deserialize wrappers
      public void Serialize(TextWriter writer, object obj);
      public object Deserialize(TextReader reader);

      public void Serialize(Stream writer, object obj);
      public object Deserialize(Stream reader);
    }
}

그림?8 은 XmlSerializer 형식의 시그니처를 나타냅니다. 이 구문은 System.Type 개체를 제공하는 호출자를 요구한다는 점에 주의하십시오. XML 일련화 엔진은 사용 중인 각각의 형식들을 위한 별개의 XmlSerializer 개체를 필요로 합니다. 개체를 일련화하거나 혹은 그 반대의 작업을 진행할 때, 작업을 수행하기 위해 사용되는 XmlSerializer 개체는 반드시 올바른 CLR 형식과 연결되어야 합니다.
XmlSerializer 형식은 Serialize와 Deserialize의 두 가지 기본적인 메서드을 가집니다. Serialize 메서드는 제공된 CLR 기반 개체에 부합하는 XML 기반의 인스턴스를 씁니다. Deserialize 메서드는 XML 기반 인스턴스를 읽어서 부합하는 CLR 기반 개체를 반환합니다. 양 메서드는 모두 XML을 읽거나 쓰기 위해 XmlReader 또는 XmlWriter를 필요로 합니다. XmlSerializer 클래스는 TextWriter/TextReader 또는 Stream 개체를 적용하는 이러한 메서드들의 오버로드된 버전을 제공합니다. 그러나 이 두 오버로드의 경우 모두에서, 근본적 구현은 단순히 XmlTextReader/XmlTextWriter를 만들어서 기본적인 Serialize 또는 Deserialize 메서드로 위임할 뿐입니다.

using System.Xml;
using System.Xml.Serialization;
using System.Text;

class MyWriter {
    static void
     WriteObjectToFile(Object obj, string fname) {
// open an XML output stream
      XmlWriter writer = new XmlTextWriter(fname, 
                                         Encoding.UTF8);
      try {
// create a serializer of the object's type
      XmlSerializer ser = new XmlSerializer(obj.GetType());
// write the object out to the XML stream
      ser.Serialize(writer, obj);
      }
      finally {
        writer.Close();
      }
    }
}

using System.Text;
using System.Xml;
using System.Xml.Serialization

class MyReader {
    static object 
    ReadObjectFromFile(Type type, string fname) {
      Object result = null;
// open an XML parser
      XmlReader reader = new XmlTextReader(fname);
      try {
// create a serializer for the type
        XmlSerializer ser = new XmlSerializer(type);
// read XML and create corresponding object
        result = ser.Deserialize(reader);
      }
      finally {
        reader.Close();
      }
    }
    return result;
}

그림?9 와 그림?10 은 Serialize와 Deserialize 메서드의 정식 용례를 각각 보여줍니다. 해당 serialize를 제대로 초기화 하려면 두 경우에서 모두 정확한 System.Type 개체가 사용되어야 함에 주의하십시오.
XmlSerializer 는 per-type 판독기/작성기 쌍의 생성과 실행을 관리합니다. 이 쌍들은, 내부 형식들에 각각 XmlSerializationReader와 XmlSerializationWriter를 제공하는 역동적으로 생성된 형식들입니다. 어떤 XmlSerializer를 예로 든다고 할 때, 여러분은 그 새로운 serializer 객체가 사용할 해당 형식을 나타내는 어떤 System.Type 객체를 제공해야만 합니다. 중복 어셈블리를 생성하지 않기 위해, XmlSerializer 생성자는 생성된 판독기/작성기 어셈블리들의 AppDomain-wide 캐시를 참조하며, 하나를 발견하게 될 경우 그 캐시 어셈블리를 재사용합니다. 하나가 발견되지 않을 경우, 그 XmlSerializer 생성자는 제시된 System.Type 개체를 반영함으로써 새로운 역동적 어셈블리를 생성합니다. 이 새로운 어셈블리는 해당 캐시에 추가되고, 따라서 다음 XmlSerializer 객체는 codegen 오버헤드와 전체 코드 사이즈를 축소시키면서 그것을 재사용할 수 있습니다. 불행하게도, 조회 인덱스가 다시 정의되어 더 복잡해 지므로 그 캐시는 단지 XMLSerializer의 일부 생성기에 대해서만 작동합니다. 사용자들은 serializer 자체를 임시저장할 수 있습니다-그것은 자유 스레드되었기 때문에 스레드를 가로질러 일련화할 수 있습니다.


그림 11 XMLSerializer 아키텍처

모든 XmlSerializer 객체는 역동적으로 생성된 어셈블리에 대한 참조를 보유하고 있습니다(그림 11 참조). 대부분의 경우, 이 어셈블리는 어떤 캐시에서 반입되며, 실제로 동일 CLR 형식을 지원하는 다른 XmlSerializer 개체와 공유될 수도 있습니다.

구성기가 사용되고 있는 것처럼 일련화됩니다. 그 결과, 그 형식의 필드/속성에 해당하는 하위 요소들은 그들이 선언되는 순서대로 나타나게 됩니다. 이것은 합리적인 기본값입니다. 왜냐하면, 모든 가능성을 생각해 볼 때, 대부분의 XML은 소프트웨어에 의해 생성되고 또한 구성기(Beta 1에서 사용 됨)가 제공하는 유연성은 어떤 순서로든 요소들을 처리해야 할 필요가 있을 경우 사용자가 느끼게 될 실행 효과를 상쇄해 주지 않기 때문입니다.
[XmlType] 특성은 사용자가 어떤 CLR 형식과 연관된 스키마 형식의 이름이나 이름 공간을 조정할 수 있게 해줍니다. [XmlType]은 XML Schema의 targetNamespace에 해당하는 어떤 Namespace 매개 변수를 적용합니다(그림 12 참조). 만약 이런 매개 변수가 존재하지 않는다면, 해당 스키마 형식은 어떤 XML 이름 공간과도 연결되지 않습니다. TypeName 매개 변수는 사용자가 해당 XML Schema 형식의 지역 이름을 조정할 수 있도록 해주며, 제공되지 않았을 경우에는 CLR 형식의 지역 이름이 사용됩니다. 그림 12에서는 그 형식의 모든 XML Schema 변환을 생략함으로써 제시하고 있지 않지만, 사용자는 어떤 스키마 매핑도 발생하기 않도록 하기 위해 IncludeInSchema-false 매개 변수를 지정할 수 있습니다.


그림 12 XMLRootAttribute/XMLTypeAttribute 매핑

만약 사용자가 어떤 XML 인스턴스 문서에서 어떤 XML Schema 복합 형식을 최상위 요소로 사용할 작정이라면 전역 요소 선언이 필요합니다. [XmlRoot] 특성은 그러한 요소 선언이 만들어지도록 합니다. 그림 12에서 보는 바와 같이, [XmlRoot] 특성은 사용자가 요소 이름과 XML 이름 공간 URI를 조정할 수 있게 해줍니다. 그것은 또한 사용자가 인스턴스 문서에서 xsi:nil을 지원하기 위해 nillable 특성을 조정하도록 해줍니다. 마지막으로, 만약 요소 선언이 복합 형식 보다는 오히려 내장된 간단한 데이터 형식을 사용할 예정이라면, 해당 DataType 특성이 사용될 수 있습니다.

Use	Parameter	Type	Description
R	ElementName	String	xsd:element/@name
T	TypeName	String	xsd:complexType/@name
R/T	Namespace	String	../xsd:schema/@targetNamespace
R	IsNullable	Boolean	xsd:element/@nillable
R	DataType	String	XSD Built-in Type Name
T	IncludeInSchema	Boolean	No corresponding XML type

그림 13[XmlRoot]/[XmlType] Parameters

그림 13은 [XmlType]와 [XmlRoot] 특성들에 대한 각각의 매개 변수를 보여줍니다.
[XmlType]와 [XmlRoot] 특성을 사용하는 것은 비교적 간단합니다. 여기에 나타난 C# 코드를 고찰해 보십시오.

using System.Xml.Serialization;

[ XmlRoot(ElementName="Bobby", Namespace="abcdef") ]
[ XmlType(TypeName="Robert", Namespace="abcdef") ]
public class Bob {}

[ XmlRoot(ElementName="Stevie", Namespace="abcdef") ]
public class Steve {}

[ XmlType(TypeName="Donald", Namespace="abcdef") ]
public class Don {}

public class Dave {}

<xsd:schema 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:target="abcdef"
    targetNamespace="abcdef"
>
    <xsd:complexType name="Robert" />
    <xsd:element name="Bobby" type="target:Robert" 
                 nillable="true" />

    <xsd:complexType name="Steve" />
    <xsd:element name="Stevie" type="target:Steve" 
                 nillable="true" />

    <xsd:complexType name="Donald" />
</xsd:schema>
<xsd:schema 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:foreign="abcdef"
    targetNamespace=""
>
    <xsd:import namespace="abcdef" />
    <xsd:element name="Don" type="foreign:Donald" 
                 nillable="true"/>
    <xsd:complexType name="Dave" />
    <xsd:element name="Dave" type="Dave" 
                 nillable="true" />
</xsd:schema>

그림 14 [XmlRoot]/[XmlType] Example Output

이 코드에 해당하는 스키마 문서는 그림 14에 제시되어 있습니다. CLR 형식 Don은 [XmlRoot] 특질을 가지지 않기 때문에, 그 스키마 문서에서의 해당 전역 요소 선언은 해당 CLR 형식 이름을 바탕으로 하며, " "의 이름공간 URI를 가진다는 것에 주의하십시오. 또한 그 CLR 형식 Steve가 [XmlType] 특성을 가지지 않기 때문에 해당 복합 형식 정의는 단순히 그 CLR 형식 이름 그대로를 사용한다는 것에도 주의하십시오.


그림 15 XSD.EXE

System.Xml.Serialization 라이브러리는 어떤 .NET 어셈블리로부터 자동으로 XML Schemas를 생성할 수 있습니다. 그것은 또한 어떤 XML Schemas로부터 주석 달린 소스 코드를 생성할 수 있습니다. 전형적으로 XSD.EXE 도구를 사용하여 이 능력에 액세스합니다. XSD.EXE 도구는 어떤 어셈블리 또는 XML Schema를 적용하며, 원하는 형식 시스템에서 형식 정의를 생성하기 위해 설명된 규칙들을 사용합니다(그림 15 참조).

---

스키마 사용자 지정

Use	Parameter	Type	Description
E	ElementName	String	xsd:element/@name
A	AttributeName	String	xsd:attribute/@name
E/A	Form	XmlSchemaForm	@form
E/A	Namespace	String	@ref (combined with XXXName)
E/A	DataType	String	XSD Built-in Type Name
E	IsNullable	Boolean	xsd:element/@nillable
E	Type	Type	Explicitly allowed derived types

그림 16 XmlAttributeAttribute/XmlElementAttribute Parameters

어떤 CLR 형식을 XML 스키마 형식으로 매핑할 때, 각 CLR 필드/속성은 해당하는 XML Schemas 형식으로 된 특정 구문으로 매핑됩니다. 기본적으로 모든 public 필드와 속성들은 어떤 구성기 내부에 있는 하위 요소들로 매핑되는 것으로 간주합니다. 이 디폴트 매핑은 [XmlElement]와 [XmlAttribute] 사용자 지정 특성들을 사용하여 재정의할 수 있습니다. 이 특성들은 특성을 사용하는 필드/속성을 각각 지역 요소 선언 또는 지역 특성 선언으로 매핑합니다. 이런 속성은 둘 다, 생성된 XML Schemas 형식을 사용자 지정하는 매개 변수를 적용합니다. 이 매개 변수들은 그림 16에 제시되어 있습니다.


그림 17 XMLElementAttribute 매핑

[XmlElement] 특성은 XML Schema 언어로 되어있는 지역 요소 선언에 매핑합니다. 그림 17과 같은 두 가지의 사용 모델이 있습니다. 첫번째 모델은 이름 공간 정보가 부모 복합 형식에 의해 지배되는 순수한 지역 요소 선언을 가정합니다. 두 번째 모델은 어떤 전역 요소 선언에 대한 참조가 사용될 것이며, 전형적으로 XML Schema 언어로 되어 있는 요소 대체 그룹에만 사용된다고 가정합니다. [XmlAttribute] 특성은 XML 특성들에 대해서만 제외하면 그것과 비슷한 방식으로 작용합니다(그림 18 참조).


그림 18 XMLAttribute 매핑

using System.Xml.Schema;
using System.Xml.Serialization;

[ XmlRoot(Name="writer", Namespace="abcdef") ]
[ XmlType(TypeName="Author", Namespace="abcdef") ]
public class Author {
    [ XmlElementAttribute("name", IsNullable=true,
                          Form=XmlSchemaForm.Qualified) ] 
    public string name;

    [ XmlElementAttribute("notbreathing", 
                          Form=XmlForm.Unqualified) ]
    public bool dead;

    [ XmlAttributeAttribute("rate") ]
    public double royaltyrate;

}

그림 19 [XmlAttribute]/[XmlElement] Example

그림?19는 [XmlElement]와 [XmlAttribute] 특성 양쪽을 모두 사용하는, 어떤 주석 달린 CLR 형식을 나타냅니다. 이런 형식을 위한 해당 스키마는 그림 20에 나와 있습니다. 이런 경우, name 요소는 form="qualified"이라고 표시되어 있으나, notbreathing 요소는 그렇지 않다는 것에 주의하십시오. 이것은 C# 코드에서 사용된 [XmlElement] 특성에서 Form 매개 변수를 사용하기 때문입니다.
XML Schemas로 매핑할 경우, CLR 열거는 특별하게 취급됩니다. 하나의 CLR 열거는 내장 형식 문자열을 CLR 열거형 멤버당 하나씩 일단의 열거된 값들로 제한하는 어떤 XML Schema 단순 형식에 매핑합니다. 이러한 제한 값들은, [XmlEnum] 특성이 사용되지 않는 한 해당 CLR 열거형 멤버의 이름과 일치합니다. 다음은 주석 달린 CLR 열거의 한 예입니다.

   using System.Xml.Serialization

   [ XmlType(TypeName="hair", Namespace="abcdef") ]
public enum AuthorHair  {
    [ XmlEnum("bald") ] Harrisonish,
    [ XmlEnum("short")] Gudginesque,
    [ XmlEnum("medium")] Skonnarded,
    [ XmlEnum("long")] Boxy,
  }
  
 

<xsd:schema 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:target="abcdef"
    targetNamespace="abcdef"
>
    <xsd:simpleType name="hair" >
      <xsd:restriction base="xsd:string" >
        <xsd:enumeration value="bald" />
        <xsd:enumeration value="short" />
        <xsd:enumeration value="medium" />
        <xsd:enumeration value="long" />
      </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>

그림 21 [XmlEnum] Example Output

해당 XML Schemas 형식을 보려면 그림?21 의 코드를 살펴보십시오.
이것을 쓸 때, CLR과 XML 형식 시스템 간의 매핑에서 취약한 측면들 중 하나가 대체와 상속성에 연결됩니다. 양 형식 시스템들은 각자의 파생, 대체 모델을 가지고 있습니다. 하지만, 일련화 엔진의 최신 구현이 항상 그 모델들을 합리적인 방식으로 처리할 수 있는 것은 아닙니다.
XML Schema 형식 시스템은 두 가지 대체 형태를 지원합니다. 하나는 xsi:type 특성을 사용하여 어떤 파생된 형식이 사용중임을 표시합니다. 이 형태는 XML 일련화 엔진에 의해 지원을 받습니다. 또 다른 형태는, 요소 대체 그룹들에 바탕을 두고 있는데, 해당 CLR 형태의 필드에 모든 허용하는 대체들의 리스트와 함께 주석을 달아야 하기 때문에 부분적으로만 지원될 뿐입니다.

---

배열

배열 형식의 필드/속성을 매핑할 때, System.Xml.Serialization 라이브러리는 항상 그 필드/혹성을 어떤 지역 요소 선언에 매핑합니다. 요소의 이름은 [XmlArray] 특성으로 제어됩니다. 마주친 각각의 배열 형식에 대해 minOccurs="0"과 maxOccurs="unbounded"라고 표시된 어떤 구성기를 포함하는 어떤 명명된 복합 형식이 생성됩니다. 그 구성기 속에는 해당 배열의 요소들에 부합하는 또 다른 지역 요소 선언이 상주합니다. 기본값으로, 이 내부 지역 요소 선언의 이름과 형식은 그 배열 요소들의 CLR 형식과 일치합니다. 사용자는 [XmlArrayItem] 특성을 이용하여 이 매핑을 제어할 수 있습니다. 사용자는 CLR 특성들을 적용하지 않은 채 다음과 같은 필드 선언을 고찰해야 합니다.

public Person [] people;

이것은 다음과 같은 XML Schema 형식을 함축할 수 있습니다.

<xsd:complexType name="ArrayOfPerson" >
  <xsd:sequence>
    <xsd:element name="Person" type="target:Person" 
                 minOccurs="0" maxOccurs="unbounded" 
                 nillable="true" />
  </xsd:sequence>
</xsd:complexType>

이런 형식에서, people 필드는 다음과 같은 지역 요소 선언에 매핑될 것입니다.

<xsd:element name="people" type="target:ArrayOfPerson" />

[XmlArray]와 [XmlArrayItem] 특성들로 요소 이름과 nillability를 제어할 수 있습니다.
요소 형식이 다형 형식인 배열들에 대해서, 사용자는 전형적으로 XML Schemas의 xsi:type 기능성에 의존할 수 있습니다. 좀더 색다른 사용법을 쓰려면, 사용자는 그림 22에 나와 있는 것처럼, [XmlArrayItem] 특성을 사용하여 poor-man의 요소 대체 그룹을 지정할 수 있습니다. 이 예에서, 생성된 스키마는 가장 안쪽의 구성기에 상이한 요소 이름/형식을 허용합니다 (그림?23).

<xsd:complexType name="Company" >
   <xsd:sequence>
    <xsd:element name="staff">
     <xsd:complexType>
      <xsd:sequence>
       <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element name="clerk" type="target:Clerk" /> 
        <xsd:element name="manager" type="target:Manager" /> 
       </xsd:choice>
      </xsd:sequence>
     </xsd:complexType>
    </xsd:element>
   </xsd:sequence>
</xsd:complexType>

그림 23 [XmlArrayItem] Example Output

---

사용자 지정 XmlSerializer

XmlSerializer 형식은 다양한 최적화/사용자 지정을 지원합니다. 특히, 사용자는 XmlSerializer 를 초기화할 때 [XmlType], [XmlElement]와 같은 일단의 사용자 지정 특성들을 공급할 수 있습니다. 이런 특성들은 해당 CLR 형식에 이미 적용되었을 수도 있는 어떤 특성이라도 재정의합니다. 이 기능의 가장 기본적인 효용은 그것으로 사용자가 the XML 일련화 엔진에 대해 알지 못하는 이미 존재하는 클래스들 위에 XML 일련화의 특성들을 삽입할 수 있다는 것입니다.
비일련화할 경우, XmlSerializer는 인식할 수 없는 특성, 요소, 문자 하위 항목, 처리 명령들을 무시합니다. 이것은 처리 명령의 경우를 제외한 나머지에 대해서, 그 deserializer가 스키마에서 유효하지 않은 입력 문서들을 적용할 것임을 의미합니다. 개발자가 이러한 동작을 사용자 지정할 수 있도록 허용하기 위해서, XmlSerializer 형식은 UnknownAttribute, UnknownElement, UnknownNode의 세 가지 이벤트를 지원합니다. UnknownAttribute와 UnknownElement는 해당 CLR 필드 또는 속성에 매핑되지 않은 입력 문서에서 어떤 특성이나 요소를 마주칠 때마다 발생합니다. UnknownNode는 해당 CLR 필드 또는 속성에 매핑되지 않은 입력 문서에서 어떤 하위 요소를 접할 때마다 발생합니다. 여기에는 처리 명령과 무시할 수 있는 공백도 포함되는데, 둘 중 어느 쪽도 스키마 유효성에는 영향을 끼치지 않습니다. 그림 24는 UnknownAttribute 이벤트를 사용하는 방법을 보여줍니다.

using System.Xml.Serialization

public static void OnAttribute(Object sender, 
                               XmlAttributeEventArgs args) {
    string localName = args.Attr.LocalName;
    string nsuri = args.Attr.NamespaceURI;
    string msg = String.Format(
                    "Unrecognized attribute {1}:{0} (line {2})", 
                    localName, nsuri,  args.LineNumber);
    throw new Exception(msg);
}

public static object ReadObject(XmlSerializer ser,
                                XmlReader reader) {
    ser.UnknownAttribute += 
                   new XmlAttributeEventHandler(OnAttribute);
    return ser.Deserialize(reader);
}

그림 24 UnknownAttribute Handler

마지막으로, 이름 공간 선언들은 일련화하는 도중, 필요할 경우 내보내 집니다. 이것은 만약 어떤 특정 이름 공간 RUI가 해당 출력 문서에서 여러 번 사용된다면, 몇 개의 중복된 이름 공간 선언이 존재할 것이라는 의미입니다. 이것으로 그 출력 문서는 상당히 장황하긴 하지만 정확하게 됩니다. 일련화할 때, 사용자는 Serialize 메서드에 이름 공간 선언들의 어떤 컬렉션을 전달할 수 있습니다. 이 컬렉션은 하위 요소들에서의 추가 선언들에 대한 요청을 약화시키면서 출력 문서들의 루트에 있는 이름 공간들을 미리 선언하는 데 사용될 수 있을 것입니다.
.NET은 이 칼럼에서 설명할 수 있는 것 보다 훨씬 많은 Schema 지원을 보유하고 있습니다. 앞으로 이야기 하고자 남겨둔 흥미진진한 단편에는 XmlValidatingReader를 통해 PSVI에서 얻을 수 있는 유효성, 스키마들, 그리고 데이터 액세스가 포함되어 있습니다.

Don에게 질문이나 의견을 보내주십시오. housews@microsoft.com.