C# XML Serialization

Bu makaleyi okumaya başlamadan önce C# Serialization ve DeSerialization makalemi okumanızı tavsiye ederim.

XML Serilization, bir sınıfın public özelliklerini yada bir metodun parametrelerini ve geri dönüş değerlerini XML stream içerisine serileştirir. XML serileştirme metod, indexer, private özellikler, read-only özellikleri (read-only koleksiyonlar hariç) içermez. Çünkü XML genel bir standart olduğundan, XML stream herhangi bir platform üzerindeki herhangi bir uygulama tarafından işlenebilmelidir. Örneğin ASP.NET Web Servisleri, servis iletişiminde verileri Internet ve Intranet üzerinden göndermek için XML serileştirme kullanarak XML stream’ler oluşturarak iletmektedir. Buna karşın ters-serileştirme işlemindede bu XML stream’ler alınarak nesne tekrar oluşturulmaktadır.

XML serileştirme ve ters-serileştirme işlemleri System.Xml.Serialization.XmlSerializer sınıfından faydalanılarak gerçekleştirilmektedir. Bu sınıfın en önemli metodları Serialize ve Deserialize‘dır.

Bir sınıf oluştururken, iki seçeneğimiz vardır ; birincisi C# yada herhangi bir .Net dili ile sınıfı kodlayarak oluşturmak, diğer seçeneğimiz ise XML Schema Definition Tool (xsd.exe) aracını kullanarak varolan bir şablona (XML Schema Definition) göre sınıf üretmek. Herhangi bir XSD tanımından üretilen bir sınıf instance’ı serileştirildiğinde, üretilen XML dosyası XML (Schema) şemanın yapısı ve kurallarına uygun bir haldedir. Böyle bir kullanımdada .Net Framework içerisindeki XmlReader ve XmlWriter gibi diğer alternatif sınıfları kullanabiliriz. Bu sınıflar XML stream’i parse etmemize olanak sağlamaktadırlar. Bununla birlikte bilinen bir XML (Schema) ile herhangi bir XML stream XmlSerialzer kullanılarak yapısal bütünlüğünü doğrulayabiliriz.

XmlSerialzer sınıfı kullanılarak üretilen XML stream üzerindeki XML namespace, element name, attribute name gibi daha bir çok farklı özelliği .Net içerisinde hali hazırda bulunan etiketler yardımıyla değiştirebilmektedir. XmlSerialzer sınıfı bir nesneyi serileştirmenin yanısıra SOAP formatında XML stream üretebilir. Bu özelliğin dışında ; SOAP mesajları üreterek XML Web Servislerine parametre olarak gönderebilir.

Serileştirilebilir Öğeler

Aşağıdaki öğeler XmlSerialzer kullanılarak serileştirilebilmektedir:

• Public read/write özellikleri.
• Public alanlar.
• ICollection yada IEnumerable ile genişletilmiş sınıflar.
• XmlElement nesneleri.
• XmlNode nesneleri.
• DataSet nesneleri.

XML serileştirme kullanmanın avantajları

XmlSerialzer serileştirilen nesneyi XML formatında serileştirerek geliştiriciye XML üzerinde bir çok manipülasyon olanağı verir. Örneğin :

• Herhangi bir alan yada bir özelliğin element olarak yada attribute olarak mı yazılacağını belirleyebilme.
• Hangi XML namespace’in kullanılacağını belirleyebilme.
• Belirlenen alan yada özelliğe verilen adın herhangi bir element yada attribute için uygun olup olmadığını belirleyebilme.

XML serileştirme kullanılacağı zaman değerlendirilmesi gereken hususlar

• Serileştirilen nesnenin tip kimliği ve assembly bilgisini içermez. Diğer bir deyişle XML serileştirme tip güvenirliğini devam ettirmez. Tip güvenirliğini kullanmak istediğiniz durumlarda binary serileştirme kullanmanız gerekir.
• Sadece public özellikler ve alanlar serileştirilir. Public olmayan verileri serileştirmek istiyorsanız binary serileştirme kullanmanız gerekir.
• XmlSerialzer sınıfı ile serileştirilecek bir sınıfın varsayılan yükleyicisi (constructor) olmalıdır.
• Metodlar serileştirilmez.
• XmlSerialzer sınıfı ICollection ve IEnumerable ile genişletilmiş sınıfları belirli gereklilikleri sağladığı zaman serileştirebilir.

XSD tip eşleme

XML Schema’nın içerdiği veri tipleri World Wide Web konsorsiyum(www.w3.org) tarafından belirlenmiştir. Bir çok basit veri tipinin örneğin int ve decimal vb. karşılığı olan farklı tipler (int32 vb.) .NetFramework içerisinde kullanılmaktadır. Fakat bazı XML veri tiplerinin .Net Framework içerisinde karşılığı bulunmamaktadır (NMTOKEN veri tipi vb.). Böyle bir durumda, herhangi bir XML Scheme’ya göre xsd.exe aracını kullanarak bir sınıf üretirseniz, karşılığı olmayan veri tipi yerine string bir özelliğe en uygun etiket uygulanarak DataType özelliğine XML veri tipinin adı verilir.

Örneğin XML Schema MyStr adında XML veri tipi NMTOKEN olan veri tipi içeriyorsa, xsd.exe aracı kullanarak üretilen sınıf özelliği aşağıdaki gibi olacaktır :

[XmlElement( DataType="NMTOKEN" )]
public string MyStr;

Benzer olarak yine, eğer bir sınıf oluşturuyorsanız belirli bir XML Schema ile veri bütünlüğünü kontrol etmelisiniz, bu sınıf içerisinde yukarıdaki gibi bir durumla karşılaşırsanız yine en uygun etiketi uygulayıp DataType özellikliğine ilgili XML veri tipi adını atamalısınız.

XML veri tipleri ile ilgili detaylı bilgilere aşağıdaki linklerdende ulaşabilirsiniz :

XML Schema Patterns for Common Data Structures
Data Type Mappings in Native XML Web Services

XML Serileştirme Örnekleri

Aşağıdaki örnekte basit bir sınıfın nasıl serileştirileceği anlatılmaktadır. Şunu unutmamak gerekir ki XML serileştirilecek nesnenin varsayılan yükleyicisi (constructor) olmak zorundadır.

private void btnBasicSerialization_Click(object sender, EventArgs e)
{
    XMLSerializeMyObject();
    XMLDeSerializeMyObject(); 
}

// Basit bir serileştirilecek sınıf.
[Serializable()]
public class MyClass
{
    public string strPublic;
    public MyClass()
    {
        strPublic = "Public Veri";
    }
}

private void XMLSerializeMyObject()
{
    // Serileştirilecek nesne oluşturuluyor.
    MyClass ob = new MyClass();

    // Serileştirilmiş nesneyi taşıyacak stream oluşturuluyor.
    Stream stream = new FileStream("BasicSerialization.xml", FileMode.Create, FileAccess.Write, FileShare.Write);

    // Nesne serileştirilecek kaydedilecek stream'e yazılıyor.
    XmlSerializer xmlserializer = new XmlSerializer(typeof(MyClass));
    xmlserializer.Serialize(stream, ob);

    // Stream kapatılıyor.
    stream.Close();
}

private void XMLDeSerializeMyObject()
{
    // Read the file back into a stream
    Stream stream = new FileStream("BasicSerialization.xml", FileMode.Open, FileAccess.Read, FileShare.Read);

    // Serileştirilmiş nesneyi ters-serileştirme için XmlSerializer oluşturuluyor.
    XmlSerializer xmlserializer = new XmlSerializer(typeof(MyClass));

    // Nesne ters-serileştirilip okunuyor.
    MyClass ob = (MyClass)xmlserializer.Deserialize(stream);

    // Stream kapatılıyor.
    stream.Close();
}

Böyle bir serileştirme işleminin sonucunda oluşan XML dosyası aşağıdaki gibi olacaktır.

<?xml version="1.0"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <strPublic>Public Veri</strPublic>
</MyClass>

DataSet Serileştirme

Aşağıdaki örnekte bir DataSet’in nasıl serileştirileceği örneklenmektedir :

private void btnDataSetSerialization_Click(object sender, EventArgs e)
{
    // DataSet oluşturuluyor.
    DataSet ds = new DataSet("MyDataSet");
    DataTable dt = new DataTable("MyDataTable");
    DataColumn dc1 = new DataColumn("ID", typeof(int));
    DataColumn dc2 = new DataColumn("Name", typeof(string));

    dt.Columns.Add(dc1);
    dt.Columns.Add(dc2);
    ds.Tables.Add(dt);

    // Bazı örnek kayıtlar ekleniyor.
    for (int i = 0; i < 3; i++)
    {
        DataRow row = dt.NewRow();
        row[0] = i;
        row[1] = i.ToString();
        dt.Rows.Add(row);
    }

    // DataSet Serileştiriliyor.
    XmlSerializer serializer = new XmlSerializer(typeof(DataSet));
    Stream stream = new FileStream("DataSetSerialization.xml", FileMode.CreateNew);
    serializer.Serialize(stream, ds);

    // Stream kapatılıyor.
    stream.Close();
}

Bu işlem sonrasında oluşan DataSetSerialization.xml dosyasınında içeriği aşağıdaki gibidir :

<?xml version="1.0"?>
<DataSet>
  <xs:schema id="MyDataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xs:element name="MyDataSet" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
      <xs:complexType>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="MyDataTable">
            <xs:complexType>
              <xs:sequence>
                <xs:element name="ID" type="xs:int" minOccurs="0" />
                <xs:element name="Name" type="xs:string" minOccurs="0" />
              </xs:sequence>
            </xs:complexType>
          </xs:element>
        </xs:choice>
      </xs:complexType>
    </xs:element>
  </xs:schema>
  <diffgr:diffgram xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" xmlns:diffgr="urn:schemas-microsoft-com:xml-diffgram-v1">
    <MyDataSet>
      <MyDataTable diffgr:id="MyDataTable1" msdata:rowOrder="0" diffgr:hasChanges="inserted">
        <ID>0</ID>
        <Name>0</Name>
      </MyDataTable>
      <MyDataTable diffgr:id="MyDataTable2" msdata:rowOrder="1" diffgr:hasChanges="inserted">
        <ID>1</ID>
        <Name>1</Name>
      </MyDataTable>
      <MyDataTable diffgr:id="MyDataTable3" msdata:rowOrder="2" diffgr:hasChanges="inserted">
        <ID>2</ID>
        <Name>2</Name>
      </MyDataTable>
    </MyDataSet>
  </diffgr:diffgram>
</DataSet>

Karmaşık Nesneleri Serileştirme

Serileştirilecek nesnenin bir özelliği yada alanı karmaşık bir nesneyi referans ediyorsa (başka bir sınıf yada liste vb.), XmlSerializer bu durumda oluşturacağı XML dosyası içerisinde yeni bir iç element oluşturarak referans nesnenin değerlerini ekler. Aşağıdaki örnekte böyle bir durumun nasıl oluşturulup düzenlendiğini gözlemleyelim :

[Serializable]
public class Item
{
    public string strProductName;
    public int nProductID;

    public Item()
    {
        strProductName = "";
        nProductID = 0;
    }
    public Item(string s, int n)
    {
        strProductName = s;
        nProductID = n;
    }
}

[Serializable]
public class Order
{
    // Serileştirilecek nesne karmaşık bir nesneye referans için referans edilen 
    // nesne serileştirilirken element olarak kullanılacağı belirtilmelidir.
    // Bu konu ile ilgili daha detaylı olarak aşağıdaki konu başlığında bulabilirsiniz;
    // XML Serileştirmeyi Etiket Kullanarak Kontrol Etmek

    [XmlElement(typeof(Item))]
    public List<Item> alOrders;

    public Order()
    {
        alOrders = new List<Item>();
    }

    [XmlInclude(typeof(Item))]
    public void Add(Item i)
    {
        alOrders.Add(i);
    }
}

private void btnComplexSerialization_Click(object sender, EventArgs e)
{
    Stream stream = null;
    try
    {
        // Serileştirilecek nesne ve referans ettiği diğer nesne oluşturuluyor.
        Order order = new Order();
        order.Add(new Item("Elma", 10));
        order.Add(new Item("Portakal", 20));
        order.Add(new Item("Çilek", 30));

        // Nesne serileştiriliyor.
        XmlSerializer serializer = new XmlSerializer(typeof(Order));
        stream = new FileStream("ComplexSerialization.xml", FileMode.Create);
        serializer.Serialize(stream, order);
        stream.Close();
    }
    catch (Exception ex)
    {
        stream.Close();
    }
}

Bu işlem sonrasında oluşan ComplexSerialization.xml dosyasınında içeriği aşağıdaki gibidir :

<?xml version="1.0"?>
<Order xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <alOrders>
    <strProductName>Elma</strProductName>
    <nProductID>10</nProductID>
  </alOrders>
  <alOrders>
    <strProductName>Portakal</strProductName>
    <nProductID>20</nProductID>
  </alOrders>
  <alOrders>
    <strProductName>Çilek</strProductName>
    <nProductID>30</nProductID>
  </alOrders>
</Order>

XML Schema Definition Tool

XML Schema definition tool (xsd.exe) .NET Framework’ün bir parçasıdır ve .Net Framework ile birlikte yüklenmektedir. Bu araç iki ana amaç için kullanılmaktadır :

1-) Belirli XML Schema’ya bağlı olarak C# yada VB.NET sınıfları üretmek için kullanılır. Böyle bir kullanımda (xsd.exe) aracı .xsd uzantılı bir şema dosyasını parametre kullanarak, XmlSerializer ile belirli bir anda serileştirilmiş olan xml dosyasında bulunan nesne bilgilerine göre nesne sınıflarını tekrar üretir.

xsd.exe MySchema.xsd

2-) DLL yada EXE’den XML Schema üretmek için kullanılır.

xsd.exe MyFile.dll

XML Serileştirmeyi Etiket Kullanarak Kontrol Etmek

XML (Attributes) etiketleri XML serileştirimede bazı özel durumlarda kullanılmaktadır ;

Bir nesneyi XML olarak serileştirirken kontrol etmek yada aynı tipteki sınıflardan altarnatif bir XML stream oluşturmak için kullanılmaktadır. Örneğin varsayılan olarak XML element adı sınıf yada özellik adına göre belirlenir. Örneğin Customer sınıfımızda Name adında public bir alanımızın olduğunu düşünelim buna bağlı olarak üretilecek XML element tag adı Name olacaktır :

public Customer
{
    public string Name;
    ...
}

<!-- Bu sınıfın instance'ı serileştirildiğinde, aşağıdaki gibi bir stream üretecektir.-->
<Name>Bora</Name> 

Bu varsayılan davranış belkide element adı için uygun bir isim üretemeyecek. Bu durumda XmlElementAttribute sayesinde serileştirilen streem içerinse element adını değiştirmemize imkan sağlamaktadır :

public class Customer
{
    [XmlElement(ElementName = "Customer Name")]
    public string strName;
}

Yukarıdaki gibi bir işlem sonrasında aşağıdaki gibi değişen element adını gözlemleyebiliriz.

<?xml version="1.0"?>
<Customer xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Customer_x0020_Name>Bora</Customer_x0020_Name>
</Customer>

Yazının devam eden diğer bölümlerinde diğer XML etiketleri ile serileştirme işlemini nasıl kontrol edebileceğimizi anlatmaya çalışacağım.

Türetilen Sınıfları Serileştirmek

XmlArrayItemAttribute etiketinin diğer bir kullanım alanıda birbirinden türeyen sınıfların serileştirilmesine yardımcı olmaktır.

Aşağıdaki örnek kodda, Manager sınıfının Employee sınıfından türediğini ve Company sınıfının içerisindede, Employee yada Manager nesneleri içeren bir array olduğunu gözlemleyelim. Employee dizisi Employee veya Manager tipinde nesneleri içeriyorsa çalışma zamanında hata alınır. Çünkü XmlSerializer Manager yada Employee tipi ile karşılatığında ne yapacağını bilemez. Böyle bir durumda XmlArrayItemAttribute farklı bu durumda hani nesnenin hangi tip olarak serileştireceğini belirterek istenmeyen bir durum oluşmasını engellemiş oluyor :

public class Company
{
    [XmlArrayItem(typeof(Employee)]
    [XmlArrayItem(typeof(Manager)]
    public Employee[] Employees;
}

public class Employee
{
    public string name;
}

public class Manager :Employee
{
    public string DepartmentName;
}

List ve Array Serileştirmek

List ve array serileştirme işlemi XmlArrayAttribute ve XmlArrayItemAttribute etiketleri ile kontrol edilmektedir. Bu etiketleri kullanarak element adı, namespace ve XSD veri tiplerini manipüle edebiliriz. XmlArrayAttribute etiketi ile bir array yada liste serileştirildiğinde en üst element adının ne olacağı belirlenip değiştirilebilir.XmlArrayItemAttribute etiketi ilede array yada list elemanlarının her biri için kullanılacak element adını belirlemek için kullanılır. Örnek olarak aşağıdaki array’i serileştirildiğinde ne gibi bir çıktı alacağımızı gözlemleyelim :

public class Company
{
    public Employee[] Employees;
}
public class Employee
{
    public string name;
}

<Group>
    <Employees>
        <Employee>
            <name>Bora</name>
            <name>Fuat</name>
            ...
        </Employee>
    </Employees>
</Group>

XmlArrayAttribute ve XmlArrayItemAttribute etiketleri ile yaptığımız değişiklik sayasinde oluşan XML’i nasıl manipüle ettiğimizi gözlemleyelim :

public class Company
{
    [XmlArray("SoftwareDevelopers")]
    [XmlArrayItem("Developer")]
    public Employee[] Employees;
}
public class Employee
{
    public string name;
}

<Group>
    <SoftwareDevelopers>
        <Developer>Bora</Developer>
        <Developer>Fuat</Developer>
         ...
    </SoftwareDevelopers>
</Group>

Serileştirmeyi Engellemek

Serileştirilmesini istemediğiniz public alan ve özelliklere XmlIgnoreAttribute etiketini uygulayarak serileştirilmemesini sağlayabilirsiniz.

XML Serileştirmeyi Ezmek

XmlSerializer kullanarak aynı sınıfı bir yada birden fazla XML stream üreterek serileştirebilirsiniz. Böyle bir kullanıma farklı iki yada daha fazla formatta XML stream’e ihtiyaç duyan Web Servisi kullanıcıları ile karşılaştığınızda yaşayabilirsiniz.

Aynı sınıf için farklı XML stream’ler oluşturmak için XmlSerializer sınıfının yükleyicisi (constructor)’nden faydalanılır.

public XmlSerializer( Type type, XmlAttributeOverrides overrides );

Bir nesneyi serileştirirken yada ters-serileştirirken XmlAttributeOverrides tipini kullanarak serileştirilen nesnenin özelliklerini, alanlarını yada sınıf etiketlerini ezilebilirsiniz.

XmlAttributeOverrides ezilen nesne tiplerinin listesinin içeririr ve bu sınıfı kullanarak yaptığınız işlemler XmlAttributes ile manipüle etmiş olduğunuz tipleride ezmektedir.

Bu başlık ile ilgili ilgili daha çok bilgiye ve örneğe ulaşabileceğinizXmlAttributeOverrides Class msdn yazısını inceleyebilirsiniz.

XML Namespace’ler ile çalışmak

XML namespace’ler XML belge içerisinde bulunan element ve attribute adlarını kısıtlayabileceğimiz metod içermektedir. Bu sayede XML belge içerisinde aynı element ve attribute adlarını tekrar edecek şekilde kullanabilir ve birbirinden ayırabiliriz. Bu kısıt ile beraber bir ön ek (prefix) ve namespace tanımı (XYZ:ABC gibi) yapılması gerekmektedir. Bu ön eki (prefix) yer tutucu gibi düşünebiliriz (alias vb.), bu ön ek sonrasında belirttiğiniz namespace URI si ile eşlenip XML dosyaya yazılacaktır. XML namespace’ler XmlSerializerNamespaces instance’ı içerisinde yer almaktadır.

Bu şekilde namespace’leri belirtilerek XML dosya oluşturmak için aşağıdaki adımları takip edip örnek kodlarda nasıl uygulandığını gözlemleyelim:

1-) Belirlediğiniz ön ek (prefix) ve namespace bilgileri verilerek XmlSerializerNamespaces sınıfının instance’ı oluşturulur.
2-) Serileştirilecek sınıflara uygun XML serileştirme etiketleri uygulayarak etiketlerin Namespace özelliğini belirlediğiniz namespace bilgisi ile değer ataması yapılır.
3-) XmlSerializer.Serialize() metodunda serileştirme işlemine XmlSerializerNamespaces nesneside parametre olarak eklenir.

private void btnWorkingWithXmlNamespaces_Click(object sender, EventArgs e)
{
    // Kitap tanımlayalım.
    Book book1 = new Book();
    Price price1 = new Price();
    price1.currency = "TL";
    price1.price = 49.99M;            
    book1.Title = "İleri C#";
    book1.price = price1;

    // Başka bir kitap daha tanımlayalım.
    Book book2 = new Book();
    Price price2 = new Price();
    price2.currency = "USD";
    price2.price = 39.99M;            
    book2.Title = "MS SQL Server 2012";
    book2.price = price2;

    // Kitap listesine kitapları ekleyelim.
    Books books = new Books();
    books.alBooks.Add(book1);
    books.alBooks.Add(book2);

    /* XML namespace ve prefix tanımlayalım. */
    XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
    namespaces.Add("KC", "www.kazimcesur.com");

    /* XML dosyaya serileştirelim. */
    Stream stream = new FileStream("Namespaces.xml", FileMode.Create, FileAccess.Write, FileShare.Write);
    XmlSerializer serializer = new XmlSerializer(typeof(Books));
    serializer.Serialize(stream, books, namespaces);
    stream.Close();
}

public class Price
{
    // currency etiket ile verilen namespace'le serileştirilsin.
    [XmlAttribute(Namespace = "www.kazimcesur.com")]
    public string currency;

    // price etiket ile verilen namespace'le serileştirilsin.
    [XmlAttribute(Namespace = "www.kazimcesur.com")]
    public decimal price;
}

public class Book
{
    // Title etiket ile verilen namespace'le serileştirilsin.
    [XmlElement(Namespace = "www.kazimcesur.com")]
    public string Title;

    // price etiket ile verilen namespace'le serileştirilsin.
    [XmlElement(Namespace = "www.kazimcesur.com")]
    public Price price;
}

public class Books
{
    // alBooks etiket ile verilen namespace'le serileştirilsin.
    [XmlElement(typeof(Book), Namespace = "www.kazimcesur.com")]
    public List<Book> alBooks = new List<Book>();
}

Yukarıdaki kodu çalıştırdığımızda oluşan xml dosyanın içeriği aşağıdaki gibi olacaktır.

<?xml version="1.0"?>
<Books xmlns:KC="www.kazimcesur.com">
  <KC:alBooks>
    <KC:Title>İleri C#</KC:Title>
    <KC:price currency="TL" price="49.99" />
  </KC:alBooks>
  <KC:alBooks>
    <KC:Title>MS SQL Server 2012</KC:Title>
    <KC:price currency="USD" price="39.99" />
  </KC:alBooks>
</Books>

XML Web Servisleri ile XML Serileştirme

XML Web Servisleri iletişim mekanizmasının temelinde XML Serileştirme kullanılmaktadır. Bu serileştirme işlemi XmlSerializer sınıfı ile gerçekleştirilmektedir. XML Web Servisleri ile üretilen XML dosyaları kontrol etmek için, serileştirilecek sınıflara, geri dönüş değerlerine, parametrelere ve Web Servislerinin kullandığı kod dosyalarına (.asmx) ilgili etiketler uygulanmalıdır (Yaptığımız örneklerdeki gibi).

Herhangi bir XML Web Servisi ile üretilen XML dosyası iki şekilde biçimlendirilebilmektedir : literal yada encoded. Bu nedenle XML Serileştirme yaparken uygulanacak etiketler aşağıdaki gibi iki başlık altında toplanabilir :

SOAP Serileştirmede encode edilirken kullanılabilecek etiketler ;

• SoapAttributeAttribute
• SoapElementAttribute
• SoapEnumAttribute
• …

XML Serileştirmede encode edilirken kullanılabilecek etiketler ;

• XmlAttributeAttribute
• XmlElementAttribute
• XmlEnumAttribute
• …

Seçime bağlı olarak uygulanabilecek bu etiketler sayesinde uygulamanız herhangi birini yada iki türüde destekleyen değerleri döndürebilmektedir.

Kaynak ;
Introducing XML Serialization
XML Serialization in the .NET Framework