EN
Ce contenu n’est pas disponible dans votre langue. Voici la version anglaise.
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

XmlArrayAttribute Class

Specifies that the XmlSerializer must serialize a particular class member as an array of XML elements.

Namespace: System.Xml.Serialization
Assembly: System.Xml (in system.xml.dll)

[AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue, AllowMultiple=false)] 
public class XmlArrayAttribute : Attribute
/** @attribute AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue, AllowMultiple=false) */ 
public class XmlArrayAttribute extends Attribute
AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue, AllowMultiple=false) 
public class XmlArrayAttribute extends Attribute
Not applicable.

The XmlArrayAttribute belongs to a family of attributes that controls how the XmlSerializer serializes or deserializes an object. For a complete list of similar attributes, see Attributes That Control XML Serialization.

You can apply the XmlArrayAttribute to a public field or read/write property that returns an array of objects. You can also apply it to collections and fields that return an ArrayList or any field that returns an object that implements the IEnumerable interface.

When you apply the XmlArrayAttribute to a class member, the Serialize method of the XmlSerializer class generates a nested sequence of XML elements from that member. An XML schema document (an .xsd file), indicates such an array as a complexType. For example, if the class to be serialized represents a purchase order, you can generate an array of purchased items by applying the XmlArrayAttribute to a public field that returns an array of objects that represent order items.

If no attributes are applied to a public field or property that returns an array of complex or primitive type objects, the XmlSerializer generates a nested sequence of XML elements by default. To more precisely control what XML elements are generated, apply an XmlArrayItemAttribute and an XmlArrayAttribute to the field or property. For example, by default, the name of the generated XML element is derived from the member identifier You can change the name of the generated XML element by setting the ElementName property.

If you serialize an array that contains items of a specific type and all the classes derived from that type, you must use the XmlArrayItemAttribute to declare each of the types.

NoteNote:

You can use XmlArray in your code instead of the longer XmlArrayAttribute.

For more information about using attributes, see Extending Metadata Using Attributes.

The following example serializes a class instance into an XML document that contains several object arrays. The XmlArrayAttribute is applied to the members that become XML element arrays.

using System;
using System.IO;
using System.Xml.Serialization;
using System.Xml;
 
public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeDocument("books.xml");
   }
 
   public void SerializeDocument(string filename)
   {
      // Creates a new XmlSerializer.
      XmlSerializer s = 
      new XmlSerializer(typeof(MyRootClass));

      // Writing the file requires a StreamWriter.
      TextWriter myWriter= new StreamWriter(filename);

      // Creates an instance of the class to serialize. 
      MyRootClass myRootClass = new MyRootClass();

      /* Uses a basic method of creating an XML array: Create and 
      populate a string array, and assign it to the 
      MyStringArray property. */

      string [] myString = {"Hello", "world", "!"};
      myRootClass.MyStringArray = myString;
       
      /* Uses a more advanced method of creating an array:
         create instances of the Item and BookItem, where BookItem 
         is derived from Item. */
      Item item1 = new Item();
      BookItem item2 = new BookItem();
  
      // Sets the objects' properties.
      item1.ItemName = "Widget1";
      item1.ItemCode = "w1";
      item1.ItemPrice = 231;
      item1.ItemQuantity = 3;
 
      item2.ItemCode = "w2";
      item2.ItemPrice = 123;
      item2.ItemQuantity = 7;
      item2.ISBN = "34982333";
      item2.Title = "Book of Widgets";
      item2.Author = "John Smith";
       
      // Fills the array with the items.
      Item [] myItems = {item1,item2};
       
      // Sets the class's Items property to the array.
      myRootClass.Items = myItems;
 
      /* Serializes the class, writes it to disk, and closes 
         the TextWriter. */
      s.Serialize(myWriter, myRootClass);
      myWriter.Close();
   }
}

// This is the class that will be serialized.
public class MyRootClass
{
   private Item [] items;
 
   /* Here is a simple way to serialize the array as XML. Using the
      XmlArrayAttribute, assign an element name and namespace. The
      IsNullable property determines whether the element will be 
      generated if the field is set to a null value. If set to true,
      the default, setting it to a null value will cause the XML
      xsi:null attribute to be generated. */
   [XmlArray(ElementName = "MyStrings",
   Namespace = "http://www.cpandl.com", IsNullable = true)]
   public string[] MyStringArray;
  
   /* Here is a more complex example of applying an 
      XmlArrayAttribute. The Items property can contain both Item 
      and BookItem objects. Use the XmlArrayItemAttribute to specify
      that both types can be inserted into the array. */
   [XmlArrayItem(ElementName= "Item", 
   IsNullable=true,
   Type = typeof(Item),
   Namespace = "http://www.cpandl.com"),
   XmlArrayItem(ElementName = "BookItem", 
   IsNullable = true, 
   Type = typeof(BookItem),
   Namespace = "http://www.cohowinery.com")]
   [XmlArray]
   public Item []Items
   {
      get{return items;}
      set{items = value;}
   }
}
 
public class Item{
   [XmlElement(ElementName = "OrderItem")]
   public string ItemName;
   public string ItemCode;
   public decimal ItemPrice;
   public int ItemQuantity;
}
 
public class BookItem:Item
{
   public string Title;
   public string Author;
   public string ISBN;
}
   

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

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

    public void SerializeDocument(String fileName)
    {
        // Creates a new XmlSerializer.
        XmlSerializer s = new XmlSerializer(MyRootClass.class.ToType());

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

        // Creates an instance of the class to serialize. 
        MyRootClass myRootClass = new MyRootClass();

        /* Uses a basic method of creating an XML array: Create and 
           populate a string array, and assign it to the 
           MyStringArray property. 
        */
        String myString[] =  { "Hello", "world", "!" };
        myRootClass.myStringArray = myString;

        /* Uses a more advanced method of creating an array:
           create instances of the Item and BookItem, where BookItem 
           is derived from Item. 
        */
        Item item1 = new Item();
        BookItem item2 = new BookItem();

        // Sets the objects' properties.
        item1.itemName = "Widget1";
        item1.itemCode = "w1";
        item1.itemPrice = Convert.ToDecimal(231);
        item1.itemQuantity = 3;

        item2.itemCode = "w2";
        item2.itemPrice = Convert.ToDecimal(123);
        item2.itemQuantity = 7;
        item2.isbn = "34982333";
        item2.title = "Book of Widgets";
        item2.author = "John Smith";

        // Fills the array with the items.
        Item myItems[] =  { item1, item2 };

        // Sets the class's Items property to the array.
        myRootClass.set_Items(myItems);

        /* Serializes the class, writes it to disk, and closes 
           the TextWriter. 
        */
        s.Serialize(myWriter, myRootClass);
        myWriter.Close();
    } //SerializeDocument
} //Run

// This is the class that will be serialized.
public class MyRootClass
{
    private Item items[];

    /* Here is a simple way to serialize the array as XML. Using the
       XmlArrayAttribute, assign an element name and namespace. The
       IsNullable property determines whether the element will be 
       generated if the field is set to a null value. If set to true,
       the default, setting it to a null value will cause the XML
       xsi:null attribute to be generated. 
    */
    /** @attribute XmlArray(ElementName = "MyStrings", 
        Namespace = "http://www.cpandl.com", IsNullable = true)
     */
    public String myStringArray[];

    /* Here is a more complex example of applying an 
       XmlArrayAttribute. The Items property can contain both Item 
       and BookItem objects. Use the XmlArrayItemAttribute to specify
       that both types can be inserted into the array. 
    */

    /** @attribute XmlArrayItem(ElementName = "Item", IsNullable = true, 
        Type = Item.class, Namespace = "http://www.cpandl.com")
        @attribute XmlArrayItem(ElementName = "BookItem", IsNullable = true, 
        Type = BookItem.class, Namespace = "http://www.cohowinery.com")
     */
    /** @attribute XmlArray()
     */
    /** @property 
     */
    public Item[] get_Items()
    {
        return items;
    } //get_Items

    /** @property 
     */
    public void set_Items(Item[] value)
    {
        items = value;
    } //set_Items
} //MyRootClass

public class Item
{
    /** @attribute XmlElement(ElementName = "OrderItem")
     */
    public String itemName;
    public String itemCode;
    public System.Decimal itemPrice;
    public int itemQuantity;
} //Item

public class BookItem extends Item
{
    public String title;
    public String author;
    public String isbn;
} //BookItem

System.Object
   System.Attribute
    System.Xml.Serialization.XmlArrayAttribute
Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0
Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.

Ajouts de la communauté

Afficher:
© 2014 Microsoft. Tous droits réservés.