Comment : activer la diffusion en continu

Article
02/27/2011

Windows Communication Foundation (WCF) peut envoyer des messages utilisant des transferts par mise en mémoire tampon ou par diffusion en continu. En mode de transfert par mise en mémoire tampon, un message doit être complètement remis avant qu'un récepteur puisse le lire. En mode de transfert par diffusion en continu, le récepteur peut commencer à traiter le message avant qu'il ne soit complètement remis. Le mode de diffusion en continu est utile lorsque les informations passées sont volumineuses et peuvent être traitées en série. Le mode de diffusion en continu est également utile lorsque le message est trop volumineux pour être mis entièrement en mémoire tampon.

Pour activer la diffusion en continu, définissez le OperationContract convenablement et activez la diffusion en continu au niveau du transport.

Pour transmettre des données en continu

Pour transmettre des données en continu le OperationContract du service doit satisfaire deux spécifications :
1. Le paramètre qui gère les données diffusées en continu doit être le seul paramètre dans la méthode. Par exemple, si le message d'entrée est celui à diffuser en continu, l'opération ne doit contenir qu'un seul paramètre d'entrée. De la même façon, si le message de sortie doit être diffusé en continu, l'opération ne doit avoir qu'un seul paramètre de sortie ou qu'une seule valeur de retour.
2. Au moins l'un des types de paramètre et de valeur de retour doit être Stream, Messageou IXmlSerializable.
Ce qui suit est un exemple de contrat de diffusion des données en continu.
```
<ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples")> _
Public Interface IStreamingSample
    <OperationContract()> _
    Function GetStream(ByVal data As String) As Stream
    <OperationContract()> _
    Function UploadStream(ByVal stream As Stream) As Boolean
    <OperationContract()> _
    Function EchoStream(ByVal stream As Stream) As Stream
    <OperationContract()> _
    Function GetReversedStream() As Stream

End Interface
```
```
[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]
public interface IStreamingSample
{
    [OperationContract]
    Stream GetStream(string data);
    [OperationContract]
    bool UploadStream(Stream stream);
    [OperationContract]
    Stream EchoStream(Stream stream);
    [OperationContract]
    Stream GetReversedStream();

}
```
L'opération GetStream reçoit des données d'entrée mises en mémoire tampon sous la forme d'une chaîne (string) mise en mémoire tampon et retourne Stream, soit des données diffusées en continu. Inversement, UploadStream prend Stream (diffusion en continu) et retourne bool (mise en mémoire tampon). EchoStream prend et retourne Stream et constitue un exemple d'opération dont les messages d'entrée et de sortie sont tous deux diffusés en continu. Enfin, GetReversedStream ne prend pas d'entrée et retourne Stream (diffusion en continu).
La diffusion en continu doit être activée sur la liaison. Affectez à une propriété TransferMode l'une des valeurs suivantes :
1. Buffered,
2. Streamed, qui active la communication par diffusion en continu dans les deux directions.
3. StreamedRequest, qui active la diffusion en continu de la demande uniquement.
4. StreamedResponse, qui active la diffusion en continu de la réponse uniquement.
La BasicHttpBinding expose la propriété TransferMode sur la liaison, tout comme NetTcpBinding et NetNamedPipeBinding. La propriété TransferMode peut également être définie sur l'élément de liaison de transport et utilisée dans une liaison personnalisée.

Les exemples suivants indiquent comment définir le TransferMode par code et en modifiant le fichier de configuration. Les exemples attribuent également à la propriété maxReceivedMessageSize la valeur 64 Mo, qui limite la taille maximale autorisée des messages en réception. La valeur par défaut de maxReceivedMessageSize est 64 Ko, ce qui est habituellement trop bas pour les scénarios de diffusion en continu. Définissez ce paramètre de quota correctement selon la taille maximale des messages que votre application est susceptible de recevoir. Notez également que la maxBufferSize contrôle la taille maximale mise en mémoire tampon ; il convient de définir convenablement cette valeur.
1. L'extrait de code de configuration suivant tiré de l'exemple présente l'affectation du mode de diffusion en continu à la propriété TransferMode sur la basicHttpBinding et sur une liaison HTTP personnalisée.
```
<basicHttpBinding>
  <binding name="HttpStreaming" maxReceivedMessageSize="67108864"
           transferMode="Streamed"/>
</basicHttpBinding>

<customBinding>
  <binding name="Soap12">
    <textMessageEncoding messageVersion="Soap12WSAddressing10" />
    <httpTransport transferMode="Streamed" maxReceivedMessageSize="67108864"/>
  </binding>
</customBinding>
```
2. L'extrait de code suivant affiche l'affectation à la propriété TransferMode la diffusion en continu sur la basicHttpBinding et sur une liaison HTTP personnalisée.
```
Public Shared Function CreateStreamingBinding() As Binding
    Dim b As New BasicHttpBinding()
    b.TransferMode = TransferMode.Streamed
    Return b
End Function
```
```
public static Binding CreateStreamingBinding()
{
    BasicHttpBinding b = new BasicHttpBinding();
    b.TransferMode = TransferMode.Streamed;
    return b;
}
```
3. L'extrait de code suivant affiche l'affectation à la propriété TransferMode de la diffusion en continu une liaison TCP personnalisée.
```
Public Shared Function CreateStreamingBinding() As Binding
    Dim transport As New TcpTransportBindingElement()
    transport.TransferMode = TransferMode.Streamed
    Dim binding As New CustomBinding(New BinaryMessageEncodingBindingElement(), _
                                     transport)
    Return binding
End Function
```
```
public static Binding CreateStreamingBinding()
{
    TcpTransportBindingElement transport = new TcpTransportBindingElement();
    transport.TransferMode = TransferMode.Streamed;
    BinaryMessageEncodingBindingElement encoder = new BinaryMessageEncodingBindingElement();
    CustomBinding binding = new CustomBinding(encoder, transport);
    return binding;
}
```

Les opérations GetStream, UploadStream et EchoStream concernent toutes l'envoi de données directement à partir d'un fichier ou l'enregistrement des données reçues directement dans un fichier. Le code suivant concerne GetStream.

Public Function GetStream(ByVal data As String) As Stream Implements IStreamingSample.GetStream
    'this file path assumes the image is in
    ' the Service folder and the service is executing
    ' in service/bin 
    Dim filePath = Path.Combine(System.Environment.CurrentDirectory, ".\..\image.jpg")
    'open the file, this could throw an exception 
    '(e.g. if the file is not found)
    'having includeExceptionDetailInFaults="True" in config 
    ' would cause this exception to be returned to the client
    Try
        Return File.OpenRead(filePath)
    Catch ex As IOException
        Console.WriteLine(String.Format("An exception was thrown while trying to open file {0}", filePath))
        Console.WriteLine("Exception is: ")
        Console.WriteLine(ex.ToString())
        Throw ex
    End Try
End Function

public Stream GetStream(string data)
{
    //this file path assumes the image is in
    // the Service folder and the service is executing
    // in service/bin 
    string filePath = Path.Combine(
        System.Environment.CurrentDirectory,
        ".\\..\\image.jpg");
    //open the file, this could throw an exception 
    //(e.g. if the file is not found)
    //having includeExceptionDetailInFaults="True" in config 
    // would cause this exception to be returned to the client
    try
    {
        FileStream imageFile = File.OpenRead(filePath);
        return imageFile;
    }
    catch (IOException ex)
    {
        Console.WriteLine(
            String.Format("An exception was thrown while trying to open file {0}", filePath));
        Console.WriteLine("Exception is: ");
        Console.WriteLine(ex.ToString());
        throw ex;
    }
}

Écriture d'un flux personnalisé

Pour effectuer un traitement spécial sur chaque bloc d'un flux alors qu'il est envoyé ou reçu, dérivez une classe de flux personnalisé de Stream. Pour donner un exemple d'un flux personnalisé, le code suivant contient une méthode GetReversedStream et une classe ReverseStream-.

GetReversedStream crée et retourne une nouvelle instance de ReverseStream. Le traitement réel se produit lorsque le système lit l'objet ReverseStream. La méthode ReverseStream.Read lit un bloc d'octets du fichier sous-jacent, les inverse, puis retourne les octets inversés. Cette méthode n'inverse pas l'ensemble du contenu du fichier, mais uniquement un bloc d'octets à la fois. Cet exemple montre comment vous pouvez traiter un flux pendant que le contenu est lu ou écrit à partir du flux.

Friend Class ReverseStream
    Inherits Stream

    Private inStream As FileStream

    Friend Sub New(ByVal filePath As String)
        'opens the file and places a StreamReader around it
        inStream = File.OpenRead(filePath)
    End Sub

    Public Overrides ReadOnly Property CanRead() As Boolean
        Get
            Return inStream.CanRead
        End Get
    End Property

    Public Overrides ReadOnly Property CanSeek() As Boolean
        Get
            Return False
        End Get
    End Property

    Public Overrides ReadOnly Property CanWrite() As Boolean
        Get
            Return False
        End Get
    End Property

    Public Overrides Sub Flush()
        Throw New Exception("This stream does not support writing.")
    End Sub

    Public Overrides ReadOnly Property Length() As Long
        Get
            Throw New Exception("This stream does not support the Length property.")
        End Get
    End Property

    Public Overrides Property Position() As Long
        Get
            Return inStream.Position
        End Get
        Set(ByVal value As Long)
            Throw New Exception("This stream does not support setting the Position property.")
        End Set
    End Property

    Public Overrides Function Read(ByVal buffer() As Byte, _
                                   ByVal offset As Integer, _
                                   ByVal count As Integer) As Integer

        Dim countRead = inStream.Read(buffer, _
                                      offset, _
                                      count)
        ReverseBuffer(buffer, _
                      offset, _
                      countRead)
        Return countRead
    End Function

    Public Overrides Function Seek(ByVal offset As Long, _
                                   ByVal origin As SeekOrigin) As Long
        Throw New Exception("This stream does not support seeking.")
    End Function

    Public Overrides Sub SetLength(ByVal value As Long)
        Throw New Exception("This stream does not support setting the Length.")
    End Sub

    Public Overrides Sub Write(ByVal buffer() As Byte, _
                               ByVal offset As Integer, _
                               ByVal count As Integer)
        Throw New Exception("This stream does not support writing.")
    End Sub

    Public Overrides Sub Close()
        inStream.Close()
        MyBase.Close()
    End Sub

    Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
        inStream.Dispose()
        MyBase.Dispose(disposing)
    End Sub

    Private Sub ReverseBuffer(ByVal buffer() As Byte, _
                              ByVal offset As Integer, _
                              ByVal count As Integer)

        Dim i = offset
        Dim j = offset + count - 1

        Do While i < j
            Dim currenti = buffer(i)
            buffer(i) = buffer(j)
            buffer(j) = currenti
            i += 1
            j -= 1
        Loop

    End Sub
End Class

class ReverseStream : Stream
{

    FileStream inStream;
    internal ReverseStream(string filePath)
    {
        //opens the file and places a StreamReader around it
        inStream = File.OpenRead(filePath);
    }
    public override bool CanRead
    {
        get { return inStream.CanRead; }
    }

    public override bool CanSeek
    {
        get { return false; }
    }

    public override bool CanWrite
    {
        get { return false; }
    }

    public override void Flush()
    {
        throw new Exception("This stream does not support writing.");
    }

    public override long Length
    {
        get { throw new Exception("This stream does not support the Length property."); }
    }

    public override long Position
    {
        get
        {
            return inStream.Position;
        }
        set
        {
            throw new Exception("This stream does not support setting the Position property.");
        }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        int countRead = inStream.Read(buffer, offset, count);
        ReverseBuffer(buffer, offset, countRead);
        return countRead;
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        throw new Exception("This stream does not support seeking.");
    }

    public override void SetLength(long value)
    {
        throw new Exception("This stream does not support setting the Length.");
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        throw new Exception("This stream does not support writing.");
    }
    public override void Close()
    {
        inStream.Close();
        base.Close();
    }
    protected override void Dispose(bool disposing)
    {
        inStream.Dispose();
        base.Dispose(disposing);
    }
    void ReverseBuffer(byte[] buffer, int offset, int count)
    {

        int i, j;

        for (i = offset, j = offset + count - 1; i < j; i++, j--)
        {
            byte currenti = buffer[i];
            buffer[i] = buffer[j];
            buffer[j] = currenti;
        }

    }
}

Partager via

Comment : activer la diffusion en continu

Pour transmettre des données en continu

Écriture d'un flux personnalisé

Voir aussi

Tâches

Concepts

Ressources supplémentaires