DataContractAttribute Klass

Definition

public ref class DataContractAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Enum | System.AttributeTargets.Struct, AllowMultiple=false, Inherited=false)]
public sealed class DataContractAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Enum | System.AttributeTargets.Struct, AllowMultiple=false, Inherited=false)>]
type DataContractAttribute = class
    inherit Attribute

Public NotInheritable Class DataContractAttribute
Inherits Attribute

Arv

Object

Attribute

DataContractAttribute

Attribut

AttributeUsageAttribute

Exempel

I följande exempel serialiseras och deserialiseras en klass med namnet Person som DataContractAttribute har tillämpats på. Observera att Namespace egenskaperna och Name har angetts till värden som åsidosätter standardinställningarna.

namespace DataContractAttributeExample
{
    // Set the Name and Namespace properties to new values.
    [DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
    class Person : IExtensibleDataObject
    {
        // To implement the IExtensibleDataObject interface, you must also
        // implement the ExtensionData property.
        private ExtensionDataObject extensionDataObjectValue;
        public ExtensionDataObject ExtensionData
        {
            get
            {
                return extensionDataObjectValue;
            }
            set
            {
                extensionDataObjectValue = value;
            }
        }

        [DataMember(Name = "CustName")]
        internal string Name;

        [DataMember(Name = "CustID")]
        internal int ID;

        public Person(string newName, int newID)
        {
            Name = newName;
            ID = newID;
        }
    }

    class Test
    {
        public static void Main()
        {
            try
            {
                WriteObject("DataContractExample.xml");
                ReadObject("DataContractExample.xml");
                Console.WriteLine("Press Enter to end");
                Console.ReadLine();
            }
            catch (SerializationException se)
            {
                Console.WriteLine
                ("The serialization operation failed. Reason: {0}",
                  se.Message);
                Console.WriteLine(se.Data);
                Console.ReadLine();
            }
        }

        public static void WriteObject(string path)
        {
            // Create a new instance of the Person class and
            // serialize it to an XML file.
            Person p1 = new Person("Mary", 1);
            // Create a new instance of a StreamWriter
            // to read and write the data.
            FileStream fs = new FileStream(path,
            FileMode.Create);
            XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));
            ser.WriteObject(writer, p1);
            Console.WriteLine("Finished writing object.");
            writer.Close();
            fs.Close();
        }
        public static void ReadObject(string path)
        {
            // Deserialize an instance of the Person class
            // from an XML file. First create an instance of the
            // XmlDictionaryReader.
            FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
            XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());

            // Create the DataContractSerializer instance.
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));

            // Deserialize the data and read it from the instance.
            Person newPerson = (Person)ser.ReadObject(reader);
            Console.WriteLine("Reading this object:");
            Console.WriteLine(String.Format("{0}, ID: {1}",
            newPerson.Name, newPerson.ID));
            fs.Close();
        }
    }
}

Namespace DataContractAttributeExample
    ' Set the Name and Namespace properties to new values.
    <DataContract(Name := "Customer", [Namespace] := "http://www.contoso.com")>  _
    Class Person
        Implements IExtensibleDataObject
        ' To implement the IExtensibleDataObject interface, you must also
        ' implement the ExtensionData property.
        Private extensionDataObjectValue As ExtensionDataObject 
        
        Public Property ExtensionData() As ExtensionDataObject _
          Implements IExtensibleDataObject.ExtensionData
            Get
                Return extensionDataObjectValue
            End Get
            Set
                extensionDataObjectValue = value
            End Set
        End Property
        
        <DataMember(Name := "CustName")>  _
        Friend Name As String
        
        <DataMember(Name := "CustID")>  _
        Friend ID As Integer
        
        
        Public Sub New(ByVal newName As String, ByVal newID As Integer) 
            Name = newName
            ID = newID
        
        End Sub 
    End Class 
    
    
    Class Test
        
        Public Shared Sub Main() 
            Try
                WriteObject("DataContractExample.xml")
                ReadObject("DataContractExample.xml")
                Console.WriteLine("Press Enter to end")
                Console.ReadLine()
            Catch se As SerializationException
                Console.WriteLine("The serialization operation failed. Reason: {0}", _
                   se.Message)
                Console.WriteLine(se.Data)
                Console.ReadLine()
            End Try
        
        End Sub 
        
        
        Public Shared Sub WriteObject(ByVal path As String) 
            ' Create a new instance of the Person class and 
            ' serialize it to an XML file.
            Dim p1 As New Person("Mary", 1)
            ' Create a new instance of a StreamWriter
            ' to read and write the data.
            Dim fs As New FileStream(path, FileMode.Create)
            Dim writer As XmlDictionaryWriter = XmlDictionaryWriter.CreateTextWriter(fs)
            Dim ser As New DataContractSerializer(GetType(Person))
            ser.WriteObject(writer, p1)
            Console.WriteLine("Finished writing object.")
            writer.Close()
            fs.Close()
        
        End Sub 
        
        Public Shared Sub ReadObject(ByVal path As String) 
            ' Deserialize an instance of the Person class 
            ' from an XML file. First create an instance of the 
            ' XmlDictionaryReader.
            Dim fs As New FileStream(path, FileMode.OpenOrCreate)
            Dim reader As XmlDictionaryReader = XmlDictionaryReader. _
              CreateTextReader(fs, New XmlDictionaryReaderQuotas())
            
            ' Create the DataContractSerializer instance.
            Dim ser As New DataContractSerializer(GetType(Person))
            
            ' Deserialize the data and read it from the instance.
            Dim newPerson As Person = CType(ser.ReadObject(reader), Person)
            Console.WriteLine("Reading this object:")
            Console.WriteLine(String.Format("{0}, ID: {1}", newPerson.Name, newPerson.ID))
            fs.Close()
        
        End Sub 
    End Class 
End Namespace

Kommentarer

Applicera DataContractAttribute attributet på typer (klasser, strukturer eller uppräkningar) som används i serialiserings- och deserialiseringsoperationer av DataContractSerializer. Om du skickar eller tar emot meddelanden med hjälp av WCF-infrastrukturen (Windows Communication Foundation) bör du även tillämpa på DataContractAttribute alla klasser som innehåller och manipulerar data som skickas i meddelanden. Mer information om datakontrakt finns i Använda datakontrakt.

Du måste också tillämpa på DataMemberAttribute alla fält, egenskaper eller händelser som innehåller värden som du vill serialisera. Genom att använda DataContractAttributeaktiverar du uttryckligen DataContractSerializer för att serialisera och deserialisera data.

Mer information om datakontrakt finns i avsnitten i Använda datakontrakt.

Datakontrakt

Ett datakontrakt är en abstrakt beskrivning av en uppsättning fält med ett namn och en datatyp för varje fält. Datakontraktet finns utanför en enda implementering så att tjänster på olika plattformar kan samverka. Så länge data som skickas mellan tjänsterna överensstämmer med samma kontrakt kan alla tjänster bearbeta data. Den här bearbetningen kallas även för ett löst kopplat system. Ett datakontrakt liknar också ett gränssnitt eftersom kontraktet anger hur data måste levereras så att de kan bearbetas av ett program. Datakontraktet kan till exempel anropa en datatyp med namnet "Person" som har två textfält med namnet "FirstName" och "LastName". Om du vill skapa ett datakontrakt tillämpar du DataContractAttribute på klassen och tillämpar på DataMemberAttribute alla fält eller egenskaper som måste serialiseras. När de serialiseras överensstämmer data med det datakontrakt som implicit är inbyggt i typen.

XML-schemadokument och SvcUtil-verktyget

Om du utbyter data med andra tjänster måste du beskriva datakontraktet. För den aktuella versionen av DataContractSerializerkan ett XML-schema användas för att definiera datakontrakt. (Andra former av metadata/beskrivning kan användas för samma ändamål.) Om du vill skapa ett XML-schema från ditt program använder du servicemodelmetadataverktyget (Svcutil.exe) med kommandoradsalternativet /dconly . När indata till verktyget är en sammansättning genererar verktyget som standard en uppsättning XML-scheman som definierar alla typer av datakontrakt som finns i sammansättningen. Du kan också använda Svcutil.exe-verktyget för att skapa Visual Basic- eller C#-klassdefinitioner som uppfyller kraven för XML-scheman som använder konstruktioner som kan uttryckas i datakontrakt. I det här fallet krävs inte kommandoradsalternativet /dconly .

Om indata till Svcutil.exe-verktyget är ett XML-schema skapar verktyget som standard en uppsättning klasser. Om du undersöker dessa klasser upptäcker du att DataContractAttribute har tillämpats. Du kan använda dessa klasser för att skapa ett nytt program för att bearbeta data som måste utbytas med andra tjänster.

Du kan också köra verktyget mot en slutpunkt som returnerar ett WSDL-dokument (Web Services Description Language) för att automatiskt generera koden och konfigurationen för att skapa en WCF-klient (Windows Communication Foundation). Den genererade koden innehåller typer som är markerade med DataContractAttribute.

Återanvända befintliga typer

Ett datakontrakt har två grundläggande krav: ett stabilt namn och en lista över medlemmar. Det stabila namnet består av namnområdets enhetliga resursidentifierare (URI) och kontraktets lokala namn. När du tillämpar DataContractAttribute på en klass använder den som standard klassnamnet som det lokala namnet och klassens namnområde (prefixet med "http://schemas.datacontract.org/2004/07/") som namnområdes-URI. Du kan åsidosätta standardvärdena genom att ange egenskaperna Name och Namespace. Du kan också ändra namnområdet genom att tillämpa ContractNamespaceAttribute på namnområdet. Använd den här funktionen när du har en befintlig typ som bearbetar data exakt som du behöver men har ett annat namnområde och klassnamn från datakontraktet. Genom att åsidosätta standardvärdena kan du återanvända din befintliga typ och låta serialiserade data överensstämma med datakontraktet.

Versionshantering

Ett datakontrakt kan också hantera senare versioner av sig själv. Det innebär att när en senare version av kontraktet innehåller extra data lagras och returneras dessa data till en avsändare orörd. Implementera IExtensibleDataObject-gränssnittet för att göra detta.

Mer information om versionshantering finns i Versionshantering av datakontrakt.

Se även

• IExtensibleDataObject
• ExtensionDataObject
• DataContractSerializer
• DataMemberAttribute
• ISerializable
• KnownTypeAttribute
• Använda datakontrakt