FileStream Constructores

Definición

Espacio de nombres:

System.IO

Ensamblado:

System.Runtime.dll

Inicializa una nueva instancia de la clase FileStream.

Sobrecargas

FileStream(SafeFileHandle, FileAccess)	Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado.
FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso especificada, el modo de creación, el permiso de lectura y escritura y uso compartido, el acceso a otros FileStreams puede tener en el mismo archivo, el tamaño del búfer y las opciones de archivo adicionales.
FileStream(String, FileMode, FileAccess, FileShare, Int32)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y uso compartido especificados y el tamaño del búfer.
FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)	Obsoletos. Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado, FileStream propiedad de instancia, tamaño del búfer y estado sincrónico o asincrónico.
FileStream(String, FileMode, FileAccess, FileShare)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y el permiso de uso compartido especificados.
FileStream(IntPtr, FileAccess, Boolean, Int32)	Obsoletos. Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado, FileStream propiedad de instancia y tamaño del búfer.
FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y uso compartido, el tamaño del búfer y el estado sincrónico o asincrónico especificados.
FileStream(String, FileMode, FileAccess)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación y el permiso de lectura y escritura especificados.
FileStream(IntPtr, FileAccess, Boolean)	Obsoletos. Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado y FileStream propiedad de instancia.
FileStream(SafeFileHandle, FileAccess, Int32)	Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificados y el tamaño del búfer.
FileStream(SafeFileHandle, FileAccess, Int32, Boolean)	Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado, el tamaño del búfer y el estado sincrónico o asincrónico.
FileStream(String, FileStreamOptions)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y uso compartido, el tamaño del búfer, las opciones de archivo adicionales, el tamaño de la asignación previa y el acceso a otros FileStreams pueden tener en el mismo archivo.
FileStream(String, FileMode)	Inicializa una nueva instancia de la clase FileStream con la ruta de acceso y el modo de creación especificados.
FileStream(IntPtr, FileAccess)	Obsoletos. Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado.

FileStream(SafeFileHandle, FileAccess)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado.

public:
 FileStream(Microsoft::Win32::SafeHandles::SafeFileHandle ^ handle, System::IO::FileAccess access);

public FileStream (Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.IO.FileAccess access);

new System.IO.FileStream : Microsoft.Win32.SafeHandles.SafeFileHandle * System.IO.FileAccess -> System.IO.FileStream

Public Sub New (handle As SafeFileHandle, access As FileAccess)

Parámetros

handle

SafeFileHandle

Identificador de archivo para el archivo en el que se encapsulará el objeto FileStream actual.

access

FileAccess

Combinación bit a bit de los valores de enumeración que establece las propiedades CanRead y CanWrite del objeto FileStream.

Excepciones

ArgumentException

access no es un campo de FileAccess.

SecurityException

El autor de la llamada no tiene el permiso necesario.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

Cuando se llama a Close, también se cierra el identificador y se disminuye el recuento de identificadores del archivo.

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a cualquier método que no sea Close después de que haya terminado de usar el identificador.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso especificada, el modo de creación, el permiso de lectura y escritura y uso compartido, el acceso a otros FileStreams puede tener en el mismo archivo, el tamaño del búfer y las opciones de archivo adicionales.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share, int bufferSize, System::IO::FileOptions options);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare * int * System.IO.FileOptions -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare, bufferSize As Integer, options As FileOptions)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que el objeto FileStream actual encapsulará.

mode

FileMode

Uno de los valores de enumeración que determina cómo abrir o crear el archivo.

access

FileAccess

Combinación bit a bit de los valores de enumeración que determina cómo el objeto FileStream puede acceder al archivo. Esto también determina los valores devueltos por las propiedades CanRead y CanWrite del objeto FileStream. CanSeek se true si path especifica un archivo de disco.

share

FileShare

Combinación bit a bit de los valores de enumeración que determina cómo compartirá el archivo los procesos.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

options

FileOptions

Combinación bit a bit de los valores de enumeración que especifica opciones de archivo adicionales.

Excepciones

ArgumentNullException

path es null.

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a la 2.1: path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno que no sea NTFS.

ArgumentOutOfRangeException

bufferSize es negativo o cero.

-o-

mode, accesso share contienen un valor no válido.

FileNotFoundException

No se encuentra el archivo, como cuando mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el pathespecificado, como cuando access es Write o ReadWrite y el archivo o directorio está establecido para el acceso de solo lectura.

-o-

Encrypted se especifica para options, pero no se admite el cifrado de archivos en la plataforma actual.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

Ejemplos

En el ejemplo siguiente se escriben datos en un archivo y, a continuación, se leen los datos mediante el objeto FileStream.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Security::AccessControl;

int main()
{
    try
    {
        // Create a file and write data to it.

        // Create an array of bytes.
        array<Byte>^ messageByte =
            Encoding::ASCII->GetBytes("Here is some data.");

        // Create a file using the FileStream class.
        FileStream^ fWrite = gcnew FileStream("test.txt", FileMode::Create,
            FileAccess::ReadWrite, FileShare::None, 8, FileOptions::None);

        // Write the number of bytes to the file.
        fWrite->WriteByte((Byte)messageByte->Length);

        // Write the bytes to the file.
        fWrite->Write(messageByte, 0, messageByte->Length);

        // Close the stream.
        fWrite->Close();


        // Open a file and read the number of bytes.

        FileStream^ fRead = gcnew FileStream("test.txt", 
            FileMode::Open);

        // The first byte is the string length.
        int length = (int)fRead->ReadByte();

        // Create a new byte array for the data.
        array<Byte>^ readBytes = gcnew array<Byte>(length);

        // Read the data from the file.
        fRead->Read(readBytes, 0, readBytes->Length);

        // Close the stream.
        fRead->Close();

        // Display the data.
        Console::WriteLine(Encoding::ASCII->GetString(readBytes));

        Console::WriteLine("Done writing and reading data.");
    }
    catch (IOException^ ex)
    {
        Console::WriteLine(ex->Message);
    }
}

using System;
using System.IO;
using System.Text;
using System.Security.AccessControl;

namespace FileSystemExample
{
    class FileStreamExample
    {
        public static void Main()
        {
            try
            {
                // Create a file and write data to it.

                // Create an array of bytes.
                byte[] messageByte = Encoding.ASCII.GetBytes("Here is some data.");

                // Create a file using the FileStream class.
                FileStream fWrite = new FileStream("test.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 8, FileOptions.None);

                // Write the number of bytes to the file.
                fWrite.WriteByte((byte)messageByte.Length);

                // Write the bytes to the file.
                fWrite.Write(messageByte, 0, messageByte.Length);

                // Close the stream.
                fWrite.Close();

                // Open a file and read the number of bytes.

                FileStream fRead = new FileStream("test.txt", FileMode.Open);

                // The first byte is the string length.
                int length = (int)fRead.ReadByte();

                // Create a new byte array for the data.
                byte[] readBytes = new byte[length];

                // Read the data from the file.
                fRead.Read(readBytes, 0, readBytes.Length);

                // Close the stream.
                fRead.Close();

                // Display the data.
                Console.WriteLine(Encoding.ASCII.GetString(readBytes));

                Console.WriteLine("Done writing and reading data.");
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            Console.ReadLine();
        }
    }
}

open System.IO
open System.Text

try
    // Create a file and write data to it.

    // Create an array of bytes.
    let messageByte = Encoding.ASCII.GetBytes "Here is some data."

    // Create a file using the FileStream class.
    let fWrite =
        new FileStream("test.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 8, FileOptions.None)

    // Write the number of bytes to the file.
    byte messageByte.Length |> fWrite.WriteByte

    // Write the bytes to the file.
    fWrite.Write(messageByte, 0, messageByte.Length)

    // Close the stream.
    fWrite.Close()

    // Open a file and read the number of bytes.

    let fRead = new FileStream("test.txt", FileMode.Open)

    // The first byte is the string length.
    let length = fRead.ReadByte() |> int

    // Create a new byte array for the data.
    let readBytes = Array.zeroCreate length

    // Read the data from the file.
    fRead.Read(readBytes, 0, readBytes.Length) |> ignore

    // Close the stream.
    fRead.Close()

    // Display the data.
    printfn $"{Encoding.ASCII.GetString readBytes}"

    printfn "Done writing and reading data."

with e ->
    printfn $"{e}"

Imports System.IO
Imports System.Text
Imports System.Security.AccessControl



Module FileStreamExample

    Sub Main()
        Try
            ' Create a file and write data to it.
            ' Create an array of bytes.
            Dim messageByte As Byte() = Encoding.ASCII.GetBytes("Here is some data.")

            ' Create a file using the FileStream class.
            Dim fWrite As New FileStream("test.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 8, FileOptions.None)

            ' Write the number of bytes to the file.
            fWrite.WriteByte(System.Convert.ToByte(messageByte.Length))

            ' Write the bytes to the file.
            fWrite.Write(messageByte, 0, messageByte.Length)

            ' Close the stream.
            fWrite.Close()


            ' Open a file and read the number of bytes.
            Dim fRead As New FileStream("test.txt", FileMode.Open)

            ' The first byte is the string length.
            Dim length As Integer = Fix(fRead.ReadByte())

            ' Create a new byte array for the data.
            Dim readBytes(length) As Byte

            ' Read the data from the file.
            fRead.Read(readBytes, 0, readBytes.Length)

            ' Close the stream.
            fRead.Close()

            ' Display the data.
            Console.WriteLine(Encoding.ASCII.GetString(readBytes))

            Console.WriteLine("Done writing and reading data.")
        Catch e As Exception
            Console.WriteLine(e)
        End Try

        Console.ReadLine()

    End Sub
End Module

Comentarios

.NET Framework no admite el acceso directo a los discos físicos a través de rutas de acceso que son nombres de dispositivo, como "\\.\PHYSICALDRIVE0 ".

El parámetro fileOptions se usa para proporcionar acceso a operaciones más avanzadas que se pueden aprovechar al crear un objeto FileStream.

El parámetro path puede ser un nombre de archivo, incluido un archivo en un recurso compartido de Convención de nomenclatura universal (UNC).

Nota

path no es necesario ser un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, en función del sistema, esta clase puede acceder a un dispositivo físico.

CanSeek es true para todos los objetos FileStream que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la propiedad CanSeek en el FileStream resultante es false. Para obtener más información, consulte CanSeek.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(String, FileMode, FileAccess, FileShare, Int32)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y uso compartido especificados y el tamaño del búfer.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share, int bufferSize);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare * int -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare, bufferSize As Integer)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que el objeto FileStream actual encapsulará.

mode

FileMode

Uno de los valores de enumeración que determina cómo abrir o crear el archivo.

access

FileAccess

Combinación bit a bit de los valores de enumeración que determina cómo el objeto FileStream puede acceder al archivo. Esto también determina los valores devueltos por las propiedades CanRead y CanWrite del objeto FileStream. CanSeek se true si path especifica un archivo de disco.

share

FileShare

Combinación bit a bit de los valores de enumeración que determina cómo compartirá el archivo los procesos.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

Excepciones

ArgumentNullException

path es null.

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a la 2.1: path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno que no sea NTFS.

ArgumentOutOfRangeException

bufferSize es negativo o cero.

-o-

mode, accesso share contienen un valor no válido.

FileNotFoundException

No se encuentra el archivo, como cuando mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el pathespecificado, como cuando access es Write o ReadWrite y el archivo o directorio está establecido para el acceso de solo lectura.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

Comentarios

.NET Framework no admite el acceso directo a los discos físicos a través de rutas de acceso que son nombres de dispositivo, como "\\.\PHYSICALDRIVE0 ".

El parámetro path puede ser un nombre de archivo, incluido un archivo en un recurso compartido de Convención de nomenclatura universal (UNC).

Nota

path no es necesario ser un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, en función del sistema, esta clase puede acceder a un dispositivo físico.

CanSeek es true para todos los objetos FileStream que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la propiedad CanSeek en el FileStream resultante es false. Para obtener más información, consulte CanSeek.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)

Source:

FileStream.cs

Precaución

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado, FileStream propiedad de instancia, tamaño del búfer y estado sincrónico o asincrónico.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access, bool ownsHandle, int bufferSize, bool isAsync);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access, bool ownsHandle, int bufferSize, bool isAsync);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess * bool * int * bool -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess, ownsHandle As Boolean, bufferSize As Integer, isAsync As Boolean)

Parámetros

handle

IntPtr

nativeint

Identificador de archivo para el archivo que este objeto FileStream encapsulará.

access

FileAccess

Combinación bit a bit de los valores de enumeración que establece las propiedades CanRead y CanWrite del objeto FileStream.

ownsHandle

Boolean

true si el identificador de archivo será propiedad de esta instancia de FileStream; de lo contrario, false.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

isAsync

Boolean

true si el identificador se abrió de forma asincrónica (es decir, en modo de E/S superpuesto); de lo contrario, false.

Atributos

ObsoleteAttribute

Excepciones

ArgumentOutOfRangeException

access es menor que FileAccess.Read o mayor que FileAccess.ReadWrite o bufferSize es menor o igual que 0.

ArgumentException

El identificador no es válido.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

El objeto FileStream tiene acceso especificado al archivo. La propiedad del identificador será la especificada. Si este FileStream posee el identificador, una llamada al método Close también cerrará el identificador. En concreto, el recuento de identificadores del archivo se disminuye. Al objeto FileStream se le asigna el tamaño de búfer especificado.

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a cualquier método que no sea Close después de que haya terminado de usar el identificador. Como alternativa, lea y escriba en el identificador antes de llamar a este constructor de FileStream.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(String, FileMode, FileAccess, FileShare)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y el permiso de uso compartido especificados.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que el objeto FileStream actual encapsulará.

mode

FileMode

Uno de los valores de enumeración que determina cómo abrir o crear el archivo.

access

FileAccess

Combinación bit a bit de los valores de enumeración que determina cómo el objeto FileStream puede acceder al archivo. Esto también determina los valores devueltos por las propiedades CanRead y CanWrite del objeto FileStream. CanSeek se true si path especifica un archivo de disco.

share

FileShare

Combinación bit a bit de los valores de enumeración que determina cómo compartirá el archivo los procesos.

Excepciones

ArgumentNullException

path es null.

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a la 2.1: path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno que no sea NTFS.

FileNotFoundException

No se encuentra el archivo, como cuando mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el pathespecificado, como cuando access es Write o ReadWrite y el archivo o directorio está establecido para el acceso de solo lectura.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

ArgumentOutOfRangeException

mode contiene un valor no válido.

Ejemplos

Este ejemplo de código forma parte de un ejemplo más grande proporcionado para el método Lock.

FileStream^ fileStream = gcnew FileStream( "Test#@@#.dat",FileMode::OpenOrCreate,FileAccess::ReadWrite,FileShare::ReadWrite );

using(FileStream fileStream = new FileStream(
    "Test#@@#.dat", FileMode.OpenOrCreate,
    FileAccess.ReadWrite, FileShare.ReadWrite))

use fileStream =
    new FileStream("Test#@@#.dat", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)

Dim aFileStream As New FileStream( _
    "Test#@@#.dat", FileMode.OpenOrCreate, _
    FileAccess.ReadWrite, FileShare.ReadWrite)

Comentarios

.NET Framework no admite el acceso directo a los discos físicos a través de rutas de acceso que son nombres de dispositivo, como "\\.\PHYSICALDRIVE0 ".

El parámetro path puede ser un nombre de archivo, incluido un archivo en un recurso compartido de Convención de nomenclatura universal (UNC).

El constructor recibe acceso de lectura y escritura al archivo y se abre el acceso de lectura compartido (es decir, las solicitudes para abrir el archivo para escribir por este u otro proceso producirán un error hasta que se haya cerrado el objeto FileStream, pero los intentos de lectura se realizarán correctamente). El tamaño del búfer se establece en el tamaño predeterminado de 4096 bytes (4 KB).

Nota

path no es necesario ser un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, en función del sistema, esta clase puede acceder a un dispositivo físico.

CanSeek es true para todos los objetos FileStream que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la propiedad CanSeek en el FileStream resultante es false. Para obtener más información, consulte CanSeek.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(IntPtr, FileAccess, Boolean, Int32)

Source:

FileStream.cs

Precaución

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado, FileStream propiedad de instancia y tamaño del búfer.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access, bool ownsHandle, int bufferSize);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access, bool ownsHandle, int bufferSize);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess * bool * int -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess, ownsHandle As Boolean, bufferSize As Integer)

Parámetros

handle

IntPtr

nativeint

Identificador de archivo para el archivo que este objeto FileStream encapsulará.

access

FileAccess

Combinación bit a bit de los valores de enumeración que establece las propiedades CanRead y CanWrite del objeto FileStream.

ownsHandle

Boolean

true si el identificador de archivo será propiedad de esta instancia de FileStream; de lo contrario, false.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

Atributos

ObsoleteAttribute

Excepciones

ArgumentOutOfRangeException

bufferSize es negativo.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

El objeto FileStream tiene acceso especificado al archivo. La propiedad del identificador será la especificada. Si este FileStream posee el identificador, una llamada al método Close también cerrará el identificador. En concreto, el recuento de identificadores del archivo se disminuye. Al objeto FileStream se le asigna el tamaño de búfer especificado.

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a cualquier método que no sea Close después de que haya terminado de usar el identificador. Como alternativa, lea y escriba en el identificador antes de llamar a este constructor de FileStream.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y uso compartido, el tamaño del búfer y el estado sincrónico o asincrónico especificados.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share, int bufferSize, bool useAsync);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize, bool useAsync);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare * int * bool -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare, bufferSize As Integer, useAsync As Boolean)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que el objeto FileStream actual encapsulará.

mode

FileMode

Uno de los valores de enumeración que determina cómo abrir o crear el archivo.

access

FileAccess

Combinación bit a bit de los valores de enumeración que determina cómo el objeto FileStream puede acceder al archivo. Esto también determina los valores devueltos por las propiedades CanRead y CanWrite del objeto FileStream. CanSeek se true si path especifica un archivo de disco.

share

FileShare

Combinación bit a bit de los valores de enumeración que determina cómo compartirá el archivo los procesos.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

useAsync

Boolean

Especifica si se va a usar E/S asincrónica o E/S sincrónica. Sin embargo, tenga en cuenta que es posible que el sistema operativo subyacente no admita E/S asincrónica, por lo que al especificar true, es posible que el identificador se abra sincrónicamente en función de la plataforma. Cuando se abre de forma asincrónica, los métodos BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) y BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) funcionan mejor en lecturas o escrituras grandes, pero pueden ser mucho más lentos para lecturas o escrituras pequeñas. Si la aplicación está diseñada para aprovechar las ventajas de la E/S asincrónica, establezca el parámetro useAsync en true. El uso correcto de E/S asincrónica puede acelerar las aplicaciones hasta un factor de 10, pero su uso sin rediseñar la aplicación para E/S asincrónica puede reducir el rendimiento hasta un factor de 10.

Excepciones

ArgumentNullException

path es null.

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a la 2.1: path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno que no sea NTFS.

ArgumentOutOfRangeException

bufferSize es negativo o cero.

-o-

mode, accesso share contienen un valor no válido.

FileNotFoundException

No se encuentra el archivo, como cuando mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el pathespecificado, como cuando access es Write o ReadWrite y el archivo o directorio está establecido para el acceso de solo lectura.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

Ejemplos

En el ejemplo de código siguiente se muestra cómo escribir datos de forma asincrónica en un archivo y, a continuación, comprobar que los datos se han escrito correctamente. Se crea un objeto State para pasar información del subproceso principal a los métodos EndReadCallback y EndWriteCallback.

using namespace System;
using namespace System::IO;
using namespace System::Threading;

// Maintain state information to be passed to 
// EndWriteCallback and EndReadCallback.
ref class State
{
private:

   // fStream is used to read and write to the file.
   FileStream^ fStream;

   // writeArray stores data that is written to the file.
   array<Byte>^writeArray;

   // readArray stores data that is read from the file.
   array<Byte>^readArray;

   // manualEvent signals the main thread 
   // when verification is complete.
   ManualResetEvent^ manualEvent;

public:
   State( FileStream^ fStream, array<Byte>^writeArray, ManualResetEvent^ manualEvent )
   {
      this->fStream = fStream;
      this->writeArray = writeArray;
      this->manualEvent = manualEvent;
      readArray = gcnew array<Byte>(writeArray->Length);
   }


   property FileStream^ FStream 
   {
      FileStream^ get()
      {
         return fStream;
      }

   }

   property array<Byte>^ WriteArray 
   {
      array<Byte>^ get()
      {
         return writeArray;
      }

   }

   property array<Byte>^ ReadArray 
   {
      array<Byte>^ get()
      {
         return readArray;
      }

   }

   property ManualResetEvent^ ManualEvent 
   {
      ManualResetEvent^ get()
      {
         return manualEvent;
      }

   }

};

ref class FStream
{
private:

   // When BeginRead is finished reading data from the file, the 
   // EndReadCallback method is called to end the asynchronous 
   // read operation and then verify the data.
   static void EndReadCallback( IAsyncResult^ asyncResult )
   {
      State^ tempState = dynamic_cast<State^>(asyncResult->AsyncState);
      int readCount = tempState->FStream->EndRead( asyncResult );
      int i = 0;
      while ( i < readCount )
      {
         if ( tempState->ReadArray[ i ] != tempState->WriteArray[ i++ ] )
         {
            Console::WriteLine( "Error writing data." );
            tempState->FStream->Close();
            return;
         }
      }

      Console::WriteLine( "The data was written to {0} "
      "and verified.", tempState->FStream->Name );
      tempState->FStream->Close();
      
      // Signal the main thread that the verification is finished.
      tempState->ManualEvent->Set();
   }


public:

   // When BeginWrite is finished writing data to the file, the
   // EndWriteCallback method is called to end the asynchronous 
   // write operation and then read back and verify the data.
   static void EndWriteCallback( IAsyncResult^ asyncResult )
   {
      State^ tempState = dynamic_cast<State^>(asyncResult->AsyncState);
      FileStream^ fStream = tempState->FStream;
      fStream->EndWrite( asyncResult );
      
      // Asynchronously read back the written data.
      fStream->Position = 0;
      asyncResult = fStream->BeginRead( tempState->ReadArray, 0, tempState->ReadArray->Length, gcnew AsyncCallback( &FStream::EndReadCallback ), tempState );
      
      // Concurrently do other work, such as 
      // logging the write operation.
   }

};


int main()
{
   
   // Create a synchronization object that gets 
   // signaled when verification is complete.
   ManualResetEvent^ manualEvent = gcnew ManualResetEvent( false );
   
   // Create the data to write to the file.
   array<Byte>^writeArray = gcnew array<Byte>(100000);
   (gcnew Random)->NextBytes( writeArray );
   FileStream^ fStream = gcnew FileStream(  "Test#@@#.dat",FileMode::Create,FileAccess::ReadWrite,FileShare::None,4096,true );
   
   // Check that the FileStream was opened asynchronously.
   Console::WriteLine( "fStream was {0}opened asynchronously.", fStream->IsAsync ? (String^)"" : "not " );
   
   // Asynchronously write to the file.
   IAsyncResult^ asyncResult = fStream->BeginWrite( writeArray, 0, writeArray->Length, gcnew AsyncCallback( &FStream::EndWriteCallback ), gcnew State( fStream,writeArray,manualEvent ) );
   
   // Concurrently do other work and then wait 
   // for the data to be written and verified.
   manualEvent->WaitOne( 5000, false );
}

using System;
using System.IO;
using System.Threading;

class FStream
{
    static void Main()
    {
        // Create a synchronization object that gets
        // signaled when verification is complete.
        ManualResetEvent manualEvent = new ManualResetEvent(false);

        // Create random data to write to the file.
        byte[] writeArray = new byte[100000];
        new Random().NextBytes(writeArray);

        FileStream fStream =
            new FileStream("Test#@@#.dat", FileMode.Create,
            FileAccess.ReadWrite, FileShare.None, 4096, true);

        // Check that the FileStream was opened asynchronously.
        Console.WriteLine("fStream was {0}opened asynchronously.",
            fStream.IsAsync ? "" : "not ");

        // Asynchronously write to the file.
        IAsyncResult asyncResult = fStream.BeginWrite(
            writeArray, 0, writeArray.Length,
            new AsyncCallback(EndWriteCallback),
            new State(fStream, writeArray, manualEvent));

        // Concurrently do other work and then wait
        // for the data to be written and verified.
        manualEvent.WaitOne(5000, false);
    }

    // When BeginWrite is finished writing data to the file, the
    // EndWriteCallback method is called to end the asynchronous
    // write operation and then read back and verify the data.
    static void EndWriteCallback(IAsyncResult asyncResult)
    {
        State tempState = (State)asyncResult.AsyncState;
        FileStream fStream = tempState.FStream;
        fStream.EndWrite(asyncResult);

        // Asynchronously read back the written data.
        fStream.Position = 0;
        asyncResult = fStream.BeginRead(
            tempState.ReadArray, 0 , tempState.ReadArray.Length,
            new AsyncCallback(EndReadCallback), tempState);

        // Concurrently do other work, such as
        // logging the write operation.
    }

    // When BeginRead is finished reading data from the file, the
    // EndReadCallback method is called to end the asynchronous
    // read operation and then verify the data.
    static void EndReadCallback(IAsyncResult asyncResult)
    {
        State tempState = (State)asyncResult.AsyncState;
        int readCount = tempState.FStream.EndRead(asyncResult);

        int i = 0;
        while(i < readCount)
        {
            if(tempState.ReadArray[i] != tempState.WriteArray[i++])
            {
                Console.WriteLine("Error writing data.");
                tempState.FStream.Close();
                return;
            }
        }
        Console.WriteLine("The data was written to {0} and verified.",
            tempState.FStream.Name);
        tempState.FStream.Close();

        // Signal the main thread that the verification is finished.
        tempState.ManualEvent.Set();
    }

    // Maintain state information to be passed to
    // EndWriteCallback and EndReadCallback.
    class State
    {
        // fStream is used to read and write to the file.
        FileStream fStream;

        // writeArray stores data that is written to the file.
        byte[] writeArray;

        // readArray stores data that is read from the file.
        byte[] readArray;

        // manualEvent signals the main thread
        // when verification is complete.
        ManualResetEvent manualEvent;

        public State(FileStream fStream, byte[] writeArray,
            ManualResetEvent manualEvent)
        {
            this.fStream   = fStream;
            this.writeArray = writeArray;
            this.manualEvent = manualEvent;
            readArray = new byte[writeArray.Length];
        }

        public FileStream FStream
        { get{ return fStream; } }

        public byte[] WriteArray
        { get{ return writeArray; } }

        public byte[] ReadArray
        { get{ return readArray; } }

        public ManualResetEvent ManualEvent
        { get{ return manualEvent; } }
    }
}

open System
open System.IO
open System.Threading

// Maintain state information to be passed to
// EndWriteCallback and EndReadCallback.
type State(fStream: FileStream, writeArray: byte[], manualEvent: ManualResetEvent) =
    // readArray stores data that is read from the file.
    let readArray = Array.zeroCreate writeArray.Length

    member _.FStream = fStream
    member _.WriteArray = writeArray
    member _.ReadArray = readArray
    member _.ManualEvent = manualEvent

// When BeginRead is finished reading data from the file, the
// EndReadCallback method is called to end the asynchronous
// read operation and then verify the data.
let endReadCallback (asyncResult: IAsyncResult) =
    let tempState = asyncResult.AsyncState :?> State
    let readCount = tempState.FStream.EndRead asyncResult

    let mutable i = 0
    let mutable errored = false

    while i < readCount do
        if tempState.ReadArray[i] <> tempState.WriteArray[i] then
            printfn "Error writing data."
            tempState.FStream.Close()
            errored <- true
            i <- readCount

        i <- i + 1

    printfn $"The data was written to {tempState.FStream.Name} and verified."
    tempState.FStream.Close()
    // Signal the main thread that the verification is finished.
    tempState.ManualEvent.Set() |> ignore


// When BeginWrite is finished writing data to the file, the
// EndWriteCallback method is called to end the asynchronous
// write operation and then read back and verify the data.
let endWriteCallback (asyncResult: IAsyncResult) =
    let tempState = asyncResult.AsyncState :?> State
    let fStream = tempState.FStream
    fStream.EndWrite asyncResult

    // Asynchronously read back the written data.
    fStream.Position <- 0

    let asyncResult =
        fStream.BeginRead(tempState.ReadArray, 0, tempState.ReadArray.Length, AsyncCallback endReadCallback, tempState)

    // Concurrently do other work, such as
    // logging the write operation.
    ()


// Create a synchronization object that gets
// signaled when verification is complete.
let manualEvent = new ManualResetEvent false

// Create random data to write to the file.
let writeArray = Array.zeroCreate 100000
Random.Shared.NextBytes writeArray

let fStream =
    new FileStream("Test#@@#.dat", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 4096, true)

// Check that the FileStream was opened asynchronously.

if fStream.IsAsync then "" else "not "
|> printfn "fStream was %sopened asynchronously."

// Asynchronously write to the file.
let asyncResult =
    fStream.BeginWrite(
        writeArray,
        0,
        writeArray.Length,
        AsyncCallback endWriteCallback,
        State(fStream, writeArray, manualEvent)
    )

// Concurrently do other work and then wait
// for the data to be written and verified.
manualEvent.WaitOne(5000, false) |> ignore

Imports System.IO
Imports System.Threading

Class FStream

    Shared Sub Main()

        ' Create a synchronization object that gets 
        ' signaled when verification is complete.
        Dim manualEvent As New ManualResetEvent(False)

        ' Create random data to write to the file.
        Dim writeArray(100000) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(writeArray)

        Dim fStream As New FileStream("Test#@@#.dat", _
            FileMode.Create, FileAccess.ReadWrite, _
            FileShare.None, 4096, True)

        ' Check that the FileStream was opened asynchronously.
        If fStream.IsAsync = True
            Console.WriteLine("fStream was opened asynchronously.")
        Else
            Console.WriteLine("fStream was not opened asynchronously.")
        End If

        ' Asynchronously write to the file.
        Dim asyncResult As IAsyncResult = fStream.BeginWrite( _
            writeArray, 0, writeArray.Length, _
            AddressOf EndWriteCallback , _
            New State(fStream, writeArray, manualEvent))

        ' Concurrently do other work and then wait
        ' for the data to be written and verified.
        manualEvent.WaitOne(5000, False)
    End Sub

    ' When BeginWrite is finished writing data to the file, the
    ' EndWriteCallback method is called to end the asynchronous 
    ' write operation and then read back and verify the data.
    Private Shared Sub EndWriteCallback(asyncResult As IAsyncResult)
        Dim tempState As State = _
            DirectCast(asyncResult.AsyncState, State)
        Dim fStream As FileStream = tempState.FStream
        fStream.EndWrite(asyncResult)

        ' Asynchronously read back the written data.
        fStream.Position = 0
        asyncResult = fStream.BeginRead( _ 
            tempState.ReadArray, 0 , tempState.ReadArray.Length, _
            AddressOf EndReadCallback, tempState)

        ' Concurrently do other work, such as 
        ' logging the write operation.
    End Sub

    ' When BeginRead is finished reading data from the file, the 
    ' EndReadCallback method is called to end the asynchronous 
    ' read operation and then verify the data.
   Private Shared Sub EndReadCallback(asyncResult As IAsyncResult)
        Dim tempState As State = _
            DirectCast(asyncResult.AsyncState, State)
        Dim readCount As Integer = _
            tempState.FStream.EndRead(asyncResult)

        Dim i As Integer = 0
        While(i < readCount)
            If(tempState.ReadArray(i) <> tempState.WriteArray(i))
                Console.WriteLine("Error writing data.")
                tempState.FStream.Close()
                Return
            End If
            i += 1
        End While

        Console.WriteLine("The data was written to {0} and " & _
            "verified.", tempState.FStream.Name)
        tempState.FStream.Close()

        ' Signal the main thread that the verification is finished.
        tempState.ManualEvent.Set()
    End Sub

    ' Maintain state information to be passed to 
    ' EndWriteCallback and EndReadCallback.
    Private Class State

        ' fStreamValue is used to read and write to the file.
        Dim fStreamValue As FileStream

        ' writeArrayValue stores data that is written to the file.
        Dim writeArrayValue As Byte()

        ' readArrayValue stores data that is read from the file.
        Dim readArrayValue As Byte()

        ' manualEvent signals the main thread 
        ' when verification is complete.
        Dim manualEventValue As ManualResetEvent 

        Sub New(aStream As FileStream, anArray As Byte(), _
            manualEvent As ManualResetEvent)

            fStreamValue     = aStream
            writeArrayValue  = anArray
            manualEventValue = manualEvent
            readArrayValue   = New Byte(anArray.Length - 1){}
        End Sub    

            Public ReadOnly Property FStream() As FileStream
                Get
                    Return fStreamValue
                End Get
            End Property

            Public ReadOnly Property WriteArray() As Byte()
                Get
                    Return writeArrayValue
                End Get
            End Property

            Public ReadOnly Property ReadArray() As Byte()
                Get
                    Return readArrayValue
                End Get
            End Property

            Public ReadOnly Property ManualEvent() As ManualResetEvent
                Get
                    Return manualEventValue
                End Get
            End Property
    End Class 
   
End Class

Comentarios

.NET Framework no admite el acceso directo a los discos físicos a través de rutas de acceso que son nombres de dispositivo, como "\\.\PHYSICALDRIVE0 ".

El parámetro path puede ser un nombre de archivo, incluido un archivo en un recurso compartido de Convención de nomenclatura universal (UNC).

Nota

path no es necesario ser un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, en función del sistema, esta clase puede acceder a un dispositivo físico.

CanSeek es true para todos los objetos FileStream que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la propiedad CanSeek en el FileStream resultante es false. Para obtener más información, consulte CanSeek.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• File
• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(String, FileMode, FileAccess)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación y el permiso de lectura y escritura especificados.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que el objeto FileStream actual encapsulará.

mode

FileMode

Uno de los valores de enumeración que determina cómo abrir o crear el archivo.

access

FileAccess

Combinación bit a bit de los valores de enumeración que determina cómo el objeto FileStream puede acceder al archivo. Esto también determina los valores devueltos por las propiedades CanRead y CanWrite del objeto FileStream. CanSeek se true si path especifica un archivo de disco.

Excepciones

ArgumentNullException

path es null.

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a la 2.1: path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno que no sea NTFS.

FileNotFoundException

No se encuentra el archivo, como cuando mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el pathespecificado, como cuando access es Write o ReadWrite y el archivo o directorio está establecido para el acceso de solo lectura.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

ArgumentOutOfRangeException

mode contiene un valor no válido.

Comentarios

.NET Framework no admite el acceso directo a los discos físicos a través de rutas de acceso que son nombres de dispositivo, como "\\.\PHYSICALDRIVE0 ".

El parámetro path puede ser un nombre de archivo, incluido un archivo en un recurso compartido de Convención de nomenclatura universal (UNC).

El constructor recibe acceso de lectura y escritura al archivo y se abre el acceso de lectura compartido (es decir, las solicitudes para abrir el archivo para escribir por este u otro proceso producirán un error hasta que se haya cerrado el objeto FileStream, pero los intentos de lectura se realizarán correctamente). El tamaño del búfer se establece en el tamaño predeterminado de 4096 bytes (4 KB).

Nota

path no es necesario ser un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, en función del sistema, esta clase puede acceder a un dispositivo físico.

CanSeek es true para todos los objetos FileStream que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la propiedad CanSeek en el FileStream resultante es false. Para obtener más información, consulte CanSeek.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(IntPtr, FileAccess, Boolean)

Source:

FileStream.cs

Precaución

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado y FileStream propiedad de instancia.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access, bool ownsHandle);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access, bool ownsHandle);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess * bool -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess, ownsHandle As Boolean)

Parámetros

handle

IntPtr

nativeint

Identificador de archivo para el archivo en el que se encapsulará el objeto FileStream actual.

access

FileAccess

Combinación bit a bit de los valores de enumeración que establece las propiedades CanRead y CanWrite del objeto FileStream.

ownsHandle

Boolean

true si el identificador de archivo será propiedad de esta instancia de FileStream; de lo contrario, false.

Atributos

ObsoleteAttribute

Excepciones

ArgumentException

access no es un campo de FileAccess.

SecurityException

El autor de la llamada no tiene el permiso necesario.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

El objeto FileStream tiene acceso especificado al archivo. La propiedad del identificador será la especificada. Si este proceso posee el identificador, una llamada al método Close también cerrará el identificador y se decrementará el recuento de identificadores del archivo. El objeto FileStream tiene el tamaño de búfer predeterminado de 4096 bytes.

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a métodos distintos de Close después de que haya terminado de usar el identificador.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(SafeFileHandle, FileAccess, Int32)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificados y el tamaño del búfer.

public:
 FileStream(Microsoft::Win32::SafeHandles::SafeFileHandle ^ handle, System::IO::FileAccess access, int bufferSize);

public FileStream (Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.IO.FileAccess access, int bufferSize);

new System.IO.FileStream : Microsoft.Win32.SafeHandles.SafeFileHandle * System.IO.FileAccess * int -> System.IO.FileStream

Public Sub New (handle As SafeFileHandle, access As FileAccess, bufferSize As Integer)

Parámetros

handle

SafeFileHandle

Identificador de archivo para el archivo en el que se encapsulará el objeto FileStream actual.

access

FileAccess

Constante FileAccess que establece las propiedades CanRead y CanWrite del objeto FileStream.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

Excepciones

ArgumentException

El parámetro handle es un identificador no válido.

-o-

El parámetro handle es un identificador sincrónico y se usó de forma asincrónica.

ArgumentOutOfRangeException

El parámetro bufferSize es negativo.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a cualquier método que no sea Close después de que haya terminado de usar el identificador. Como alternativa, lea y escriba en el identificador antes de llamar a este constructor de FileStream.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(SafeFileHandle, FileAccess, Int32, Boolean)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado, el tamaño del búfer y el estado sincrónico o asincrónico.

public:
 FileStream(Microsoft::Win32::SafeHandles::SafeFileHandle ^ handle, System::IO::FileAccess access, int bufferSize, bool isAsync);

public FileStream (Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.IO.FileAccess access, int bufferSize, bool isAsync);

new System.IO.FileStream : Microsoft.Win32.SafeHandles.SafeFileHandle * System.IO.FileAccess * int * bool -> System.IO.FileStream

Public Sub New (handle As SafeFileHandle, access As FileAccess, bufferSize As Integer, isAsync As Boolean)

Parámetros

handle

SafeFileHandle

Identificador de archivo para el archivo que este objeto FileStream encapsulará.

access

FileAccess

Combinación bit a bit de los valores de enumeración que establece las propiedades CanRead y CanWrite del objeto FileStream.

bufferSize

Int32

Valor de Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

isAsync

Boolean

true si el identificador se abrió de forma asincrónica (es decir, en modo de E/S superpuesto); de lo contrario, false.

Excepciones

ArgumentException

El parámetro handle es un identificador no válido.

-o-

El parámetro handle es un identificador sincrónico y se usó de forma asincrónica.

ArgumentOutOfRangeException

El parámetro bufferSize es negativo.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

SecurityException

El autor de la llamada no tiene el permiso necesario.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

Establezca el parámetro isAsync en true para abrir el identificador de archivo de forma asincrónica. Cuando el parámetro es true, la secuencia utiliza E/S superpuesta para realizar operaciones de archivo de forma asincrónica. Sin embargo, el parámetro no tiene que ser true llamar al método ReadAsync, WriteAsynco CopyToAsync. Cuando se false el parámetro isAsync y se llama a las operaciones asincrónicas de lectura y escritura, el subproceso de la interfaz de usuario sigue sin bloquearse, pero la operación de E/S real se realiza de forma sincrónica.

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a cualquier método que no sea Close después de que haya terminado de usar el identificador. Como alternativa, lea y escriba en el identificador antes de llamar a este constructor de FileStream.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(String, FileStreamOptions)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso, el modo de creación, el permiso de lectura y escritura y uso compartido, el tamaño del búfer, las opciones de archivo adicionales, el tamaño de la asignación previa y el acceso a otros FileStreams pueden tener en el mismo archivo.

public:
 FileStream(System::String ^ path, System::IO::FileStreamOptions ^ options);

public FileStream (string path, System.IO.FileStreamOptions options);

new System.IO.FileStream : string * System.IO.FileStreamOptions -> System.IO.FileStream

Public Sub New (path As String, options As FileStreamOptions)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que la instancia de FileStream actual encapsulará.

options

FileStreamOptions

Objeto que describe los parámetros opcionales FileStream que se van a usar.

Excepciones

ArgumentNullException

path o options es null.

ArgumentException

path es una cadena vacía, solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como CON:, COM1:o LPT1:, en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no sea de archivo, como CON:, COM1:, LPT1:, etc. en un entorno que no sea NTFS.

FileNotFoundException

No se encuentra el archivo, como cuando Mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

-o-

El disco estaba lleno (cuando se proporcionó PreallocationSize y path apuntaba a un archivo normal).

-o-

El archivo era demasiado grande (cuando se proporcionó PreallocationSize y path apuntaba a un archivo normal).

SecurityException

El autor de la llamada no tiene el permiso necesario.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el Access solicitado para el pathespecificado, como cuando Access es Write o ReadWrite y el archivo o directorio está establecido para el acceso de solo lectura.

-o-

Encrypted se especifica para Options , pero no se admite el cifrado de archivos en la plataforma actual.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

Comentarios

Al especificar un valor para PreallocationSize se proporciona una sugerencia sobre el tamaño de la asignación previa, pero no una garantía segura. Para obtener detalles de uso completos, consulte la documentación de PreallocationSize.

FileStream(String, FileMode)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con la ruta de acceso y el modo de creación especificados.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode);

public FileStream (string path, System.IO.FileMode mode);

new System.IO.FileStream : string * System.IO.FileMode -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode)

Parámetros

path

String

Ruta de acceso relativa o absoluta para el archivo que el objeto FileStream actual encapsulará.

mode

FileMode

Uno de los valores de enumeración que determina cómo abrir o crear el archivo.

Excepciones

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a la 2.1: path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o varios caracteres no válidos.

-o-

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno NTFS.

NotSupportedException

path hace referencia a un dispositivo que no es de archivo, como "con:", "com1:", "lpt1:", etc. en un entorno que no sea NTFS.

ArgumentNullException

path es null.

SecurityException

El autor de la llamada no tiene el permiso necesario.

FileNotFoundException

No se encuentra el archivo, como cuando mode es FileMode.Truncate o FileMode.Open, y el archivo especificado por path no existe. El archivo ya debe existir en estos modos.

UnauthorizedAccessException

path especifica un archivo que es de solo lectura.

IOException

Error de E/S, como especificar FileMode.CreateNew cuando el archivo especificado por path ya existe, se produjo.

-o-

Se ha cerrado la secuencia.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, como estar en una unidad no asignada.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

ArgumentOutOfRangeException

mode contiene un valor no válido.

Ejemplos

En el ejemplo de código siguiente se muestra cómo escribir datos en un archivo, byte byte y, a continuación, comprobar que los datos se han escrito correctamente.

using namespace System;
using namespace System::IO;
int main()
{
   String^ fileName =  "Test@##@.dat";
   
   // Create random data to write to the file.
   array<Byte>^dataArray = gcnew array<Byte>(100000);
   (gcnew Random)->NextBytes( dataArray );
   FileStream^ fileStream = gcnew FileStream( fileName,FileMode::Create );
   try
   {
      
      // Write the data to the file, byte by byte.
      for ( int i = 0; i < dataArray->Length; i++ )
      {
         fileStream->WriteByte( dataArray[ i ] );

      }
      
      // Set the stream position to the beginning of the file.
      fileStream->Seek( 0, SeekOrigin::Begin );
      
      // Read and verify the data.
      for ( int i = 0; i < fileStream->Length; i++ )
      {
         if ( dataArray[ i ] != fileStream->ReadByte() )
         {
            Console::WriteLine( "Error writing data." );
            return  -1;
         }

      }
      Console::WriteLine( "The data was written to {0} "
      "and verified.", fileStream->Name );
   }
   finally
   {
      fileStream->Close();
   }

}

using System;
using System.IO;

class FStream
{
    static void Main()
    {
        const string fileName = "Test#@@#.dat";

        // Create random data to write to the file.
        byte[] dataArray = new byte[100000];
        new Random().NextBytes(dataArray);

        using(FileStream
            fileStream = new FileStream(fileName, FileMode.Create))
        {
            // Write the data to the file, byte by byte.
            for(int i = 0; i < dataArray.Length; i++)
            {
                fileStream.WriteByte(dataArray[i]);
            }

            // Set the stream position to the beginning of the file.
            fileStream.Seek(0, SeekOrigin.Begin);

            // Read and verify the data.
            for(int i = 0; i < fileStream.Length; i++)
            {
                if(dataArray[i] != fileStream.ReadByte())
                {
                    Console.WriteLine("Error writing data.");
                    return;
                }
            }
            Console.WriteLine("The data was written to {0} " +
                "and verified.", fileStream.Name);
        }
    }
}

open System
open System.IO


let fileName = "Test#@@#.dat"

// Create random data to write to the file.
let dataArray = Array.zeroCreate 100000
Random.Shared.NextBytes dataArray

do
    use fileStream = new FileStream(fileName, FileMode.Create)
    // Write the data to the file, byte by byte.
    for i = 0 to dataArray.Length - 1 do
        fileStream.WriteByte dataArray[i]

    // Set the stream position to the beginning of the file.
    fileStream.Seek(0, SeekOrigin.Begin) |> ignore

    // Read and verify the data.
    for i in 0L .. fileStream.Length - 1L do
        if dataArray[int i] <> (fileStream.ReadByte() |> byte) then
            printfn "Error writing data."
            exit 1

    printfn $"The data was written to {fileStream.Name} and verified."

Imports System.IO
Imports System.Text

Class FStream

    Shared Sub Main()

        Const fileName As String = "Test#@@#.dat"

        ' Create random data to write to the file.
        Dim dataArray(100000) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(dataArray)

        Dim fileStream As FileStream = _
            new FileStream(fileName, FileMode.Create)
        Try

            ' Write the data to the file, byte by byte.
            For i As Integer = 0 To dataArray.Length - 1
                fileStream.WriteByte(dataArray(i))
            Next i

            ' Set the stream position to the beginning of the stream.
            fileStream.Seek(0, SeekOrigin.Begin)

            ' Read and verify the data.
            For i As Integer = 0 To _
                CType(fileStream.Length, Integer) - 1

                If dataArray(i) <> fileStream.ReadByte() Then
                    Console.WriteLine("Error writing data.")
                    Return
                End If
            Next i
            Console.WriteLine("The data was written to {0} " & _
                "and verified.", fileStream.Name)
        Finally
            fileStream.Close()
        End Try
    
    End Sub
End Class

Comentarios

.NET Framework no admite el acceso directo a los discos físicos a través de rutas de acceso que son nombres de dispositivo, como "\\.\PHYSICALDRIVE0 ".

El parámetro path puede ser un nombre de archivo, incluido un archivo en un recurso compartido de Convención de nomenclatura universal (UNC).

El constructor recibe acceso de lectura y escritura al archivo y se abre el acceso de lectura compartido (es decir, las solicitudes para abrir el archivo para escribir por este u otro proceso producirán un error hasta que se haya cerrado el objeto FileStream, pero los intentos de lectura se realizarán correctamente).

No puede usar este constructor para abrir archivos de solo lectura; en su lugar, debe usar un constructor que acepte un parámetro FileAccess con el valor establecido en FileAccess.Read.

El tamaño del búfer se establece en el tamaño predeterminado de 4096 bytes (4 KB).

Nota

path no es necesario ser un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, en función del sistema, esta clase puede acceder a un dispositivo físico.

CanSeek es true para todos los objetos FileStream que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la propiedad CanSeek en el FileStream resultante es false. Para obtener más información, consulte CanSeek.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

En el caso de los constructores sin un parámetro FileAccess, si el parámetro mode está establecido en Append, Write es el acceso predeterminado. De lo contrario, el acceso se establece en ReadWrite.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• InvalidPathChars
• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo

FileStream(IntPtr, FileAccess)

Source:

FileStream.cs

Precaución

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.

Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el permiso de lectura y escritura especificado.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess)

Parámetros

handle

IntPtr

nativeint

Identificador de archivo para el archivo en el que se encapsulará el objeto FileStream actual.

access

FileAccess

Combinación bit a bit de los valores de enumeración que establece las propiedades CanRead y CanWrite del objeto FileStream.

Atributos

ObsoleteAttribute

Excepciones

ArgumentException

access no es un campo de FileAccess.

SecurityException

El autor de la llamada no tiene el permiso necesario.

IOException

Se produjo un error de E/S, como un error de disco.

-o-

Se ha cerrado la secuencia.

UnauthorizedAccessException

El sistema operativo no permite el access solicitado para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo se establece para el acceso de solo lectura.

Comentarios

Cuando se llama a Close, también se cierra el identificador y se disminuye el recuento de identificadores del archivo.

FileStream supone que tiene control exclusivo sobre el identificador. Leer, escribir o buscar mientras un FileStream también mantiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame a Flush antes de usar el identificador y evite llamar a cualquier método que no sea Close después de que haya terminado de usar el identificador.

Cautela

Al compilar un conjunto de caracteres con una configuración cultural determinada y recuperar esos mismos caracteres con una configuración cultural diferente, es posible que los caracteres no se puedan interpretar y podrían provocar una excepción.

FileShare.Read es el valor predeterminado para esos constructores de FileStream sin un parámetro FileShare.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Common I/O Tasks.

Consulte también

• de E/S de flujo y archivos
• Cómo: Leer texto de un de archivos
• Cómo: Escribir texto en un archivo