MessageEncodingBindingElement Classe

Définition

Espace de noms:

System.ServiceModel.Channels

Assemblys:

System.ServiceModel.dll, System.ServiceModel.Primitives.dll

Paquet:

System.ServiceModel.Primitives v10.0.652802

Source:

MessageEncodingBindingElement.cs

Élément de liaison qui spécifie la version du message utilisée pour encoder les messages.

public ref class MessageEncodingBindingElement abstract : System::ServiceModel::Channels::BindingElement

public abstract class MessageEncodingBindingElement : System.ServiceModel.Channels.BindingElement

type MessageEncodingBindingElement = class
    inherit BindingElement

Public MustInherit Class MessageEncodingBindingElement
Inherits BindingElement

Héritage

Object

BindingElement

MessageEncodingBindingElement

Dérivé

System.ServiceModel.Channels.BinaryMessageEncodingBindingElement

System.ServiceModel.Channels.ByteStreamMessageEncodingBindingElement

System.ServiceModel.Channels.MtomMessageEncodingBindingElement

System.ServiceModel.Channels.TextMessageEncodingBindingElement

System.ServiceModel.Channels.WebMessageEncodingBindingElement

Exemples

L’exemple de code suivant montre comment implémenter une classe dérivée de MessageEncodingBindingElement:

public class CustomTextMessageBindingElement : MessageEncodingBindingElement, IWsdlExportExtension
{
    private MessageVersion msgVersion;
    private string mediaType;
    private string encoding;
    private XmlDictionaryReaderQuotas readerQuotas;

    CustomTextMessageBindingElement(CustomTextMessageBindingElement binding)
        : this(binding.Encoding, binding.MediaType, binding.MessageVersion)
    {
        this.readerQuotas = new XmlDictionaryReaderQuotas();
        binding.ReaderQuotas.CopyTo(this.readerQuotas);
    }

    public CustomTextMessageBindingElement(string encoding, string mediaType,
        MessageVersion msgVersion)
    {
        if (encoding == null)
            throw new ArgumentNullException(nameof(encoding));

        if (mediaType == null)
            throw new ArgumentNullException(nameof(mediaType));

        if (msgVersion == null)
            throw new ArgumentNullException(nameof(msgVersion));

        this.msgVersion = msgVersion;
        this.mediaType = mediaType;
        this.encoding = encoding;
        this.readerQuotas = new XmlDictionaryReaderQuotas();
    }

    public CustomTextMessageBindingElement(string encoding, string mediaType)
        : this(encoding, mediaType, MessageVersion.Soap11WSAddressing10)
    {
    }

    public CustomTextMessageBindingElement(string encoding)
        : this(encoding, "text/xml")
    {
    }

    public CustomTextMessageBindingElement()
        : this("UTF-8")
    {
    }

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

        set
        {
            if (value == null)
                throw new ArgumentNullException(nameof(value));
            this.msgVersion = value;
        }
    }

    public string MediaType
    {
        get
        {
            return this.mediaType;
        }

        set
        {
            if (value == null)
                throw new ArgumentNullException(nameof(value));
            this.mediaType = value;
        }
    }

    public string Encoding
    {
        get
        {
            return this.encoding;
        }

        set
        {
            if (value == null)
                throw new ArgumentNullException(nameof(value));
            this.encoding = value;
        }
    }

    // This encoder does not enforces any quotas for the unsecure messages. The
    // quotas are enforced for the secure portions of messages when this encoder
    // is used in a binding that is configured with security.
    public XmlDictionaryReaderQuotas ReaderQuotas
    {
        get
        {
            return this.readerQuotas;
        }
    }

    #region IMessageEncodingBindingElement Members
    public override MessageEncoderFactory CreateMessageEncoderFactory()
    {
        return new CustomTextMessageEncoderFactory(this.MediaType,
            this.Encoding, this.MessageVersion);
    }

    #endregion

    public override BindingElement Clone()
    {
        return new CustomTextMessageBindingElement(this);
    }

    public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        context.BindingParameters.Add(this);
        return context.BuildInnerChannelFactory<TChannel>();
    }

    public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        return context.CanBuildInnerChannelFactory<TChannel>();
    }

    public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        context.BindingParameters.Add(this);
        return context.BuildInnerChannelListener<TChannel>();
    }

    public override bool CanBuildChannelListener<TChannel>(BindingContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        context.BindingParameters.Add(this);
        return context.CanBuildInnerChannelListener<TChannel>();
    }

    public override T GetProperty<T>(BindingContext context)
    {
        if (typeof(T) == typeof(XmlDictionaryReaderQuotas))
        {
            return (T)(object)this.readerQuotas;
        }
        else
        {
            return base.GetProperty<T>(context);
        }
    }

    #region IWsdlExportExtension Members

    void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
    {
    }

    void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
    {
        // The MessageEncodingBindingElement is responsible for ensuring that the WSDL has the correct
        // SOAP version. We can delegate to the WCF implementation of TextMessageEncodingBindingElement for this.
        TextMessageEncodingBindingElement mebe = new TextMessageEncodingBindingElement();
        mebe.MessageVersion = this.msgVersion;
        ((IWsdlExportExtension)mebe).ExportEndpoint(exporter, context);
    }

    #endregion
}

Remarques

L’encodage est le processus de transformation d’un message en une séquence d’octets. Le décodage est le processus inverse. Windows Communication Foundation (WCF) comprend trois types d’encodage pour les messages SOAP : MTOM (Text, Binary and Message Transmission Optimization Mechanism).

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 trois classes de base abstraites suivantes :

• MessageEncodingBindingElement

• MessageEncoderFactory

• MessageEncoder

Substituez Encoder pour retourner une instance de votre MessageEncoder personnalisé. Remplacez la CreateMessageEncoderFactory méthode pour retourner une instance de cette fabrique.

Tout type qui dérive de MessageEncodingBindingElement est responsable de la mise à jour de la version de la liaison SOAP dans le document WSDL généré pour le service. Pour ce faire, implémentez la ExportEndpoint(WsdlExporter, WsdlEndpointConversionContext) méthode pour modifier le WSDL généré.

Windows Communication Foundation (WCF) fournit trois types d’éléments de liaison dérivés de la MessageEncodingBindingElement classe qui peuvent fournir un encodage MTOM (Text, Binary And Message Transmission Optimization Mechanism).

• TextMessageEncodingBindingElement: le plus interopérable, mais l’encodeur le moins efficace pour les messages XML. Un service web ou un client de service web peut généralement comprendre du code XML textuel. Toutefois, la transmission de grands blocs de données binaires en tant que texte n’est pas efficace.

• BinaryMessageEncodingBindingElement: représente l’élément de liaison qui spécifie l’encodage de caractères et le contrôle de version de message utilisés pour les messages XML binaires. Cela est plus efficace, mais le moins interopérable des options d’encodage.

• MtomMessageEncodingBindingElement: représente l’élément de liaison qui spécifie l’encodage de caractères et le contrôle de version des messages utilisés pour un message à l’aide d’un encodage MTOM (Message Transmission Optimization Mechanism). MTOM est une technologie efficace pour transmettre des données binaires dans des messages WCF. L’encodeur MTOM tente d’équilibrer l’efficacité et l’interopérabilité. L’encodage MTOM transmet la plupart des données XML sous forme textuelle, mais optimise les grands blocs de données binaires en les transmettant as-is, sans conversion en texte.

Constructeurs

Nom	Description
MessageEncodingBindingElement()	Initialise une nouvelle instance de la classe MessageEncodingBindingElement.
MessageEncodingBindingElement(MessageEncodingBindingElement)	Initialise une nouvelle instance de la MessageEncodingBindingElement classe initialisée à partir d’un élément existant.

Propriétés

Nom	Description
MessageVersion	En cas de substitution dans une classe dérivée, obtient ou définit la version du message qui peut être gérée par les encodeurs de message générés par la fabrique d’encodeur de message.

Méthodes

Nom	Description
BuildChannelFactory<TChannel>(BindingContext)	Initialise une fabrique de canaux pour produire des canaux d’un type spécifié à partir du contexte de liaison. (Hérité de BindingElement)
CanBuildChannelFactory<TChannel>(BindingContext)	Retourne une valeur qui indique si l’élément de liaison peut générer une fabrique de canaux pour un type spécifique de canal. (Hérité de BindingElement)
Clone()	En cas de substitution dans une classe dérivée, retourne une copie de l’objet d’élément de liaison. (Hérité de BindingElement)
CreateMessageEncoderFactory()	En cas de substitution dans une classe dérivée, crée une fabrique pour produire des encodeurs de messages.
GetProperty<T>(BindingContext)	Retourne l’objet typé demandé, le cas échéant, à partir de la couche appropriée dans la pile de canaux.