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, el modo de creación, los permisos de lectura y escritura y de uso compartido, el acceso que otras secuencias de archivos pueden tener al mismo archivo, el tamaño del búfer y otras opciones de archivo que se hayan especificado.
FileStream(String, FileMode, FileAccess, FileShare, Int32)	Inicializa una nueva instancia de la clase FileStream con el tamaño de búfer, el permiso de lectura y escritura y de uso compartido, el modo de creación y la ruta de acceso especificados.
FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)	Obsoletos. Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el estado sincrónico o asincrónico, el tamaño de búfer, la propiedad de la instancia de FileStream y el permiso de lectura y escritura especificados.
FileStream(String, FileMode, FileAccess, FileShare)	Inicializa una nueva instancia de la clase FileStream con el permiso de uso compartido, el permiso de lectura y escritura, el modo de creación y la ruta de acceso especificados.
FileStream(IntPtr, FileAccess, Boolean, Int32)	Obsoletos. Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el tamaño de búfer, la propiedad de la instancia de FileStream y el permiso de lectura y escritura especificados.
FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)	Inicializa una nueva instancia de la clase FileStream con el estado sincrónico o asincrónico, el tamaño de búfer, el permiso de lectura y escritura y de uso compartido, el modo de creación y la ruta de acceso especificados.
FileStream(String, FileMode, FileAccess)	Inicializa una nueva instancia de la clase FileStream con el permiso de lectura y escritura, el modo de creación y la ruta de acceso 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 establecido y la propiedad de la instancia de FileStream.
FileStream(SafeFileHandle, FileAccess, Int32)	Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, con el tamaño de búfer y el permiso de lectura y escritura especificados.
FileStream(SafeFileHandle, FileAccess, Int32, Boolean)	Inicializa una nueva instancia de la clase FileStream para el identificador de archivo especificado, y con el permiso de lectura y escritura, el tamaño de búfer y el estado sincrónico o asincrónico especificados.
FileStream(String, FileStreamOptions)	Inicializa una nueva instancia de la FileStream clase 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 que otros FileStreams pueden tener en el mismo archivo.
FileStream(String, FileMode)	Inicializa una nueva instancia de la clase FileStream con el modo de creación y la ruta de acceso 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 que el objeto FileStream actual va a encapsular.

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 llamador no dispone del permiso requerido.

IOException

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

o bien

Se ha cerrado la secuencia.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

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

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría dar lugar a daños en los datos. Para la seguridad de los datos, llame Flush a antes de usar el identificador y evite llamar a cualquier método distinto de Close después de que haya terminado de usar el identificador.

Precaución

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 producir una excepción.

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

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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, el modo de creación, los permisos de lectura y escritura y de uso compartido, el acceso que otras secuencias de archivos pueden tener al mismo archivo, el tamaño del búfer y otras opciones de archivo que se hayan especificado.

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 del archivo que va a encapsular el objeto FileStream actual.

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 que devuelven las propiedades CanRead y CanWrite del objeto FileStream. CanSeek es 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 los procesos compartirán el archivo.

bufferSize

Int32

Valor 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 las opciones de archivo adicionales.

Excepciones

ArgumentNullException

path es null.

ArgumentException

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

o bien

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

NotSupportedException

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

ArgumentOutOfRangeException

bufferSize es un valor negativo o es cero.

o bien

mode, access o 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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está en una unidad no asignada.

UnauthorizedAccessException

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

o bien

Encrypted se ha especificado 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 FileStream objeto .

#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 fileOptions parámetro se usa para proporcionar acceso a operaciones más avanzadas que se pueden aprovechar al crear un FileStream objeto.

El path parámetro 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 que sea un archivo almacenado en el 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 FileStream objetos que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la CanSeek propiedad en el resultante FileStream es false. Para obtener información adicional, vea CanSeek.

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 el tamaño de búfer, el permiso de lectura y escritura y de uso compartido, el modo de creación y la ruta de acceso especificados.

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 del archivo que va a encapsular el objeto FileStream actual.

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 que devuelven las propiedades CanRead y CanWrite del objeto FileStream. CanSeek es 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 los procesos compartirán el archivo.

bufferSize

Int32

Valor 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 2.1: path es una cadena vacía (""), contiene solo espacio en blanco o contiene uno o varios caracteres no válidos.

o bien

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

NotSupportedException

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

ArgumentOutOfRangeException

bufferSize es un valor negativo o es cero.

o bien

mode, access o 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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el objeto access solicitado para el objeto path especificado, 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 path parámetro 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 que sea un archivo almacenado en el 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 FileStream objetos que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la CanSeek propiedad en el resultante FileStream es false. Para obtener información adicional, vea CanSeek.

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 estado sincrónico o asincrónico, el tamaño de búfer, la propiedad de la instancia de FileStream y el permiso de lectura y escritura especificados.

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 va a 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

Es true si esta instancia de FileStream va a ser la propietaria del identificador de archivo; en caso contrario, es false.

bufferSize

Int32

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

isAsync

Boolean

Es true si se abrió el identificador de forma asincrónica (es decir, en modo de E/S superpuesta); de lo contrario, es 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 bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

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

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame Flush a 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 FileStream constructor.

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

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

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

FileStream(String, FileMode, FileAccess, FileShare)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con el permiso de uso compartido, el permiso de lectura y escritura, el modo de creación y la ruta de acceso 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 del archivo que va a encapsular el objeto FileStream actual.

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 que devuelven las propiedades CanRead y CanWrite del objeto FileStream. CanSeek es 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 los procesos compartirán el archivo.

Excepciones

ArgumentNullException

path es null.

ArgumentException

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

o bien

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

NotSupportedException

path hace referencia a un dispositivo que no es un archivo, como "con:", "com1:", "lpt1:", etc. en un entorno distinto de 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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el objeto access solicitado para el objeto path especificado, 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 Lock método .

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 path parámetro puede ser un nombre de archivo, incluido un archivo en un recurso compartido de convención de nomenclatura universal (UNC).

El constructor tiene acceso de lectura y escritura al archivo y se abre compartiendo acceso de lectura (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 FileStream objeto, 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 que sea un archivo almacenado en el 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 FileStream objetos que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la CanSeek propiedad en el resultante FileStream es false. Para obtener información adicional, vea CanSeek.

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 tamaño de búfer, la propiedad de la instancia de FileStream y el permiso de lectura y escritura especificados.

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 va a 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

Es true si esta instancia de FileStream va a ser la propietaria del identificador de archivo; en caso contrario, es false.

bufferSize

Int32

Valor 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 bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

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

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría dar lugar a daños en los datos. Para la seguridad de los datos, llame Flush a antes de usar el identificador y evite llamar a cualquier método distinto de Close después de que haya terminado de usar el identificador. Como alternativa, lea y escriba en el identificador antes de llamar a este FileStream constructor.

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

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 el estado sincrónico o asincrónico, el tamaño de búfer, el permiso de lectura y escritura y de uso compartido, el modo de creación y la ruta de acceso 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 del archivo que va a encapsular el objeto FileStream actual.

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 que devuelven las propiedades CanRead y CanWrite del objeto FileStream. CanSeek es 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 los procesos compartirán el archivo.

bufferSize

Int32

Valor 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 utilizar E/S asincrónica o sincrónica. Sin embargo, tenga en cuenta que el sistema operativo subyacente quizás no admita E/S asincrónica, por lo que cuando se especifica true, puede que el identificador se abra de forma sincrónica 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) proporcionan un rendimiento mejor en lecturas o escrituras grandes, pero es posible que sean mucho más lentos para lecturas o escrituras pequeñas. Si la aplicación se ha diseñado para aprovechar al máximo la E/S asincrónica, establezca el parámetro useAsync en true. El uso de la E/S asincrónica de forma correcta puede agilizar las aplicaciones en hasta un factor de 10, pero su uso sin volver a diseñar la aplicación para la E/S asincrónica puede disminuir el rendimiento en hasta un factor de 10.

Excepciones

ArgumentNullException

path es null.

ArgumentException

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

o bien

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

NotSupportedException

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

ArgumentOutOfRangeException

bufferSize es un valor negativo o es cero.

o bien

mode, access o 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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el objeto access solicitado para el objeto path especificado, 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 escribieron correctamente. Se crea un State objeto para pasar información del subproceso principal a los EndReadCallback métodos 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 path parámetro 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 que sea un archivo almacenado en el 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 FileStream objetos que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la CanSeek propiedad en el resultante FileStream es false. Para obtener información adicional, vea CanSeek.

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

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

FileStream(String, FileMode, FileAccess)

Source:

FileStream.cs

Inicializa una nueva instancia de la clase FileStream con el permiso de lectura y escritura, el modo de creación y la ruta de acceso 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 del archivo que va a encapsular el objeto FileStream actual.

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 que devuelven las propiedades CanRead y CanWrite del objeto FileStream. CanSeek es true si path especifica un archivo de disco.

Excepciones

ArgumentNullException

path es null.

ArgumentException

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

o bien

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

NotSupportedException

path hace referencia a un dispositivo que no es un archivo, como "con:", "com1:", "lpt1:", etc. en un entorno distinto de 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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está en una unidad no asignada.

UnauthorizedAccessException

El sistema operativo no permite el objeto access solicitado para el objeto path especificado, 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 path parámetro puede ser un nombre de archivo, incluido un archivo en un recurso compartido de convención de nomenclatura universal (UNC).

El constructor tiene acceso de lectura y escritura al archivo y se abre compartiendo acceso de lectura (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 FileStream objeto, 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 que sea un archivo almacenado en el 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 FileStream objetos que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la CanSeek propiedad en el resultante FileStream es false. Para obtener información adicional, vea CanSeek.

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

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 establecido y la propiedad de la instancia de FileStream.

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 que el objeto FileStream actual va a 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

Es true si esta instancia de FileStream va a ser la propietaria del identificador de archivo; en caso contrario, es false.

Atributos

ObsoleteAttribute

Excepciones

ArgumentException

access no es un campo de FileAccess.

SecurityException

El llamador no dispone del permiso requerido.

IOException

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

o bien

Se ha cerrado la secuencia.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

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

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame Flush a 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 FileStream constructores sin un FileShare parámetro .

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 tamaño de búfer y el permiso de lectura y escritura especificados.

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 que el objeto FileStream actual va a encapsular.

access

FileAccess

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

bufferSize

Int32

Valor 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 tiene un identificador que no es válido.

o bien

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 bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame Flush a 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 FileStream constructor.

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

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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, y con el permiso de lectura y escritura, el tamaño de búfer y el estado sincrónico o asincrónico especificados.

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 va a 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 Int32 positivo mayor que 0 que indica el tamaño del búfer. El tamaño de búfer predeterminado es 4096.

isAsync

Boolean

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

Excepciones

ArgumentException

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

o bien

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 bien

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

Establezca el isAsync parámetro 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 para llamar al ReadAsyncmétodo , WriteAsynco CopyToAsync . Cuando el isAsync parámetro es false y llama a las operaciones asincrónicas de lectura y escritura, el subproceso de la interfaz de usuario todavía no está bloqueado, pero la operación de E/S real se realiza de forma sincrónica.

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame Flush a 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 FileStream constructor.

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

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

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

FileStream(String, FileStreamOptions)

Source:

FileStream.cs

Inicializa una nueva instancia de la FileStream clase con la ruta de acceso especificada, 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 actual FileStream 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, contiene solo espacios en blanco o contiene uno o varios caracteres no válidos.

O bien

path hace referencia a un dispositivo que no sea 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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

O bien

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

O bien

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

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está en una unidad no asignada.

UnauthorizedAccessException

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

o bien

Encrypted se especifica para Options , pero el cifrado de archivos no se admite 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

Especificar un valor para PreallocationSize proporciona una sugerencia sobre el tamaño de 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 el modo de creación y la ruta de acceso 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 del archivo que va a encapsular el objeto FileStream actual.

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 2.1: path es una cadena vacía (""), contiene solo espacios en blanco o contiene uno o varios caracteres no válidos.

o bien

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

NotSupportedException

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

ArgumentNullException

path es null.

SecurityException

El llamador no dispone del permiso requerido.

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

Se ha producido un error de E/S, como cuando se especifica FileMode.CreateNew cuando el archivo especificado por path ya existe.

o bien

Se ha cerrado la secuencia.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, por ejemplo, está 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 escribieron 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 path parámetro puede ser un nombre de archivo, incluido un archivo en un recurso compartido de convención de nomenclatura universal (UNC).

El constructor tiene acceso de lectura y escritura al archivo y se abre compartiendo acceso de lectura (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 FileStream objeto, 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 FileAccess parámetro 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 que sea un archivo almacenado en el 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 FileStream objetos que encapsulan archivos. Si path indica un dispositivo que no admite la búsqueda, la CanSeek propiedad en el resultante FileStream es false. Para obtener información adicional, vea CanSeek.

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

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

Precaución

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 producir una excepción.

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

• InvalidPathChars
• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• 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 que el objeto FileStream actual va a encapsular.

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 llamador no dispone del permiso requerido.

IOException

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

o bien

Se ha cerrado la secuencia.

UnauthorizedAccessException

El access solicitado no está permitido por el sistema operativo para el identificador de archivo especificado, como cuando access es Write o ReadWrite y el identificador de archivo está establecido para el acceso de solo lectura.

Comentarios

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

FileStream supone que tiene control exclusivo sobre el controlador. La lectura, escritura o búsqueda mientras un FileStream objeto también contiene un identificador podría provocar daños en los datos. Para la seguridad de los datos, llame Flush a 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.

Precaución

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 producir una excepción.

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

Para obtener una lista de las operaciones comunes de archivos y directorios, consulte Tareas comunes de E/S.

Consulte también

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