AnonymousPipeClientStream Classe

Définition

Expose le côté client d’un flux de canal anonyme, qui prend en charge les opérations de lecture et d’écriture synchrones et asynchrones (sans prise en charge de l’annulation sur les plateformes Windows).

public ref class AnonymousPipeClientStream sealed : System::IO::Pipes::PipeStream
public sealed class AnonymousPipeClientStream : System.IO.Pipes.PipeStream
type AnonymousPipeClientStream = class
    inherit PipeStream
Public NotInheritable Class AnonymousPipeClientStream
Inherits PipeStream
Héritage
AnonymousPipeClientStream
Héritage
AnonymousPipeClientStream

Exemples

L’exemple suivant envoie une chaîne d’un processus parent à un processus enfant à l’aide de canaux anonymes. Cet exemple crée un AnonymousPipeServerStream objet dans un processus parent avec la PipeDirection valeur Out. Il crée également un AnonymousPipeClientStream objet dans un processus enfant avec la PipeDirection valeur In. Le processus parent envoie ensuite une chaîne fournie par l’utilisateur au processus enfant. La chaîne est affichée dans la console.

Cet exemple concerne le processus client, qui est démarré par le processus serveur. Nommez l’exécutable résultant à partir du code pipeClient.exe client et copiez-le dans le même répertoire que l’exécutable du serveur lorsque vous exécutez cet exemple. Pour obtenir l’ensemble de l’exemple de code, y compris le code du client et du serveur de canal, consultez Guide pratique pour utiliser des canaux anonymes pour la communication interprocesseur locale.

//<snippet01>
#using <System.Core.dll>

using namespace System;
using namespace System::IO;
using namespace System::IO::Pipes;

ref class PipeClient
{
public:
    static void Main(array<String^>^ args)
    {
        if (args->Length > 1)
        {
            PipeStream^ pipeClient = gcnew AnonymousPipeClientStream(PipeDirection::In, args[1]);

            Console::WriteLine("[CLIENT] Current TransmissionMode: {0}.",
                pipeClient->TransmissionMode);

            StreamReader^ sr = gcnew StreamReader(pipeClient);

            // Display the read text to the console
            String^ temp;

            // Wait for 'sync message' from the server.
            do
            {
                Console::WriteLine("[CLIENT] Wait for sync...");
                temp = sr->ReadLine();
            }
            while (!temp->StartsWith("SYNC"));

            // Read the server data and echo to the console.
            while ((temp = sr->ReadLine()) != nullptr)
            {
                Console::WriteLine("[CLIENT] Echo: " + temp);
            }
            sr->Close();
            pipeClient->Close();
        }
        Console::Write("[CLIENT] Press Enter to continue...");
        Console::ReadLine();
    }
};

int main()
{
    array<String^>^ args = Environment::GetCommandLineArgs();
    PipeClient::Main(args);
}
//</snippet01>
//<snippet01>
using System;
using System.IO;
using System.IO.Pipes;

class PipeClient
{
    static void Main(string[] args)
    {
        if (args.Length > 0)
        {
            using (PipeStream pipeClient =
                new AnonymousPipeClientStream(PipeDirection.In, args[0]))
            {
                Console.WriteLine("[CLIENT] Current TransmissionMode: {0}.",
                   pipeClient.TransmissionMode);

                using (StreamReader sr = new StreamReader(pipeClient))
                {
                    // Display the read text to the console
                    string temp;

                    // Wait for 'sync message' from the server.
                    do
                    {
                        Console.WriteLine("[CLIENT] Wait for sync...");
                        temp = sr.ReadLine();
                    }
                    while (!temp.StartsWith("SYNC"));

                    // Read the server data and echo to the console.
                    while ((temp = sr.ReadLine()) != null)
                    {
                        Console.WriteLine("[CLIENT] Echo: " + temp);
                    }
                }
            }
        }
        Console.Write("[CLIENT] Press Enter to continue...");
        Console.ReadLine();
    }
}
//</snippet01>
'<snippet01>
Imports System.IO
Imports System.IO.Pipes

Class PipeClient
    Shared Sub Main(args() as String)
        If args.Length > 0 Then
            Using pipeClient As New AnonymousPipeClientStream(PipeDirection.In, args(0))
                Console.WriteLine("[CLIENT] Current TransmissionMode: {0}.", _
                   pipeClient.TransmissionMode)

                Using sr As New StreamReader(pipeClient)
                    ' Display the read text to the console
                    Dim temp As String

                    ' Wait for 'sync message' from the server.
                    Do
                        Console.WriteLine("[CLIENT] Wait for sync...")
                        temp = sr.ReadLine()
                    Loop While temp.StartsWith("SYNC") = False

                    ' Read the server data and echo to the console.
                    temp = sr.ReadLine()
                    While Not temp = Nothing
                        Console.WriteLine("[CLIENT] Echo: " + temp)
                        temp = sr.ReadLine()
                    End While
                End Using
            End Using
        End If
        Console.Write("[CLIENT] Press Enter to continue...")
        Console.ReadLine()
    End Sub
End Class
'</snippet01>

Remarques

Les canaux anonymes permettent d’assurer une communication interprocessus sécurisée et sécurisée entre les processus enfants et parents. La AnonymousPipeClientStream classe permet à un processus enfant de se connecter à un processus parent et d’échanger des informations avec celui-ci.

Les canaux anonymes sont des canaux unidirectionnel sans nom qui transfèrent généralement des données entre les processus parent et enfant. Les canaux anonymes sont toujours locaux ; ils ne peuvent pas être utilisés sur un réseau. Une PipeDirection valeur de n’est InOut pas prise en charge, car les canaux anonymes sont définis comme unidirectionnel.

Les canaux anonymes ne prennent pas en charge le PipeTransmissionMode.Message mode lecture.

Le côté client d’un canal anonyme doit être créé à partir d’un handle de canal fourni par le côté serveur en appelant la GetClientHandleAsString méthode. La chaîne est ensuite passée en tant que paramètre lors de la création du processus client. À partir du processus client, il est passé au AnonymousPipeClientStream constructeur en tant que pipeHandleAsString paramètre.

Sur Windows, les opérations de lecture et d’écriture asynchrones (qui se chevauchent) ne sont pas prises en charge par les canaux anonymes (voir https://docs.microsoft.com/en-us/windows/win32/ipc/anonymous-pipe-operations). La AnonymousPipeClientStream classe planifie toujours le travail sur le pool de threads sur les plateformes Windows afin que les opérations asynchrones Stream fonctionnent, mais l’annulation de ces opérations n’est pas prise en charge.

Constructeurs

AnonymousPipeClientStream(PipeDirection, SafePipeHandle)

Initialise une nouvelle instance de la classe AnonymousPipeClientStream à partir du handle spécifié.

AnonymousPipeClientStream(PipeDirection, String)

Initialise une nouvelle instance de la classe AnonymousPipeClientStream avec le sens du canal spécifié et une représentation sous forme de chaîne du handle du canal.

AnonymousPipeClientStream(String)

Initialise une nouvelle instance de la classe AnonymousPipeClientStream avec la représentation sous forme de chaîne du handle du canal.

Propriétés

CanRead

Obtient une valeur indiquant si le flux actuel prend en charge les opérations de lecture.

(Hérité de PipeStream)
CanSeek

Obtient une valeur indiquant si le flux actuel prend en charge les opérations de recherche.

(Hérité de PipeStream)
CanTimeout

Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente.

(Hérité de Stream)
CanWrite

Obtient une valeur indiquant si le flux actuel prend en charge les opérations d'écriture.

(Hérité de PipeStream)
InBufferSize

Obtient la taille, en octets, de la mémoire tampon entrante pour un canal.

(Hérité de PipeStream)
IsAsync

Obtient une valeur indiquant si un objet PipeStream a été ouvert en mode asynchrone ou synchrone.

(Hérité de PipeStream)
IsConnected

Obtient ou définit une valeur indiquant si un objet PipeStream est connecté.

(Hérité de PipeStream)
IsHandleExposed

Obtient une valeur indiquant si un handle vers un objet PipeStream est exposé.

(Hérité de PipeStream)
IsMessageComplete

Obtient une valeur indiquant s'il y a plus de données dans le message retourné par l'opération de lecture la plus récente.

(Hérité de PipeStream)
Length

Obtient la longueur d'un flux, en octets.

(Hérité de PipeStream)
OutBufferSize

Obtient la taille, en octets, de la mémoire tampon sortante pour un canal.

(Hérité de PipeStream)
Position

Obtient ou définit la position actuelle du flux en cours.

(Hérité de PipeStream)
ReadMode

Définit le mode de lecture pour l’objet AnonymousPipeClientStream.

ReadTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’effectuer la lecture avant dépassement du délai d’attente.

(Hérité de Stream)
SafePipeHandle

Reçoit le handle sécurisé pour l'extrémité locale du canal que l'objet PipeStream en cours encapsule.

(Hérité de PipeStream)
TransmissionMode

Obtient le mode de transmission par canal pris en charge par le canal actuel.

WriteTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’écrire des données avant l’expiration du délai d’attente.

(Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération de lecture asynchrone.

(Hérité de PipeStream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone.

(Hérité de PipeStream)
CheckPipePropertyOperations()

Vérifie que l'état du canal correspond à celui requis pour l'obtention ou la définition des propriétés.

(Hérité de PipeStream)
CheckReadOperations()

Vérifie que le canal est connecté pour permettre les opérations de lecture.

(Hérité de PipeStream)
CheckWriteOperations()

Vérifie que le canal est connecté pour permettre les opérations d'écriture.

(Hérité de PipeStream)
Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé.

(Hérité de Stream)
CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyTo(Stream, Int32)

Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, Int32)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
CreateWaitHandle()
Obsolète.
Obsolète.
Obsolète.

Alloue un objet WaitHandle.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par Stream.

(Hérité de Stream)
Dispose(Boolean)

Libère les ressources non managées utilisées par la classe PipeStream et libère éventuellement les ressources managées.

(Hérité de PipeStream)
DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par Stream.

(Hérité de Stream)
EndRead(IAsyncResult)

Met fin à une requête de lecture asynchrone en attente.

(Hérité de PipeStream)
EndWrite(IAsyncResult)

Met fin à une requête d'écriture asynchrone en attente.

(Hérité de PipeStream)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Finalize()

Libère les ressources non managées et exécute d’autres opérations de nettoyage avant la récupération de l’instance de AnonymousPipeClientStream par le garbage collection.

Flush()

Efface la mémoire tampon pour le flux actuel et provoque l'écriture des données mises en mémoire tampon dans l'appareil sous-jacent.

(Hérité de PipeStream)
FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent.

(Hérité de Stream)
FlushAsync(CancellationToken)

Efface la mémoire tampon pour le flux actuel de manière asynchrone et provoque l'écriture des données mises en mémoire tampon dans l'appareil sous-jacent.

(Hérité de PipeStream)
GetAccessControl()

Obtient un objet PipeSecurity qui encapsule les entrées de la liste de contrôle d'accès (ACL) pour le canal décrit par l'objet PipeStream actuel.

(Hérité de PipeStream)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializeHandle(SafePipeHandle, Boolean, Boolean)

Initialise un objet PipeStream à partir de l'objet SafePipeHandle spécifié.

(Hérité de PipeStream)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
ObjectInvariant()
Obsolète.

Assure la prise en charge d'un Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

Lit un bloc d’octets depuis un flux et écrit les données dans une mémoire tampon spécifiée, en commençant à une position spécifiée pour une longueur spécifiée.

(Hérité de PipeStream)
Read(Span<Byte>)

Lit une séquence d’octets dans le flux actuel, les écrit dans un tableau d’octets et avance la position dans le flux du nombre d’octets lus.

(Hérité de PipeStream)
ReadAsync(Byte[], Int32, Int32)

Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d’octets du flux actuel dans un tableau d’octets, en commençant à une position spécifiée pour un nombre spécifié d’octets, avance la position dans le flux du nombre d’octets lus et supervise les demandes d’annulation.

(Hérité de PipeStream)
ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d’octets dans le flux actuel, les écrit dans une plage de mémoire d’octets, avance la position dans le flux du nombre d’octets lus et supervise les demandes d’annulation.

(Hérité de PipeStream)
ReadAtLeast(Span<Byte>, Int32, Boolean)

Lit au moins un nombre minimal d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus.

(Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

Lit de manière asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadByte()

Lit un octet à partir d'un canal.

(Hérité de PipeStream)
ReadExactly(Byte[], Int32, Int32)

Lit le nombre d’octets count du flux actuel et avance la position dans le flux.

(Hérité de Stream)
ReadExactly(Span<Byte>)

Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que soit buffer rempli.

(Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

Lit de manière asynchrone le nombre d’octets count du flux actuel, avance la position dans le flux et surveille les demandes d’annulation.

(Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)

Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer soit rempli et surveille les demandes d’annulation.

(Hérité de Stream)
Seek(Int64, SeekOrigin)

Affecte la valeur spécifiée à la position actuelle du flux en cours.

(Hérité de PipeStream)
SetAccessControl(PipeSecurity)

Applique les entrées de la liste de contrôle d'accès (ACL) spécifiées par un objet PipeSecurity au canal spécifié par l'objet PipeStream actuel.

(Hérité de PipeStream)
SetLength(Int64)

Définit la longueur du flux actuel à la valeur spécifiée.

(Hérité de PipeStream)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
WaitForPipeDrain()

Attend que l'autre extrémité du canal lise tous les octets envoyés.

(Hérité de PipeStream)
Write(Byte[], Int32, Int32)

Écrit un bloc d'octets dans le flux actuel en utilisant les données d'une mémoire tampon.

(Hérité de PipeStream)
Write(ReadOnlySpan<Byte>)

Écrit une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d’octets écrits.

(Hérité de PipeStream)
WriteAsync(Byte[], Int32, Int32)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone un nombre spécifié d’octets d’un tableau d’octets en commençant à une position spécifiée, avance la position actuelle dans ce flux du nombre d’octets écrit et supervise les demandes d’annulation.

(Hérité de PipeStream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.

(Hérité de PipeStream)
WriteByte(Byte)

Écrit un octet dans le flux en cours.

(Hérité de PipeStream)

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)

Lit de façon asynchrone les octets du Stream et les écrit dans le PipeWriter spécifié en utilisant un jeton d’annulation.

GetAccessControl(PipeStream)

Retourne les informations de sécurité d’un flux de canal.

SetAccessControl(PipeStream, PipeSecurity)

Change les attributs de sécurité d’un flux de canal existant.

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.

S’applique à