MessageEncodingBindingElement Klas

Definitie

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

Overname

Object

BindingElement

MessageEncodingBindingElement

Afgeleid

System.ServiceModel.Channels.BinaryMessageEncodingBindingElement

System.ServiceModel.Channels.ByteStreamMessageEncodingBindingElement

System.ServiceModel.Channels.MtomMessageEncodingBindingElement

System.ServiceModel.Channels.TextMessageEncodingBindingElement

System.ServiceModel.Channels.WebMessageEncodingBindingElement

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u een klasse implementeert die is afgeleid van 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
}

Opmerkingen

Encoding is het proces van het transformeren van een bericht in een reeks bytes. Decodering is het omgekeerde proces. Windows Communication Foundation (WCF) bevat drie typen codering voor SOAP-berichten: Text, Binary and Message Transmission Optimization Mechanism (MTOM).

Gebruik deze klasse als u een aangepaste berichtcoderingsprogramma wilt implementeren. Als u uw eigen aangepaste berichtcoderingsprogramma wilt implementeren, moet u aangepaste implementaties van de volgende drie abstracte basisklassen opgeven:

• MessageEncodingBindingElement

• MessageEncoderFactory

• MessageEncoder

Overschrijf het Encoder om een exemplaar van uw aangepaste MessageEncoderexemplaar te retourneren. Overschrijf de CreateMessageEncoderFactory methode om een exemplaar van deze factory te retourneren.

Elk type dat is afgeleid van MessageEncodingBindingElement , is verantwoordelijk voor het bijwerken van de versie van de SOAP-binding in het WSDL-document dat voor de service is gegenereerd. Dit wordt gedaan door de ExportEndpoint(WsdlExporter, WsdlEndpointConversionContext) methode te implementeren om de gegenereerde WSDL te wijzigen.

Windows Communication Foundation (WCF) biedt drie typen bindingselementen die zijn afgeleid van de klasse MessageEncodingBindingElement die kunnen voorzien in tekst-, binaire en MTOM-codering (Message Transmission Optimization Mechanism).

• TextMessageEncodingBindingElement: de meest interoperabele, maar de minst efficiënte encoder voor XML-berichten. Een webservice- of webserviceclient kan over het algemeen tekstuele XML begrijpen. Het verzenden van grote blokken binaire gegevens als tekst is niet efficiënt.

• BinaryMessageEncodingBindingElement: vertegenwoordigt het bindingselement dat het tekencoderings- en berichtversiebeheer specificeert dat wordt gebruikt voor XML-berichten op basis van binaire bestanden. Dit is de meest efficiënte maar minst interoperabele van de coderingsopties.

• MtomMessageEncodingBindingElement: vertegenwoordigt het bindingselement dat het tekencoderings- en berichtversiebeheer aangeeft dat wordt gebruikt voor een bericht met behulp van een MTOM-codering (Message Transmission Optimization Mechanism). MTOM is een efficiënte technologie voor het verzenden van binaire gegevens in WCF-berichten. De MTOM-encoder probeert de efficiëntie en interoperabiliteit te verdelen. De MTOM-codering verzendt de meeste XML in tekstvorm, maar optimaliseert grote blokken binaire gegevens door ze as-iste verzenden, zonder conversie naar tekst.