BufferedStream Classe
Definizione
Aggiunge un livello di buffer per operazioni di lettura e scrittura in un altro flusso.Adds a buffering layer to read and write operations on another stream. La classe non può essere ereditata.This class cannot be inherited.
public ref class BufferedStream sealed : System::IO::Stream
public sealed class BufferedStream : System.IO.Stream
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class BufferedStream : System.IO.Stream
type BufferedStream = class
inherit Stream
[<System.Runtime.InteropServices.ComVisible(true)>]
type BufferedStream = class
inherit Stream
Public NotInheritable Class BufferedStream
Inherits Stream
- Ereditarietà
- Ereditarietà
- Attributi
Esempio
Negli esempi di codice seguenti viene illustrato come utilizzare la BufferedStream
classe sulla NetworkStream
classe per aumentare le prestazioni di determinate operazioni di I/O.The following code examples show how to use the BufferedStream
class over the NetworkStream
class to increase the performance of certain I/O operations. Avviare il server in un computer remoto prima di avviare il client.Start the server on a remote computer before starting the client. Specificare il nome del computer remoto come argomento della riga di comando all'avvio del client.Specify the remote computer name as a command-line argument when starting the client. Variare le dataArraySize
streamBufferSize
costanti e per visualizzarne l'effetto sulle prestazioni.Vary the dataArraySize
and streamBufferSize
constants to view their effect on performance.
Nel primo esempio viene illustrato il codice eseguito nel client e nel secondo esempio viene illustrato il codice eseguito nel server.The first example shows the code that runs on the client, and the second example shows the code that runs on the server.
Esempio 1: codice eseguito nel clientExample 1: Code that runs on the client
#using <system.dll>
using namespace System;
using namespace System::IO;
using namespace System::Globalization;
using namespace System::Net;
using namespace System::Net::Sockets;
static const int streamBufferSize = 1000;
public ref class Client
{
private:
literal int dataArraySize = 100;
literal int numberOfLoops = 10000;
Client(){}
public:
static void ReceiveData( Stream^ netStream, Stream^ bufStream )
{
DateTime startTime;
Double networkTime;
Double bufferedTime = 0;
int bytesReceived = 0;
array<Byte>^receivedData = gcnew array<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;
while ( bytesReceived < numberOfLoops * receivedData->Length )
{
bytesReceived += bufStream->Read( receivedData, 0, receivedData->Length );
}
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 ? (String^)"faster" : "slower" );
}
static void SendData( Stream^ netStream, Stream^ bufStream )
{
DateTime startTime;
Double networkTime;
Double bufferedTime;
// Create random data to send to the server.
array<Byte>^dataToSend = gcnew array<Byte>(dataArraySize);
(gcnew 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).ToString(), 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).ToString(), 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 ? (String^)"faster" : "slower" );
}
};
int main( int argc, char *argv[] )
{
// Check that an argument was specified when the
// program was invoked.
if ( argc == 1 )
{
Console::WriteLine( "Error: The name of the host computer"
" must be specified when the program is invoked." );
return -1;
}
String^ remoteName = gcnew String( argv[ 1 ] );
// Create the underlying socket and connect to the server.
Socket^ clientSocket = gcnew Socket( AddressFamily::InterNetwork,SocketType::Stream,ProtocolType::Tcp );
clientSocket->Connect( gcnew 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.
NetworkStream^ netStream = gcnew NetworkStream( clientSocket,true );
BufferedStream^ bufStream = gcnew BufferedStream( netStream,streamBufferSize );
try
{
// Check whether the underlying stream supports seeking.
Console::WriteLine( "NetworkStream {0} seeking.\n", bufStream->CanSeek ? (String^)"supports" : "does not support" );
// Send and receive data.
if ( bufStream->CanWrite )
{
Client::SendData( netStream, bufStream );
}
if ( bufStream->CanRead )
{
Client::ReceiveData( netStream, bufStream );
}
}
finally
{
// When bufStream is closed, netStream is in turn closed,
// which in turn shuts down the connection and closes
// clientSocket.
Console::WriteLine( "\nShutting down connection." );
bufStream->Close();
}
}
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");
}
}
' 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
Esempio 2: codice in esecuzione nel serverExample 2: Code that runs on the server
#using <system.dll>
using namespace System;
using namespace System::Net;
using namespace System::Net::Sockets;
int main()
{
// This is a Windows Sockets 2 error code.
const int WSAETIMEDOUT = 10060;
Socket^ serverSocket;
int bytesReceived;
int totalReceived = 0;
array<Byte>^receivedData = gcnew array<Byte>(2000000);
// Create random data to send to the client.
array<Byte>^dataToSend = gcnew array<Byte>(2000000);
(gcnew Random)->NextBytes( dataToSend );
IPAddress^ ipAddress = Dns::Resolve( Dns::GetHostName() )->AddressList[ 0 ];
IPEndPoint^ ipEndpoint = gcnew IPEndPoint( ipAddress,1800 );
// Create a socket and listen for incoming connections.
Socket^ listenSocket = gcnew 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.\n" );
}
finally
{
listenSocket->Close();
}
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();
}
}
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();
}
}
}
' 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
Commenti
Un buffer è un blocco di byte in memoria usato per memorizzare nella cache i dati, riducendo così il numero di chiamate al sistema operativo.A buffer is a block of bytes in memory used to cache data, thereby reducing the number of calls to the operating system. I buffer migliorano le prestazioni di lettura e scrittura.Buffers improve read and write performance. Un buffer può essere utilizzato sia per la lettura che per la scrittura, ma mai simultaneamente.A buffer can be used for either reading or writing, but never both simultaneously. I Read Write metodi e di BufferedStream
gestiscono automaticamente il buffer.The Read and Write methods of BufferedStream
automatically maintain the buffer.
Importante
Il tipo implementa l'interfaccia IDisposable.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try
/catch
.To dispose of the type directly, call its Dispose method in a try
/catch
block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using
in C# o Using
in Visual Basic.To dispose of it indirectly, use a language construct such as using
(in C#) or Using
(in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.
BufferedStream
può essere composto intorno a determinati tipi di flussi.BufferedStream
can be composed around certain types of streams. Fornisce le implementazioni per la lettura e la scrittura di byte in un'origine dati o in un repository sottostante.It provides implementations for reading and writing bytes to an underlying data source or repository. Usare BinaryReader e BinaryWriter per la lettura e la scrittura di altri tipi di dati.Use BinaryReader and BinaryWriter for reading and writing other data types. BufferedStream
è progettato per impedire che il buffer rallenti l'input e l'output quando il buffer non è necessario.BufferedStream
is designed to prevent the buffer from slowing down input and output when the buffer is not needed. Se si leggono e si scrivono sempre dimensioni maggiori delle dimensioni del buffer interno, è BufferedStream
possibile che non venga allocato anche il buffer interno.If you always read and write for sizes greater than the internal buffer size, then BufferedStream
might not even allocate the internal buffer. BufferedStream
Inoltre, memorizza nel buffer le letture e le Scritture in un buffer condiviso.BufferedStream
also buffers reads and writes in a shared buffer. Si presuppone che l'utente esegua quasi sempre una serie di letture o Scritture, ma raramente si alternano tra i due.It is assumed that you will almost always be doing a series of reads or writes, but rarely alternate between the two of them.
Costruttori
BufferedStream(Stream) |
Inizializza una nuova istanza della classe BufferedStream con una dimensione predefinita del buffer di 4096 byte.Initializes a new instance of the BufferedStream class with a default buffer size of 4096 bytes. |
BufferedStream(Stream, Int32) |
Inizializza una nuova istanza della classe BufferedStream con la dimensione specificata del buffer.Initializes a new instance of the BufferedStream class with the specified buffer size. |
Proprietà
BufferSize |
Ottiene le dimensioni del buffer in byte per questo flusso memorizzato nel buffer.Gets the buffer size in bytes for this buffered stream. |
CanRead |
Ottiene un valore che indica se il flusso corrente supporta la lettura.Gets a value indicating whether the current stream supports reading. |
CanSeek |
Ottiene un valore che indica se il flusso corrente supporta la ricerca.Gets a value indicating whether the current stream supports seeking. |
CanTimeout |
Ottiene un valore che determina se il flusso corrente prevede il timeout.Gets a value that determines whether the current stream can time out. (Ereditato da Stream) |
CanWrite |
Ottiene un valore che indica se il flusso corrente supporta la scrittura.Gets a value indicating whether the current stream supports writing. |
Length |
Ottiene la lunghezza del flusso in byte.Gets the stream length in bytes. |
Position |
Ottiene la posizione all'interno del flusso corrente.Gets the position within the current stream. |
ReadTimeout |
Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out. (Ereditato da Stream) |
UnderlyingStream |
Ottiene l'istanza di Stream sottostante per questo flusso memorizzato nel buffer.Gets the underlying Stream instance for this buffered stream. |
WriteTimeout |
Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out. (Ereditato da Stream) |
Metodi
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Inizia un'operazione di lettura asincrona.Begins an asynchronous read operation. Si consiglia di usare ReadAsync(Byte[], Int32, Int32, CancellationToken).(Consider using ReadAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Inizia un'operazione di lettura asincrona.Begins an asynchronous read operation. Si consiglia di usare ReadAsync(Byte[], Int32, Int32).(Consider using ReadAsync(Byte[], Int32, Int32) instead.) (Ereditato da Stream) |
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Inizia un'operazione di scrittura asincrona.Begins an asynchronous write operation. Si consiglia di usare WriteAsync(Byte[], Int32, Int32, CancellationToken).(Consider using WriteAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Inizia un'operazione di scrittura asincrona.Begins an asynchronous write operation. Si consiglia di usare WriteAsync(Byte[], Int32, Int32).(Consider using WriteAsync(Byte[], Int32, Int32) instead.) (Ereditato da Stream) |
Close() |
Chiude il flusso e libera le risorse, in particolare le risorse di sistema come socket e handle di file, associate al flusso corrente memorizzato nel buffer.Closes the stream and releases any resources (especially system resources such as sockets and file handles) associated with the current buffered stream. |
Close() |
Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente.Instead of calling this method, ensure that the stream is properly disposed. (Ereditato da Stream) |
CopyTo(Stream) |
Legge i byte dal flusso corrente e li scrive in un altro flusso.Reads the bytes from the current stream and writes them to another stream. (Ereditato da Stream) |
CopyTo(Stream, Int32) |
Legge i byte dal flusso memorizzato nel buffer corrente e li scrive in un altro flusso.Reads the bytes from the current buffered stream and writes them to another stream. |
CopyTo(Stream, Int32) |
Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. (Ereditato da Stream) |
CopyToAsync(Stream) |
Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso.Asynchronously reads the bytes from the current stream and writes them to another stream. (Ereditato da Stream) |
CopyToAsync(Stream, CancellationToken) |
Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token. (Ereditato da Stream) |
CopyToAsync(Stream, Int32) |
Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. (Ereditato da Stream) |
CopyToAsync(Stream, Int32, CancellationToken) |
Legge in modo asincrono i byte dal flusso memorizzato nel buffer corrente e li scrive in un altro flusso, usando dimensioni del buffer e un token di annullamento specificati.Asynchronously reads the bytes from the current buffered stream and writes them to another stream, using a specified buffer size and cancellation token. |
CopyToAsync(Stream, Int32, CancellationToken) |
Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. (Ereditato da Stream) |
CreateObjRef(Type) |
Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. (Ereditato da MarshalByRefObject) |
CreateWaitHandle() |
Obsoleta.
Alloca un oggetto WaitHandle.Allocates a WaitHandle object. (Ereditato da Stream) |
Dispose() |
Rilascia tutte le risorse usate da Stream.Releases all resources used by the Stream. (Ereditato da Stream) |
Dispose(Boolean) |
Rilascia le risorse non gestite usate da Stream e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the Stream and optionally releases the managed resources. (Ereditato da Stream) |
DisposeAsync() |
Consente di rilasciare in modo asincrono le risorse non gestite usate dal flusso memorizzato nel buffer.Asynchronously releases the unmanaged resources used by the buffered stream. |
DisposeAsync() |
Consente di liberare in modo asincrono le risorse non gestite utilizzate da Stream.Asynchronously releases the unmanaged resources used by the Stream. (Ereditato da Stream) |
EndRead(IAsyncResult) |
Attende il completamento dell'operazione di lettura asincrona in sospeso.Waits for the pending asynchronous read operation to complete. Si consiglia di usare ReadAsync(Byte[], Int32, Int32, CancellationToken).(Consider using ReadAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
EndRead(IAsyncResult) |
Attende il completamento della lettura asincrona in sospeso.Waits for the pending asynchronous read to complete. Si consiglia di usare ReadAsync(Byte[], Int32, Int32).(Consider using ReadAsync(Byte[], Int32, Int32) instead.) (Ereditato da Stream) |
EndWrite(IAsyncResult) |
Termina un'operazione di scrittura asincrona, rimanendo bloccato fino al completamento dell'operazione di I/O.Ends an asynchronous write operation and blocks until the I/O operation is complete. Si consiglia di usare WriteAsync(Byte[], Int32, Int32, CancellationToken).(Consider using WriteAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
EndWrite(IAsyncResult) |
Termina un'operazione di scrittura asincrona.Ends an asynchronous write operation. Si consiglia di usare WriteAsync(Byte[], Int32, Int32).(Consider using WriteAsync(Byte[], Int32, Int32) instead.) (Ereditato da Stream) |
Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object. (Ereditato da Object) |
Flush() |
Consente di cancellare i dati di tutti i buffer del flusso e la scrittura dei dati memorizzati nel buffer nella periferica sottostante.Clears all buffers for this stream and causes any buffered data to be written to the underlying device. |
FlushAsync() |
Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. (Ereditato da Stream) |
FlushAsync(CancellationToken) |
Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. |
FlushAsync(CancellationToken) |
Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. (Ereditato da Stream) |
GetHashCode() |
Funge da funzione hash predefinita.Serves as the default hash function. (Ereditato da Object) |
GetLifetimeService() |
Obsoleta.
Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance. (Ereditato da MarshalByRefObject) |
GetType() |
Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance. (Ereditato da Object) |
InitializeLifetimeService() |
Obsoleta.
Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance. (Ereditato da MarshalByRefObject) |
MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object. (Ereditato da Object) |
MemberwiseClone(Boolean) |
Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object. (Ereditato da MarshalByRefObject) |
ObjectInvariant() |
Obsoleta.
Fornisce supporto per un oggetto Contract.Provides support for a Contract. (Ereditato da Stream) |
Read(Byte[], Int32, Int32) |
Copia i byte dal flusso correntemente memorizzato nel buffer in una matrice.Copies bytes from the current buffered stream to an array. |
Read(Span<Byte>) |
Copia byte dal flusso memorizzato nel buffer corrente a un intervallo di byte e sposta in avanti la posizione all'interno del flusso memorizzato nel buffer in base al numero di byte letti.Copies bytes from the current buffered stream to a byte span and advances the position within the buffered stream by the number of bytes read. |
Read(Span<Byte>) |
Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. (Ereditato da Stream) |
ReadAsync(Byte[], Int32, Int32) |
Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. (Ereditato da Stream) |
ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. |
ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. (Ereditato da Stream) |
ReadAsync(Memory<Byte>, CancellationToken) |
Legge in modo asincrono una sequenza di byte dal flusso memorizzato nel buffer corrente e sposta in avanti la posizione all'interno del flusso memorizzato nel buffer in base al numero di byte letti.Asynchronously reads a sequence of bytes from the current buffered stream and advances the position within the buffered stream by the number of bytes read. |
ReadAsync(Memory<Byte>, CancellationToken) |
Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. (Ereditato da Stream) |
ReadByte() |
Legge un byte dal flusso sottostante e restituisce il cast di byte su un parametro |
Seek(Int64, SeekOrigin) |
Imposta la posizione all'interno del flusso corrente memorizzato nel buffer.Sets the position within the current buffered stream. |
SetLength(Int64) |
Imposta la lunghezza del flusso memorizzato nel buffer.Sets the length of the buffered stream. |
ToString() |
Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object. (Ereditato da Object) |
Write(Byte[], Int32, Int32) |
Copia i byte nel flusso memorizzato nel buffer e sposta la posizione corrente, all'interno del flusso memorizzato nel buffer, in base al numero di byte scritto.Copies bytes to the buffered stream and advances the current position within the buffered stream by the number of bytes written. |
Write(ReadOnlySpan<Byte>) |
Scrive una sequenza di byte nel flusso memorizzato nel buffer corrente e sposta in avanti la posizione nel flusso in base al numero di byte scritti.Writes a sequence of bytes to the current buffered stream and advances the current position within this buffered stream by the number of bytes written. |
Write(ReadOnlySpan<Byte>) |
Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. (Ereditato da Stream) |
WriteAsync(Byte[], Int32, Int32) |
Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. (Ereditato da Stream) |
WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. |
WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. (Ereditato da Stream) |
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Scrive in modo asincrono una sequenza di byte nel flusso memorizzato nel buffer corrente e sposta in avanti la posizione all'interno del flusso memorizzato nel buffer corrente in base al numero di byte scritti ed esegue il monitoraggio delle richieste di annullamento.Asynchronously writes a sequence of bytes to the current buffered stream, advances the current position within this buffered stream by the number of bytes written, and monitors cancellation requests. |
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. (Ereditato da Stream) |
WriteByte(Byte) |
Scrive un byte nella posizione corrente all'interno del flusso memorizzato nel buffer.Writes a byte to the current position in the buffered stream. |
Implementazioni dell'interfaccia esplicita
IDisposable.Dispose() |
Rilascia tutte le risorse usate da Stream.Releases all resources used by the Stream. (Ereditato da Stream) |
Metodi di estensione
ConfigureAwait(IAsyncDisposable, Boolean) |
Consente di configurare la modalità di esecuzione delle espressioni await per le attività restituite da un elemento disposable asincrono.Configures how awaits on the tasks returned from an async disposable are performed. |