BufferedStream Osztály

Definíció

Névtér:

System.IO

Szerelvény:

mscorlib.dll

Pufferelési réteget ad hozzá egy másik stream olvasási és írási műveleteihez. Ez az osztály nem örökölhető.

public ref class BufferedStream sealed : System::IO::Stream

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class BufferedStream : System.IO.Stream

[<System.Runtime.InteropServices.ComVisible(true)>]
type BufferedStream = class
    inherit Stream

Public NotInheritable Class BufferedStream
Inherits Stream

Öröklődés

Object

MarshalByRefObject

Stream

BufferedStream

Attribútumok

ComVisibleAttribute

Példák

Az alábbi kódpéldák bemutatják, hogyan lehet az BufferedStream osztályt az osztályon keresztül NetworkStream használni bizonyos I/O-műveletek teljesítményének növeléséhez. Indítsa el a kiszolgálót egy távoli számítógépen, mielőtt elindítja az ügyfelet. Az ügyfél indításakor adja meg a távoli számítógép nevét parancssori argumentumként. Az állandók és streamBufferSize az állandók módosítása a dataArraySize teljesítményre gyakorolt hatásuk megtekintéséhez.

Az első példa az ügyfélen futó kódot, a második pedig a kiszolgálón futó kódot mutatja be.

1. példa: Az ügyfélen futó kód

using System;
using System.IO;
using System.Globalization;
using System.Net;
using System.Net.Sockets;

public class Client
{
    const int dataArraySize    =   100;
    const int streamBufferSize =  1000;
    const int numberOfLoops    = 10000;

    static void Main(string[] args)
    {
        // Check that an argument was specified when the
        // program was invoked.
        if(args.Length == 0)
        {
            Console.WriteLine("Error: The name of the host computer" +
                " must be specified when the program is invoked.");
            return;
        }

        string remoteName = args[0];

        // Create the underlying socket and connect to the server.
        Socket clientSocket = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);

        clientSocket.Connect(new IPEndPoint(
            Dns.Resolve(remoteName).AddressList[0], 1800));

        Console.WriteLine("Client is connected.\n");

        // Create a NetworkStream that owns clientSocket and
        // then create a BufferedStream on top of the NetworkStream.
        // Both streams are disposed when execution exits the
        // using statement.
        using(Stream
            netStream = new NetworkStream(clientSocket, true),
            bufStream =
                  new BufferedStream(netStream, streamBufferSize))
        {
            // Check whether the underlying stream supports seeking.
            Console.WriteLine("NetworkStream {0} seeking.\n",
                bufStream.CanSeek ? "supports" : "does not support");

            // Send and receive data.
            if(bufStream.CanWrite)
            {
                SendData(netStream, bufStream);
            }
            if(bufStream.CanRead)
            {
                ReceiveData(netStream, bufStream);
            }

            // When bufStream is closed, netStream is in turn
            // closed, which in turn shuts down the connection
            // and closes clientSocket.
            Console.WriteLine("\nShutting down the connection.");
            bufStream.Close();
        }
    }

    static void SendData(Stream netStream, Stream bufStream)
    {
        DateTime startTime;
        double networkTime, bufferedTime;

        // Create random data to send to the server.
        byte[] dataToSend = new byte[dataArraySize];
        new Random().NextBytes(dataToSend);

        // Send the data using the NetworkStream.
        Console.WriteLine("Sending data using NetworkStream.");
        startTime = DateTime.Now;
        for(int i = 0; i < numberOfLoops; i++)
        {
            netStream.Write(dataToSend, 0, dataToSend.Length);
        }
        networkTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes sent in {1} seconds.\n",
            numberOfLoops * dataToSend.Length,
            networkTime.ToString("F1"));

        // Send the data using the BufferedStream.
        Console.WriteLine("Sending data using BufferedStream.");
        startTime = DateTime.Now;
        for(int i = 0; i < numberOfLoops; i++)
        {
            bufStream.Write(dataToSend, 0, dataToSend.Length);
        }
        bufStream.Flush();
        bufferedTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes sent in {1} seconds.\n",
            numberOfLoops * dataToSend.Length,
            bufferedTime.ToString("F1"));

        // Print the ratio of write times.
        Console.WriteLine("Sending data using the buffered " +
            "network stream was {0} {1} than using the network " +
            "stream alone.\n",
            (networkTime/bufferedTime).ToString("P0"),
            bufferedTime < networkTime ? "faster" : "slower");
    }

    static void ReceiveData(Stream netStream, Stream bufStream)
    {
        DateTime startTime;
        double networkTime, bufferedTime = 0;
        int bytesReceived = 0;
        byte[] receivedData = new byte[dataArraySize];

        // Receive data using the NetworkStream.
        Console.WriteLine("Receiving data using NetworkStream.");
        startTime = DateTime.Now;
        while(bytesReceived < numberOfLoops * receivedData.Length)
        {
            bytesReceived += netStream.Read(
                receivedData, 0, receivedData.Length);
        }
        networkTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes received in {1} seconds.\n",
            bytesReceived.ToString(),
            networkTime.ToString("F1"));

        // Receive data using the BufferedStream.
        Console.WriteLine("Receiving data using BufferedStream.");
        bytesReceived = 0;
        startTime = DateTime.Now;

        int numBytesToRead = receivedData.Length;

        while (numBytesToRead > 0)
        {
            // Read may return anything from 0 to numBytesToRead.
            int n = bufStream.Read(receivedData,0, receivedData.Length);
            // The end of the file is reached.
            if (n == 0)
                break;
            bytesReceived += n;
            numBytesToRead -= n;
        }

        bufferedTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes received in {1} seconds.\n",
            bytesReceived.ToString(),
            bufferedTime.ToString("F1"));

        // Print the ratio of read times.
        Console.WriteLine("Receiving data using the buffered network" +
            " stream was {0} {1} than using the network stream alone.",
            (networkTime/bufferedTime).ToString("P0"),
            bufferedTime < networkTime ? "faster" : "slower");
    }
}

module Client

open System
open System.IO
open System.Net
open System.Net.Sockets

let dataArraySize    =   100
let streamBufferSize =  1000
let numberOfLoops    = 10000

let sendData (netStream: Stream) (bufStream: Stream) =
    // Create random data to send to the server.
    let dataToSend = Array.zeroCreate dataArraySize
    Random().NextBytes dataToSend

    // Send the data using the NetworkStream.
    printfn "Sending data using NetworkStream."
    let startTime = DateTime.Now
    for _ = 0 to numberOfLoops - 1 do
        netStream.Write(dataToSend, 0, dataToSend.Length)
    let networkTime = (DateTime.Now - startTime).TotalSeconds
    printfn $"{numberOfLoops * dataToSend.Length} bytes sent in {networkTime:F1} seconds.\n"

    // Send the data using the BufferedStream.
    printfn "Sending data using BufferedStream."
    let startTime = DateTime.Now
    for _ = 0 to numberOfLoops - 1 do
        bufStream.Write(dataToSend, 0, dataToSend.Length)
    bufStream.Flush()
    let bufferedTime = (DateTime.Now - startTime).TotalSeconds
    printfn $"{numberOfLoops * dataToSend.Length} bytes sent in {bufferedTime:F1} seconds.\n"

    // Print the ratio of write times.
    printfn $"""Sending data using the buffered network stream was {networkTime / bufferedTime:P0} {if bufferedTime < networkTime then "faster" else "slower"} than using the network stream alone."""
    printfn ""

let receiveData (netStream: Stream) (bufStream: Stream) =
    let mutable bytesReceived = 0
    let receivedData = Array.zeroCreate dataArraySize

    // Receive data using the NetworkStream.
    printfn "Receiving data using NetworkStream."
    let startTime = DateTime.Now
    while bytesReceived < numberOfLoops * receivedData.Length do
        bytesReceived <- bytesReceived + netStream.Read(receivedData, 0, receivedData.Length)
    let networkTime = (DateTime.Now - startTime).TotalSeconds
    printfn $"{bytesReceived} bytes received in {networkTime:F1} seconds.\n"

    // Receive data using the BufferedStream.
    printfn "Receiving data using BufferedStream."
    bytesReceived <- 0
    let startTime = DateTime.Now

    let mutable numBytesToRead = receivedData.Length

    let mutable broken = false
    while not broken && numBytesToRead > 0 do
        // Read may return anything from 0 to numBytesToRead.
        let n = bufStream.Read(receivedData,0, receivedData.Length)
        // The end of the file is reached.
        if n = 0 then
            broken <- true
        else
            bytesReceived <- bytesReceived + n
            numBytesToRead <- numBytesToRead - n

    let bufferedTime = (DateTime.Now - startTime).TotalSeconds
    printfn $"{bytesReceived} bytes received in {bufferedTime:F1} seconds.\n"

    // Print the ratio of read times.
    printfn $"""Receiving data using the buffered network stream was {networkTime / bufferedTime:P0} {if bufferedTime < networkTime then "faster" else "slower"} than using the network stream alone."""

[<EntryPoint>]
let main args =
    // Check that an argument was specified when the
    // program was invoked.
    if args.Length = 0 then
        printfn "Error: The name of the host computer must be specified when the program is invoked."
    else
        let remoteName = args[0]

        // Create the underlying socket and connect to the server.
        let clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)

        clientSocket.Connect(IPEndPoint(Dns.GetHostEntry(remoteName).AddressList[0], 1800))

        printfn "Client is connected.\n"

        // Create a NetworkStream that owns clientSocket and
        // then create a BufferedStream on top of the NetworkStream.
        // Both streams are disposed when execution exits the
        // using statement.
        use netStream = new NetworkStream(clientSocket, true)
        use bufStream = new BufferedStream(netStream, streamBufferSize)
        // Check whether the underlying stream supports seeking.
        printfn $"""NetworkStream {if bufStream.CanSeek then "supports" else "does not support"} seeking.\n"""

        // Send and receive data.
        if bufStream.CanWrite then
            sendData netStream bufStream
        if bufStream.CanRead then
            receiveData netStream bufStream

        // When bufStream is closed, netStream is in turn
        // closed, which in turn shuts down the connection
        // and closes clientSocket.
        printfn "\nShutting down the connection."
        bufStream.Close()
    0

' Compile using /r:System.dll.
Imports System.IO
Imports System.Globalization
Imports System.Net
Imports System.Net.Sockets

Public Class Client 

    Const dataArraySize As Integer    =   100
    Const streamBufferSize As Integer =  1000
    Const numberOfLoops As Integer    = 10000

    Shared Sub Main(args As String()) 
    
        ' Check that an argument was specified when the 
        ' program was invoked.
        If args.Length = 0 Then
            Console.WriteLine("Error: The name of the host " & _
                "computer must be specified when the program " & _ 
                "is invoked.")
            Return
        End If

        Dim remoteName As String = args(0)

        ' Create the underlying socket and connect to the server.
        Dim clientSocket As New Socket(AddressFamily.InterNetwork, _
            SocketType.Stream, ProtocolType.Tcp)

        clientSocket.Connect(New IPEndPoint( _
            Dns.Resolve(remoteName).AddressList(0), 1800))

        Console.WriteLine("Client is connected." & vbCrLf)

        ' Create a NetworkStream that owns clientSocket and then 
        ' create a BufferedStream on top of the NetworkStream.
        Dim netStream As New NetworkStream(clientSocket, True)
        Dim bufStream As New _
            BufferedStream(netStream, streamBufferSize)
        
        Try
            ' Check whether the underlying stream supports seeking.
            If bufStream.CanSeek Then
                Console.WriteLine("NetworkStream supports" & _
                    "seeking." & vbCrLf)
            Else
                Console.WriteLine("NetworkStream does not " & _
                    "support seeking." & vbCrLf)
            End If

            ' Send and receive data.
            If bufStream.CanWrite Then
                SendData(netStream, bufStream)
            End If            
            If bufStream.CanRead Then
                ReceiveData(netStream, bufStream)
            End If
        Finally

            ' When bufStream is closed, netStream is in turn 
            ' closed, which in turn shuts down the connection 
            ' and closes clientSocket.
            Console.WriteLine(vbCrLf & "Shutting down the connection.")
            bufStream.Close()
        End Try
    End Sub

    Shared Sub SendData(netStream As Stream, bufStream As Stream)
    
        Dim startTime As DateTime 
        Dim networkTime As Double, bufferedTime As Double 

        ' Create random data to send to the server.
        Dim dataToSend(dataArraySize - 1) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(dataToSend)

        ' Send the data using the NetworkStream.
        Console.WriteLine("Sending data using NetworkStream.")
        startTime = DateTime.Now
        For i As Integer = 1 To numberOfLoops
            netStream.Write(dataToSend, 0, dataToSend.Length)
        Next i
        networkTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes sent in {1} seconds." & vbCrLf, _
            numberOfLoops * dataToSend.Length, _
            networkTime.ToString("F1"))

        ' Send the data using the BufferedStream.
        Console.WriteLine("Sending data using BufferedStream.")
        startTime = DateTime.Now
        For i As Integer = 1 To numberOfLoops
            bufStream.Write(dataToSend, 0, dataToSend.Length)
        Next i
        
        bufStream.Flush()
        bufferedTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes sent In {1} seconds." & vbCrLf, _
            numberOfLoops * dataToSend.Length, _
            bufferedTime.ToString("F1"))

        ' Print the ratio of write times.
        Console.Write("Sending data using the buffered " & _
            "network stream was {0}", _
            (networkTime/bufferedTime).ToString("P0"))
        If bufferedTime < networkTime Then
            Console.Write(" faster")
        Else
            Console.Write(" slower")
        End If
        Console.WriteLine(" than using the network stream alone.")
    End Sub

    Shared Sub ReceiveData(netStream As Stream, bufStream As Stream)
    
        Dim startTime As DateTime 
        Dim networkTime As Double, bufferedTime As Double = 0

        Dim bytesReceived As Integer = 0
        Dim receivedData(dataArraySize - 1) As Byte

        ' Receive data using the NetworkStream.
        Console.WriteLine("Receiving data using NetworkStream.")
        startTime = DateTime.Now
        While bytesReceived < numberOfLoops * receivedData.Length
            bytesReceived += netStream.Read( _
                receivedData, 0, receivedData.Length)
        End While
        networkTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes received in {1} " & _
            "seconds." & vbCrLf, _
            bytesReceived.ToString(), _
            networkTime.ToString("F1"))

        ' Receive data using the BufferedStream.
        Console.WriteLine("Receiving data using BufferedStream.")
        bytesReceived = 0
        startTime = DateTime.Now

        Dim numBytesToRead As Integer = receivedData.Length
        Dim n As Integer
        Do While numBytesToRead > 0

            'Read my return anything from 0 to numBytesToRead
            n = bufStream.Read(receivedData, 0, receivedData.Length)
            'The end of the file is reached.
            If n = 0 Then
                Exit Do
            End If

            bytesReceived += n
            numBytesToRead -= n
        Loop

        bufferedTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes received in {1} " & _
            "seconds." & vbCrLf, _
            bytesReceived.ToString(), _
            bufferedTime.ToString("F1"))

        ' Print the ratio of read times.
        Console.Write("Receiving data using the buffered " & _
            "network stream was {0}", _
            (networkTime/bufferedTime).ToString("P0"))
        If bufferedTime < networkTime Then
            Console.Write(" faster")
        Else
            Console.Write(" slower")
        End If
        Console.WriteLine(" than using the network stream alone.")
    End Sub
End Class

2. példa: A kiszolgálón futó kód

using System;
using System.Net;
using System.Net.Sockets;

public class Server
{
    static void Main()
    {
        // This is a Windows Sockets 2 error code.
        const int WSAETIMEDOUT = 10060;

        Socket serverSocket;
        int bytesReceived, totalReceived = 0;
        byte[] receivedData = new byte[2000000];

        // Create random data to send to the client.
        byte[] dataToSend = new byte[2000000];
        new Random().NextBytes(dataToSend);

        IPAddress ipAddress =
            Dns.Resolve(Dns.GetHostName()).AddressList[0];

        IPEndPoint ipEndpoint = new IPEndPoint(ipAddress, 1800);

        // Create a socket and listen for incoming connections.
        using(Socket listenSocket = new Socket(
            AddressFamily.InterNetwork, SocketType.Stream,
            ProtocolType.Tcp))
        {
            listenSocket.Bind(ipEndpoint);
            listenSocket.Listen(1);

            // Accept a connection and create a socket to handle it.
            serverSocket = listenSocket.Accept();
            Console.WriteLine("Server is connected.\n");
        }

        try
        {
            // Send data to the client.
            Console.Write("Sending data ... ");
            int bytesSent = serverSocket.Send(
                dataToSend, 0, dataToSend.Length, SocketFlags.None);
            Console.WriteLine("{0} bytes sent.\n",
                bytesSent.ToString());

            // Set the timeout for receiving data to 2 seconds.
            serverSocket.SetSocketOption(SocketOptionLevel.Socket,
                SocketOptionName.ReceiveTimeout, 2000);

            // Receive data from the client.
            Console.Write("Receiving data ... ");
            try
            {
                do
                {
                    bytesReceived = serverSocket.Receive(receivedData,
                        0, receivedData.Length, SocketFlags.None);
                    totalReceived += bytesReceived;
                }
                while(bytesReceived != 0);
            }
            catch(SocketException e)
            {
                if(e.ErrorCode == WSAETIMEDOUT)
                {
                    // Data was not received within the given time.
                    // Assume that the transmission has ended.
                }
                else
                {
                    Console.WriteLine("{0}: {1}\n",
                        e.GetType().Name, e.Message);
                }
            }
            finally
            {
                Console.WriteLine("{0} bytes received.\n",
                    totalReceived.ToString());
            }
        }
        finally
        {
            serverSocket.Shutdown(SocketShutdown.Both);
            Console.WriteLine("Connection shut down.");
            serverSocket.Close();
        }
    }
}

module Server

open System
open System.Net
open System.Net.Sockets

// This is a Windows Sockets 2 error code.
let WSAETIMEDOUT = 10060

let mutable bytesReceived = -1 
let mutable totalReceived = 0
let receivedData = Array.zeroCreate 2000000

// Create random data to send to the client.
let dataToSend = Array.zeroCreate 2000000
Random().NextBytes dataToSend

let ipAddress = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0]

let ipEndpoint = IPEndPoint(ipAddress, 1800)

// Create a socket and listen for incoming connections.
let serverSocket = 
    use listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
    listenSocket.Bind ipEndpoint
    listenSocket.Listen 1

    // Accept a connection and create a socket to handle it.
    listenSocket.Accept()

printfn "Server is connected.\n"

try
    // Send data to the client.
    printf "Sending data ... "
    let bytesSent = serverSocket.Send(dataToSend, 0, dataToSend.Length, SocketFlags.None)
    printfn $"{bytesSent} bytes sent.\n"

    // Set the timeout for receiving data to 2 seconds.
    serverSocket.SetSocketOption(SocketOptionLevel.Socket,
        SocketOptionName.ReceiveTimeout, 2000)

    // Receive data from the client.
    printf "Receiving data ... "
    try
        try
            while bytesReceived <> 0 do
                bytesReceived <- serverSocket.Receive(receivedData, 0, receivedData.Length, SocketFlags.None)
                totalReceived <- totalReceived + bytesReceived

        with :? SocketException as e ->
            if e.ErrorCode = WSAETIMEDOUT then
                // Data was not received within the given time.
                // Assume that the transmission has ended.
                ()
            else
                printfn $"{e.GetType().Name}: {e.Message}\n"
    finally
        printfn $"{totalReceived} bytes received.\n"
finally
    serverSocket.Shutdown SocketShutdown.Both
    printfn "Connection shut down."
    serverSocket.Close()

' Compile using /r:System.dll.
Imports System.Net
Imports System.Net.Sockets

Public Class Server 

    Shared Sub Main() 
    
        ' This is a Windows Sockets 2 error code.
        Const WSAETIMEDOUT As Integer = 10060

        Dim serverSocket As Socket 
        Dim bytesReceived As Integer
        Dim totalReceived As Integer = 0
        Dim receivedData(2000000-1) As Byte

        ' Create random data to send to the client.
        Dim dataToSend(2000000-1) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(dataToSend)

        Dim ipAddress As IPAddress = _
            Dns.Resolve(Dns.GetHostName()).AddressList(0)

        Dim ipEndpoint As New IPEndPoint(ipAddress, 1800)

        ' Create a socket and listen for incoming connections.
        Dim listenSocket As New Socket(AddressFamily.InterNetwork, _
            SocketType.Stream, ProtocolType.Tcp)
        
        Try
            listenSocket.Bind(ipEndpoint)
            listenSocket.Listen(1)

            ' Accept a connection and create a socket to handle it.
            serverSocket = listenSocket.Accept()
            Console.WriteLine("Server is connected." & vbCrLf)
        Finally
            listenSocket.Close()
        End Try

        Try
            ' Send data to the client.
            Console.Write("Sending data ... ")
            Dim bytesSent As Integer = serverSocket.Send( _
                dataToSend, 0, dataToSend.Length, SocketFlags.None)
            Console.WriteLine("{0} bytes sent." & vbCrLf, _
                bytesSent.ToString())

            ' Set the timeout for receiving data to 2 seconds.
            serverSocket.SetSocketOption(SocketOptionLevel.Socket, _
                SocketOptionName.ReceiveTimeout, 2000)

            ' Receive data from the client.
            Console.Write("Receiving data ... ")
            Try
                Do
                    bytesReceived = serverSocket.Receive( _
                        receivedData, 0, receivedData.Length, _
                        SocketFlags.None)
                    totalReceived += bytesReceived
                Loop While bytesReceived <> 0
            Catch e As SocketException
                If(e.ErrorCode = WSAETIMEDOUT)
                
                    ' Data was not received within the given time.
                    ' Assume that the transmission has ended.
                Else
                    Console.WriteLine("{0}: {1}" & vbCrLf, _
                        e.GetType().Name, e.Message)
                End If
            Finally
                Console.WriteLine("{0} bytes received." & vbCrLf, _
                    totalReceived.ToString())
            End Try
        Finally
            serverSocket.Shutdown(SocketShutdown.Both)
            Console.WriteLine("Connection shut down.")
            serverSocket.Close()
        End Try
    
    End Sub
End Class

Megjegyzések

A puffer az adatok gyorsítótárazásához használt memória bájtokból álló blokkja, ezáltal csökkentve az operációs rendszerre irányuló hívások számát. A pufferek javítják az olvasási és írási teljesítményt. A puffer használható olvasáshoz vagy íráshoz, de mindkettő egyszerre soha nem használható. A Read puffer automatikus karbantartásának BufferedStream módjai és Write módszerei.

Important

Ez a típus implementálja a IDisposable felületet. Ha befejezte a típus használatát, közvetlenül vagy közvetve kell megsemmisítenie. A típus közvetlen ártalmatlanításához hívja meg a Dispose metódust egy try/catch blokkban. Ha közvetve szeretné megsemmisíteni, használjon olyan nyelvi szerkezetet, mint a using (C#-ban) vagy Using (a Visual Basicben). További információ: "Az IDisposable-t megvalósító objektum használata" című szakasz a IDisposable felület témakörében.

BufferedStream bizonyos típusú streamek köré lehet összeállítani. Implementációkat biztosít a bájtok egy mögöttes adatforrásba vagy adattárba való olvasásához és írásához. BinaryWriter Más adattípusok olvasására BinaryReader és írására használható. BufferedStream úgy lett kialakítva, hogy megakadályozza, hogy a puffer lelassítsa a bemenetet és a kimenetet, ha nincs szükség a pufferre. Ha mindig a belső pufferméretnél nagyobb méretű írási és olvasási műveletekhez ír, akkor BufferedStream előfordulhat, hogy még a belső puffert sem foglalja le. BufferedStream a megosztott pufferben lévő olvasásokat és írásokat is puffereli. Feltételezzük, hogy szinte mindig olvasások vagy írások sorozatát fogja elvégezni, de ritkán váltja ki őket.

Konstruktorok

Name	Description
BufferedStream(Stream, Int32)	Inicializálja az BufferedStream osztály új példányát a megadott puffermérettel.
BufferedStream(Stream)	Inicializálja az BufferedStream osztály új példányát, amelynek alapértelmezett puffermérete 4096 bájt.

Tulajdonságok

Name	Description
CanRead	Egy értéket kap, amely jelzi, hogy az aktuális stream támogatja-e az olvasást.
CanSeek	Egy értéket kap, amely jelzi, hogy az aktuális stream támogatja-e a keresést.
CanTimeout	Olyan értéket kap, amely meghatározza, hogy az aktuális stream időtúllépést okozhat-e. (Öröklődés forrása Stream)
CanWrite	Egy értéket kap, amely jelzi, hogy az aktuális stream támogatja-e az írást.
Length	Bájtban lekéri a stream hosszát.
Position	Lekéri az aktuális streamen belüli pozíciót.
ReadTimeout	Ezredmásodpercben lekéri vagy beállítja azt az értéket, amely meghatározza, hogy a stream mennyi ideig kísérel meg olvasni, mielőtt túllépi az időkorlátot. (Öröklődés forrása Stream)
WriteTimeout	Ezredmásodpercben lekéri vagy beállít egy értéket, amely meghatározza, hogy a stream mennyi ideig kísérel meg írni, mielőtt időtúllépést végezne. (Öröklődés forrása Stream)

Metódusok

Name	Description
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Aszinkron olvasási műveletet kezd. (Fontolja meg a használatot ReadAsync(Byte[], Int32, Int32, CancellationToken) .)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Aszinkron írási műveletet kezd. (Fontolja meg a használatot WriteAsync(Byte[], Int32, Int32, CancellationToken) .)
Close()	Bezárja az aktuális streamet, és felszabadítja az aktuális adatfolyamhoz társított összes erőforrást (például szoftvercsatornákat és fájlfogópontokat). A metódus meghívása helyett győződjön meg arról, hogy a stream megfelelően van elosztva. (Öröklődés forrása Stream)
CopyTo(Stream, Int32)	Beolvassa a bájtokat az aktuális streamből, és egy megadott pufferméret használatával egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyTo(Stream)	Beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy megadott pufferméret és lemondási jogkivonat használatával egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, Int32)	Aszinkron módon beolvassa a bájtokat az aktuális adatfolyamból, és egy megadott puffermérettel egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CreateObjRef(Type)	Létrehoz egy objektumot, amely tartalmazza a távoli objektumokkal való kommunikációhoz használt proxy létrehozásához szükséges összes releváns információt. (Öröklődés forrása MarshalByRefObject)
CreateWaitHandle()	Elavult. Objektum lefoglalása WaitHandle . (Öröklődés forrása Stream)
Dispose()	Felszabadítja a .-hez használt összes erőforrást Stream. (Öröklődés forrása Stream)
Dispose(Boolean)	Felszabadítja a felügyelt erőforrások által Stream használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása Stream)
EndRead(IAsyncResult)	Megvárja, amíg a függőben lévő aszinkron olvasási művelet befejeződik. (Fontolja meg a használatot ReadAsync(Byte[], Int32, Int32, CancellationToken) .)
EndWrite(IAsyncResult)	Befejez egy aszinkron írási műveletet, és letiltja az I/O-művelet befejezését. (Fontolja meg a használatot WriteAsync(Byte[], Int32, Int32, CancellationToken) .)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Flush()	Törli a stream összes pufferét, és a pufferelt adatokat a mögöttes eszközre írja.
FlushAsync()	Aszinkron módon törli az adatfolyam összes pufferét, és a pufferelt adatokat a mögöttes eszközre írja. (Öröklődés forrása Stream)
FlushAsync(CancellationToken)	Aszinkron módon törli a stream összes pufferét, a pufferelt adatokat az alapul szolgáló eszközre írja, és figyeli a lemondási kérelmeket.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
ObjectInvariant()	Elavult. Támogatja a Contract. (Öröklődés forrása Stream)
Read(Byte[], Int32, Int32)	Bájtokat másol az aktuális pufferelt adatfolyamból egy tömbbe.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtok sorozatát az aktuális adatfolyamból, az olvasási bájtok számával előrelép a streamben, és figyeli a lemondási kérelmeket.
ReadAsync(Byte[], Int32, Int32)	Aszinkron módon beolvassa az aktuális adatfolyamból származó bájtok sorozatát, és az olvasási bájtok számával előrelépteti a streamen belüli pozíciót. (Öröklődés forrása Stream)
ReadByte()	Beolvassa a bájtot a mögöttes adatfolyamból, és visszaadja a bájt leadott értékét egy int, vagy -1 ad vissza, ha a stream végéről olvas.
Seek(Int64, SeekOrigin)	Beállítja az aktuális pufferelt adatfolyamon belüli pozíciót.
SetLength(Int64)	Beállítja a pufferelt stream hosszát.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
Write(Byte[], Int32, Int32)	Bájtokat másol a pufferelt adatfolyamba, és a megírt bájtok számával előrelépteti a pufferelt adatfolyam aktuális pozícióját.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon bájtok sorozatát írja az aktuális streambe, az aktuális pozíciót a streamen belül a megírt bájtok számával lépteti előre, és figyeli a lemondási kérelmeket.
WriteAsync(Byte[], Int32, Int32)	Aszinkron módon bájtok sorozatát írja az aktuális adatfolyamba, és a megírt bájtok számával előrelépteti a stream aktuális pozícióját. (Öröklődés forrása Stream)
WriteByte(Byte)	Bájtot ír a pufferelt adatfolyam aktuális helyére.

Lásd még

• FileStream
• MemoryStream
• Stream
• Fájl és folyam I/O
• Útmutató: Szöveg beolvasása fájlból
• Útmutató: Szöveg írása fájlba