Message Classe

Définition

Représente l'unité de communication entre des points de terminaison dans un environnement distribué.Represents the unit of communication between endpoints in a distributed environment.

public ref class Message abstract : IDisposable
public abstract class Message : IDisposable
type Message = class
    interface IDisposable
Public MustInherit Class Message
Implements IDisposable
Héritage
Message
Implémente

Exemples

L'exemple de code suivant illustre un client qui utilise la fabrication de canal pour envoyer un message et en lire la réponse.The following code example shows a client that uses the channel factory to send a message and read the reply.

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

Remarques

La classe Message permet de communiquer des informations arbitraires entre un expéditeur et un destinataire sur un réseau.The Message class provides a means of communicating arbitrary information between a sender and a receiver on a network. Elle peut servir à relayer des informations, suggérer ou même demander un plan d'action ou des données.It can be used to relay information, suggest or demand a course of action, or request data.

La structure d'un objet Message représente une enveloppe SOAP.The structure of a Message object represents a SOAP envelope. Elle comporte deux parties distinctes : le corps du message et une collection d’en-têtes facultative, représentée par la classe Headers.It consists of two distinct parts: the message's body and an optional collection of headers, represented by the Headers class. Le contenu du message consiste en des données définies par l'application et envoyées par un expéditeur à un destinataire.The message content is application-defined data sent from a sender to a receiver. Les en-têtes de message favorisent une extensibilité du système et des applications qui répond à vos besoins d’évolution puisque vous pouvez définir le code permettant de manipuler et de répondre à des en-têtes spécifiques.The message headers enable system and application extensibility to meet the changing requirements, because you can define code to manipulate and respond to specific headers. Vous pouvez également définir vos propres en-têtes.You can also define your own headers. Les en-têtes de message sont sérialisés ou désérialisés avec le contenu du message.Message headers are serialized or deserialized along with the contents of the message.

Les messages sont reçus et envoyés dans des formats particuliers.Messages are received and sent in particular formats. Deux formats sont pris en charge : le format XML texte standard et un format XML binaire.Support is provided for two formats: the standard text-based XML format and a binary-based XML format. L'objet Message peut être utilisé pour représenter les enveloppes SOAP 1.1 et SOAP 1.2.The Message object can be used to represent both SOAP 1.1 and SOAP 1.2 envelopes. Notez qu'une instance de Message est résolue à la création et est liée à une version SOAP spécifique.Note that an instance of Message is fixed upon creation and is bound to a specific SOAP version. La propriété Version représente la version SOAP du message.The Version property represents the SOAP version of the message.

Un objet Message peut être sérialisé vers un magasin externe à l'aide de la méthode WriteMessage.A Message object can be serialized to an external store by using the WriteMessage method. Les propriétés du message peuvent également être sérialisées, mais elles doivent être identifiées individuellement et sérialisées séparément.Properties of the message can also be serialized, but they have to be individually identified and serialized separately. La désérialisation d'un message pour créer un objet Message en mémoire peut se faire à l'aide de CreateMessage.Deserializing a message to create an in-memory Message object can be done using CreateMessage. Les propriétés doivent également être désérialisées individuellement et ajoutées manuellement dans la collection des propriétés pour l’instance Message spécifique.Properties must also be deserialized individually and manually added to the property collection for the specific Message instance.

La taille d'un objet Message est fixée sur la taille des données que cet objet transmet.The size of a Message object is fixed to the size of data it is transmitting. Chaque corps est modelé comme une instance de XmlReader, sans aucune limite prédéfinie pour la taille du flux de données que l'instance XmlReader encapsule.Every body is modeled as an instance of XmlReader, with no predefined limit on the size of the stream that the XmlReader instance is wrapping. Toutefois, des fournisseurs de canal spécifiques peuvent définir une limite pour la taille des messages qu'ils traitent.However, specific channel providers can have a limit on the size of messages that they process.

Un Message peut être annoté avec des informations utiles générées par une entité qui a examiné et traité le message.A Message can be annotated with useful information generated by an entity that has examined and processed the message. Cette fonctionnalité est fournie par les propriétés Headers et Properties.This functionality is provided by the Headers and Properties properties. La collection Headers représente le jeu d’en-têtes SOAP sur le message.The Headers collection represents the set of SOAP headers on the message.

La propriété Properties représente le jeu d'annotations au niveau de traitement sur le message.The Properties property represents the set of processing-level annotations on the message. Du fait que les informations contenues dans les en-têtes sont transmises par câble, une entité qui examine un en-tête doit prendre en charge la ou les versions sous-jacentes des protocoles utilisés par l'en-tête.Because information in headers is transmitted on the wire, an entity that examines a header must support the underlying version(s) of the protocols used by the header. Toutefois, les propriétés offrent un moyen d'annoter un message plus indépendant de la version.However, properties provide a more version-independent way of annotating a message.

Pour créer une instance Message, utilisez l'une des méthodes CreateMessage.To create a Message instance, use one of the CreateMessage methods.

Il est recommandé que le consommateur d'un message appelle toujours Close lorsqu'il a fini de consommer le contenu du message.It is recommended that a consumer of a message always call Close when the consumer is finished accessing the contents of the message. Cette action libère des ressources système finies (par exemple, des sockets, des canaux nommés) liées à la durée de vie du message.This action frees finite system resources (for example, sockets, named pipes) that are tied to the lifetime of the message.

Remarque spéciale destinée aux utilisateurs C++ managés dérivés de cette classe :Special note for Managed C++ users deriving from this class:

  • Placez votre code de nettoyage dans (On)(Begin)Close (et/ou OnAbort), pas dans un destructeur.Put your cleanup code in (On)(Begin)Close (and/or OnAbort), not in a destructor.

  • Évitez les destructeurs car ils provoquent la génération automatique de IDisposable par le compilateur.Avoid destructors: they cause the compiler to auto-generate IDisposable.

  • Évitez les membres sans référence car ils peuvent provoquer la génération automatique de IDisposable par le compilateur.Avoid non-reference members: they can cause the compiler to auto-generate IDisposable.

  • Évitez les finaliseurs ; cependant, si vous en incluez un, vous devrez supprimer l'avertissement de génération et appeler SuppressFinalize(Object) et le finaliseur depuis (On)(Begin)Close (et/ou OnAbort) pour émuler le comportement prévu propre à l'interface IDisposable générée automatiquement.Avoid finalizers; but if you include one, suppress the build warning and call SuppressFinalize(Object) and the finalizer itself from (On)(Begin)Close (and/or OnAbort) to emulate what would have been the auto-generated IDisposable behavior.

Notes pour les responsables de l’implémentation

Lorsque vous héritez de Message, vous devez remplacer les membres suivants : Headers et Version.When you inherit from Message, you must override the following members: Headers, and Version.

Constructeurs

Message()

Initialise une nouvelle instance de la classe Message.Initializes a new instance of the Message class.

Propriétés

Headers

En cas de remplacement dans une classe dérivée, obtient les en-têtes du message.When overridden in a derived class, gets the headers of the message.

IsDisposed

Retourne une valeur qui indique si Message est supprimé.Returns a value that indicates whether the Message is disposed.

IsEmpty

Retourne une valeur qui indique si Message est vide.Returns a value that indicates whether the Message is empty.

IsFault

Obtient une valeur qui indique si ce message génère des erreurs SOAP.Gets a value that indicates whether this message generates any SOAP faults.

Properties

En cas de remplacement dans une classe dérivée, obtient un jeu d'annotations au niveau du traitement dans le message.When overridden in a derived class, gets a set of processing-level annotations to the message.

State

Obtient l'état actuel de ce Message.Gets the current state of this Message.

Version

En cas de remplacement dans une classe dérivée, obtient la version SOAP du message.When overridden in a derived class, gets the SOAP version of the message.

Méthodes

BeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)

Démarre l'écriture asynchrone du contenu du corps du message.Starts the asynchronous writing of the contents of the message body.

BeginWriteMessage(XmlDictionaryWriter, AsyncCallback, Object)

Démarre l'écriture asynchrone de l'intégralité du message.Starts the asynchronous writing of the entire message.

Close()

Ferme Message et libère toutes les ressources.Closes the Message and releases any resources.

CreateBufferedCopy(Int32)

Stocke un objet Message entier dans la mémoire tampon en vue de son accès ultérieurement.Stores an entire Message into a memory buffer for future access.

CreateMessage(MessageVersion, FaultCode, String, Object, String)

Crée un message qui contient une erreur SOAP, son motif et les informations relatives à l'erreur, une version et une action.Creates a message that contains a SOAP fault, a reason and the detail for the fault, a version and an action.

CreateMessage(MessageVersion, FaultCode, String, String)

Crée un message qui contient une erreur SOAP, son motif, la version et une action.Creates a message that contains a SOAP fault, the reason for the fault, a version and an action.

CreateMessage(MessageVersion, MessageFault, String)

Crée un message contenant une erreur SOAP, une version et une action.Creates a message that contains a SOAP fault, a version and an action.

CreateMessage(MessageVersion, String)

Crée un message qui contient une version et une action.Creates a message that contains a version and an action.

CreateMessage(MessageVersion, String, BodyWriter)

Crée un message avec un corps consistant en un tableau d'octets.Creates a message with a body that consists of an array of bytes.

CreateMessage(MessageVersion, String, Object)

Crée un message avec la version, l'action et le corps spécifiés.Creates a message with the specified version, action and body.

CreateMessage(MessageVersion, String, Object, XmlObjectSerializer)

Crée un message à l'aide de la version, l'action, le corps du message et le sérialiseur spécifiés.Creates a message using the specified version, action, message body and serializer.

CreateMessage(MessageVersion, String, XmlDictionaryReader)

Crée un message avec la version, l'action et le corps spécifiés.Creates a message with the specified version, action and body.

CreateMessage(MessageVersion, String, XmlReader)

Crée un message à l'aide du lecteur, de l'action et de la version spécifiés.Creates a message using the specified reader, action and version.

CreateMessage(XmlDictionaryReader, Int32, MessageVersion)

Crée un message à l'aide du lecteur, de l'action et de la version spécifiés.Creates a message using the specified reader, action and version.

CreateMessage(XmlReader, Int32, MessageVersion)

Crée un message à l'aide du lecteur, de l'action et de la version spécifiés.Creates a message using the specified reader, action and version.

EndWriteBodyContents(IAsyncResult)

Met fin à l'écriture asynchrone du contenu du corps du message.Ends the asynchronous writing of the contents of the message body.

EndWriteMessage(IAsyncResult)

Met fin à l'écriture asynchrone de l'intégralité du message.Ends the asynchronous writing of the entire message.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetBody<T>()

Récupère le corps de cette instance Message.Retrieves the body of this Message instance.

GetBody<T>(XmlObjectSerializer)

Récupère le corps de ce Message à l'aide du sérialiseur spécifié.Retrieves the body of this Message using the specified serializer.

GetBodyAttribute(String, String)

Récupère les attributs du corps du message.Retrieves the attributes of the message body.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetReaderAtBodyContents()

Obtient le lecteur de dictionnaire XML qui accède au contenu du corps du message.Gets the XML dictionary reader that accesses the body content of this message.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
OnBeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)

Déclenche un événement lorsque le message démarre l'écriture du contenu du corps du message.Raises an event when the message starts writing the contents of the message body.

OnBeginWriteMessage(XmlDictionaryWriter, AsyncCallback, Object)

Déclenche un événement lorsque l'écriture de messages entiers démarre.Raises an event the writing of entire messages starts.

OnBodyToString(XmlDictionaryWriter)

Appelé lorsque le corps du message est converti en chaîne.Called when the message body is converted to a string.

OnClose()

Appelé lorsque le message est fermé.Called when the message is closing.

OnCreateBufferedCopy(Int32)

Appelé lorsqu'un tampon de messages est créé pour stocker ce message.Called when a message buffer is created to store this message.

OnEndWriteBodyContents(IAsyncResult)

Déclenche un événement lorsque l'écriture du contenu du corps du message se termine.Raises an event when writing of the contents of the message body ends.

OnEndWriteMessage(IAsyncResult)

Déclenche un événement lorsque l'écriture du message entier se termine.Raises an event when the writing of the entire message ends.

OnGetBody<T>(XmlDictionaryReader)

Appelée lorsque le corps du message est récupéré.Called when the body of the message is retrieved.

OnGetBodyAttribute(String, String)

Appelé lorsque les attributs du corps du message sont récupérés.Called when the attributes of the message body is retrieved.

OnGetReaderAtBodyContents()

Appelée lorsqu'un lecteur de dictionnaire XML qui accède au contenu du corps du message est récupéré.Called when an XML dictionary reader that accesses the body content of this message is retrieved.

OnWriteBodyContents(XmlDictionaryWriter)

Appelé lorsque le corps du message est écrit dans un fichier XML.Called when the message body is written to an XML file.

OnWriteMessage(XmlDictionaryWriter)

Appelé lorsque l'intégralité du message est écrite dans un fichier XML.Called when the entire message is written to an XML file.

OnWriteStartBody(XmlDictionaryWriter)

Appelé lorsque le corps de début est écrit dans un fichier XML.Called when the start body is written to an XML file.

OnWriteStartEnvelope(XmlDictionaryWriter)

Appelé lorsque l'enveloppe de début est écrite dans un fichier XML.Called when the start envelope is written to an XML file.

OnWriteStartHeaders(XmlDictionaryWriter)

Appelé lorsque l'en-tête de début est écrit dans un fichier XML.Called when the start header is written to an XML file.

ToString()

Retourne une chaîne qui représente l'instance Message actuelle.Returns a string that represents the current Message instance.

WriteBody(XmlDictionaryWriter)

Écrit l'élément body à l'aide du XmlDictionaryWriter spécifié.Writes the body element using the specified XmlDictionaryWriter.

WriteBody(XmlWriter)

Sérialise le corps du message à l'aide du XmlWriter spécifié.Serializes the message body using the specified XmlWriter.

WriteBodyContents(XmlDictionaryWriter)

Sérialise le contenu du corps à l'aide du XmlDictionaryWriter spécifié.Serializes the body content using the specified XmlDictionaryWriter.

WriteMessage(XmlDictionaryWriter)

Sérialise l'intégralité du message à l'aide du XmlDictionaryWriter spécifié.Serializes the entire message using the specified XmlDictionaryWriter.

WriteMessage(XmlWriter)

Sérialise l'intégralité du message à l'aide du XmlWriter spécifié.Serializes the entire message using the specified XmlWriter.

WriteStartBody(XmlDictionaryWriter)

Sérialise le corps de début du message à l'aide de l'objet XmlDictionaryWriter spécifié.Serializes the start body of the message using the specified XmlDictionaryWriter.

WriteStartBody(XmlWriter)

Sérialise le corps de début du message à l'aide de l'objet XmlDictionaryWriter spécifié.Serializes the start body of the message using the specified XmlDictionaryWriter.

WriteStartEnvelope(XmlDictionaryWriter)

Sérialise l'enveloppe de début à l'aide du XmlDictionaryWriter spécifié.Serializes the start envelope using the specified XmlDictionaryWriter.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Ferme toutes les ressources utilisées par ce message.Closes all the resources used by this message. Cette méthode ne peut pas être héritée.This method cannot be inherited.

Méthodes d’extension

ToHttpRequestMessage(Message)

Crée une instance HttpRequestMessage à partir d'une instance Message.Creates a HttpRequestMessage instance from an Message instance.

ToHttpResponseMessage(Message)

Crée une instance HttpResponseMessage à partir d'une instance Message.Creates a HttpResponseMessage instance from an Message instance.

S’applique à