Condividi tramite


PipeStream.Read Metodo

Definizione

Overload

Read(Span<Byte>)

Legge una sequenza di byte dal flusso corrente, li scrive in una matrice di byte e fa avanzare la posizione all'interno del flusso in base al numero di byte letti.

Read(Byte[], Int32, Int32)

Legge un blocco di byte da un flusso e scrive i dati in un buffer specificato che inizia in una posizione specificata per una lunghezza specificata.

Read(Span<Byte>)

Origine:
PipeStream.Unix.cs
Origine:
PipeStream.Unix.cs
Origine:
PipeStream.Unix.cs

Legge una sequenza di byte dal flusso corrente, li scrive in una matrice di byte e fa avanzare la posizione all'interno del flusso in base al numero di byte letti.

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

Parametri

buffer
Span<Byte>

Un'area di memoria. Quando questo metodo termina, il contenuto di quest'area viene sostituito dai byte letti dall'origine corrente.

Restituisce

Numero complessivo di byte letti nel buffer. È possibile che questo numero sia inferiore a quello dei byte allocati in buffer se la quantità di byte attualmente disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso.

Eccezioni

Il numero di byte letti supera la lunghezza del buffer.

Il flusso non supporta la lettura.

Impossibile accedere a una pipe chiusa.

Pipe non ancora connessa.

-oppure-

Pipe in stato disconnesso.

-oppure-

L'handle di pipe non è stato impostato. Verificare se l'implementazione PipeStream ha chiamato InitializeHandle(SafePipeHandle, Boolean, Boolean).

Commenti

Utilizzare la CanRead proprietà per determinare se l'oggetto corrente PipeStream supporta le operazioni di lettura.

Usare il ReadAsync metodo per leggere in modo asincrono dal flusso corrente.

Questo metodo legge un massimo di buffer.Length byte dal flusso corrente e li archivia in buffer. La posizione corrente all'interno del flusso è avanzata dal numero di byte letti; Tuttavia, se si verifica un'eccezione, la posizione corrente all'interno del flusso rimane invariata.

Questo metodo verrà bloccato fino a quando non è possibile leggere almeno un byte di dati, nel caso in cui non siano disponibili dati.

Questo metodo restituisce 0 solo quando non sono presenti più dati nel flusso e non è più previsto (ad esempio un socket chiuso o la fine del file).

Questo metodo è libero di restituire meno byte rispetto a quanto richiesto anche se la fine del flusso non è stata raggiunta.

Usare BinaryReader per la lettura dei tipi di dati primitivi.

Si applica a

Read(Byte[], Int32, Int32)

Origine:
PipeStream.Unix.cs
Origine:
PipeStream.Unix.cs
Origine:
PipeStream.Unix.cs

Legge un blocco di byte da un flusso e scrive i dati in un buffer specificato che inizia in una posizione specificata per una lunghezza specificata.

public:
 override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);
public override int Read (byte[] buffer, int offset, int count);
[System.Security.SecurityCritical]
public override int Read (byte[] buffer, int offset, int count);
override this.Read : byte[] * int * int -> int
[<System.Security.SecurityCritical>]
override this.Read : byte[] * int * int -> int
Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parametri

buffer
Byte[]

Quando questo metodo viene restituito, contiene la matrice di byte specificata con i valori compresi tra offset e (offset + count - 1) sostituiti con i byte letti dall'origine corrente.

offset
Int32

L'offset del byte nella matrice buffer in corrispondenza del quale verranno inseriti i byte letti.

count
Int32

Numero massimo di byte da leggere.

Restituisce

Il numero complessivo di byte letti in buffer. È possibile che questo numero sia inferiore a quello dei byte richiesti se tale quantità di byte non è attualmente disponibile oppure 0 se è stata raggiunta la fine del flusso.

Attributi

Eccezioni

buffer è null.

offset è minore di 0.

-oppure-

count è minore di 0.

count è maggiore del numero di byte disponibili in buffer.

La pipe è chiusa.

La pipe non supporta operazioni di lettura.

Pipe disconnessa, in attesa di connessione oppure handle non impostato.

Errore di I/O.

Esempio

Nell'esempio seguente viene creato un client pipe anonimo e un server pipe. Il server pipe usa il Read metodo per leggere una serie di byte dal client della pipe come codice di convalida. Sia il client pipe che il server pipe fanno parte dello stesso esempio. La parte del server dell'esempio crea un processo client e la passa come argomento a un handle di pipe anonima.

#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

Commenti

Utilizzare la CanRead proprietà per determinare se l'oggetto corrente PipeStream supporta le operazioni di lettura.

Chiamare i blocchi del Read metodo fino a quando non count vengono letti i byte o la fine del flusso. Per le operazioni di lettura asincrone, vedere BeginRead e EndRead.

Si applica a