Streaming

L’exemple Stream illustre l’utilisation de la communication en mode de transfert de streaming. Le service expose plusieurs opérations qui envoient et reçoivent des flux. Cet exemple est auto-hébergé. Le client et le service sont des programmes console.

Remarque

La procédure d’installation et les instructions de génération de cet exemple se trouvent à la fin de cette rubrique.

Windows Communication Foundation (WCF) peut communiquer en deux modes de transfert : mis en mémoire tampon ou diffusion en continu. Dans le mode de transfert mis en mémoire tampon par défaut, un message doit être entièrement remis avant qu’un récepteur puisse le lire. Dans le mode de transfert de streaming, 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 transmises sont longues et peuvent être traitées en série. Le mode streaming est également utile lorsque le message est trop volumineux pour être entièrement mis en mémoire tampon.

Contrats de streaming et de service

La diffusion en continu est un élément à prendre en compte lors de la conception d’un contrat de service. Si une opération reçoit ou retourne de grandes quantités de données, vous devez envisager de diffuser ces données en continu pour éviter une utilisation élevée de la mémoire en raison de la mise en mémoire tampon des messages d’entrée ou de sortie. Pour diffuser en continu des données, le paramètre qui contient ces données doit être le seul paramètre dans le message. Par exemple, si le message d’entrée est celui à diffuser en continu, l’opération doit avoir exactement un paramètre d’entrée. De même, si le message de sortie doit être diffusé en continu, l’opération doit avoir exactement un paramètre de sortie ou une valeur de retour. Dans les deux cas, le type de valeur de paramètre ou de retour doit être soit Stream, Messageou IXmlSerializable. Voici le contrat de service utilisé dans cet exemple de diffusion en continu.

[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 certaines données d’entrée sous forme de chaîne, qui est mise en mémoire tampon et retourne un Stream, qui est diffusé en continu. À l’inverse, UploadStream prend un Stream (diffusé en continu) et retourne un bool (mis en mémoire tampon). EchoStream prend et retourne Stream et est un exemple d’opération dont les messages d’entrée et de sortie sont tous deux diffusés en continu. Enfin, GetReversedStream n’accepte aucune entrée et retourne une Stream (diffusée en continu).

Activation des transferts avec diffusion en continu

La définition de contrats d’opération comme décrit précédemment fournit la diffusion en continu au niveau du modèle de programmation. Si vous vous arrêtez là, le transport met toujours en mémoire tampon l'ensemble du contenu du message. Pour activer le streaming de transport, sélectionnez un mode de transfert sur l’élément de liaison du transport. La propriété TransferMode de l'élément de liaison peut avoir la valeur Buffered, Streamed, StreamedRequest ou StreamedResponse. L'affectation de Streamed au mode de transfert permet d'assurer la communication en mode de diffusion en continu dans les deux sens. Définir le mode de transfert sur StreamedRequest ou StreamedResponse permet la communication en streaming uniquement dans la demande ou uniquement dans la réponse, respectivement.

Le basicHttpBinding expose la propriété TransferMode sur la liaison, tout comme le font NetTcpBinding et NetNamedPipeBinding. Pour les autres transports, vous devez créer une liaison personnalisée pour pouvoir définir le mode de transfert.

Le code de configuration suivant de l'exemple présente l'affectation du mode de diffusion en continu à la propriété TransferMode sur basicHttpBinding et une liaison HTTP personnalisée :

<!-- An example basicHttpBinding using streaming. -->
<basicHttpBinding>
  <binding name="HttpStreaming" maxReceivedMessageSize="67108864"
           transferMode="Streamed"/>
</basicHttpBinding>
<!-- An example customBinding using HTTP and streaming.-->
<customBinding>
  <binding name="Soap12">
    <textMessageEncoding messageVersion="Soap12WSAddressing10" />
    <httpTransport transferMode="Streamed"
                   maxReceivedMessageSize="67108864"/>
  </binding>
</customBinding>

En plus de définir la valeur de transferMode à Streamed, le code de configuration précédent fixe la valeur de maxReceivedMessageSize à 64 Mo. En tant que mécanisme de défense, maxReceivedMessageSize place une limite sur la taille maximale autorisée des messages à recevoir. La valeur par défaut maxReceivedMessageSize est de 64 Ko, généralement trop faible pour les scénarios de streaming.

Traitement des données telles qu’elles sont diffusées en continu

Les opérations GetStreamet UploadStreamEchoStream tous traitent de l’envoi de données directement à partir d’un fichier ou de l’enregistrement des données reçues directement dans un fichier. Toutefois, dans certains cas, il est nécessaire d’envoyer ou de recevoir de grandes quantités de données et d’effectuer un traitement sur des blocs de données lors de son envoi ou de sa réception. Une façon de traiter ces scénarios consiste à écrire un flux personnalisé (une classe dérivée de Stream) qui traite les données telles qu’elles sont lues ou écrites. L'GetReversedStream opération et la ReverseStream classe sont un exemple de ceci.

GetReversedStream crée et retourne une nouvelle instance de ReverseStream. Le traitement réel se produit lorsque le système lit à partir de cet ReverseStream objet. L’implémentation ReverseStream.Read lit un segment d’octets du fichier sous-jacent, les inverse, puis retourne les octets inversés. Cela n’inverse pas l’intégralité du contenu du fichier ; il inverse un bloc d’octets à la fois. Il s’agit d’un exemple qui montre comment effectuer un traitement de flux à mesure que le contenu est lu ou écrit depuis et vers le flux.

class ReverseStream : Stream
{

    FileStream inStream;
    internal ReverseStream(string filePath)
    {
        //Opens the file and places a StreamReader around it.
        inStream = File.OpenRead(filePath);
    }

    // Other methods removed for brevity.

    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 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;
        }

    }
}

Exécution de l’exemple

Pour exécuter l’exemple, commencez par générer le service et le client en suivant les instructions à la fin de ce document. Démarrez ensuite le service et le client dans deux fenêtres de console différentes. Lorsque le client démarre, il attend que vous appuyiez sur Entrée lorsque le service est prêt. Le client appelle ensuite les méthodes GetStream(), UploadStream() puis GetReversedStream() sur HTTP, puis sur TCP. Voici un exemple de sortie du service suivi d’un exemple de sortie du client :

Résultat du service :

The streaming service is ready.
Press <ENTER> to terminate service.

Saving to file D:\...\uploadedfile
......................
File D:\...\uploadedfile saved
Saving to file D:\...\uploadedfile
...............
File D:\...\uploadedfile saved

Sortie du client :

Press <ENTER> when service is ready
------ Using HTTP ------
Calling GetStream()
Saving to file D:\...\clientfile
......................
Wrote 33405 bytes to stream

File D:\...\clientfile saved
Calling UploadStream()
Calling GetReversedStream()
Saving to file D:\...\clientfile
......................
Wrote 33405 bytes to stream

File D:\...\clientfile saved
------ Using Custom HTTP ------
Calling GetStream()
Saving to file D:\...\clientfile
...............
Wrote 33405 bytes to stream

File D:\...\clientfile saved
Calling UploadStream()
Calling GetReversedStream()
Saving to file D:\...\clientfile
...............
Wrote 33405 bytes to stream

File D:\...\clientfile saved

Press <ENTER> to terminate client.

Pour configurer, générer et exécuter l’exemple

Assurez-vous d’avoir effectué la Procédure d’installation unique pour les exemples Windows Communication Foundation.
Pour générer l’édition C# ou Visual Basic .NET de la solution, conformez-vous aux instructions figurant dans Building the Windows Communication Foundation Samples.
Pour exécuter l’exemple dans une configuration à un ou plusieurs ordinateurs, conformez-vous aux instructions figurant dans la rubrique Exécution des exemples Windows Communication Foundation.