Message Classe

Référence

Définition

Espace de noms:: System.ServiceModel.Channels

Assembly:: System.ServiceModel.Primitives.dll

Assembly:: System.ServiceModel.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente l'unité de communication entre des points de terminaison dans un environnement distribué.

public ref class Message abstract : IDisposable

public abstract class Message : IDisposable

type Message = class
    interface IDisposable

Public MustInherit Class Message
Implements IDisposable

Héritage: Object
Message

Implémente: IDisposable

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.

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. Elle peut servir à relayer des informations, suggérer ou même demander un plan d'action ou des données.

La structure d'un objet Message représente une enveloppe SOAP. Elle comporte deux parties distinctes : le corps du message et une collection d’en-têtes facultative, représentée par la classe Headers. Le contenu du message consiste en des données définies par l'application et envoyées par un expéditeur à un destinataire. 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. Vous pouvez également définir vos propres en-têtes. Les en-têtes de message sont sérialisés ou désérialisés avec le contenu du message.

Les messages sont reçus et envoyés dans des formats particuliers. Deux formats sont pris en charge : le format XML texte standard et un format XML binaire. L'objet Message peut être utilisé pour représenter les enveloppes SOAP 1.1 et SOAP 1.2. Notez qu'une instance de Message est résolue à la création et est liée à une version SOAP spécifique. La propriété Version représente la version SOAP du message.

Un objet Message peut être sérialisé vers un magasin externe à l'aide de la méthode WriteMessage. 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. La désérialisation d'un message pour créer un objet Message en mémoire peut se faire à l'aide de 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.

La taille d'un objet Message est fixée sur la taille des données que cet objet transmet. 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. Toutefois, des fournisseurs de canal spécifiques peuvent définir une limite pour la taille des messages qu'ils traitent.

Un Message peut être annoté avec des informations utiles générées par une entité qui a examiné et traité le message. Cette fonctionnalité est fournie par les propriétés Headers et Properties. La collection Headers représente le jeu d’en-têtes SOAP sur le message.

La propriété Properties représente le jeu d'annotations au niveau de traitement sur le 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. Toutefois, les propriétés offrent un moyen d'annoter un message plus indépendant de la version.

Pour créer une instance Message, utilisez l'une des méthodes CreateMessage.

Il est recommandé que le consommateur d'un message appelle toujours Close lorsqu'il a fini de consommer le contenu du 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.

Remarque spéciale destinée aux utilisateurs C++ managés dérivés de cette classe :

Placez votre code de nettoyage dans (On)(Begin)Close (et/ou OnAbort), pas dans un destructeur.
Évitez les destructeurs car ils provoquent la génération automatique de IDisposable par le compilateur.
Évitez les membres sans référence car ils peuvent provoquer la génération automatique de IDisposable par le compilateur.
É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.

Notes pour les responsables de l’implémentation

Lorsque vous héritez de Message, vous devez remplacer les membres suivants : Headers et Version.

Constructeurs

Message()

Initialise une nouvelle instance de la classe Message.

Propriétés

Headers	En cas de remplacement dans une classe dérivée, obtient les en-têtes du message.
IsDisposed	Retourne une valeur qui indique si Message est supprimé.
IsEmpty	Retourne une valeur qui indique si Message est vide.
IsFault	Obtient une valeur qui indique si ce message génère des erreurs SOAP.
Properties	En cas de remplacement dans une classe dérivée, obtient un jeu d'annotations au niveau du traitement dans le message.
State	Obtient l'état actuel de ce Message.
Version	En cas de remplacement dans une classe dérivée, obtient la version SOAP du message.

Méthodes

BeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)	Démarre l'écriture asynchrone du contenu du corps du message.
BeginWriteMessage(XmlDictionaryWriter, AsyncCallback, Object)	Démarre l'écriture asynchrone de l'intégralité du message.
Close()	Ferme Message et libère toutes les ressources.
CreateBufferedCopy(Int32)	Stocke un objet Message entier dans la mémoire tampon en vue de son accès ultérieurement.
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.
CreateMessage(MessageVersion, FaultCode, String, String)	Crée un message qui contient une erreur SOAP, son motif, la version et une action.
CreateMessage(MessageVersion, MessageFault, String)	Crée un message contenant une erreur SOAP, une version et une action.
CreateMessage(MessageVersion, String)	Crée un message qui contient une version et une action.
CreateMessage(MessageVersion, String, BodyWriter)	Crée un message avec un corps consistant en un tableau d'octets.
CreateMessage(MessageVersion, String, Object)	Crée un message avec la version, l'action et le corps spécifiés.
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.
CreateMessage(MessageVersion, String, XmlDictionaryReader)	Crée un message avec la version, l'action et le corps spécifiés.
CreateMessage(MessageVersion, String, XmlReader)	Crée un message à l'aide du lecteur, de l'action et de la version spécifiés.
CreateMessage(XmlDictionaryReader, Int32, MessageVersion)	Crée un message à l'aide du lecteur, de l'action et de la version spécifiés.
CreateMessage(XmlReader, Int32, MessageVersion)	Crée un message à l'aide du lecteur, de l'action et de la version spécifiés.
EndWriteBodyContents(IAsyncResult)	Met fin à l'écriture asynchrone du contenu du corps du message.
EndWriteMessage(IAsyncResult)	Met fin à l'écriture asynchrone de l'intégralité du message.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetBody<T>()	Récupère le corps de cette instance Message.
GetBody<T>(XmlObjectSerializer)	Récupère le corps de ce Message à l'aide du sérialiseur spécifié.
GetBodyAttribute(String, String)	Récupère les attributs du corps du message.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetReaderAtBodyContents()	Obtient le lecteur de dictionnaire XML qui accède au contenu du corps du message.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (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.
OnBeginWriteMessage(XmlDictionaryWriter, AsyncCallback, Object)	Déclenche un événement lorsque l'écriture de messages entiers démarre.
OnBodyToString(XmlDictionaryWriter)	Appelé lorsque le corps du message est converti en chaîne.
OnClose()	Appelé lorsque le message est fermé.
OnCreateBufferedCopy(Int32)	Appelé lorsqu'un tampon de messages est créé pour stocker ce message.
OnEndWriteBodyContents(IAsyncResult)	Déclenche un événement lorsque l'écriture du contenu du corps du message se termine.
OnEndWriteMessage(IAsyncResult)	Déclenche un événement lorsque l'écriture du message entier se termine.
OnGetBody<T>(XmlDictionaryReader)	Appelée lorsque le corps du message est récupéré.
OnGetBodyAttribute(String, String)	Appelé lorsque les attributs du corps du message sont récupérés.
OnGetReaderAtBodyContents()	Appelée lorsqu'un lecteur de dictionnaire XML qui accède au contenu du corps du message est récupéré.
OnWriteBodyContents(XmlDictionaryWriter)	Appelé lorsque le corps du message est écrit dans un fichier XML.
OnWriteMessage(XmlDictionaryWriter)	Appelé lorsque l'intégralité du message est écrite dans un fichier XML.
OnWriteStartBody(XmlDictionaryWriter)	Appelé lorsque le corps de début est écrit dans un fichier XML.
OnWriteStartEnvelope(XmlDictionaryWriter)	Appelé lorsque l'enveloppe de début est écrite dans un fichier XML.
OnWriteStartHeaders(XmlDictionaryWriter)	Appelé lorsque l'en-tête de début est écrit dans un fichier XML.
ToString()	Retourne une chaîne qui représente l'instance Message actuelle.
WriteBody(XmlDictionaryWriter)	Écrit l'élément body à l'aide du XmlDictionaryWriter spécifié.
WriteBody(XmlWriter)	Sérialise le corps du message à l'aide du XmlWriter spécifié.
WriteBodyContents(XmlDictionaryWriter)	Sérialise le contenu du corps à l'aide du XmlDictionaryWriter spécifié.
WriteMessage(XmlDictionaryWriter)	Sérialise l'intégralité du message à l'aide du XmlDictionaryWriter spécifié.
WriteMessage(XmlWriter)	Sérialise l'intégralité du message à l'aide du XmlWriter spécifié.
WriteStartBody(XmlDictionaryWriter)	Sérialise le corps de début du message à l'aide de l'objet XmlDictionaryWriter spécifié.
WriteStartBody(XmlWriter)	Sérialise le corps de début du message à l'aide de l'objet XmlDictionaryWriter spécifié.
WriteStartEnvelope(XmlDictionaryWriter)	Sérialise l'enveloppe de début à l'aide du XmlDictionaryWriter spécifié.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Ferme toutes les ressources utilisées par ce message. Cette méthode ne peut pas être héritée.

Méthodes d’extension

ToHttpRequestMessage(Message)	Crée une instance HttpRequestMessage à partir d'une instance Message.
ToHttpResponseMessage(Message)	Crée une instance HttpResponseMessage à partir d'une instance Message.

S’applique à