Stream Clase

Definición

public ref class Stream abstract : IDisposable

public ref class Stream abstract : MarshalByRefObject, IAsyncDisposable, IDisposable

public ref class Stream abstract : MarshalByRefObject, IDisposable

public abstract class Stream : IDisposable

public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable

public abstract class Stream : MarshalByRefObject, IDisposable

[System.Serializable]
public abstract class Stream : MarshalByRefObject, IDisposable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Stream : MarshalByRefObject, IDisposable

type Stream = class
    interface IDisposable

type Stream = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable

type Stream = class
    inherit MarshalByRefObject
    interface IDisposable

[<System.Serializable>]
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class Stream
Implements IDisposable

Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable

Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IDisposable

Herencia

Object

Stream

Herencia

Object

MarshalByRefObject

Stream

Derivado

Microsoft.JScript.COMCharStream

System.Data.OracleClient.OracleBFile

System.Data.OracleClient.OracleLob

System.Data.SqlTypes.SqlFileStream

System.IO.BufferedStream

Más…

Atributos

SerializableAttribute ComVisibleAttribute

Implementaciones

IDisposable IAsyncDisposable

Ejemplos

En el ejemplo siguiente se muestra cómo usar dos objetos FileStream para copiar de forma asincrónica los archivos de un directorio a otro directorio. La clase FileStream deriva de la clase Stream. Observe que el controlador de eventos Click para el control Button está marcado con el modificador async porque llama a un método asincrónico.

using System;
using System.Threading.Tasks;
using System.Windows;
using System.IO;

namespace WpfApplication
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            string StartDirectory = @"c:\Users\exampleuser\start";
            string EndDirectory = @"c:\Users\exampleuser\end";

            foreach (string filename in Directory.EnumerateFiles(StartDirectory))
            {
                using (FileStream SourceStream = File.Open(filename, FileMode.Open))
                {
                    using (FileStream DestinationStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf('\\'))))
                    {
                        await SourceStream.CopyToAsync(DestinationStream);
                    }
                }
            }
        }
    }
}

Imports System.IO

Class MainWindow

    Private Async Sub Button_Click(sender As Object, e As RoutedEventArgs)
        Dim StartDirectory As String = "c:\Users\exampleuser\start"
        Dim EndDirectory As String = "c:\Users\exampleuser\end"

        For Each filename As String In Directory.EnumerateFiles(StartDirectory)
            Using SourceStream As FileStream = File.Open(filename, FileMode.Open)
                Using DestinationStream As FileStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf("\"c)))
                    Await SourceStream.CopyToAsync(DestinationStream)
                End Using

            End Using
        Next
    End Sub

End Class

Comentarios

Stream es la clase base abstracta de todos los flujos. Una secuencia es una abstracción de una secuencia de bytes, como un archivo, un dispositivo de entrada y salida, una canalización de comunicación entre procesos o un socket TCP/IP. La clase Stream y sus clases derivadas proporcionan una vista genérica de estos diferentes tipos de entrada y salida, y aíslan al programador de los detalles específicos del sistema operativo y los dispositivos subyacentes.

Las secuencias implican tres operaciones fundamentales:

• Puede leer desde secuencias. La lectura es la transferencia de datos de una secuencia a una estructura de datos, como una matriz de bytes.

• Puede escribir en secuencias. Escribir es la transferencia de datos de una estructura de datos a una secuencia.

• Las secuencias pueden admitir la búsqueda. La búsqueda hace referencia a la consulta y modificación de la posición actual dentro de una secuencia. La funcionalidad seek depende del tipo de memoria auxiliar que tiene una secuencia. Por ejemplo, los flujos de red no tienen ningún concepto unificado de una posición actual y, por lo tanto, normalmente no admiten la búsqueda.

Algunas de las secuencias más usadas que heredan de Stream son FileStreamy MemoryStream.

Según el origen de datos o el repositorio subyacentes, los flujos solo admiten algunas de estas funcionalidades. Puede consultar una secuencia para sus funcionalidades mediante las propiedades CanRead, CanWritey CanSeek de la clase Stream.

Los métodos Read y Write leen y escriben datos en diversos formatos. Para las secuencias que admiten búsquedas, use los métodos Seek y SetLength y las propiedades Position y Length para consultar y modificar la posición y longitud actuales de una secuencia.

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de usar el tipo, debe eliminarlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch. Para eliminarlo indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea la sección "Using an Object that Implements IDisposable" (Usar un objeto que implementa IDisposable) en el tema IDisposable interfaz.

Al eliminar un objeto Stream se vacían los datos almacenados en búfer y básicamente se llama al método Flush. Dispose también libera recursos del sistema operativo, como identificadores de archivos, conexiones de red o memoria usadas para cualquier almacenamiento en búfer interno. La clase BufferedStream proporciona la capacidad de encapsular una secuencia almacenada en búfer alrededor de otra secuencia para mejorar el rendimiento de lectura y escritura.

A partir de .NET Framework 4.5, la clase Stream incluye métodos asincrónicos para simplificar las operaciones asincrónicas. Un método asincrónico contiene Async en su nombre, como ReadAsync, WriteAsync, CopyToAsyncy FlushAsync. Estos métodos permiten realizar operaciones de E/S intensivas en recursos sin bloquear el subproceso principal. Esta consideración de rendimiento es especialmente importante en una aplicación de la Tienda Windows 8.x o una aplicación de escritorio en la que una operación de secuencia que consume mucho tiempo puede bloquear el subproceso de la interfaz de usuario y hacer que la aplicación aparezca como si no estuviera funcionando. Los métodos asincrónicos se usan junto con las palabras clave async y await en Visual Basic y C#.

Cuando se usa en una aplicación de la Tienda Windows 8.x, Stream incluye dos métodos de extensión: AsInputStream y AsOutputStream. Estos métodos convierten un objeto Stream en una secuencia de Windows Runtime. También puedes convertir una secuencia en Windows Runtime en un objeto Stream mediante los métodos AsStreamForRead y AsStreamForWrite. Para obtener más información, consulte Cómo: Convertir entre secuencias de .NET Framework y flujos de Windows Runtime

Algunas implementaciones de flujo realizan el almacenamiento en búfer local de los datos subyacentes para mejorar el rendimiento. Para estos flujos, puede usar el método Flush o FlushAsync para borrar los búferes internos y asegurarse de que todos los datos se han escrito en el origen de datos o el repositorio subyacentes.

Si necesita una secuencia sin memoria auxiliar (también conocida como cubo de bits), use el campo Null para recuperar una instancia de una secuencia diseñada para este propósito.

Notas a los implementadores

Al implementar una clase derivada de Stream, debe proporcionar implementaciones para los métodos Read(Byte[], Int32, Int32) y Write(Byte[], Int32, Int32). Los métodos asincrónicos ReadAsync(Byte[], Int32, Int32), WriteAsync(Byte[], Int32, Int32)y CopyToAsync(Stream) usan los métodos sincrónicos Read(Byte[], Int32, Int32) y Write(Byte[], Int32, Int32) en sus implementaciones. Por lo tanto, las implementaciones de Read(Byte[], Int32, Int32) y Write(Byte[], Int32, Int32) funcionarán correctamente con los métodos asincrónicos. Las implementaciones predeterminadas de ReadByte() y WriteByte(Byte) crean una nueva matriz de bytes de un solo elemento y, a continuación, llaman a las implementaciones de Read(Byte[], Int32, Int32) y Write(Byte[], Int32, Int32). Al derivar de Stream, se recomienda invalidar estos métodos para acceder al búfer interno, si tiene uno, para mejorar considerablemente el rendimiento. También debe proporcionar implementaciones de CanRead, CanSeek, CanWrite, Flush(), Length, Position, Seek(Int64, SeekOrigin)y SetLength(Int64).

No invalide el método Close(), en su lugar, coloque toda la lógica de limpieza Stream en el método Dispose(Boolean). Para obtener más información, vea Implementación de un método Dispose.

Constructores

Campos

Propiedades

Métodos

Implementaciones de interfaz explícitas

Métodos de extensión

Se aplica a

Consulte también

• FileStream
• MemoryStream
• BufferedStream
• de E/S de flujo y archivos
• Cómo: Convertir entre secuencias de .NET Framework y flujos de Windows Runtime