XmlIncludeAttribute.Type-Eigenschaft

Ruft den Typ des aufzunehmenden Objekts ab oder legt diesen fest.

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

Syntax

'Declaration
Public Property Type As Type
'Usage
Dim instance As XmlIncludeAttribute
Dim value As Type

value = instance.Type

instance.Type = value

public Type Type { get; set; }

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

/** @property */
public Type get_Type ()

/** @property */
public void set_Type (Type value)

public function get Type () : Type

public function set Type (value : Type)

Eigenschaftenwert

Der Type des aufzunehmenden Objekts.

Beispiel

Im folgenden Beispiel wird die Klasse Group definiert, die das Feld Employees enthält, das ein Array von Employee-Objekten zurückgibt. Im Beispiel wird die Manager-Klasse von Employee-Klasse abgeleitet und das XmlIncludeAttribute auf die Employee-Klasse angewendet. Beim Erstellen eines Group-Objekts wird ein Manager-Objekt in das Employee-Array eingefügt. Abschließend wird das Group-Objekt serialisiert.

Imports System
Imports System.IO
Imports System.Xml.Serialization
Imports Microsoft.VisualBasic


Public Class Group
    Public Employees() As Employee
End Class

' Instruct the XmlSerializer to accept Manager types as well.
<XmlInclude(GetType(Manager))> _
Public Class Employee
    Public Name As String
End Class

Public Class Manager
    Inherits Employee
    Public Level As Integer
End Class


Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeObject("IncludeExample.xml")
        test.DeserializeObject("IncludeExample.xml")
    End Sub    
    
    
    Public Sub SerializeObject(ByVal filename As String)
        Dim s As New XmlSerializer(GetType(Group))
        Dim writer As New StreamWriter(filename)
        Dim group As New Group()
        
        Dim manager As New Manager()
        Dim emp1 As New Employee()
        Dim emp2 As New Employee()
        
        manager.Name = "Zeus"
        manager.Level = 2
        
        emp1.Name = "Ares"
        
        emp2.Name = "Artemis"
        
        Dim emps() As Employee = {manager, emp1, emp2}
        group.Employees = emps
        
        s.Serialize(writer, group)
        writer.Close()
    End Sub    
    
    Public Sub DeserializeObject(ByVal filename As String)
        Dim fs As New FileStream(filename, FileMode.Open)
        Dim x As New XmlSerializer(GetType(Group))
        Dim g As Group = CType(x.Deserialize(fs), Group)
        Console.Write("Members:")
        
        Dim e As Employee
        For Each e In  g.Employees
            Console.WriteLine(ControlChars.Tab + e.Name)
        Next e
    End Sub
End Class

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

public class Group
{   
   public Employee[] Employees;
}   

// Instruct the XmlSerializer to accept Manager types as well.
[XmlInclude(typeof(Manager))]
public class Employee
{
   public string Name;
}

public class Manager:Employee
{
   public int Level;
}


public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeObject("IncludeExample.xml");
      test.DeserializeObject("IncludeExample.xml");
   }


   public void SerializeObject(string filename)
   {
      XmlSerializer s = new XmlSerializer(typeof(Group));
      TextWriter writer = new StreamWriter(filename);
      Group group = new Group();
      
      Manager manager = new Manager();
      Employee emp1 = new Employee();
      Employee emp2 = new Employee();

      manager.Name = "Zeus";
      manager.Level = 2;

      emp1.Name = "Ares";

      emp2.Name = "Artemis";

      Employee [] emps = new Employee[3]{manager, emp1, emp2};
      group.Employees = emps;

      s.Serialize(writer, group);
      writer.Close();
   }

   public void DeserializeObject(string filename)
   {
      FileStream fs = new FileStream(filename, FileMode.Open);
      XmlSerializer x = new XmlSerializer(typeof(Group));
      Group g = (Group) x.Deserialize(fs);
      Console.Write("Members:");
      
      foreach(Employee e in g.Employees) 
      {
         Console.WriteLine("\t" + e.Name);
      }
   }
}

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

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

ref class Employee;

ref class Manager;

ref class Group
{
public:
   array<Employee^>^Employees;
};

// Instruct the XmlSerializer to accept Manager types as well.
[XmlInclude(Manager::typeid)]
public ref class Employee
{
public:
   String^ Name;
};

public ref class Manager: public Employee
{
public:
   int Level;
};

void SerializeObject( String^ filename )
{
   XmlSerializer^ s = gcnew XmlSerializer( Group::typeid );
   TextWriter^ writer = gcnew StreamWriter( filename );
   Group^ group = gcnew Group;
   Manager^ manager = gcnew Manager;
   Employee^ emp1 = gcnew Employee;
   Employee^ emp2 = gcnew Employee;
   manager->Name = "Zeus";
   manager->Level = 2;
   emp1->Name = "Ares";
   emp2->Name = "Artemis";
   array<Employee^>^emps = {manager,emp1,emp2};
   group->Employees = emps;
   s->Serialize( writer, group );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
   XmlSerializer^ x = gcnew XmlSerializer( Group::typeid );
   Group^ g = dynamic_cast<Group^>(x->Deserialize( fs ));
   Console::Write( "Members:" );
   System::Collections::IEnumerator^ myEnum = g->Employees->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Employee^ e = safe_cast<Employee^>(myEnum->Current);
      Console::WriteLine( "\t{0}", e->Name );
   }
}

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

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

public class Group
{
    public Employee employees[];
} //Group

// Instruct the XmlSerializer to accept Manager types as well.
/** @attribute XmlInclude(Manager.class)
 */
public class Employee
{
    public String name;
} //Employee

public class Manager extends Employee
{
    public int level;
} //Manager

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

    public void SerializeObject(String fileName)
    {
        XmlSerializer s = new XmlSerializer(Group.class.ToType());
        TextWriter writer = new StreamWriter(fileName);
        Group group = new Group();
        
        Manager manager = new Manager();
        Employee emp1 = new Employee();
        Employee emp2 = new Employee();

        manager.name = "Zeus";
        manager.level = 2;
        emp1.name = "Ares";
        emp2.name = "Artemis";

        Employee emps[] = new Employee[] { manager, emp1, emp2 };

        group.employees = emps;
        s.Serialize(writer, group);
        writer.Close();
    } //SerializeObject

    public void DeserializeObject(String fileName)
    {
        FileStream fs = new FileStream(fileName, FileMode.Open);
        XmlSerializer x = new XmlSerializer(Group.class.ToType());
        Group g = (Group)x.Deserialize(fs);

        Console.Write("Members:");
        for (int iCtr = 0; iCtr < g.employees.length; iCtr++) {
            Employee e = g.employees[iCtr];
            Console.WriteLine("\t" + e.name);
        }
    } //DeserializeObject
} //Run

Plattformen

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

XmlIncludeAttribute-Klasse
XmlIncludeAttribute-Member
System.Xml.Serialization-Namespace