PipeStream.Read Méthode

Définition

Espace de noms:

System.IO.Pipes

Assembly:

System.IO.Pipes.dll

Surcharges

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.
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.

Read(Span<Byte>)

Source:

PipeStream.Unix.cs

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.

public:
 override int Read(Span<System::Byte> buffer);

public override int Read (Span<byte> buffer);

override this.Read : Span<byte> -> int

Public Overrides Function Read (buffer As Span(Of Byte)) As Integer

Paramètres

buffer

Span<Byte>

Région de la mémoire. Quand cette méthode est retournée, le contenu de cette région est remplacé par les octets lus dans la source actuelle.

Retours

Int32

Nombre total d'octets lus dans l'élément buffer. Le nombre d’octets peut être inférieur au nombre d’octets alloués dans buffer si ce nombre d’octets n’est pas actuellement disponible, ou égal à zéro (0) si la fin du flux a été atteinte.

Exceptions

ArgumentNullException

Le nombre d’octets lus était plus long que la longueur de la mémoire tampon.

NotSupportedException

Le flux ne prend pas en charge la lecture.

ObjectDisposedException

Impossible d’accéder à un canal fermé.

InvalidOperationException

Le canal n’a pas encore été connecté.

- ou -

Le canal est dans un état déconnecté.

- ou -

Le handle du canal n’a pas été défini. (Votre implémentation PipeStream a-t-elle appelé InitializeHandle(SafePipeHandle, Boolean, Boolean)?

Remarques

Utilisez la CanRead propriété pour déterminer si l’objet actuel PipeStream prend en charge les opérations de lecture.

Utilisez la ReadAsync méthode pour lire de manière asynchrone à partir du flux actuel.

Cette méthode lit un maximum d’octets buffer.Length du flux actuel et les stocke dans buffer. La position actuelle dans le flux est avancée par le nombre d’octets lus ; Toutefois, si une exception se produit, la position actuelle dans le flux reste inchangée.

Cette méthode se bloque jusqu’à ce qu’au moins un octet de données puisse être lu, dans le cas où aucune donnée n’est disponible.

Cette méthode retourne 0 uniquement lorsqu’il n’y a plus de données dans le flux et qu’aucune autre donnée n’est attendue (par exemple, un socket fermé ou la fin du fichier).

Cette méthode est libre de retourner moins d’octets que demandé même si la fin du flux n’a pas été atteinte.

À utiliser BinaryReader pour lire les types de données primitifs.

Read(Byte[], Int32, Int32)

Source:

PipeStream.Unix.cs

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.

public:
 override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);

public override int Read (byte[] buffer, int offset, int count);

override this.Read : byte[] * int * int -> int

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

Paramètres

buffer

Byte[]

Quand cette méthode est retournée, contient le tableau d’octets spécifié dont les valeurs comprises entre offset et (offset + count - 1) sont remplacées par les octets lus dans la source actuelle.

offset

Int32

Offset d'octet dans le tableau buffer auquel les octets lus seront placés.

count

Int32

Nombre maximal d'octets à lire.

Retours

Int32

Nombre total d'octets qui sont lus dans buffer. Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible actuellement, ou il peut être égal à 0 si la fin du flux est atteinte.

Exceptions

ArgumentNullException

buffer a la valeur null.

ArgumentOutOfRangeException

offset est inférieur à 0.

- ou -

count est inférieur à 0.

ArgumentException

count est supérieur au nombre d’octets disponible dans buffer.

ObjectDisposedException

Le canal est fermé.

NotSupportedException

Le canal ne prend pas en charge les opérations de lecture.

InvalidOperationException

Le canal est déconnecté, en attente de connexion ou le handle n’a pas été défini.

IOException

Une erreur d’E/S s’est produite.

Exemples

L’exemple suivant crée un client de canal anonyme et un serveur de canal. Le serveur de canal utilise la Read méthode pour lire une série d’octets du client de canal en tant que code de validation. Le client de canal et le serveur de canal font partie du même exemple. La partie serveur de l’exemple crée un processus client et lui passe un handle de canal anonyme en tant qu’argument.

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

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

ref class PipeStreamExample
{
private:
    static array<Byte>^ matchSign = {9, 0, 9, 0};

public:
    static void Main()
    {
        array<String^>^ args = Environment::GetCommandLineArgs();
        if (args->Length < 2)
        {
            Process^ clientProcess = gcnew Process();

            clientProcess->StartInfo->FileName = Environment::CommandLine;

            AnonymousPipeServerStream^ pipeServer =
                gcnew AnonymousPipeServerStream(PipeDirection::In,
                HandleInheritability::Inheritable);
            // Pass the client process a handle to the server.
            clientProcess->StartInfo->Arguments = pipeServer->GetClientHandleAsString();
            clientProcess->StartInfo->UseShellExecute = false;
            Console::WriteLine("[SERVER] Starting client process...");
            clientProcess->Start();

            pipeServer->DisposeLocalCopyOfClientHandle();

            try
            {
                if (WaitForClientSign(pipeServer))
                {
                    Console::WriteLine("[SERVER] Valid sign code received!");
                }
                else
                {
                    Console::WriteLine("[SERVER] Invalid sign code received!");
                }
            }
            catch (IOException^ e)
            {
                 Console::WriteLine("[SERVER] Error: {0}", e->Message);
            }
            clientProcess->WaitForExit();
            clientProcess->Close();
            Console::WriteLine("[SERVER] Client quit. Server terminating.");
        }
        else
        {
            PipeStream^ pipeClient =
                gcnew AnonymousPipeClientStream(PipeDirection::Out, args[1]);
            try
            {
                Console::WriteLine("[CLIENT] Sending sign code...");
                SendClientSign(pipeClient);
            }
            catch (IOException^ e)
            {
                Console::WriteLine("[CLIENT] Error: {0}", e->Message);
            }
            Console::WriteLine("[CLIENT] Terminating.");
        }
    }

private:
    static bool WaitForClientSign(PipeStream^ inStream)
    {
        array<Byte>^ inSign = gcnew array<Byte>(matchSign->Length);
        int len = inStream->Read(inSign, 0, matchSign->Length);
        bool valid = len == matchSign->Length;

        while (valid && len-- > 0)
        {
            valid = valid && (matchSign[len] == inSign[len]);
        }
        return valid;
    }

    static void SendClientSign(PipeStream^ outStream)
    {
        outStream->Write(matchSign, 0, matchSign->Length);
    }
};

int main()
{
    PipeStreamExample::Main();
}

using System;
using System.IO;
using System.IO.Pipes;
using System.Diagnostics;

class PipeStreamExample
{
    private static byte[] matchSign = {9, 0, 9, 0};

    public static void Main()
    {
        string[] args = Environment.GetCommandLineArgs();
        if (args.Length < 2)
        {
            Process clientProcess = new Process();

            clientProcess.StartInfo.FileName = Environment.CommandLine;

            using (AnonymousPipeServerStream pipeServer =
                new AnonymousPipeServerStream(PipeDirection.In,
                HandleInheritability.Inheritable))
            {
                // Pass the client process a handle to the server.
                clientProcess.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
                clientProcess.StartInfo.UseShellExecute = false;
                Console.WriteLine("[SERVER] Starting client process...");
                clientProcess.Start();

                pipeServer.DisposeLocalCopyOfClientHandle();

                try
                {
                    if (WaitForClientSign(pipeServer))
                    {
                        Console.WriteLine("[SERVER] Valid sign code received!");
                    }
                    else
                    {
                        Console.WriteLine("[SERVER] Invalid sign code received!");
                    }
                }
                catch (IOException e)
                {
                    Console.WriteLine("[SERVER] Error: {0}", e.Message);
                }
            }
            clientProcess.WaitForExit();
            clientProcess.Close();
            Console.WriteLine("[SERVER] Client quit. Server terminating.");
        }
        else
        {
            using (PipeStream pipeClient = new AnonymousPipeClientStream(PipeDirection.Out, args[1]))
            {
                try
                {
                    Console.WriteLine("[CLIENT] Sending sign code...");
                    SendClientSign(pipeClient);
                }
                catch (IOException e)
                {
                     Console.WriteLine("[CLIENT] Error: {0}", e.Message);
                }
            }
            Console.WriteLine("[CLIENT] Terminating.");
        }
    }

    private static bool WaitForClientSign(PipeStream inStream)
    {
        byte[] inSign = new byte[matchSign.Length];
        int len = inStream.Read(inSign, 0, matchSign.Length);
        bool valid = len == matchSign.Length;

        while (valid && len-- > 0)
        {
            valid = valid && (matchSign[len] == inSign[len]);
        }
        return valid;
    }

    private static void SendClientSign(PipeStream outStream)
    {
        outStream.Write(matchSign, 0, matchSign.Length);
    }
}

Imports System.IO
Imports System.IO.Pipes
Imports System.Diagnostics

Class PipeStreamExample
    Private Shared matchSign() As Byte = {9, 0, 9, 0}

    Public Shared Sub Main()
        Dim args() As String = Environment.GetCommandLineArgs()
        If args.Length < 2 Then
            Dim clientProcess As New Process()

            clientProcess.StartInfo.FileName = Environment.CommandLine

            Using pipeServer As New AnonymousPipeServerStream( _
                PipeDirection.In, HandleInheritability.Inheritable)

                ' Pass the client process a handle to the server.
                clientProcess.StartInfo.Arguments = pipeServer.GetClientHandleAsString()
                clientProcess.StartInfo.UseShellExecute = false
                Console.WriteLine("[SERVER] Starting client process...")
                clientProcess.Start()

                pipeServer.DisposeLocalCopyOfClientHandle()

                Try
                    If WaitForClientSign(pipeServer) Then
                        Console.WriteLine("[SERVER] Valid sign code received!")
                    Else
                        Console.WriteLine("[SERVER] Invalid sign code received!")
                    End If
                Catch e As IOException
                    Console.WriteLine("[SERVER] Error: {0}", e.Message)
                End Try
            End Using
            clientProcess.WaitForExit()
            clientProcess.Close()
            Console.WriteLine("[SERVER] Client quit. Server terminating.")
        Else
            Using pipeClient As PipeStream = New AnonymousPipeClientStream(PipeDirection.Out, args(1))
                Try
                    Console.WriteLine("[CLIENT] Sending sign code...")
                    SendClientSign(pipeClient)
                Catch e As IOException
                    Console.WriteLine("[CLIENT] Error: {0}", e.Message)
                End Try
            End Using
            Console.WriteLine("[CLIENT] Terminating.")
        End If
    End Sub

    Private Shared Function WaitForClientSign(inStream As PipeStream) As Boolean
        Dim inSign() As Byte = Array.CreateInstance(GetType(Byte), matchSign.Length)
        Dim len As Integer = inStream.Read(inSign, 0, matchSign.Length)
        Dim valid = len.Equals(matchSign.Length)

        While len > 0
            len -= 1
            valid = valid And (matchSign(len).Equals(inSign(len)))
        End While
        Return valid
    End Function

    Private Shared Sub SendClientSign(outStream As PipeStream)
        outStream.Write(matchSign, 0, matchSign.Length)
    End Sub
End Class

Remarques

Utilisez la CanRead propriété pour déterminer si l’objet actuel PipeStream prend en charge les opérations de lecture.

L’appel de la Read méthode se bloque jusqu’à ce count que les octets soient lus ou que la fin du flux soit atteinte. Pour les opérations de lecture asynchrones, consultez BeginRead et EndRead.