XmlChoiceIdentifierAttribute Klass

Definition

public ref class XmlChoiceIdentifierAttribute : Attribute

[System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property | System.AttributeTargets.ReturnValue, AllowMultiple=false)]
public class XmlChoiceIdentifierAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property | System.AttributeTargets.ReturnValue, AllowMultiple=false)>]
type XmlChoiceIdentifierAttribute = class
    inherit Attribute

Public Class XmlChoiceIdentifierAttribute
Inherits Attribute

Arv

Object

Attribute

XmlChoiceIdentifierAttribute

Attribut

AttributeUsageAttribute

Exempel

I följande exempel serialiseras en klass med namnet Choices som innehåller två fält och MyChoiceManyChoices . XmlChoiceIdentifierAttribute Tillämpas på varje fält som anger (via MemberName egenskapen) en annan klassmedlem som hämtar eller anger en uppräkning som identifierar medlemsvärdet. Fältet MyChoice kan anges till ett enda värde, med en motsvarande uppräkningsmedlem som finns i fältet EnumType . Fältet ManyChoices returnerar en matris med objekt. Fältet ChoiceArray returnerar en matris med uppräkningsvärden. För varje matrismedlem i ManyChoices fältet finns en motsvarande medlem i matrisen som returneras av fältet ChoiceArray .

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

public class Choices{
   // The MyChoice field can be set to any one of 
   // the types below. 
   [XmlChoiceIdentifier("EnumType")]
   [XmlElement("Word", typeof(string))]
   [XmlElement("Number", typeof(int))]
   [XmlElement("DecimalNumber", typeof(double))]
   public object MyChoice;

   // Don't serialize this field. The EnumType field
   // contains the enumeration value that corresponds
   // to the MyChoice field value.
   [XmlIgnore]
   public ItemChoiceType EnumType;

   // The ManyChoices field can contain an array
   // of choices. Each choice must be matched to
   // an array item in the ChoiceArray field.
   [XmlChoiceIdentifier("ChoiceArray")]
   [XmlElement("Item", typeof(string))]
   [XmlElement("Amount", typeof(int))]
   [XmlElement("Temp", typeof(double))]
   public object[] ManyChoices;

   // TheChoiceArray field contains the enumeration
   // values, one for each item in the ManyChoices array.
   [XmlIgnore]
   public MoreChoices[] ChoiceArray;
}

[XmlType(IncludeInSchema=false)]
public enum ItemChoiceType{
   None,
   Word, 
   Number,
   DecimalNumber
}

public enum MoreChoices{
   None,
   Item,
   Amount,
   Temp
}

public class Test{
   static void Main(){
      Test t = new Test();
      t.SerializeObject("Choices.xml");
      t.DeserializeObject("Choices.xml");
   }

   private void SerializeObject(string filename){
      XmlSerializer mySerializer = 
      new XmlSerializer(typeof(Choices));
      TextWriter writer = new StreamWriter(filename);
      Choices myChoices = new Choices();

      // Set the MyChoice field to a string. Set the
      // EnumType to Word.
      myChoices.MyChoice= "Book";
      myChoices.EnumType = ItemChoiceType.Word;

      // Populate an object array with three items, one
      // of each enumeration type. Set the array to the 
      // ManyChoices field.
      object[] strChoices = new object[]{"Food",  5, 98.6};
      myChoices.ManyChoices=strChoices;

      // For each item in the ManyChoices array, add an
      // enumeration value.
      MoreChoices[] itmChoices = new MoreChoices[]
      {MoreChoices.Item, 
      MoreChoices.Amount,
      MoreChoices.Temp};
      myChoices.ChoiceArray=itmChoices;
      
      mySerializer.Serialize(writer, myChoices);
      writer.Close();
   }

   private void DeserializeObject(string filename){
      XmlSerializer ser = new XmlSerializer(typeof(Choices));

      // A FileStream is needed to read the XML document.
      FileStream fs = new FileStream(filename, FileMode.Open);
      Choices myChoices = (Choices)
      ser.Deserialize(fs);
      fs.Close();

      // Disambiguate the MyChoice value using the enumeration.
      if(myChoices.EnumType == ItemChoiceType.Word){
           Console.WriteLine("Word: " +  
            myChoices.MyChoice.ToString());
        }
      else if(myChoices.EnumType == ItemChoiceType.Number){
           Console.WriteLine("Number: " +
            myChoices.MyChoice.ToString());
        }
      else if(myChoices.EnumType == ItemChoiceType.DecimalNumber){
           Console.WriteLine("DecimalNumber: " +
            myChoices.MyChoice.ToString());
        }

      // Disambiguate the ManyChoices values using the enumerations.
      for(int i = 0; i<myChoices.ManyChoices.Length; i++){
      if(myChoices.ChoiceArray[i] == MoreChoices.Item)
        Console.WriteLine("Item: " + (string) myChoices.ManyChoices[i]);
      else if(myChoices.ChoiceArray[i] == MoreChoices.Amount)
        Console.WriteLine("Amount: " + myChoices.ManyChoices[i].ToString());
      if(myChoices.ChoiceArray[i] == MoreChoices.Temp)
        Console.WriteLine("Temp: " + (string) myChoices.ManyChoices[i].ToString());
        }
   }
}

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

Public Class Choices
   ' The MyChoice field can be set to any one of 
   ' the types below. 
   <XmlChoiceIdentifier("EnumType"), _
   XmlElement("Word", GetType(String)), _
   XmlElement("Number", GetType(Integer)), _
   XmlElement("DecimalNumber", GetType(double))> _
   Public MyChoice As Object 

   ' Don't serialize this field. The EnumType field
   ' contains the enumeration value that corresponds
   ' to the MyChoice field value.
   <XmlIgnore> _
   Public EnumType As ItemChoiceType 

   'The ManyChoices field can contain an array
   ' of choices. Each choice must be matched to
   ' an array item in the ChoiceArray field.
   <XmlChoiceIdentifier("ChoiceArray"), _
   XmlElement("Item", GetType(string)), _
   XmlElement("Amount", GetType(Integer)), _
   XmlElement("Temp", GetType(double))> _
   Public ManyChoices() As Object

   ' TheChoiceArray field contains the enumeration
   ' values, one for each item in the ManyChoices array.
   <XmlIgnore> _
   Public ChoiceArray() As MoreChoices
End Class

<XmlType(IncludeInSchema:=false)> _
Public Enum ItemChoiceType
   None
   Word 
   Number
   DecimalNumber
End Enum

<XmlType(IncludeInSchema:=false)> _
Public Enum MoreChoices
   None
   Item
   Amount
   Temp
End Enum

Public Class Test
   Shared Sub Main()
      Dim t  As Test = New Test()
      t.SerializeObject("Choices.xml")
      t.DeserializeObject("Choices.xml")
   End Sub

   private Sub SerializeObject(filename As string)
      Dim mySerializer As XmlSerializer = _
      New XmlSerializer(GetType(Choices))
      Dim writer As TextWriter = New StreamWriter(filename)
      Dim myChoices As Choices = New Choices()

      ' Set the MyChoice field to a string. Set the
      ' EnumType to Word.
      myChoices.MyChoice= "Book"
      myChoices.EnumType = ItemChoiceType.Word

      ' Populate an object array with three items, one
      ' of each enumeration type. Set the array to the 
      ' ManyChoices field.
      Dim strChoices () As Object = New object(){"Food",  5, 98.6}
      myChoices.ManyChoices=strChoices

      ' For each item in the ManyChoices array, add an
      ' enumeration value.
      Dim itmChoices () As MoreChoices = New MoreChoices() _
      {MoreChoices.Item, _
      MoreChoices.Amount, _
      MoreChoices.Temp}
      myChoices.ChoiceArray=itmChoices
      
      mySerializer.Serialize(writer, myChoices)
      writer.Close()
   End Sub

   private Sub DeserializeObject(filename As string)
      Dim ser As XmlSerializer = New XmlSerializer(GetType(Choices))
      

      ' A FileStream is needed to read the XML document.
      Dim fs As FileStream = New FileStream(filename, FileMode.Open)
      
      Dim myChoices As Choices = CType(ser.Deserialize(fs), Choices)

      fs.Close()

      ' Disambiguate the MyChoice value Imports the enumeration.
      if myChoices.EnumType = ItemChoiceType.Word Then
           Console.WriteLine("Word: " & _
           myChoices.MyChoice.ToString())
        
      else if myChoices.EnumType = ItemChoiceType.Number Then 
           Console.WriteLine("Number: " & _
            myChoices.MyChoice.ToString())
        
      else if myChoices.EnumType = ItemChoiceType.DecimalNumber Then
         Console.WriteLine("DecimalNumber: " & _
            myChoices.MyChoice.ToString())
        End If

      ' Disambiguate the ManyChoices values Imports the enumerations.
      Dim i As Integer
      for i = 0 to myChoices.ManyChoices.Length -1
      if myChoices.ChoiceArray(i) = MoreChoices.Item Then
        Console.WriteLine("Item: " +  _
        myChoices.ManyChoices(i).ToString())
      else if myChoices.ChoiceArray(i) = MoreChoices.Amount Then
        Console.WriteLine("Amount: " + _
        myChoices.ManyChoices(i).ToString())
      else if (myChoices.ChoiceArray(i) = MoreChoices.Temp)
        Console.WriteLine("Temp: " + _
        myChoices.ManyChoices(i).ToString())
        End If
        Next i
      
   End Sub
End Class

Kommentarer

Xml-schemaelementdefinitionen med namnet xsi:choice används för att definiera ett komplext element som bara kan innehålla ett underordnat element i en instans (maxoccurs = 1). Det underordnade barnet kan vara en av flera typer, och det kan ha ett av flera namn. Varje namn är associerat med en viss typ. Flera namn kan dock associeras med samma typ. På grund av detta är en instans av ett sådant element otydlig. Tänk till exempel på följande schemafragment som definierar ett sådant otydligt element med namnet MyChoice.

<xsd:complexType name="MyChoice">
 <xsd:sequence>
 <xsd:choice minOccurs="0" maxOccurs="1">
 <xsd:element minOccurs="1" maxOccurs="1" name="ChoiceOne" type="xsd:string" />
 <xsd:element minOccurs="1" maxOccurs="1" name="ChoiceTwo" type="xsd:string" />
 </xsd:choice>
 </xsd:sequence>
</xsd:complexType>

Med XmlChoiceIdentifierAttribute kan du tilldela ett särskilt uppräkningsvärde till varje instans av medlemmen. Du måste antingen skapa uppräkningen själv eller så kan den genereras av XML-schemadefinitionsverktyget (Xsd.exe). Följande C#-kod visar hur XmlChoiceIdentifierAttribute tillämpas på ett Item fält. MemberName Egenskapen identifierar det fält som innehåller uppräkningen som används ytterligare för att identifiera valet.

public class Choices{
 [XmlChoiceIdentifier("ItemType")]
 [XmlChoiceIdentifier("ChoiceOne")]
 [XmlChoiceIdentifier("ChoiceTwo")]
 public string MyChoice;

 // Do not serialize this next field:
 [XmlIgnore]
 public ItemChoiceType ItemType;
}
// Do not include this enumeration in the XML schema.
[XmlType(IncludeInSchema = false)]
public enum ItemChoiceType{
 ChoiceOne,
 ChoiceTwo,
}

När den här koden är på plats kan du serialisera och deserialisera den här klassen genom att ställa in ItemType fältet på en lämplig uppräkning. Om du till exempel vill serialisera Choice klassen liknar C#-koden följande.

Choices mc = new Choices();
mc.MyChoice = "Item Choice One";
mc.ItemType = ItemChoiceType.ChoiceOne;

Vid deserialisering liknar C#-koden följande:

MyChoice mc = (MyChoice) myXmlSerializer.Deserialize(myReader);
if(mc.ItemType == ItemChoiceType.ChoiceOne)
 {
     // Handle choice one.
 }
if(mc.ItemType == ItemChoiceType.ChoiceTwo)
 {
     // Handle choice two.
 }
if(mc.ItemType != null)
 {
     throw CreateUnknownTypeException(mc.Item);
 }

Det finns ett andra scenario när XmlChoiceIdentifierAttribute används. I följande schema är medlemmen ett fält som returnerar en matris med objekt (maxOccurs="obundna"). Matrisen kan innehålla de första objekten ("D-a-t-a") och andrahandsvalet ("MoreData").

<xsd:complexType name="MyChoice">
 <xsd:sequence>
 <xsd:choice minOccurs="0" maxOccurs="unbounded">
 <xsd:element minOccurs="1" maxOccurs="1" name="D-a-t-a" type="xsd:string" />
 <xsd:element minOccurs="1" maxOccurs="1" name="MoreData" type="xsd:string" />
 </xsd:choice>
 </xsd:sequence>
</xsd:complexType>

Den resulterande klassen använder sedan ett fält för att returnera en matris med objekt. För varje objekt i matrisen måste en motsvarande ItemChoiceType uppräkning också hittas. Matchande uppräkningar finns i matrisen som returneras av fältet ItemsElementName .

public class MyChoice {
 [System.Xml.Serialization.XmlElementAttribute("D-a-t-a", typeof(string), IsNullable=false)]
 [System.Xml.Serialization.XmlElementAttribute("MoreData", typeof(string), IsNullable=false)]
 [System.Xml.Serialization.XmlChoiceIdentifierAttribute("ItemsElementName")]
 public string[] Items;
 [System.Xml.Serialization.XmlElementAttribute(IsNullable=false)]
 [System.Xml.Serialization.XmlIgnoreAttribute()]
 public ItemsChoiceType[] ItemsElementName;
}
[System.Xml.Serialization.XmlTypeAttribute(IncludeInSchema=false)]
public enum ItemsChoiceType {
 [System.Xml.Serialization.XmlEnumAttribute("D-a-t-a")]
 Data,
 MoreData,
}

När du deserialiserar ett objekt som innehåller ett antal alternativ använder du en kontrollstruktur (till exempel en om... Sedan... else structure) för att avgöra hur du deserialiserar ett visst värde. I kontrollstrukturen kontrollerar du uppräkningsvärdet och deserialiserar värdet därefter.

Se även

• XmlAttributes
• Introduktion till XML-serialisering
• Anvisningar: Ange ett alternativt elementnamn för en XML-dataström
• Kontrollera XML-serialisering med hjälp av attribut
• Exempel på XML-serialisering
• XML-schemadefinitionsverktyg (Xsd.exe)