MessageEncoder 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.

L'encodeur est le composant utilisé pour écrire des messages dans un flux de données et lire des messages à partir d'un flux de données.

public ref class MessageEncoder abstract

public abstract class MessageEncoder

type MessageEncoder = class

Public MustInherit Class MessageEncoder

Héritage: Object
MessageEncoder

Exemples

Le code suivant constitue un exemple de classe dérivée de MessageEncoder.

public class CustomTextMessageEncoder : MessageEncoder
{
    private CustomTextMessageEncoderFactory factory;
    private XmlWriterSettings writerSettings;
    private string contentType;

    public CustomTextMessageEncoder(CustomTextMessageEncoderFactory factory)
    {
        this.factory = factory;

        this.writerSettings = new XmlWriterSettings();
        this.writerSettings.Encoding = Encoding.GetEncoding(factory.CharSet);
        this.contentType = string.Format("{0}; charset={1}",
            this.factory.MediaType, this.writerSettings.Encoding.HeaderName);
    }

    public override string ContentType
    {
        get
        {
            return this.contentType;
        }
    }

    public override string MediaType
    {
        get
        {
            return factory.MediaType;
        }
    }

    public override MessageVersion MessageVersion
    {
        get
        {
            return this.factory.MessageVersion;
        }
    }

    public override bool IsContentTypeSupported(string contentType)
    {
        if (base.IsContentTypeSupported(contentType))
        {
            return true;
        }
        if (contentType.Length == this.MediaType.Length)
        {
            return contentType.Equals(this.MediaType, StringComparison.OrdinalIgnoreCase);
        }
        else
        {
            if (contentType.StartsWith(this.MediaType, StringComparison.OrdinalIgnoreCase)
                && (contentType[this.MediaType.Length] == ';'))
            {
                return true;
            }
        }
        return false;
    }

    public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
    {
        byte[] msgContents = new byte[buffer.Count];
        Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length);
        bufferManager.ReturnBuffer(buffer.Array);

        MemoryStream stream = new MemoryStream(msgContents);
        return ReadMessage(stream, int.MaxValue);
    }

    public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
    {
        XmlReader reader = XmlReader.Create(stream);
        return Message.CreateMessage(reader, maxSizeOfHeaders, this.MessageVersion);
    }

    public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
    {
        MemoryStream stream = new MemoryStream();
        XmlWriter writer = XmlWriter.Create(stream, this.writerSettings);
        message.WriteMessage(writer);
        writer.Close();

        byte[] messageBytes = stream.GetBuffer();
        int messageLength = (int)stream.Position;
        stream.Close();

        int totalLength = messageLength + messageOffset;
        byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
        Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);

        ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
        return byteArray;
    }

    public override void WriteMessage(Message message, Stream stream)
    {
        XmlWriter writer = XmlWriter.Create(stream, this.writerSettings);
        message.WriteMessage(writer);
        writer.Close();
    }

Remarques

MessageEncoder est une classe de base qui fournit des implémentations qui prennent en charge un type de contenu MIME (Multipurpose Internet Mail Extensions) et une version de message, et définit l’interface pour la sérialisation et la désérialisation des messages en fonction de ce type de contenu. Utilisez-la comme classe de base pour écrire votre propre encodeur personnalisé.

Utilisez cette classe si vous souhaitez implémenter un encodeur de message personnalisé. Pour implémenter votre propre encodeur de message personnalisé, vous devez fournir des implémentations personnalisées des classes de base abstraites suivantes :

Substituez Encoder pour retourner une instance de votre MessageEncoder personnalisé. Puis rattachez votre MessageEncoderFactory personnalisé à la pile d’élément de liaison utilisée pour configurer le service ou le client en substituant la méthode CreateMessageEncoderFactory pour retourner une instance de cette fabrique.

La tâche de conversion entre la représentation en mémoire d'un message et une représentation Infoset (Information Set) XML qui peuvent être écrites dans un flux de données est encapsulée dans la classe MessageEncoder, qui sert généralement de fabrique pour les lecteurs et writers XML qui prennent en charge des types d'encodages XML spécifiques.

Les principales méthodes sur l'objet MessageEncoder sont WriteMessage et ReadMessage. La méthode WriteMessage accepte un objet Message et l'écrit dans un objet Stream. ReadMessage prend un objet et une Stream taille d’en-tête maximale et retourne un Message objet.

Constructeurs

MessageEncoder()

Initialise une nouvelle instance de la classe MessageEncoder.

Propriétés

ContentType	En cas de substitution dans une classe dérivée, obtient le type de contenu MIME utilisé par l'encodeur.
MediaType	En cas de substitution dans une classe dérivée, obtient la valeur du type de média utilisé par l'encodeur.
MessageVersion	En cas de substitution dans une classe dérivée, obtient la valeur de la version du message utilisée par l'encodeur.

Méthodes

BeginWriteMessage(Message, Stream, AsyncCallback, Object)	Démarre l'écriture du message pour l'encodeur de message avec le message, le flux de données, le rappel et l'état spécifiés.
EndWriteMessage(IAsyncResult)	Met fin à l'écriture de messages pour l'auteur du code de message.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetProperty<T>()	Retourne un objet typé demandé (s'il existe) à partir de la couche appropriée dans la pile de canaux.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
IsContentTypeSupported(String)	Retourne une valeur qui indique si une valeur content-type au niveau du message spécifiée est prise en charge par l'encodeur de message.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ReadMessage(ArraySegment<Byte>, BufferManager)	En cas de substitution dans une classe dérivée, lit un message dans une mémoire tampon spécifiée.
ReadMessage(ArraySegment<Byte>, BufferManager, String)	En cas de substitution dans une classe dérivée, lit un message dans un flux de données spécifié.
ReadMessage(Stream, Int32)	En cas de substitution dans une classe dérivée, lit un message dans un flux de données spécifié.
ReadMessage(Stream, Int32, String)	En cas de substitution dans une classe dérivée, lit un message dans un flux de données spécifié.
ToString()	Renvoie le type de contenu utilisé par l'encodeur de message.
WriteMessage(Message, Int32, BufferManager)	Écrit un message dont la taille est inférieure à celle spécifiée dans une mémoire tampon de tableau d'octets.
WriteMessage(Message, Int32, BufferManager, Int32)	En cas de substitution dans une classe dérivée, écrit un message dont la taille est inférieure à celle spécifiée dans une mémoire tampon de tableau d'octets à l'offset spécifié.
WriteMessage(Message, Stream)	En cas de substitution dans une classe dérivée, écrit un message dans un flux de données spécifié.

S’applique à