PipeStream.Read Metoda

Reference

Definice

Obor názvů:: System.IO.Pipes

Sestavení:: System.IO.Pipes.dll

Sestavení:: netstandard.dll

Sestavení:: System.Core.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Přetížení

Read(Span<Byte>)	Načte posloupnost bajtů z aktuálního datového proudu, zapíše je do pole bajtů a posune pozici v rámci datového proudu o počet přečtených bajtů.
Read(Byte[], Int32, Int32)	Načte blok bajtů z datového proudu a zapíše data do zadané vyrovnávací paměti počínaje zadanou polohou na zadanou délku.

Read(Span<Byte>)

Zdroj:: PipeStream.Unix.cs

Zdroj:: PipeStream.Unix.cs

Zdroj:: PipeStream.Unix.cs

Načte posloupnost bajtů z aktuálního datového proudu, zapíše je do pole bajtů a posune pozici v rámci datového proudu o počet přečtených bajtů.

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

Parametry

buffer: Span<Byte>

Oblast paměti. Když se tato metoda vrátí, obsah této oblasti se nahradí bajty načtenými z aktuálního zdroje.

Návraty

Int32

Celkový počet bajtů přečtených do buffer. To může být menší než počet bajtů přidělených v buffer , pokud tento počet bajtů není aktuálně k dispozici, nebo nula (0), pokud bylo dosaženo konce datového proudu.

Výjimky

ArgumentNullException

Počet přečtených bajtů byl delší než délka vyrovnávací paměti.

NotSupportedException

Datový proud nepodporuje čtení.

ObjectDisposedException

Nelze získat přístup k uzavřenému kanálu.

InvalidOperationException

Kanál ještě není připojený.

-nebo-

Kanál je v odpojeném stavu.

-nebo-

Úchyt potrubí nebyl nastaven. (Volala InitializeHandle(SafePipeHandle, Boolean, Boolean)vaše PipeStream implementace ?

Poznámky

CanRead Pomocí vlastnosti určete, zda aktuální PipeStream objekt podporuje operace čtení.

K asynchronnímu čtení z aktuálního datového ReadAsync proudu použijte metodu .

Tato metoda načte maximální počet buffer.Length bajtů z aktuálního datového proudu a uloží je do buffer. Aktuální pozice v rámci datového proudu je rozšířena o počet přečtených bajtů; pokud však dojde k výjimce, aktuální pozice v rámci datového proudu zůstane beze změny.

Tato metoda bude blokovat, dokud nebude možné přečíst alespoň jeden bajt dat v případě, že nejsou k dispozici žádná data.

Tato metoda vrátí hodnotu 0 pouze v případě, že datový proud neobsahuje žádná další data a neočekává se žádné další (například zavřený soket nebo konec souboru).

Tato metoda může bezplatně vrátit méně bajtů, než požaduje, i když nebylo dosaženo konce datového proudu.

Slouží BinaryReader ke čtení primitivních datových typů.

Platí pro

Read(Byte[], Int32, Int32)

Zdroj:: PipeStream.Unix.cs

Zdroj:: PipeStream.Unix.cs

Zdroj:: PipeStream.Unix.cs

Načte blok bajtů z datového proudu a zapíše data do zadané vyrovnávací paměti počínaje zadanou polohou na zadanou délku.

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

Parametry

buffer: Byte[]

Když se tato metoda vrátí, obsahuje zadané pole bajtů s hodnotami mezi offset a (offset + count - 1) nahrazenými bajty načtenými z aktuálního zdroje.

offset: Int32

Posun bajtů v buffer poli, ve kterém budou umístěny přečtené bajty.

count: Int32

Maximální počet bajtů ke čtení.

Návraty

Int32

Celkový počet bajtů, které se načtou do buffer. To může být menší než požadovaný počet bajtů, pokud tento počet bajtů není aktuálně k dispozici, nebo 0, pokud je dosaženo konce datového proudu.

Atributy: SecurityCriticalAttribute

Výjimky

ArgumentNullException

buffer je null.

ArgumentOutOfRangeException

offset je menší než 0.

-nebo-

count je menší než 0.

ArgumentException

count je větší než počet bajtů dostupných v buffernástroji .

ObjectDisposedException

Potrubí je zavřené.

NotSupportedException

Kanál nepodporuje operace čtení.

InvalidOperationException

Kanál je odpojený, čeká na připojení nebo nebyl nastaven popisovač.

IOException

Došlo k jakékoli vstupně-výstupní chybě.

Příklady

Následující příklad vytvoří anonymního klienta kanálu a server kanálu. Server kanálů používá metodu Read ke čtení řady bajtů z klienta kanálu jako ověřovací kód. Klient kanálu i server kanálu jsou součástí stejného příkladu. Serverová část příkladu vytvoří klientský proces a předá mu anonymní popisovač kanálu jako 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

Poznámky

CanRead Pomocí vlastnosti určete, zda aktuální PipeStream objekt podporuje operace čtení.

Read Volání bloků metody, dokud count nejsou přečtené bajty nebo dosažení konce datového proudu. Informace o asynchronních operacích čtení najdete v tématech BeginRead a EndRead.

Platí pro

Sdílet prostřednictvím

PipeStream.Read Metoda

Definice

Přetížení

Read(Span<Byte>)

Parametry

Návraty

Výjimky

Poznámky

Platí pro

Read(Byte[], Int32, Int32)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Další materiály