Proprietà XmlAttributes.XmlText (System.Xml.Serialization)

Cambia visualizzazione:

ScriptFree

Riferimento a .NET Framework

Proprietà XmlAttributes.XmlText

Ottiene o imposta un oggetto che fa in modo che XmlSerializer serializzi un campo pubblico o una proprietà pubblica in lettura/scrittura come testo XML.

Spazio dei nomi: System.Xml.Serialization
Assembly: System.Xml (in system.xml.dll)

Sintassi

Visual Basic - (Dichiarazione)

Public Property XmlText As XmlTextAttribute

Visual Basic (Utilizzo)

Dim instance As XmlAttributes
Dim value As XmlTextAttribute

value = instance.XmlText

instance.XmlText = value

public XmlTextAttribute XmlText { get; set; }

C++

public:
property XmlTextAttribute^ XmlText {
	XmlTextAttribute^ get ();
	void set (XmlTextAttribute^ value);
}

/** @property */
public XmlTextAttribute get_XmlText ()

/** @property */
public void set_XmlText (XmlTextAttribute value)

JScript

public function get XmlText () : XmlTextAttribute

public function set XmlText (value : XmlTextAttribute)

Valore proprietà

Un XmlTextAttribute che esegue l'override della serializzazione predefinita di un campo pubblico o di una proprietà.

Note

Per impostazione predefinita, una proprietà public di lettura/scrittura o un campo public viene serializzato da XmlSerializer come elemento XML. È tuttavia possibile forzare la serializzazione di un campo o una proprietà come testo XML applicando un XmlTextAttribute al campo o alla proprietà.

Nota
XmlTextAttribute non può essere applicato a un campo o a una proprietà che restituisce una matrice.

Per eseguire l'override della serializzazione predefinita di un campo o di una proprietà (che non restituisce una matrice), creare un XmlTextAttribute e assegnarlo alla proprietà XmlText di un oggetto XmlAttributes. Aggiungere l'oggetto XmlAttributes a un oggetto XmlAttributeOverrides e specificare il tipo dell'oggetto che contiene la proprietà o il campo sottoposto a override e il nome di tale campo o proprietà.

Esempio

Nell'esempio riportato di seguito viene serializzata una classe denominata Group che contiene un campo di nome Comment. Per eseguire l'override del modo predefinito in cui XmlSerializer serializza il campo, nell'esempio viene creato un oggetto XmlAttributeOverrides e un oggetto XmlAttributes. Si crea quindi un oggetto XmlTextAttribute che viene assegnato alla proprietà XmlText e si aggiunge l'oggetto XmlAttributes (con il nome del campo da serializzare come testo XML) all'oggetto XmlAttributeOverrides. Infine, viene creato un XmlSerializer utilizzando l'oggetto XmlAttributeOverrides.

Visual Basic

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


' This is the class that will be serialized.
Public Class Group
    Public GroupName As String
    
    ' This field will be serialized as XML text. 
    Public Comment As String
End Class


Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeObject("OverrideText.xml")
        test.DeserializeObject("OverrideText.xml")
    End Sub

        
    ' Return an XmlSerializer to be used for overriding. 
    Public Function CreateOverrider() As XmlSerializer
        ' Create the XmlAttributeOverrides and XmlAttributes objects.
        Dim xOver As New XmlAttributeOverrides()
        Dim xAttrs As New XmlAttributes()
        
        ' Create an XmlTextAttribute and assign it to the XmlText
        ' property. This instructs the XmlSerializer to treat the
        ' Comment field as XML text. 
        Dim xText As New XmlTextAttribute()
        xAttrs.XmlText = xText
        xOver.Add(GetType(Group), "Comment", xAttrs)
        
        ' Create the XmlSerializer, and return it.
        Return New XmlSerializer(GetType(Group), 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 myGroup As New Group()
        
        ' Set the object properties.
        myGroup.GroupName = ".NET"
        myGroup.Comment = "Great Stuff!"
        ' Serialize the class, and close the TextWriter.
        mySerializer.Serialize(writer, myGroup)
        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 myGroup As Group = CType(mySerializer.Deserialize(fs), Group)
        Console.WriteLine(myGroup.GroupName)
        Console.WriteLine(myGroup.Comment)
    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 Group
{
   public string GroupName;

   // This field will be serialized as XML text. 
   public string Comment;
}
 
public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeObject("OverrideText.xml");
      test.DeserializeObject("OverrideText.xml");
   }

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

      /* Create an XmlTextAttribute and assign it to the XmlText 
      property. This instructs the XmlSerializer to treat the 
      Comment field as XML text. */      
      XmlTextAttribute xText = new XmlTextAttribute();
      xAttrs.XmlText = xText;
      xOver.Add(typeof(Group), "Comment", xAttrs);

      // Create the XmlSerializer, and return it.
      return new XmlSerializer(typeof(Group), 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.
      Group myGroup = new Group();

      // Set the object properties.
      myGroup.GroupName = ".NET";
      myGroup.Comment = "Great Stuff!";      
      // Serialize the class, and close the TextWriter.
      mySerializer.Serialize(writer, myGroup);
      writer.Close();
   }

   public void DeserializeObject(string filename)
   {
      XmlSerializer mySerializer = CreateOverrider();
      FileStream fs = new FileStream(filename, FileMode.Open);
      Group myGroup = (Group) 
      mySerializer.Deserialize(fs);
      Console.WriteLine(myGroup.GroupName);
      Console.WriteLine(myGroup.Comment);
   }
}

C++

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

using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Xml::Serialization;

// This is the class that will be serialized.
public ref class Group
{
public:
   String^ GroupName;

   // This field will be serialized as XML text. 
   String^ Comment;
};

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

   /* Create an XmlTextAttribute and assign it to the XmlText 
      property. This instructs the XmlSerializer to treat the 
      Comment field as XML text. */
   XmlTextAttribute^ xText = gcnew XmlTextAttribute;
   xAttrs->XmlText = xText;
   xOver->Add( Group::typeid, "Comment", xAttrs );

   // Create the XmlSerializer, and return it.
   return gcnew XmlSerializer( Group::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.
   Group^ myGroup = gcnew Group;

   // Set the object properties.
   myGroup->GroupName = ".NET";
   myGroup->Comment = "Great Stuff!";

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

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

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

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

// This is the class that will be serialized.
public class Group
{
    public String groupName;
    // This field will be serialized as XML text. 
    public String comment;
} //Group

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

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

        /* Create an XmlTextAttribute and assign it to the XmlText 
           property. This instructs the XmlSerializer to treat the 
           Comment field as XML text. */
        XmlTextAttribute xText = new XmlTextAttribute();
        xAttrs.set_XmlText(xText);
        xOver.Add(Group.class.ToType(), "Comment", xAttrs);

        // Create the XmlSerializer, and return it.
        return new XmlSerializer(Group.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.
        Group myGroup = new Group();

        // Set the object properties.
        myGroup.groupName = ".NET";
        myGroup.comment = "Great Stuff!";

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

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

        Console.WriteLine(myGroup.groupName);
        Console.WriteLine(myGroup.comment);
    } //DeserializeObject
} //Run

Piattaforme

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

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

Informazioni sulla versione

.NET Framework

Supportato in: 2.0 1.1 1.0

.NET Compact Framework

Supportato in: 2.0

Vedere anche

Riferimenti

Classe XmlAttributes
Membri XmlAttributes
Spazio dei nomi System.Xml.Serialization