Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

BufferedStream (Clase)

Agrega una capa de almacenamiento en búfer para las operaciones de lectura y escritura en otra secuencia. Esta clase no puede heredarse.

Espacio de nombres:  System.IO
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public sealed class BufferedStream : Stream

El tipo BufferedStream expone los siguientes miembros.

  NombreDescripción
Método públicoBufferedStream(Stream)Inicializa una nueva instancia de la clase BufferedStream con un tamaño de búfer predeterminado de 4096 bytes.
Método públicoBufferedStream(Stream, Int32)Inicializa una nueva instancia de la clase BufferedStream con el tamaño de búfer especificado.
Arriba

  NombreDescripción
Propiedad públicaCanReadObtiene un valor que indica si la secuencia actual admite lectura. (Invalida a Stream.CanRead).
Propiedad públicaCanSeekObtiene un valor que indica si la secuencia actual admite operaciones Seek. (Invalida a Stream.CanSeek).
Propiedad públicaCanTimeoutObtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. (Se hereda de Stream).
Propiedad públicaCanWriteObtiene un valor que indica si la secuencia actual admite escritura. (Invalida a Stream.CanWrite).
Propiedad públicaLengthObtiene la longitud de la secuencia en bytes. (Invalida a Stream.Length).
Propiedad públicaPositionObtiene la posición dentro de la secuencia actual. (Invalida a Stream.Position).
Propiedad públicaReadTimeoutObtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. (Se hereda de Stream).
Propiedad públicaWriteTimeoutObtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. (Se hereda de Stream).
Arriba

  NombreDescripción
Método públicoBeginReadComienza una operación de lectura asincrónica. (Utilice ReadAsync en su lugar; vea la sección comentarios.) (Invalida a Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)).

In .NET Framework Client Profile 4, este miembro se hereda de Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
Método públicoBeginWriteComienza una operación de escritura asincrónica. (Utilice WriteAsync en su lugar; vea la sección comentarios.) (Invalida a Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)).

In .NET Framework Client Profile 4, este miembro se hereda de Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Método públicoCloseCierra la secuencia actual y libera todos los recursos (como sockets e identificadores de archivo) asociados a esta. En lugar de llamar a este método, asegúrese de que el flujo se desecha correctamente. (Se hereda de Stream).
Método públicoCopyTo(Stream) Cierra la secuencia actual y libera todos los recursos (tales como sockets y manejadores de archivo)asociados a la secuencia actual. (Se hereda de Stream).
Método públicoCopyTo(Stream, Int32) En vez de llamar a este método, asegúrese de que la secuencia actual ha sido correctamente liberada. (Se hereda de Stream).
Método públicoCopyToAsync(Stream)Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia. (Se hereda de Stream).
Método públicoCopyToAsync(Stream, Int32)Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. (Se hereda de Stream).
Método públicoCopyToAsync(Stream, Int32, CancellationToken)Lee asincrónicamente los bytes de la secuencia actual y los escribe en otro flujo, utilizando el tamaño de búfer especificado y el token de cancelación. (Se hereda de Stream).
Método públicoCreateObjRefCrea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Se hereda de MarshalByRefObject).
Método públicoDispose()Libera todos los recursos utilizados por Stream. (Se hereda de Stream).
Método públicoEndReadEspera a que se complete la operación asincrónica de lectura que se encuentra pendiente. (Utilice ReadAsync en su lugar; vea la sección comentarios.) (Invalida a Stream.EndRead(IAsyncResult)).

In .NET Framework Client Profile 4, este miembro se hereda de Stream.EndRead(IAsyncResult).
Método públicoEndWriteTermina una operación de escritura asincrónica y se bloquea hasta que se completa la operación de E/S. (Utilice WriteAsync en su lugar; vea la sección comentarios.) (Invalida a Stream.EndWrite(IAsyncResult)).

In .NET Framework Client Profile 4, este miembro se hereda de Stream.EndWrite(IAsyncResult).
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoFlushBorra todos los búferes para esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. (Invalida a Stream.Flush()).
Método públicoFlushAsync()Borra asincrónicamente todos los búferes para este flujo y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. (Se hereda de Stream).
Método públicoFlushAsync(CancellationToken)Borra asincrónicamente todos los búferes del flujo actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. (Invalida a Stream.FlushAsync(CancellationToken)).
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetLifetimeServiceRecupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoInitializeLifetimeServiceObtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método públicoReadCopia bytes, procedentes de la secuencia actual almacenada en el búfer, en una matriz. (Invalida a Stream.Read(Byte[], Int32, Int32)).
Método públicoReadAsync(Byte[], Int32, Int32)Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. (Se hereda de Stream).
Método públicoReadAsync(Byte[], Int32, Int32, CancellationToken)Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. (Invalida a Stream.ReadAsync(Byte[], Int32, Int32, CancellationToken)).
Método públicoReadByteLee un byte de la secuencia subyacente y devuelve el byte convertido en un int, o devuelve -1 si se lee desde el final de la secuencia. (Invalida a Stream.ReadByte()).
Método públicoSeekEstablece la posición dentro de la secuencia almacenada en búfer actualmente. (Invalida a Stream.Seek(Int64, SeekOrigin)).
Método públicoSetLengthEstablece la longitud de la secuencia almacenada en el búfer. (Invalida a Stream.SetLength(Int64)).
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Método públicoWriteCopia bytes en la secuencia almacenada en el búfer y avanza la posición actual dentro de la secuencia almacenada en el búfer según el número de bytes escritos. (Invalida a Stream.Write(Byte[], Int32, Int32)).
Método públicoWriteAsync(Byte[], Int32, Int32)Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. (Se hereda de Stream).
Método públicoWriteAsync(Byte[], Int32, Int32, CancellationToken)Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. (Invalida a Stream.WriteAsync(Byte[], Int32, Int32, CancellationToken)).
Método públicoWriteByteEscribe un byte en la posición actual de la secuencia almacenada en el búfer. (Invalida a Stream.WriteByte(Byte)).
Arriba

Un búfer es un bloque de bytes de la memoria utilizado para almacenar datos en la memoria caché y, de este modo, reducir el número de llamadas al sistema operativo. Así, los búferes mejoran el rendimiento de lectura y de escritura. Se puede utilizar un búfer para leer o escribir, pero nunca para ambas cosas simultáneamente. Los métodos Read y Write de BufferedStream mantienen el búfer de forma automática.

BufferedStream puede formarse alrededor de determinados tipos de secuencias. Proporciona implementaciones para leer y escribir bytes en un repositorio o un origen de datos subyacente. Utilice BinaryReader y BinaryWriter para leer y escribir otros tipos de datos. BufferedStream se ha diseñado para impedir que el búfer ralentice la entrada y la salida cuando no es necesario el búfer. Si siempre lee y escribe tamaños mayores que el tamaño del búfer interno, es posible que BufferedStream ni siquiera asigne el búfer interno. BufferedStream también almacena en el búfer las lecturas y escrituras de un búfer compartido. Se supone que casi siempre se estarán realizando lecturas o escrituras, pero que rara vez se alternará entre las dos.

Los ejemplos de código siguientes muestran cómo utilizar la clase BufferedStream a la clase NetworkStream para aumentar el rendimiento de ciertas operaciones de E/S. Se debe iniciar el servidor en un equipo remoto antes de iniciar el cliente. Se ha de especificar el nombre del equipo remoto como un argumento de la línea de comandos al iniciar el cliente. Se deben variar las constantes dataArraySize y streamBufferSize para ver su efecto en el rendimiento.

El primer ejemplo muestra el código que se ejecuta en el cliente, y el segundo ejemplo muestra el código que se ejecuta en el servidor.

Ejemplo 1: Código que se ejecuta en el cliente


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");
    }
}


Ejemplo 2: Código que se ejecuta en el servidor


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();
        }
    }
}


.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros públicos static (Shared en Visual Basic) de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft