Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

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

 

Publicado: octubre de 2016

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.

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

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

Parámetros

path
Type: System.String

Ruta de acceso relativa o absoluta del archivo que va a encapsular el objeto FileStream actual.

mode
Type: System.IO.FileMode

Constante que determina cómo abrir o crear el archivo.

access
Type: System.IO.FileAccess

Constante que determina cómo puede obtener acceso al archivo el objeto FileStream. 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
Type: System.IO.FileShare

Constante que determina cómo compartirán el archivo los procesos.

bufferSize
Type: System.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
Type: System.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 y BeginWrite 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.

Exception Condition
ArgumentNullException

El valor de path es null.

ArgumentException

path es una cadena vacía (""), solo contiene espacios en blanco o contiene uno o más caracteres no válidos.

-o-

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

El sistema dispone de Windows 98 o Windows 98 Second Edition y share está establecido en FileShare.Delete.

-o-

Se ha cerrado la secuencia.

SecurityException

El llamador no dispone del permiso requerido.

DirectoryNotFoundException

La ruta de acceso especificada no es válida, porque, 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. Por ejemplo, en plataformas basadas en Windows, las rutas de acceso deben tener menos de 248 caracteres y los nombres de archivo deben tener menos de 260 caracteres.

.NET Framework no admite el acceso directo a discos físicos a través de rutas de acceso que sean 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).

System_CAPS_noteNota

path no es necesario que sea un archivo almacenado en disco; puede ser cualquier parte de un sistema que admita el acceso a través de secuencias. Por ejemplo, dependiendo 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, el CanSeek propiedad resultante FileStream es false. Para obtener información adicional, vea CanSeek.

System_CAPS_cautionPrecaución

Cuando se compile un juego de caracteres con una configuración cultural concreta y se recuperan los mismos caracteres con una configuración cultural diferente, los caracteres no pueden interpretarse y podrían provocar que se produzca una excepción.

Para obtener una lista de operaciones de directorio y de archivo común, consulte Tareas de E/S comunes.

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

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

FileIOPermission

for reading, writing, and appending to files. Associated enumerations: F:System.Security.Permissions.FileIOPermissionAccess.Read, F:System.Security.Permissions.FileIOPermissionAccess.Write, and F:System.Security.Permissions.FileIOPermissionAccess.Append.

Plataforma universal de Windows
Disponible desde 10
.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: