XmlElementAttribute 建構函式

參考

定義

命名空間:: System.Xml.Serialization

組件:: System.Xml.XmlSerializer.dll

組件:: System.Xml.ReaderWriter.dll

組件:: System.Xml.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

初始化 XmlElementAttribute 類別的新執行個體。

多載

XmlElementAttribute()	初始化 XmlElementAttribute 類別的新執行個體。
XmlElementAttribute(String)	初始化 XmlElementAttribute 類別的新執行個體，並且指定 XML 項目的名稱。
XmlElementAttribute(Type)	初始化 XmlElementAttribute 類別的新執行個體，並針對套用 XmlElementAttribute 的成員指定型別。序列化或還原序列化包含這個型別的物件時，XmlSerializer 會使用該型別。
XmlElementAttribute(String, Type)	初始化 XmlElementAttribute 的新執行個體，並針對套用 XmlElementAttribute 的成員指定 XML 項目名稱和衍生型別。這個成員型別用於 XmlSerializer 序列化包含它的物件時。

XmlElementAttribute()

初始化 XmlElementAttribute 類別的新執行個體。

public:
 XmlElementAttribute();

public XmlElementAttribute ();

Public Sub New ()

範例

下列範例會將套 XmlElementAttribute 用至類別。

public ref class MyClass
{
public:

   [XmlElement]
   String^ TeacherName;
};

public class MyClass
{
   [XmlElement()]
   public string TeacherName;
}

Public Class MyClass1
    <XmlElement()> Public TeacherName As String
End Class

適用於

XmlElementAttribute(String)

初始化 XmlElementAttribute 類別的新執行個體，並且指定 XML 項目的名稱。

public:
 XmlElementAttribute(System::String ^ elementName);

public XmlElementAttribute (string elementName);

public XmlElementAttribute (string? elementName);

new System.Xml.Serialization.XmlElementAttribute : string -> System.Xml.Serialization.XmlElementAttribute

Public Sub New (elementName As String)

參數

elementName: String

序列成員的 XML 項目名稱。

範例

下列範例顯示包含名為的單一欄位的 Vehicles 簡單類別。此範例會將 XmlElementAttribute 套用至欄位，並包含 elementName 參數，藉此指示 XmlSerializer 產生名為「Cars」而非「Vehicles」的 XML 元素。

public ref class Transportation
{
public:

   [XmlElement("Cars")]
   String^ Vehicles;
};

public class Transportation
{
   [XmlElement("Cars")]
   public string Vehicles;
}

Public Class Transportation
    <XmlElement("Cars")> Public Vehicles As String
End Class

備註

根據預設，在 XmlSerializer 序列化類別實例時，會使用成員名稱做為 XML 專案名稱。例如，名為 Vehicle 的欄位會產生名為的 Vehicle XML 專案。不過，如果您需要不同的元素，例如 Cars ，請將它 elementName 傳入參數。

適用於

XmlElementAttribute(Type)

初始化 XmlElementAttribute 類別的新執行個體，並針對套用 XmlElementAttribute 的成員指定型別。序列化或還原序列化包含這個型別的物件時，XmlSerializer 會使用該型別。

public:
 XmlElementAttribute(Type ^ type);

public XmlElementAttribute (Type type);

public XmlElementAttribute (Type? type);

new System.Xml.Serialization.XmlElementAttribute : Type -> System.Xml.Serialization.XmlElementAttribute

Public Sub New (type As Type)

參數

type: Type

衍生自成員型別的物件 Type。

範例

下列範例會序列化名為 Orchestra 的類別，其中包含名為 Instruments 的單一欄位，它會傳回物件的陣列 Instrument 。名為 Brass 的第二個類別繼承自 Instrument 類別。此範例會將 XmlElementAttribute 套用至 Instruments 欄位，並指定 Brass 類型，讓 Instruments 欄位接受 Brass 物件。此範例也會藉由設定 ElementName 屬性來指定 XML 專案的名稱。

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

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

public ref class Brass: public Instrument
{
public:
   bool IsValved;
};

public ref class Orchestra
{
public:
   array<Instrument^>^Instruments;
};

void SerializeObject( String^ filename )
{
   // To write the file, a TextWriter is required.
   TextWriter^ writer = gcnew StreamWriter( filename );
   XmlAttributeOverrides^ attrOverrides = gcnew XmlAttributeOverrides;
   XmlAttributes^ attrs = gcnew XmlAttributes;

   // Creates an XmlElementAttribute that overrides the Instrument type.
   XmlElementAttribute^ attr = gcnew XmlElementAttribute( Brass::typeid );
   attr->ElementName = "Brass";

   // Adds the element to the collection of elements.
   attrs->XmlElements->Add( attr );
   attrOverrides->Add( Orchestra::typeid, "Instruments", attrs );

   // Creates the XmlSerializer using the XmlAttributeOverrides.
   XmlSerializer^ s = gcnew XmlSerializer( Orchestra::typeid,attrOverrides );

   // Creates the object to serialize.
   Orchestra^ band = gcnew Orchestra;

   // Creates an object of the derived type.
   Brass^ i = gcnew Brass;
   i->Name = "Trumpet";
   i->IsValved = true;
   array<Instrument^>^myInstruments = {i};
   band->Instruments = myInstruments;
   s->Serialize( writer, band );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   XmlAttributeOverrides^ attrOverrides = gcnew XmlAttributeOverrides;
   XmlAttributes^ attrs = gcnew XmlAttributes;

   // Creates an XmlElementAttribute that override the Instrument type.
   XmlElementAttribute^ attr = gcnew XmlElementAttribute( Brass::typeid );
   attr->ElementName = "Brass";

   // Adds the element to the collection of elements.
   attrs->XmlElements->Add( attr );
   attrOverrides->Add( Orchestra::typeid, "Instruments", attrs );

   // Creates the XmlSerializer using the XmlAttributeOverrides.
   XmlSerializer^ s = gcnew XmlSerializer( Orchestra::typeid,attrOverrides );
   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
   Orchestra^ band = dynamic_cast<Orchestra^>(s->Deserialize( fs ));
   Console::WriteLine( "Brass:" );

   /* Deserializing differs from serializing. To read the 
      derived-object values, declare an object of the derived 
      type (Brass) and cast the Instrument instance to it. */
   Brass^ b;
   System::Collections::IEnumerator^ myEnum = band->Instruments->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Instrument^ i = safe_cast<Instrument^>(myEnum->Current);
      b = dynamic_cast<Brass^>(i);
      Console::WriteLine( "{0}\n{1}", b->Name, b->IsValved );
   }
}

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

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

public class Orchestra
{
   public Instrument[] Instruments;
}

public class Instrument
{
   public string Name;
}

public class Brass:Instrument{
   public bool IsValved;
}

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

    public void SerializeObject(string filename)
    {
      // To write the file, a TextWriter is required.
      TextWriter writer = new StreamWriter(filename);

      XmlAttributeOverrides attrOverrides =
         new XmlAttributeOverrides();
      XmlAttributes attrs = new XmlAttributes();

      // Creates an XmlElementAttribute that overrides the Instrument type.
      XmlElementAttribute attr = new
      XmlElementAttribute(typeof(Brass));
      attr.ElementName = "Brass";

      // Adds the element to the collection of elements.
      attrs.XmlElements.Add(attr);
      attrOverrides.Add(typeof(Orchestra), "Instruments", attrs);

      // Creates the XmlSerializer using the XmlAttributeOverrides.
      XmlSerializer s =
      new XmlSerializer(typeof(Orchestra), attrOverrides);

      // Creates the object to serialize.
      Orchestra band = new Orchestra();

      // Creates an object of the derived type.
      Brass i = new Brass();
      i.Name = "Trumpet";
      i.IsValved = true;
      Instrument[] myInstruments = {i};
      band.Instruments = myInstruments;
      s.Serialize(writer,band);
      writer.Close();
   }

   public void DeserializeObject(string filename)
   {
      XmlAttributeOverrides attrOverrides =
         new XmlAttributeOverrides();
      XmlAttributes attrs = new XmlAttributes();

      // Creates an XmlElementAttribute that override the Instrument type.
      XmlElementAttribute attr = new
      XmlElementAttribute(typeof(Brass));
      attr.ElementName = "Brass";

      // Adds the element to the collection of elements.
      attrs.XmlElements.Add(attr);
      attrOverrides.Add(typeof(Orchestra), "Instruments", attrs);

      // Creates the XmlSerializer using the XmlAttributeOverrides.
      XmlSerializer s =
      new XmlSerializer(typeof(Orchestra), attrOverrides);

      FileStream fs = new FileStream(filename, FileMode.Open);
      Orchestra band = (Orchestra) s.Deserialize(fs);
      Console.WriteLine("Brass:");

      /* Deserializing differs from serializing. To read the
         derived-object values, declare an object of the derived
         type (Brass) and cast the Instrument instance to it. */
      Brass b;
      foreach(Instrument i in band.Instruments)
      {
         b= (Brass)i;
         Console.WriteLine(
         b.Name + "\n" +
         b.IsValved);
      }
   }
}

Option Strict
Option Explicit

Imports System.IO
Imports System.Xml.Serialization

Public Class Orchestra
    Public Instruments() As Instrument
End Class

Public Class Instrument
    Public Name As String
End Class

Public Class Brass
    Inherits Instrument
    Public IsValved As Boolean
End Class

Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeObject("Override.xml")
        test.DeserializeObject("Override.xml")
    End Sub
    
    
    Public Sub SerializeObject(filename As String)
        ' To write the file, a TextWriter is required.
        Dim writer As New StreamWriter(filename)
        
        Dim attrOverrides As New XmlAttributeOverrides()
        Dim attrs As New XmlAttributes()
        
        ' Creates an XmlElementAttribute that overrides the Instrument type.
        Dim attr As New XmlElementAttribute(GetType(Brass))
        attr.ElementName = "Brass"
        
        ' Adds the element to the collection of elements.
        attrs.XmlElements.Add(attr)
        attrOverrides.Add(GetType(Orchestra), "Instruments", attrs)
        
        ' Creates the XmlSerializer using the XmlAttributeOverrides.
        Dim s As New XmlSerializer(GetType(Orchestra), attrOverrides)
        
        ' Creates the object to serialize.
        Dim band As New Orchestra()
        
        ' Creates an object of the derived type.
        Dim i As New Brass()
        i.Name = "Trumpet"
        i.IsValved = True
        Dim myInstruments() As Instrument = {i}
        band.Instruments = myInstruments
        s.Serialize(writer, band)
        writer.Close()
    End Sub
    
    
    Public Sub DeserializeObject(filename As String)
        Dim attrOverrides As New XmlAttributeOverrides()
        Dim attrs As New XmlAttributes()
        
        ' Create an XmlElementAttribute that override the Instrument type.
        Dim attr As New XmlElementAttribute(GetType(Brass))
        attr.ElementName = "Brass"
        
        ' Add the element to the collection of elements.
        attrs.XmlElements.Add(attr)
        attrOverrides.Add(GetType(Orchestra), "Instruments", attrs)
        
        ' Create the XmlSerializer using the XmlAttributeOverrides.
        Dim s As New XmlSerializer(GetType(Orchestra), attrOverrides)
        
        Dim fs As New FileStream(filename, FileMode.Open)
        Dim band As Orchestra = CType(s.Deserialize(fs), Orchestra)
        Console.WriteLine("Brass:")
        
        ' Deserializing differs from serializing. To read the
        ' derived-object values, declare an object of the derived
        ' type (Brass) and cast the Instrument instance to it. 
        Dim b As Brass
        Dim i As Instrument
        For Each i In  band.Instruments
            b = CType(i, Brass)
            Console.WriteLine((b.Name + ControlChars.Cr + b.IsValved.ToString()))
        Next i
    End Sub
End Class

備註

type使用參數來指定衍生自基類的類型。例如，假設名為 MyAnimal 的屬性會 Animal 傳回物件。您想要增強物件，因此您可以建立名為 Mammal 的新類別，該類別繼承自 Animal 類別。若要指示 XmlSerializer 在序列化 MyAnimal 屬性時接受 Mammal 類別，請將類別的 Mammal 傳遞 Type 至建構函式。

適用於

XmlElementAttribute(String, Type)

初始化 XmlElementAttribute 的新執行個體，並針對套用 XmlElementAttribute 的成員指定 XML 項目名稱和衍生型別。這個成員型別用於 XmlSerializer 序列化包含它的物件時。

public:
 XmlElementAttribute(System::String ^ elementName, Type ^ type);

public XmlElementAttribute (string elementName, Type type);

public XmlElementAttribute (string? elementName, Type? type);

new System.Xml.Serialization.XmlElementAttribute : string * Type -> System.Xml.Serialization.XmlElementAttribute

Public Sub New (elementName As String, type As Type)

參數

elementName: String