Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês
Esta documentação foi arquivada e não está sendo atualizada.

Classe XmlAttributeOverrides

Permite que você substituir a propriedade, campo e atributos de classe quando você usa o XmlSerializer para serializar ou desserializar um objeto.

Namespace:  System.Xml.Serialization
Assembly:  System.Xml (em System.Xml. dll)

public class XmlAttributeOverrides

The XmlAttributeOverrides enables the XmlSerializer to override the default way of serializing a set of objects.Substituir serialização dessa maneira tem dois usos: primeiro, você pode ControlarParar e ParaumentParar Para seriParalizParação de objeParas encontrParados em umPara DLL--mesmo se você não tiver ParacessParar pPararPara Para fonte; Em segundo lugar, você pode criar um conjunto de classes serializáveis, mas serializar os objetos no Múltiplo maneiras.Por exemplo, em vez de serialização de membros de uma instância de classe como elementos XML, você pode serializá-los como atributos XML, resultando em um documento mais eficiente para transporte.

Depois de criar um objeto de XmlAttributeOverrides , passe-lo como um argumento para o construtor de XmlSerializer.O resultante XmlSerializer usa os dados contidos o XmlAttributeOverrides para substituir atributos que Controlaram como os objetos são serializados.Para fazer isso, a XmlAttributeOverrides contém uma coleção dos tipos de objeto que são substituídas, bem como um XmlAttributes objeto associado com cada tipo de objeto substituído.O próprio objeto XmlAttributes contém um conjunto apropriado de objetos de atributo que Controlaram como cada campo, a propriedade ou a classe é serializada.

O processo para criar e usar um objeto XmlAttributeOverrides é da seguinte maneira:

  1. Crie um objeto XmlAttributes.

  2. Criar um objeto de atributo que é apropriado para o objeto seja substituído.Por exemplo, pPararPara substituir um cParampo ou propriedParade, crie um <Para0> $ </Para0>, usParando o tipo novo e derivParado.XmlElementAttributeOpcionalmente, você pode atribuir um novo ElementNameou Namespace que substitui o nome do atributo da classe base ou namespace.

  3. ParadicionPara o objePara ParatribuPara pPararPara o ParapropriParado <Para0> $ </Para0> PropriedParade ou coleção.XmlAttributesFor example, you would add the XmlElementAttribute to the XmlElements collection of the XmlAttributes object, specifying the member name that is being overridden.

  4. Crie um objeto XmlAttributeOverrides.

  5. Using the Add method, add the XmlAttributes object to the XmlAttributeOverrides object.If the object being overridden is an XmlRootAttribute or XmlTypeAttribute, you need only to specify the type of the overridden object.Mas se você estiver substituindo um campo ou propriedade, você também deve especificar o nome do membro substituído.

  6. Ao construir a XmlSerializer, passe o XmlAttributeOverrides para o construtor de XmlSerializer.

  7. Use o resultante XmlSerializer para serializar ou desserializar os objetos de classe derivada.

O exemplo a seguir serializa uma classe chamada Orchestra, que contém um Simples campo chamado Instruments que retorna uma matriz de objetos de Instrument.Uma classe de segundo chamada Brass herda da classe Instrument.O exemplo usa uma instância da classe XmlAttributeOverrides para substituir o campo de Instrument , permitindo que o campo para aceitar Brass objetos.

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

publicclass Orchestra
{
   public Instrument[] Instruments;
}   

publicclass Instrument
{
   public string Name;
}

publicclass Brass:Instrument
{
   publicbool IsValved;
}

publicclass Run
{
    publicstaticvoid Main()
    {
       Run test = new Run();
       test.SerializeObject("Override.xml");
       test.DeserializeObject("Override.xml");
    }

    publicvoid SerializeObject(string filename)
    {
      /* Each overridden field, property, or type requires 
      an XmlAttributes object. */
      XmlAttributes attrs = new XmlAttributes();

      /* Create an XmlElementAttribute to override the 
      field that returns Instrument objects. The overridden field
      returns Brass objects instead. */
      XmlElementAttribute attr = new XmlElementAttribute();
      attr.ElementName = "Brass";
      attr.Type = typeof(Brass);

      // Add the element to the collection of elements.
      attrs.XmlElements.Add(attr);

      // Create the XmlAttributeOverrides object.
      XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();

      /* Add the type of the class that contains the overridden 
      member and the XmlAttributes to override it with to the 
      XmlAttributeOverrides object. */
      attrOverrides.Add(typeof(Orchestra), "Instruments", attrs);

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

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

      // Create the object that will be serialized.
      Orchestra band = new Orchestra();

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

      // Serialize the object.
      s.Serialize(writer,band);
      writer.Close();
   }

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

      // Create an XmlElementAttribute to override the Instrument.
      XmlElementAttribute attr = new XmlElementAttribute();
      attr.ElementName = "Brass";
      attr.Type = typeof(Brass);

      // Add the XmlElementAttribute to the collection of objects.
      attrs.XmlElements.Add(attr);

      attrOverrides.Add(typeof(Orchestra), "Instruments", attrs);

      // Create 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:");

      /* The difference between deserializing the overridden 
      XML document and serializing it is this: To read the derived 
      object values, you must 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);
      }
   }
}



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

public class Orchestra
{
    public Instrument instruments[];
} //Orchestra

public class Instrument
{
    public String name;
} //Instrument

public class Brass extends Instrument
{
    public boolean isValved;
} //Brass

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

    public void SerializeObject(String fileName)
    {
        /* Each overridden field, property, or type requires 
           an XmlAttributes object.
         */
        XmlAttributes attrs = new XmlAttributes();

        /* Create an XmlElementAttribute to override the 
           field that returns Instrument objects. The overridden field
           returns Brass objects instead.
         */
        XmlElementAttribute attr = new XmlElementAttribute();
        attr.set_ElementName("Brass");
        attr.set_Type(Brass.class.ToType());

        // Add the element to the collection of elements.
        attrs.get_XmlElements().Add(attr);

        // Create the XmlAttributeOverrides object.
        XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();

        /* Add the type of the class that contains the overridden 
           member and the XmlAttributes to override it with to the 
           XmlAttributeOverrides object.
         */
        attrOverrides.Add(Orchestra.class.ToType(), "instruments", attrs);

        // Create the XmlSerializer using the XmlAttributeOverrides.
        XmlSerializer s =
            new XmlSerializer(Orchestra.class.ToType(), attrOverrides);

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

        // Create the object that will be serialized.
        Orchestra band = new Orchestra();

        // Create an object of the derived type.
        Brass i = new Brass();
        i.name = "Trumpet";
        i.isValved = true;
        Instrument myInstruments[] ={ i };
        band.instruments = myInstruments;

        // Serialize the object.
        s.Serialize(writer, band);
        writer.Close();
    } //SerializeObject

    public void DeserializeObject(String fileName)
    {
        XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
        XmlAttributes attrs = new XmlAttributes();

        // Create an XmlElementAttribute to override the Instrument.
        XmlElementAttribute attr = new XmlElementAttribute();
        attr.set_ElementName("Brass");
        attr.set_Type(Brass.class.ToType());

        // Add the XmlElementAttribute to the collection of objects.
        attrs.get_XmlElements().Add(attr);
        attrOverrides.Add(Orchestra.class.ToType(), "instruments", attrs);

        // Create the XmlSerializer using the XmlAttributeOverrides.
        XmlSerializer s =
            new XmlSerializer(Orchestra.class.ToType(), attrOverrides);
        FileStream fs = new FileStream(fileName, FileMode.Open);
        Orchestra band = (Orchestra)s.Deserialize(fs);
        Console.WriteLine("Brass:");

        /* The difference between deserializing the overridden 
           XML document and serializing it is this: To read the derived 
           object values, you must declare an object of the derived type 
           (Brass), and cast the Instrument instance to it.
         */
        Brass b;
        for (int iCtr = 0; iCtr < band.instruments.length; iCtr++) {
            Instrument i = (Instrument)band.instruments.get_Item(iCtr);
            b = (Brass)i;
            Console.WriteLine(b.name + "\n"
                + System.Convert.ToString(b.isValved));
        }
    } //DeserializeObject
} //Run


System.Object
  System.Xml.Serialization.XmlAttributeOverrides

Quaisquer membros público estático (compartilhado no Visual Basic) deste tipo são processos seguros. Quaisquer membros de instância não são garantidos como processos seguros.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, O Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

O .NET Framework e .NET Compact Framework não suporte para todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatível com: 3.5, 2.0

XNA Framework

Compatível com: , 1.0
Mostrar: