FileStream (Clase) (System.IO)

Biblioteca de clases de .NET Framework

FileStream (Clase)

Actualización: noviembre 2007

Expone un objeto Stream alrededor de un archivo; se admiten operaciones de lectura y escritura sincrónica y asincrónica.

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

Sintaxis

Visual Basic (Declaración)

<ComVisibleAttribute(True)> _
Public Class FileStream _
    Inherits Stream

Visual Basic (Uso)

Dim instance As FileStream

[ComVisibleAttribute(true)]
public class FileStream : Stream

Visual C++

[ComVisibleAttribute(true)]
public ref class FileStream : public Stream

/** @attribute ComVisibleAttribute(true) */
public class FileStream extends Stream

JScript

public class FileStream extends Stream

Comentarios

Utilice la clase FileStream para leer, escribir, abrir y cerrar archivos en un sistema de archivos, así como para manipular otros identificadores del sistema operativo relacionados con archivos, incluidos los de canalizaciones, entrada estándar y salida estándar. Puede especificar que las operaciones de lectura y escritura sean sincrónicas o asincrónicas. FileStream almacena en el búfer la entrada y la salida para obtener un mejor rendimiento.

Los objetos FileStream admiten el acceso aleatorio a los archivos mediante el método Seek. Seek permite que se mueva la posición de lectura/escritura a cualquier posición dentro del archivo. Esto se realiza mediante parámetros de punto de referencia de desplazamiento de byte. El desplazamiento de byte es relativo al punto de referencia de búsqueda, que puede ser el comienzo, la posición actual o el final del archivo subyacente, según lo representado por las tres propiedades de la clase SeekOrigin.

Nota:
Los archivos de disco siempre admiten el acceso aleatorio. En el momento de la construcción, el valor de la propiedad CanSeek se establece en true o false dependiendo del tipo de archivo subyacente. En concreto, si el tipo de archivo subyacente es FILE_TYPE_DISK, según se define en winbase.h, el valor de la propiedad CanSeek es true. En caso contrario, el valor de la propiedad CanSeek es false.

Aunque los métodos sincrónicos Read y Write y los métodos asincrónicosBeginRead, BeginWrite, EndRead y EndWrite pueden funcionar tanto en modo sincrónico como asincrónico, el modo afecta al rendimiento de estos métodos. De forma predeterminada, FileStream abre los archivos sincrónicamente, pero proporciona el constructor FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean) para abrirlos asincrónicamente.

Si un proceso termina con parte de un archivo bloqueado o cierra un archivo que tiene bloqueos pendientes, el comportamiento no estará definido.

Asegúrese de llamar al método Dispose en todos los objetos FileStream, sobre todo en entornos con espacio en disco limitado. La ejecución de operaciones de E/S puede producir una excepción si no hay espacio en disco disponible y no se llama al método Dispose antes de que finalice FileStream.

Para obtener información sobre las operaciones de directorio y otros archivos, vea las clases File, Directory y Path. La clase File es una clase de utilidad con métodos estáticos dedicados principalmente a la creación de objetos FileStream según las rutas de acceso de archivo y la entrada estándar, la salida estándar y los dispositivos de error estándar. La clase MemoryStream crea una secuencia a partir de una matriz de bytes y funciona de manera similar a FileStream.

Para obtener una lista de tareas de E/S comunes, vea Tareas de E/S comunes.

Detección de cambios de posición en la secuencia

Cuando un objeto FileStream no tiene control exclusivo sobre su identificador, otro subproceso podría tener acceso al identificador del archivo al mismo tiempo y cambiar la posición del puntero de archivos del sistema operativo que está asociado con el identificador del archivo. En este caso, podría verse comprometida la posición almacenada en memoria caché del objeto FileStream, así como los datos almacenados en memoria caché en el búfer. El objeto FileStream realiza comprobaciones de manera rutinaria en los métodos que obtienen acceso al búfer almacenado en memoria caché para garantizar que la posición del identificador del sistema operativo es la misma que la posición almacenada en caché utilizada por el objeto FileStream.

Si se detecta un cambio inesperado en la posición del identificador en una llamada al método Read, .NET Framework descarta el contenido del búfer y vuelve a leer la secuencia del archivo. Esto puede afectar al rendimiento, en función del tamaño del archivo y de cualquier otro proceso que pueda afectar a la posición de la secuencia del archivo.

Si se detecta un cambio inesperado en la posición del identificador en una llamada al método Write, el contenido del búfer se descarta y se produce una excepción IOException.

Un objeto FileStream no tiene control exclusivo sobre su identificador cuando se obtiene acceso a la propiedad SafeFileHandle para exponer el identificador o cuando el objeto FileStream recibe la propiedad SafeFileHandle de su constructor.

Ejemplos

En el siguiente ejemplo se muestran algunos de los constructores FileStream.

Visual Basic

Imports System
Imports System.IO
Imports System.Text

Public Class Test

    Public Shared Sub Main()
        Dim path As String = "c:\temp\MyTest.txt"

        ' Delete the file if it exists.
        If File.Exists(path) Then
            File.Delete(path)
        End If

        'Create the file.
        Dim fs As FileStream = File.Create(path)

        AddText(fs, "This is some text")
        AddText(fs, "This is some more text,")
        AddText(fs, Environment.NewLine & "and this is on a new line")
        AddText(fs, Environment.NewLine & Environment.NewLine)
        AddText(fs, "The following is a subset of characters:" & Environment.NewLine)

        Dim i As Integer

        For i = 1 To 120
            AddText(fs, Convert.ToChar(i).ToString())

            'Split the output at every 10th character.
            If Math.IEEERemainder(Convert.ToDouble(i), 10) = 0 Then
                AddText(fs, Environment.NewLine)
            End If
        Next

        fs.Close()

        'Open the stream and read it back.
        fs = File.OpenRead(path)
        Dim b(1024) As Byte
        Dim temp As UTF8Encoding = New UTF8Encoding(True)

        Do While fs.Read(b, 0, b.Length) > 0
            Console.WriteLine(temp.GetString(b))
        Loop

        fs.Close()
    End Sub

    Private Shared Sub AddText(ByVal fs As FileStream, ByVal value As String)
        Dim info As Byte() = New UTF8Encoding(True).GetBytes(value)
        fs.Write(info, 0, info.Length)
    End Sub
End Class

using System;
using System.IO;
using System.Text;

class Test 
{
    
    public static void Main() 
    {
        string path = @"c:\temp\MyTest.txt";

        // Delete the file if it exists.
        if (File.Exists(path)) 
        {
            File.Delete(path);
        }

        //Create the file.
        using (FileStream fs = File.Create(path)) 
        {
            AddText(fs, "This is some text");
            AddText(fs, "This is some more text,");
            AddText(fs, "\r\nand this is on a new line");
            AddText(fs, "\r\n\r\nThe following is a subset of characters:\r\n");

            for (int i=1;i < 120;i++) 
            {
                AddText(fs, Convert.ToChar(i).ToString());

                //Split the output at every 10th character.
                if (Math.IEEERemainder(Convert.ToDouble(i), 10) == 0) 
                {
                    AddText(fs, "\r\n");
                }
            }
        }

        //Open the stream and read it back.
        using (FileStream fs = File.OpenRead(path)) 
        {
            byte[] b = new byte[1024];
            UTF8Encoding temp = new UTF8Encoding(true);
            while (fs.Read(b,0,b.Length) > 0) 
            {
                Console.WriteLine(temp.GetString(b));
            }
        }
    }

    private static void AddText(FileStream fs, string value) 
    {
        byte[] info = new UTF8Encoding(true).GetBytes(value);
        fs.Write(info, 0, info.Length);
    }
}

Visual C++

using namespace System;
using namespace System::IO;
using namespace System::Text;

void AddText( FileStream^ fs, String^ value )
{
   array<Byte>^info = (gcnew UTF8Encoding( true ))->GetBytes( value );
   fs->Write( info, 0, info->Length );
}

int main()
{
   String^ path = "c:\\temp\\MyTest.txt";

   // Delete the file if it exists.
   if ( File::Exists( path ) )
   {
      File::Delete( path );
   }

   //Create the file.
   {
      FileStream^ fs = File::Create( path );
      try
      {
         AddText( fs, "This is some text" );
         AddText( fs, "This is some more text," );
         AddText( fs, "\r\nand this is on a new line" );
         AddText( fs, "\r\n\r\nThe following is a subset of characters:\r\n" );
         for ( int i = 1; i < 120; i++ )
         {
            AddText( fs, Convert::ToChar( i ).ToString() );

            //Split the output at every 10th character.
            if ( Math::IEEERemainder( Convert::ToDouble( i ), 10 ) == 0 )
            {
               AddText( fs, "\r\n" );
            }
         }
      }
      finally
      {
         if ( fs )
            delete (IDisposable^)fs;
      }
   }

   //Open the stream and read it back.
   {
      FileStream^ fs = File::OpenRead( path );
      try
      {
         array<Byte>^b = gcnew array<Byte>(1024);
         UTF8Encoding^ temp = gcnew UTF8Encoding( true );
         while ( fs->Read( b, 0, b->Length ) > 0 )
         {
            Console::WriteLine( temp->GetString( b ) );
         }
      }
      finally
      {
         if ( fs )
            delete (IDisposable^)fs;
      }
   }
}

import System.*;
import System.IO.*;
import System.Text.*;

class Test
{
    public static void main(String[] args)
    {
        String path = "c:\\temp\\MyTest.txt";

        // Delete the file if it exists.
        if (File.Exists(path)) {
            File.Delete(path);
        }

        //Create the file.
        {
            FileStream fs = File.Create(path);
            try {
                AddText(fs, "This is some text");
                AddText(fs, "This is some more text,");
                AddText(fs, "\r\nand this is on a new line");
                AddText(fs, 
                    "\r\n\r\nThe following is a subset of characters:\r\n");
                for (int i = 1; i < 120; i++) {
                    AddText(fs, System.Convert.ToString((char)i));

                    //Split the output at every 10th character.
                    if (Math.IEEEremainder(Convert.ToDouble(i), 10) == 0) {
                        AddText(fs, "\r\n");
                    }
                }
            }
            finally {
                fs.Dispose();
            }
        }
        //Open the stream and read it back.
        {
            FileStream fs = File.OpenRead(path);
            try {
                ubyte b[] = new ubyte[1024];
                UTF8Encoding temp = new UTF8Encoding(true);
                while (fs.Read(b, 0, b.length) > 0) {
                    Console.WriteLine(temp.GetString(b));
                }
            }
            finally {
                fs.Dispose();
            }
        }
    } //main

    private static void AddText(FileStream fs, String value)
    {
        ubyte info[] = (new UTF8Encoding(true)).GetBytes(value);
        fs.Write(info, 0, info.length);
    } //AddText
} //Test

En el ejemplo siguiente se abre un archivo o se crea si todavía no existe, y se agrega información al final del archivo.

Visual Basic

Imports System
Imports System.IO
Imports System.Text

Class FSOpenWrite

    Public Shared Sub Main()
        Dim fs As New FileStream("c:\Variables.txt", FileMode.Append, FileAccess.Write, FileShare.Write)
        fs.Close()
        Dim sw As New StreamWriter("c:\Variables.txt", True, Encoding.ASCII)
        Dim NextLine As String = "This is the appended text."
        sw.Write(NextLine)
        sw.Close()
    End Sub 'Main
End Class 'FSOpenWrite

using System;
using System.IO;
using System.Text;

class FSOpenWrite
{
    public static void Main()
    {
        FileStream fs=new FileStream("c:\\Variables.txt", FileMode.Append, FileAccess.Write, FileShare.Write);
        fs.Close();
        StreamWriter sw=new StreamWriter("c:\\Variables.txt", true, Encoding.ASCII);
        string NextLine="This is the appended line.";
        sw.Write(NextLine);
        sw.Close();
    }
}

Visual C++

using namespace System;
using namespace System::IO;
using namespace System::Text;
int main()
{
   FileStream^ fs = gcnew FileStream( "c:\\Variables.txt",FileMode::Append,FileAccess::Write,FileShare::Write );
   fs->Close();
   StreamWriter^ sw = gcnew StreamWriter( "c:\\Variables.txt",true,Encoding::ASCII );
   String^ NextLine = "This is the appended line.";
   sw->Write( NextLine );
   sw->Close();
}

Jerarquía de herencia

System..::.Object
  System..::.MarshalByRefObject
    System.IO..::.Stream
      System.IO..::.FileStream
        System.IO.IsolatedStorage..::.IsolatedStorageFileStream

Seguridad para subprocesos

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

Plataformas

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Información de versión