PipeStream.Read Metode

Definisi

Ruang nama:

System.IO.Pipes

Rakitan:

System.IO.Pipes.dll

Overload

Read(Span<Byte>)	Membaca urutan byte dari aliran saat ini, menulisnya ke array byte, dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca.
Read(Byte[], Int32, Int32)	Membaca blok byte dari aliran dan menulis data ke buffer tertentu mulai dari posisi tertentu untuk panjang yang ditentukan.

Read(Span<Byte>)

Sumber:

PipeStream.Unix.cs

Membaca urutan byte dari aliran saat ini, menulisnya ke array byte, dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca.

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

Parameter

buffer

Span<Byte>

Wilayah memori. Ketika metode ini kembali, konten wilayah ini digantikan oleh byte yang dibaca dari sumber saat ini.

Mengembalikan

Int32

Jumlah total byte yang dibaca ke bufferdalam . Ini bisa kurang dari jumlah byte yang dialokasikan buffer jika banyak byte saat ini tidak tersedia, atau nol (0) jika akhir aliran telah tercapai.

Pengecualian

ArgumentNullException

Jumlah byte yang dibaca lebih panjang dari panjang buffer.

NotSupportedException

Aliran tidak mendukung pembacaan.

ObjectDisposedException

Tidak dapat mengakses pipa tertutup.

InvalidOperationException

Pipa belum tersambung.

-atau-

Pipa dalam keadaan terputus.

-atau-

Handel pipa belum disetel. (Apakah implementasi Anda PipeStream memanggil InitializeHandle(SafePipeHandle, Boolean, Boolean)?

Keterangan

CanRead Gunakan properti untuk menentukan apakah objek saat ini PipeStream mendukung operasi baca.

ReadAsync Gunakan metode untuk membaca secara asinkron dari aliran saat ini.

Metode ini membaca maksimum buffer.Length byte dari aliran saat ini dan menyimpannya di buffer. Posisi saat ini dalam aliran dimajukan dengan jumlah byte yang dibaca; namun, jika pengecualian terjadi, posisi saat ini dalam aliran tetap tidak berubah.

Metode ini akan memblokir hingga setidaknya satu byte data dapat dibaca, jika tidak ada data yang tersedia.

Metode ini mengembalikan 0 hanya ketika tidak ada lagi data dalam aliran dan tidak ada lagi yang diharapkan (seperti soket tertutup atau akhir file).

Metode ini gratis untuk mengembalikan lebih sedikit byte daripada yang diminta meskipun akhir aliran belum tercapai.

Gunakan BinaryReader untuk membaca jenis data primitif.

Read(Byte[], Int32, Int32)

Sumber:

PipeStream.Unix.cs

Membaca blok byte dari aliran dan menulis data ke buffer tertentu mulai dari posisi tertentu untuk panjang yang ditentukan.

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

Parameter

buffer

Byte[]

Ketika metode ini kembali, berisi array byte yang ditentukan dengan nilai antara offset dan (offset + count - 1) digantikan oleh byte yang dibaca dari sumber saat ini.

offset

Int32

Offset byte dalam buffer array tempat byte yang dibaca akan ditempatkan.

count

Int32

Jumlah maksimum byte yang akan dibaca.

Mengembalikan

Int32

Jumlah total byte yang dibaca ke dalam buffer. Ini mungkin kurang dari jumlah byte yang diminta jika jumlah byte tersebut saat ini tidak tersedia, atau 0 jika akhir aliran tercapai.

Pengecualian

ArgumentNullException

bufferadalah null.

ArgumentOutOfRangeException

offset kurang dari 0.

-atau-

count kurang dari 0.

ArgumentException

count lebih besar dari jumlah byte yang tersedia di buffer.

ObjectDisposedException

Pipa ditutup.

NotSupportedException

Pipa tidak mendukung operasi baca.

InvalidOperationException

Pipa terputus, menunggu untuk tersambung, atau handel belum diatur.

IOException

Terjadi kesalahan I/O.

Contoh

Contoh berikut membuat klien pipa anonim dan server pipa. Server pipa menggunakan Read metode untuk membaca serangkaian byte dari klien pipa sebagai kode validasi. Klien pipa dan server pipa adalah bagian dari contoh yang sama. Bagian server dari contoh membuat proses klien dan meneruskannya handel pipa anonim sebagai argumen.

#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

Keterangan

CanRead Gunakan properti untuk menentukan apakah objek saat ini PipeStream mendukung operasi baca.

Memanggil Read blok metode hingga count byte dibaca atau akhir aliran tercapai. Untuk operasi baca asinkron, lihat BeginRead dan EndRead.