XmlAttributes.XmlEnum プロパティとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

XmlAttributes.XmlEnum プロパティ

XmlSerializer が列挙体メンバをシリアル化する方法を指定するオブジェクトを取得または指定します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Property XmlEnum As
 XmlEnumAttribute

Visual Basic (使用法)

Dim instance As XmlAttributes
Dim value As XmlEnumAttribute

value = instance.XmlEnum

instance.XmlEnum = value

public XmlEnumAttribute XmlEnum { get; set;
 }

C++

public:
property XmlEnumAttribute^ XmlEnum {
    XmlEnumAttribute^ get ();
    void set (XmlEnumAttribute^ value);
}

/** @property */
public XmlEnumAttribute get_XmlEnum ()

/** @property */
public void set_XmlEnum (XmlEnumAttribute value)

JScript

public function get XmlEnum
 () : XmlEnumAttribute

public function set XmlEnum
 (value : XmlEnumAttribute)

プロパティ値
XmlSerializer が列挙体メンバをシリアル化する方法を指定する XmlEnumAttribute。

解説

オーバーライドする各識別子について、XmlAttributes オブジェクトを作成し、XmlEnum プロパティを、識別子をオーバーライドする XmlEnumAttribute に設定する必要があります。XmlAttributes オブジェクトを XmlAttributeOverrides オブジェクトに追加し、列挙体を保持しているクラスの Type とオーバーライドされたメンバ名の両方を指定します。

使用例

Food と FoodType という名前の 2 つのクラスをシリアル化する例を次に示します。FoodType クラスには、オーバーライドされた 2 つの列挙体が含まれています。この例では、それぞれの列挙体について XmlEnumAttribute オブジェクトが作成され、そのオブジェクトが XmlAttributes オブジェクトの XmlEnum プロパティに割り当てられます。次に、XmlAttributes オブジェクトを XmlAttributeOverrides オブジェクトに追加し、これを使用して XmlSerializer を作成します。

Visual Basic

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


' This is the class that will be serialized.
Public Class Food
    Public Type As FoodType
End Class

Public Enum FoodType
    ' Subsequent code overrides these enumerations.
    Low
    High
End Enum


Public Class Run
    
    Public Shared Sub Main()
        Dim test As New
 Run()
        test.SerializeObject("OverrideEnum.xml")
        test.DeserializeObject("OverrideEnum.xml")
    End Sub
    
    
    ' Return an XmlSerializer used for overriding. 
    Public Function CreateOverrider() As
 XmlSerializer
        ' Create the XmlAttributeOverrides and XmlAttributes objects.
        Dim xOver As New
 XmlAttributeOverrides()
        Dim xAttrs As New
 XmlAttributes()
        
        ' Add an XmlEnumAttribute for the FoodType.Low enumeration.
        Dim xEnum As New
 XmlEnumAttribute()
        xEnum.Name = "Cold"
        xAttrs.XmlEnum = xEnum
        xOver.Add(GetType(FoodType), "Low",
 xAttrs)
        
        ' Add an XmlEnumAttribute for the FoodType.High enumeration.
        xAttrs = New XmlAttributes()
        xEnum = New XmlEnumAttribute()
        xEnum.Name = "Hot"
        xAttrs.XmlEnum = xEnum
        xOver.Add(GetType(FoodType), "High",
 xAttrs)
        
        ' Create the XmlSerializer, and return it.
        Return New XmlSerializer(GetType(Food),
 xOver)
    End Function
    
        
    Public Sub SerializeObject(ByVal
 filename As String)
        ' Create an instance of the XmlSerializer class.
        Dim mySerializer As XmlSerializer =
 CreateOverrider()
        ' Writing the file requires a TextWriter.
        Dim writer As New
 StreamWriter(filename)
        
        ' Create an instance of the class that will be serialized.
        Dim myFood As New
 Food()
        
        ' Set the object properties.
        myFood.Type = FoodType.High
        
        ' Serialize the class, and close the TextWriter.
        mySerializer.Serialize(writer, myFood)
        writer.Close()
    End Sub
    
    
    Public Sub DeserializeObject(ByVal
 filename As String)
        Dim mySerializer As XmlSerializer =
 CreateOverrider()
        Dim fs As New FileStream(filename,
 FileMode.Open)
        Dim myFood As Food = CType(mySerializer.Deserialize(fs),
 Food)
        
        Console.WriteLine(myFood.Type)
    End Sub
End Class

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

// This is the class that will be serialized.
public class Food
{
   public FoodType Type;
}

public enum FoodType
{
   // Subsequent code overrides these enumerations.
   Low,
   High
}


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

   // Return an XmlSerializer used for overriding. 
   public XmlSerializer CreateOverrider()
   {
      // Create the XmlAttributeOverrides and XmlAttributes objects.
      XmlAttributeOverrides xOver = new XmlAttributeOverrides();
      XmlAttributes xAttrs = new XmlAttributes();

      // Add an XmlEnumAttribute for the FoodType.Low enumeration.
      XmlEnumAttribute xEnum = new XmlEnumAttribute();
      xEnum.Name = "Cold";
      xAttrs.XmlEnum = xEnum;
      xOver.Add(typeof(FoodType), "Low", xAttrs);

      // Add an XmlEnumAttribute for the FoodType.High enumeration.
      xAttrs = new XmlAttributes();
      xEnum = new XmlEnumAttribute();
      xEnum.Name = "Hot";
      xAttrs.XmlEnum = xEnum;
      xOver.Add(typeof(FoodType), "High", xAttrs);

      // Create the XmlSerializer, and return it.
      return new XmlSerializer(typeof(Food),
 xOver);
   }
   
 
   public void SerializeObject(string
 filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlSerializer mySerializer =  CreateOverrider();
      // Writing the file requires a TextWriter.
      TextWriter writer = new StreamWriter(filename);

      // Create an instance of the class that will be serialized.
      Food myFood = new Food();

      // Set the object properties.
      myFood.Type = FoodType.High;

      // Serialize the class, and close the TextWriter.
      mySerializer.Serialize(writer, myFood);
      writer.Close();
   }

   public void DeserializeObject(string
 filename)
   {
      XmlSerializer mySerializer = CreateOverrider();
      FileStream fs = new FileStream(filename, FileMode.Open);
      Food myFood = (Food) 
      mySerializer.Deserialize(fs);

      Console.WriteLine(myFood.Type);
   }
}

C++

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

using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Xml::Serialization;
public enum class FoodType
{
   // Subsequent code overrides these enumerations.
   Low, High
};

// This is the class that will be serialized.
public ref class Food
{
public:
   FoodType Type;
};

// Return an XmlSerializer used for overriding. 
XmlSerializer^ CreateOverrider()
{
   // Create the XmlAttributeOverrides and XmlAttributes objects.
   XmlAttributeOverrides^ xOver = gcnew XmlAttributeOverrides;
   XmlAttributes^ xAttrs = gcnew XmlAttributes;

   // Add an XmlEnumAttribute for the FoodType.Low enumeration.
   XmlEnumAttribute^ xEnum = gcnew XmlEnumAttribute;
   xEnum->Name = "Cold";
   xAttrs->XmlEnum = xEnum;
   xOver->Add( FoodType::typeid, "Low", xAttrs );

   // Add an XmlEnumAttribute for the FoodType.High enumeration.
   xAttrs = gcnew XmlAttributes;
   xEnum = gcnew XmlEnumAttribute;
   xEnum->Name = "Hot";
   xAttrs->XmlEnum = xEnum;
   xOver->Add( FoodType::typeid, "High", xAttrs );

   // Create the XmlSerializer, and return it.
   return gcnew XmlSerializer( Food::typeid,xOver );
}

void SerializeObject( String^ filename )
{
   // Create an instance of the XmlSerializer class.
   XmlSerializer^ mySerializer = CreateOverrider();

   // Writing the file requires a TextWriter.
   TextWriter^ writer = gcnew StreamWriter( filename );

   // Create an instance of the class that will be serialized.
   Food^ myFood = gcnew Food;

   // Set the object properties.
   myFood->Type = FoodType::High;

   // Serialize the class, and close the TextWriter.
   mySerializer->Serialize( writer, myFood );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   XmlSerializer^ mySerializer = CreateOverrider();
   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
   Food^ myFood = dynamic_cast<Food^>(mySerializer->Deserialize( fs ));
   Console::WriteLine( myFood->Type );
}

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

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

// This is the class that will be serialized.
public class Food
{
    public FoodType type;

    Food()
    {
        type = new FoodType();
    } //Food
} //Food

public class FoodType
{
    public int member;

    FoodType()
    {
        member = 0;
    } //FoodType

    public int get_member()
    {
        return member;
    } //get_member

    public void set_member(int
 n)
    {
        member = n;
    } //set_member

    public String getMemberType()
    {
        if (member == 0) {
            return "low";
        }
        else {
            return "high";
        }
    } //getMemberType

    public static int low
 = 0;
    public static int high
 = 1;
} //FoodType

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

    // Return an XmlSerializer used for overriding. 
    public XmlSerializer CreateOverrider()
    {
        // Create the XmlAttributeOverrides and XmlAttributes objects.
        XmlAttributeOverrides xOver = new XmlAttributeOverrides();
        XmlAttributes xAttrs = new XmlAttributes();

        // Add an XmlEnumAttribute for the FoodType.Low enumeration.
        XmlEnumAttribute xEnum = new XmlEnumAttribute();
        xEnum.set_Name("Cold");
        xAttrs.set_XmlEnum(xEnum);
        xOver.Add(FoodType.class.ToType(), "low", xAttrs);

        // Add an XmlEnumAttribute for the FoodType.High enumeration.
        xAttrs = new XmlAttributes();
        xEnum = new XmlEnumAttribute();
        xEnum.set_Name("Hot");
        xAttrs.set_XmlEnum(xEnum);
        xOver.Add(FoodType.class.ToType(), "high", xAttrs);

        // Create the XmlSerializer, and return it.
        return new XmlSerializer(Food.class.ToType(),
 xOver);
    } //CreateOverrider

    public void SerializeObject(String fileName)
    {
        // Create an instance of the XmlSerializer class.
        XmlSerializer mySerializer = CreateOverrider();

        // Writing the file requires a TextWriter.
        TextWriter writer = new StreamWriter(fileName);

        // Create an instance of the class that will be serialized.
        Food myFood = new Food();

        // Set the object properties.
        myFood.type.set_member(FoodType.high);

        // Serialize the class, and close the TextWriter.
        mySerializer.Serialize(writer, myFood);
        writer.Close();
    } //SerializeObject

    public void DeserializeObject(String fileName)
    {
        XmlSerializer mySerializer = CreateOverrider();
        FileStream fs = new FileStream(fileName, FileMode.Open);
        Food myFood = (Food)mySerializer.Deserialize(fs);

        Console.WriteLine(myFood.type.getMemberType());
    } //DeserializeObject
} //Run