MessageEncodingBindingElement Classe

Définition

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) inclut trois types d'encodage des messages SOAP : Texte, Binaire et MTOM (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é. Substituez la méthode CreateMessageEncoderFactory pour retourner une instance de cette fabrique.

Les types qui dérivent de MessageEncodingBindingElement sont chargés de mettre à jour la version de la liaison SOAP dans le document WSDL généré pour le service. Cela est fait en implémentant la méthode ExportEndpoint(WsdlExporter, WsdlEndpointConversionContext) pour modifier le WSDL généré.

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

• TextMessageEncodingBindingElement est l'encodeur le plus interopérable, mais le moins efficace pour les messages XML. Un service Web ou un client de service Web comprend généralement le langage XML textuel. Toutefois, transmettre de larges blocs de données binaires sous la forme de 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 des messages utilisés pour les messages XML binaires. Cette option d'encodage est la plus efficace mais la moins interopérable.

• MtomMessageEncodingBindingElement: 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 un message à l’aide d’un encodage MTOM (Message Transmission Optimization Mechanism). MTOM est une technologie efficace de transmission de données binaires dans les messages WCF. L'encodeur MTOM tente de parvenir à un équilibre entre rendement et interopérabilité. L'encodage MTOM transmet la plupart du XML sous forme textuelle, mais optimise les grands blocs de données binaires en les transmettant tels quels, sans conversion en texte.

Constructeurs

Propriétés

Méthodes

S’applique à