MessageEncodingBindingElement Classe

Definição

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

Herança

Object

BindingElement

MessageEncodingBindingElement

Derivado

System.ServiceModel.Channels.BinaryMessageEncodingBindingElement

System.ServiceModel.Channels.ByteStreamMessageEncodingBindingElement

System.ServiceModel.Channels.MtomMessageEncodingBindingElement

System.ServiceModel.Channels.TextMessageEncodingBindingElement

System.ServiceModel.Channels.WebMessageEncodingBindingElement

Exemplos

O exemplo de código a seguir mostra como implementar uma classe derivada 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
}

Comentários

A codificação é o processo de transformação de uma mensagem em uma sequência de bytes. A decodificação é o processo inverso. O Windows Communication Foundation (WCF) inclui três tipos de codificação para mensagens SOAP: Mecanismo de Otimização de Transmissão de Mensagens, Binário e Binário (MTOM).

Use essa classe se quiser implementar um codificador de mensagens personalizado. Para implementar seu próprio codificador de mensagens personalizado, você deve fornecer implementações personalizadas das três classes base abstratas a seguir:

• MessageEncodingBindingElement

• MessageEncoderFactory

• MessageEncoder

Substitua Encoder para retornar uma instância do seu MessageEncoder personalizado. Substitua o CreateMessageEncoderFactory método para retornar uma instância desta fábrica.

Qualquer tipo que derive de MessageEncodingBindingElement é responsável por atualizar a versão da vinculação SOAP no documento WSDL gerado para o serviço. Isso é feito implementando o ExportEndpoint(WsdlExporter, WsdlEndpointConversionContext) método para modificar o WSDL gerado.

O WCF (Windows Communication Foundation) fornece três tipos de elementos de associação derivados da MessageEncodingBindingElement classe que podem fornecer codificação MTOM (Mecanismo de Otimização de Transmissão de Mensagens, Binário e Binário).

• TextMessageEncodingBindingElement: o codificador mais interoperável, mas o codificador menos eficiente para mensagens XML. Um serviço Web ou cliente de serviço Web geralmente pode entender XML textual. No entanto, a transmissão de grandes blocos de dados binários como texto não é eficiente.

• BinaryMessageEncodingBindingElement: representa o elemento de associação que especifica a codificação de caracteres e o controle de versão da mensagem usados para mensagens XML baseadas em binário. Isso é mais eficiente, mas menos interoperável das opções de codificação.

• MtomMessageEncodingBindingElement: representa o elemento de associação que especifica a codificação de caracteres e o controle de versão de mensagem usados para uma mensagem usando uma codificação MTOM (Mecanismo de Otimização de Transmissão de Mensagens). O MTOM é uma tecnologia eficiente para transmitir dados binários em mensagens WCF. O codificador MTOM tenta equilibrar a eficiência e a interoperabilidade. A codificação MTOM transmite a maioria dos XML na forma textual, mas otimiza grandes blocos de dados binários transmitindo-os as-is, sem conversão em texto.