XmlChoiceIdentifierAttribute Classe
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Spécifie que le membre peut être détecté à l'aide d'une énumération.
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
- Héritage
- Attributs
L’exemple suivant sérialise une classe nommée Choices
qui inclut deux champs, MyChoice
et ManyChoices
. le XmlChoiceIdentifierAttribute est appliqué à chaque champ qui spécifie (via la MemberName propriété) un autre membre de classe qui obtient ou définit une énumération qui détecte la valeur du membre. Le MyChoice
champ peut être défini sur une valeur unique, avec un membre d’énumération correspondant trouvé dans le EnumType
champ. Le ManyChoices
champ retourne un tableau d’objets. Le ChoiceArray
champ retourne un tableau de valeurs d’énumération. Pour chaque membre du tableau dans le ManyChoices
champ, un membre correspondant se trouve dans le tableau retourné par le ChoiceArray
champ .
#using <System.dll>
#using <System.xml.dll>
using namespace System;
using namespace System::Xml;
using namespace System::Xml::Serialization;
using namespace System::IO;
[XmlType(IncludeInSchema=false)]
public enum class ItemChoiceType
{
None, Word, Number, DecimalNumber
};
public enum class MoreChoices
{
None, Item, Amount, Temp
};
public ref class Choices
{
public:
// The MyChoice field can be set to any one of
// the types below.
[XmlChoiceIdentifier("EnumType")]
[XmlElement("Word",String::typeid)]
[XmlElement("Number",Int32::typeid)]
[XmlElement("DecimalNumber",Double::typeid)]
Object^ MyChoice;
// Don't serialize this field. The EnumType field
// contains the enumeration value that corresponds
// to the MyChoice field value.
[XmlIgnore]
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",String::typeid)]
[XmlElement("Amount",Int32::typeid)]
[XmlElement("Temp",Double::typeid)]
array<Object^>^ManyChoices;
// TheChoiceArray field contains the enumeration
// values, one for each item in the ManyChoices array.
[XmlIgnore]
array<MoreChoices>^ChoiceArray;
};
void SerializeObject( String^ filename );
void DeserializeObject( String^ filename );
int main()
{
SerializeObject( "Choices.xml" );
DeserializeObject( "Choices.xml" );
}
void SerializeObject( String^ filename )
{
XmlSerializer^ mySerializer = gcnew XmlSerializer( Choices::typeid );
TextWriter^ writer = gcnew StreamWriter( filename );
Choices^ myChoices = gcnew 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.
array<Object^>^strChoices = {"Food",5,98.6};
myChoices->ManyChoices = strChoices;
// For each item in the ManyChoices array, add an
// enumeration value.
array<MoreChoices>^ itmChoices = {MoreChoices::Item,MoreChoices::Amount,MoreChoices::Temp};
myChoices->ChoiceArray = itmChoices;
mySerializer->Serialize( writer, myChoices );
writer->Close();
}
void DeserializeObject( String^ filename )
{
XmlSerializer^ ser = gcnew XmlSerializer( Choices::typeid );
// A FileStream is needed to read the XML document.
FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
Choices^ myChoices = safe_cast<Choices^>(ser->Deserialize( fs ));
fs->Close();
// Disambiguate the MyChoice value using the enumeration.
if ( myChoices->EnumType == ItemChoiceType::Word )
{
Console::WriteLine( "Word: {0}", myChoices->MyChoice->ToString() );
}
else
if ( myChoices->EnumType == ItemChoiceType::Number )
{
Console::WriteLine( "Number: {0}", myChoices->MyChoice->ToString() );
}
else
if ( myChoices->EnumType == ItemChoiceType::DecimalNumber )
{
Console::WriteLine( "DecimalNumber: {0}", 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: {0}", 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: {0}", myChoices->ManyChoices[ i ]->ToString() );
}
}
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
La définition d’élément de schéma XML nommée xsi:choice
est utilisée pour définir un élément complexe qui ne peut contenir qu’un seul enfant dans une instance (maxoccurs = 1). Cet enfant peut être de plusieurs types, et il peut avoir l’un des noms suivants. Chaque nom est associé à un type spécifique ; Toutefois, plusieurs noms peuvent être associés au même type. Pour cette raison, une instance d’un tel élément est indistincte. Par exemple, considérez le fragment de schéma suivant qui définit un élément indistinct nommé 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>
le XmlChoiceIdentifierAttribute vous permet d’affecter une valeur d’énumération spéciale à chaque instance du membre. Vous devez créer l’énumération vous-même ou elle peut être générée par l’outil de définition de schéma XML (Xsd.exe). Le code C# suivant montre comment est XmlChoiceIdentifierAttribute appliqué à un Item
champ ; la MemberName propriété identifie le champ qui contient l’énumération qui est utilisée pour détecter le choix.
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,
}
Lorsque ce code est en place, vous pouvez sérialiser et désérialiser cette classe en définissant le ItemType
champ sur une énumération appropriée. Par exemple, pour sérialiser la Choice
classe, le code C# ressemble à ce qui suit.
Choices mc = new Choices();
mc.MyChoice = "Item Choice One";
mc.ItemType = ItemChoiceType.ChoiceOne;
Lors de la désérialisation, le code C# ressemble à ce qui suit :
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);
}
Il existe un deuxième scénario où est XmlChoiceIdentifierAttribute utilisé. Dans le schéma suivant, le membre est un champ qui retourne un tableau d’éléments (maxOccurs="unbounded »). Le tableau peut contenir des objets du premier choix (« D-a-t-a ») et du deuxième choix (« 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>
La classe résultante utilise ensuite un champ pour retourner un tableau d’éléments. Pour chaque élément du tableau, une énumération correspondante ItemChoiceType
doit également être trouvée. Les énumérations correspondantes sont contenues dans le tableau retourné par le ItemsElementName
champ .
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,
}
Lors de la désérialisation d’un objet qui inclut une plage de choix, utilisez une structure de contrôle (par exemple, un si... Puis... else structure) pour déterminer comment désérialiser une valeur particulière. Dans la structure de contrôle, vérifiez la valeur d’énumération et désérialisez la valeur en conséquence.
Xml |
Initialise une nouvelle instance de la classe XmlChoiceIdentifierAttribute. |
Xml |
Initialise une nouvelle instance de la classe XmlChoiceIdentifierAttribute. |
Member |
Obtient ou définit le nom du champ qui retourne l'énumération à utiliser lors de la détection des types. |
Type |
Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute. (Hérité de Attribute) |
Equals(Object) |
Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute) |
Get |
Retourne le code de hachage de cette instance. (Hérité de Attribute) |
Get |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
Is |
En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée. (Hérité de Attribute) |
Match(Object) |
En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute) |
Memberwise |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
To |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
_Attribute. |
Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Attribute) |
_Attribute. |
Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface. (Hérité de Attribute) |
_Attribute. |
Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Attribute) |
_Attribute. |
Fournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de Attribute) |
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
UWP | 10.0 |
Commentaires sur .NET
.NET est un projet open source. Sélectionnez un lien pour fournir des commentaires :