BodyWriter Classe

Définition

Espace de noms:

System.ServiceModel.Channels

Assembly:

System.ServiceModel.Primitives.dll

Assembly:

System.ServiceModel.dll

Représente l'enregistreur du corps du message.

public ref class BodyWriter abstract

public abstract class BodyWriter

type BodyWriter = class

Public MustInherit Class BodyWriter

Héritage

Object

BodyWriter

Dérivé

System.ServiceModel.Channels.StreamBodyWriter

System.ServiceModel.Security.WSTrustRequestBodyWriter

System.ServiceModel.Security.WSTrustResponseBodyWriter

Exemples

L'exemple suivant montre comment dériver une classe à partir de BodyWriter. Cette substitution accepte un tableau de chaînes et les écrit dans une XmlDictionaryWriter.

using System;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Xml;

namespace UEBodyWriter
{
    class MyBodyWriter : BodyWriter
    {
        const string textTag = "text";
        string[] bodySegment;

        public MyBodyWriter(string[] strData) : base(true)
        {
            int length = strData.Length;

            this.bodySegment = new string[length];
            for (int i = 0; i < length; i++)
            {
                this.bodySegment[i] = strData[i];
            }
        }

        protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
        {
           writer.WriteStartElement(textTag);

           foreach (string str in bodySegment)
           {
               writer.WriteString(str);
           }

            writer.WriteEndElement();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string[] strings = {"Hello", "world"};
            MyBodyWriter bw = new MyBodyWriter(strings);

            StringBuilder strBuilder = new StringBuilder(10);
            XmlWriter writer = XmlWriter.Create(strBuilder);
            XmlDictionaryWriter dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);

            bw.WriteBodyContents(dictionaryWriter);
            dictionaryWriter.Flush();
        }
    }
}

Imports System.Text
Imports System.ServiceModel
Imports System.ServiceModel.Channels
Imports System.Xml

Namespace UEBodyWriter
    Friend Class MyBodyWriter
        Inherits BodyWriter
        Private Const textTag As String = "text"
        Private bodySegment() As String

        Public Sub New(ByVal strData() As String)
            MyBase.New(True)
            Dim length = strData.Length

            Me.bodySegment = New String(length - 1){}
            For i = 0 To length - 1
                Me.bodySegment(i) = strData(i)
            Next i
        End Sub

        Protected Overrides Sub OnWriteBodyContents(ByVal writer As XmlDictionaryWriter)
           writer.WriteStartElement(textTag)

            For Each str As String In bodySegment
                writer.WriteString(str)
            Next str

            writer.WriteEndElement()
        End Sub
    End Class

    Module Module1
        Sub Main(ByVal args() As String)
            Dim strings() As String = {"Hello", "world"}
            Dim bw As New MyBodyWriter(strings)

            Dim strBuilder As New StringBuilder(10)
            Dim writer = XmlWriter.Create(strBuilder)
            Dim dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer)

            bw.WriteBodyContents(dictionaryWriter)
            dictionaryWriter.Flush()
        End Sub
    End Module
End Namespace

Remarques

Un message se compose d'en-têtes et d'un corps. Les en-têtes sont mis en mémoire tampon et le corps est transmis en continu. Étant donné que le corps est transmis en continu, l'utilisateur ne peut pas passer le contenu réel du corps à un message. L'utilisateur doit alors passer une classe qui sait comment écrire le corps lorsque cela lui est demandé. Cela est effectué en passant une classe dérivée de BodyWriter à Message. Un message appelle la classe dérivée de BodyWriter à chaque fois qu'il requiert que le corps soit écrit à l'aide d'une XmlWriter.

Constructeurs

BodyWriter(Boolean)

Initialise une nouvelle instance de la classe BodyWriter qui indique de façon explicite s'il faut effectuer une mise en mémoire tampon.

Propriétés

IsBuffered

Obtient une valeur qui indique si la méthode en écriture peut être appelée plusieurs fois.

Méthodes

BeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)	Démarre l'écriture du contenu du corps pour l'enregistreur de corps avec l'enregistreur, le rappel et l'état spécifiés.
CreateBufferedCopy(Int32)	Crée une copie mise en mémoire tampon du corps.
EndWriteBodyContents(IAsyncResult)	Met fin à l'écriture du contenu de corps.
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)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
OnBeginWriteBodyContents(XmlDictionaryWriter, AsyncCallback, Object)	Déclenche un événement lorsque l'enregistreur de corps démarre l'écriture du contenu du corps avec l'enregistreur, le rappel et l'état spécifiés.
OnCreateBufferedCopy(Int32)	Fournit un point d'extensibilité lorsque le contenu du corps est écrit.
OnEndWriteBodyContents(IAsyncResult)	Déclenche un événement lorsque l'enregistreur de corps termine d'écrire le contenu du corps.
OnWriteBodyContents(XmlDictionaryWriter)	Une fois implémenté, fournit un point d'extensibilité lorsque le contenu du corps est écrit.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
WriteBodyContents(XmlDictionaryWriter)	Écrit le contenu du corps du message.