Condividi tramite

PipeStream.Read Metodo

Definizione

Spazio dei nomi:
System.IO.Pipes
Assembly:
netstandard.dll, System.IO.Pipes.dll
Assembly:
System.IO.Pipes.dll
Assembly:
netstandard.dll
Assembly:
System.Core.dll

Overload

Nome Descrizione
Read(Span<Byte>)

Legge una sequenza di byte dal flusso corrente, le scrive in una matrice di byte e sposta in avanti 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 a partire da una posizione specificata per una lunghezza specificata.

Read(Span<Byte>)

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

Legge una sequenza di byte dal flusso corrente, le scrive in una matrice di byte e sposta in avanti 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>

Area di memoria. Quando termina, il contenuto di questa area viene sostituito dai byte letti dall'origine corrente.

Restituisce

Int32

Numero totale di byte letti in buffer. Può essere minore del numero di byte allocati in buffer se tale numero di byte non è attualmente disponibile oppure zero (0) se è stata raggiunta la fine del flusso.

Eccezioni

ArgumentNullException

Il numero di byte letti è maggiore della lunghezza del buffer.

NotSupportedException

Il flusso non supporta la lettura.

ObjectDisposedException

Impossibile accedere a una pipe chiusa.

InvalidOperationException

La pipe non è ancora stata connessa.

oppure

La pipe è in uno stato disconnesso.

oppure

L'handle pipe non è stato impostato. (L'implementazione è stata PipeStream chiamata InitializeHandle(SafePipeHandle, Boolean, Boolean)?

Commenti

Utilizzare la CanRead proprietà per determinare se l'oggetto corrente PipeStream supporta 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 sarà 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 di 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
Origine:
PipeStream.Unix.cs
Origine:
PipeStream.Unix.cs

Legge un blocco di byte da un flusso e scrive i dati in un buffer specificato a partire da 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 termina, questo metodo contiene la matrice di byte specificata con i valori compresi tra offset e (offset + count - 1) sostituiti dai byte letti dall'origine corrente.

offset
Int32

Offset di byte nella buffer matrice in cui verranno posizionati i byte letti.

count
Int32

Numero massimo di byte da leggere.

Restituisce

Int32

Numero totale di byte letti in buffer. Potrebbe essere minore del numero di byte richiesti se tale numero di byte non è attualmente disponibile o 0 se viene raggiunta la fine del flusso.

Attributi
SecurityCriticalAttribute

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

offset è minore di 0.

oppure

count è minore di 0.

ArgumentException

count è maggiore del numero di byte disponibili in buffer.

ObjectDisposedException

La pipe è chiusa.

NotSupportedException

La pipe non supporta le operazioni di lettura.

InvalidOperationException

La pipe è disconnessa, in attesa di connessione o l'handle non è stato impostato.

IOException

Si è verificato un 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 di pipe come codice di convalida. Sia il client pipe che il server pipe fanno parte dello stesso esempio. La parte server dell'esempio crea un processo client e la passa come argomento un handle di pipe anonimo.

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 operazioni di lettura.

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

Si applica a