Message Klasse

Definition

Namespace:

System.ServiceModel.Channels

Assembly:

System.ServiceModel.Primitives.dll

Paket:

System.ServiceModel.Primitives v6.2.0

Source:

Message.cs

Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.

public ref class Message abstract : IDisposable

public abstract class Message : IDisposable

type Message = class
    interface IDisposable

Public MustInherit Class Message
Implements IDisposable

Vererbung

Object

Message

Implementiert

IDisposable

Beispiele

Das folgende Codebeispiel zeigt einen Client, der die Kanalfactory zum Senden einer Nachricht und zum Lesen der Antwort verwendet.

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Runtime.Serialization;

namespace ConsoleApplication1
{
    class client
    {

        static void RunClient()
        {
            //Step1: create a binding with just HTTP
            CustomBinding binding = new CustomBinding();
            binding.Elements.Add(new HttpTransportBindingElement());
            //Step2: use the binding to build the channel factory
            IChannelFactory<IRequestChannel> factory =
            binding.BuildChannelFactory<IRequestChannel>(
                             new BindingParameterCollection());
            //open the channel factory
            factory.Open();
            //Step3: use the channel factory to create a channel
            IRequestChannel channel = factory.CreateChannel(
               new EndpointAddress("http://localhost:8080/channelapp"));
            channel.Open();
            //Step4: create a message
            Message requestmessage = Message.CreateMessage(
                MessageVersion.Soap12WSAddressing10,
                "http://contoso.com/someaction",
                 "This is the body data");
            //send message
            Message replymessage = channel.Request(requestmessage);
            Console.WriteLine("Reply message received");
            Console.WriteLine("Reply action: {0}",
                                  replymessage.Headers.Action);
            string data = replymessage.GetBody<string>();
            Console.WriteLine("Reply content: {0}", data);
            //Step5: don't forget to close the message
            requestmessage.Close();
            replymessage.Close();
            //don't forget to close the channel
            channel.Close();
            //don't forget to close the factory
            factory.Close();
        }
        public static void Main()
        {
            Console.WriteLine("Press [ENTER] when service is ready");
            Console.ReadLine();
            RunClient();
            Console.WriteLine("Press [ENTER] to exit");
            Console.ReadLine();
        }
    }
}

Imports System.Collections.Generic
Imports System.Text
Imports System.ServiceModel
Imports System.ServiceModel.Channels
Imports System.Runtime.Serialization

Namespace ConsoleApplication1
    Friend Class client


        Private Shared Sub RunClient()
            'Step1: create a binding with just HTTP
            Dim binding As New CustomBinding()
            binding.Elements.Add(New HttpTransportBindingElement())
            'Step2: use the binding to build the channel factory
            Dim factory As IChannelFactory(Of IRequestChannel) = binding.BuildChannelFactory(Of IRequestChannel)(New BindingParameterCollection())
            'open the channel factory
            factory.Open()
            'Step3: use the channel factory to create a channel
            Dim channel As IRequestChannel = factory.CreateChannel(New EndpointAddress("http://localhost:8080/channelapp"))
            channel.Open()
            'Step4: create a message
            Dim requestmessage As Message = Message.CreateMessage(MessageVersion.Soap12WSAddressing10, "http://contoso.com/someaction", "This is the body data")
            'send message
            Dim replymessage As Message = channel.Request(requestmessage)
            Console.WriteLine("Reply message received")
            Console.WriteLine("Reply action: {0}", replymessage.Headers.Action)
            Dim data = replymessage.GetBody(Of String)()
            Console.WriteLine("Reply content: {0}", data)
            'Step5: don't forget to close the message
            requestmessage.Close()
            replymessage.Close()
            'don't forget to close the channel
            channel.Close()
            'don't forget to close the factory
            factory.Close()
        End Sub
        Public Shared Sub Main()
            Console.WriteLine("Press [ENTER] when service is ready")
            Console.ReadLine()
            RunClient()
            Console.WriteLine("Press [ENTER] to exit")
            Console.ReadLine()
        End Sub
    End Class
End Namespace

Hinweise

Die Message-Klasse bietet eine Möglichkeit, beliebige Informationen zwischen einem Absender und Empfänger in einem Netzwerk zu kommunizieren. Sie kann zum Weiterleiten von Informationen, zum Vorschlagen oder Fordern einer Vorgehensweise oder zum Anfordern von Daten verwendet werden.

Die Struktur eines Message-Objekts stellt einen SOAP-Umschlag dar. Er besteht aus zwei verschiedenen Teilen: dem Nachrichtentext und einer optionalen Auflistung von Headern, die von der Headers-Klasse dargestellt werden. Der Nachrichteninhalt stellt von einer Anwendung definierte Daten dar, die von einem Absender an einen Empfänger gesendet werden. Die Nachrichtenheader ermöglichen die Erweiterung von System und Anwendungen, um sich ändernden Anforderungen gerecht zu werden, da Sie Code definieren können, mit dem nur bestimmte Header bearbeitet oder nur auf bestimmte Header reagiert wird. Sie können außerdem eigene Header definieren. Nachrichtenheader werden zusammen mit dem Inhalt der Nachricht serialisiert oder deserialisiert.

Nachrichten werden in bestimmten Formaten empfangen und gesendet. Es werden zwei Formate unterstützt: Das standardmäßige, textbasierte XML-Format und ein binäres XML-Format. Das Message-Objekt kann sowohl zum Darstellen von SOAP 1.1- als auch SOAP 1.2-Umschlägen verwendet werden. Beachten Sie, dass eine Instanz von Message bei der Erstellung festgelegt wird und an eine bestimmte SOAP-Version gebunden ist. Die Version-Eigenschaft stellt die SOAP-Version der Nachricht dar.

Ein Message-Objekt kann in einen externen Speicher serialisiert werden, indem die WriteMessage-Methode verwendet wird. Es können auch Eigenschaften der Nachricht serialisiert werden, wobei diese jedoch einzeln identifiziert und serialisiert werden müssen. Um eine Nachricht zu deserialisieren und ein Message-Objekt im Arbeitsspeicher zu erstellen, kann CreateMessage verwendet werden. Eigenschaften für die spezifische Message-Instanz müssen ebenfalls einzeln deserialisiert und manuell zur Eigenschaftenauflistung hinzugefügt werden .

Die Größe eines Message-Objekts ist an die Größe der Daten, die es überträgt, gebunden. Jeder Nachrichtentext ist als Instanz von XmlReader angelegt, wobei der Stream, der von der XmlReader-Instanz eingebunden wird, keiner vordefinierten Größenbeschränkung unterliegt. Bestimmte Channelanbieter können jedoch die Größe der Nachrichten, die sie verarbeiten, beschränken.

Eine Message kann mit nützlichen Informationen kommentiert werden, die von einer Entität generiert werden, die die Nachricht überprüft und verarbeitet hat. Diese Funktionen werden von der Headers-Eigenschaft und Properties-Eigenschaft zur Verfügung gestellt. Die Headers-Auflistung stellt den Satz von SOAP-Headern in der Nachricht dar.

Die Properties-Eigenschaft stellt den Satz von Anmerkungen auf Verarbeitungsebene über die Nachricht dar. Da Informationen in Headern über das Netzwerk gesendet werden, muss eine Entität, die einen Header überprüft, die zugrunde liegende(n) Version(en) der vom Header verwendeten Protokolle unterstützen. Eigenschaften bieten jedoch eine weniger versionsabhängige Möglichkeit zum Kommentieren einer Nachricht.

Verwenden Sie zum Erstellen einer Message-Instanz eine der CreateMessage-Methoden.

Es wird empfohlen, dass ein Consumer einer Nachricht immer Close aufruft, wenn der Consumer nicht mehr auf den Nachrichteninhalt zugreift. Hierdurch werden finite Systemressourcen (beispielsweise Sockets und Named Pipes) freigegeben, die mit der Lebensdauer der Nachricht verknüpft sind.

Spezieller Hinweis für Benutzer von Managed C++, die von dieser Klasse ableiten:

• Fügen Sie den Bereinigungscode in (On)(Begin)Close (and/or OnAbort) ein, nicht in einen Destruktor.

• Vermeiden Sie Destruktoren: Sie bewirken, dass der Compiler IDisposable automatisch generiert.

• Vermeiden Sie Member ohne Verweis: Sie können bewirken, dass der Compiler IDisposable automatisch generiert.

• Vermeiden Sie Finalizer. Wenn Sie dennoch einen Finalizer verwenden, sollten Sie die Buildwarnung unterdrücken und SuppressFinalize(Object) sowie den Finalizer selbst über (On)(Begin)Close (and/or OnAbort) aufrufen, um das ansonsten automatisch generierte IDisposable-Verhalten zu emulieren.

Hinweise für Ausführende

Wenn Sie von Message erben, müssen Sie folgende Member überschreiben: Headers und Version.

Konstruktoren

Message()

Initialisiert eine neue Instanz der Message-Klasse.

Eigenschaften

Headers	Ruft beim Überschreiben in einer abgeleiteten Klasse die Header der Nachricht ab.
IsDisposed	Gibt einen Wert zurück, der angibt, ob Message verworfen wurde.
IsEmpty	Gibt einen Wert zurück, der angibt, ob Message leer ist.
IsFault	Ruft einen Wert ab, der angibt, ob diese Nachricht SOAP-Fehler generiert.
Properties	Ruft beim Überschreiben in einer abgeleiteten Klasse einen Satz von Anmerkungen auf Vearbeitungsebene für die Nachricht ab.
State	Ruft den aktuellen Status dieser Message ab.
Version	Ruft beim Überschreiben in einer abgeleiteten Klasse die SOAP-Version der Nachricht ab.

Methoden

BeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)	Startet das asynchrone Schreiben der Inhalte des Nachrichtentexts.
BeginWriteMessage(XmlDictionaryWriter, AsyncCallback, Object)	Startet das asynchrone Schreiben der gesamten Nachricht.
Close()	Schließt Message und gibt alle Ressourcen frei.
CreateBufferedCopy(Int32)	Speichert eine gesamte Message in einem Speicherpuffer für den späteren Zugriff.
CreateMessage(MessageVersion, FaultCode, String, Object, String)	Erstellt eine Nachricht, die einen SOAP-Fehler, einen Grund und Details für den Fehler, eine Version und eine Aktion enthält.
CreateMessage(MessageVersion, FaultCode, String, String)	Erstellt eine Nachricht, die einen SOAP-Fehler, einen Grund für den Fehler, eine Version und eine Aktion enthält.
CreateMessage(MessageVersion, MessageFault, String)	Erstellt eine Nachricht, die einen SOAP-Fehler, eine Version und eine Aktion enthält.
CreateMessage(MessageVersion, String)	Erstellt eine Nachricht, die eine Version und eine Aktion enthält.
CreateMessage(MessageVersion, String, BodyWriter)	Erstellt eine Nachricht mit einem Text, der aus einem Array von Byte besteht.
CreateMessage(MessageVersion, String, Object)	Erstellt eine Nachricht mit der angegebenen Version, Aktion und angegebenem Text.
CreateMessage(MessageVersion, String, Object, XmlObjectSerializer)	Erstellt eine Nachricht mit der angegebenen Version, Aktion, dem Nachrichtentext und Serialisierungsprogramm.
CreateMessage(MessageVersion, String, XmlDictionaryReader)	Erstellt eine Nachricht mit der angegebenen Version, Aktion und angegebenem Text.
CreateMessage(MessageVersion, String, XmlReader)	Erstellt eine Nachricht mit dem angegebenen Reader, der Aktion und Version.
CreateMessage(XmlDictionaryReader, Int32, MessageVersion)	Erstellt eine Nachricht mit dem angegebenen Reader, der Aktion und Version.
CreateMessage(XmlReader, Int32, MessageVersion)	Erstellt eine Nachricht mit dem angegebenen Reader, der Aktion und Version.
EndWriteBodyContents(IAsyncResult)	Beendet das asynchrone Schreiben der Inhalte des Nachrichtentexts.
EndWriteMessage(IAsyncResult)	Beendet das asynchrone Schreiben der gesamten Nachricht.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetBody<T>()	Ruft den Text dieser Message-Instanz ab.
GetBody<T>(XmlObjectSerializer)	Ruft den Text dieser Message mit dem angegebenen Serialisierungsprogramm ab.
GetBodyAttribute(String, String)	Ruft die Attribute des Nachrichtentexts ab.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetReaderAtBodyContents()	Ruft den XML-Wörterbuchreader ab, der auf den Textinhalt dieser Nachricht zugreift.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnBeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)	Löst ein Ereignis aus, wenn die Meldung mit dem Schreiben der Inhalte des Nachrichtentexts beginnt.
OnBeginWriteMessage(XmlDictionaryWriter, AsyncCallback, Object)	Löst ein Ereignis aus, wenn das Schreiben von gesamten Nachrichten beginnt.
OnBodyToString(XmlDictionaryWriter)	Wird aufgerufen, wenn der Nachrichtentext in eine Zeichenfolge konvertiert wird.
OnClose()	Wird aufgerufen, wenn die Nachricht geschlossen wird.
OnCreateBufferedCopy(Int32)	Wird aufgerufen, wenn ein Nachrichtenpuffer erstellt wird, um diese Nachricht zu speichern.
OnEndWriteBodyContents(IAsyncResult)	Löst ein Ereignis aus, wenn das Schreiben der Inhalte des Nachrichtentextes beendet wird.
OnEndWriteMessage(IAsyncResult)	Löst ein Ereignis aus, wenn das Schreiben der gesamten Nachricht beendet wird.
OnGetBody<T>(XmlDictionaryReader)	Wird aufgerufen, wenn der Nachrichtentext abgerufen wird.
OnGetBodyAttribute(String, String)	Wird aufgerufen, wenn die Attribute des Nachrichtentexts abgerufen werden.
OnGetReaderAtBodyContents()	Wird aufgerufen, wenn ein XML-Wörterbuchreader abgerufen wird, der auf den Textinhalt dieser Nachricht zugreift.
OnWriteBodyContents(XmlDictionaryWriter)	Wird aufgerufen, wenn der Nachrichtentext in eine XML-Datei geschrieben wird.
OnWriteBodyContentsAsync(XmlDictionaryWriter)	Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.
OnWriteMessage(XmlDictionaryWriter)	Wird aufgerufen, wenn die gesamte Nachricht in eine XML-Datei geschrieben wird.
OnWriteMessageAsync(XmlDictionaryWriter)	Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.
OnWriteStartBody(XmlDictionaryWriter)	Wird aufgerufen, wenn der Starttext in eine XML-Datei geschrieben wird.
OnWriteStartEnvelope(XmlDictionaryWriter)	Wird aufgerufen, wenn der Startumschlag in eine XML-Datei geschrieben wird.
OnWriteStartHeaders(XmlDictionaryWriter)	Wird aufgerufen, wenn der Startheader in eine XML-Datei geschrieben wird.
ToString()	Gibt eine Zeichenfolge zurück, die die aktuelle Message-Instanz darstellt.
WriteBody(XmlDictionaryWriter)	Schreibt das Textelement mit dem angegebenen XmlDictionaryWriter.
WriteBody(XmlWriter)	Serialisiert den Nachrichtentext mit dem angegebenen XmlWriter.
WriteBodyContents(XmlDictionaryWriter)	Serialisiert den Textinhalt mit dem angegebenen XmlDictionaryWriter.
WriteBodyContentsAsync(XmlDictionaryWriter)	Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.
WriteMessage(XmlDictionaryWriter)	Serialisiert die gesamte Nachricht mit dem angegebenen XmlDictionaryWriter.
WriteMessage(XmlWriter)	Serialisiert die gesamte Nachricht mit dem angegebenen XmlWriter.
WriteMessageAsync(XmlDictionaryWriter)	Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.
WriteMessageAsync(XmlWriter)	Stellt die Kommunikationseinheit zwischen Endpunkten in einer verteilten Umgebung dar.
WriteStartBody(XmlDictionaryWriter)	Serialisiert den Anfangstext der Nachricht mit dem angegebenen XmlDictionaryWriter.
WriteStartBody(XmlWriter)	Serialisiert den Anfangstext der Nachricht mit dem angegebenen XmlDictionaryWriter.
WriteStartEnvelope(XmlDictionaryWriter)	Serialisiert den Startumschlag mit dem angegebenen XmlDictionaryWriter.

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Schließt alle Ressourcen, die von dieser Nachricht verwendet werden. Diese Methode kann nicht vererbt werden.

Erweiterungsmethoden