Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

 

Data di pubblicazione: ottobre 2016

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione, l'autorizzazione di lettura/scrittura e condivisione, la dimensione del buffer e lo stato sincrono o asincrono specificati.

Spazio dei nomi:   System.IO
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

path
Type: System.String

Percorso relativo o assoluto per il file che sarà incapsulato dall'oggetto FileStream corrente.

mode
Type: System.IO.FileMode

Costante che determina la modalità di apertura o di creazione del file.

access
Type: System.IO.FileAccess

Costante che determina la modalità di accesso al file da parte dell'oggetto FileStream. Determina anche i valori restituiti dalle proprietà CanRead e CanWrite dell'oggetto FileStream. CanSeek è true se path specifica un file su disco.

share
Type: System.IO.FileShare

Costante che determina la modalità di condivisione del file da parte dei processi.

bufferSize
Type: System.Int32

Valore positivo Int32 maggiore di 0 che indica la dimensione del buffer. La dimensione del buffer predefinita è 4096.

useAsync
Type: System.Boolean

Specifica se usare I/O asincroni o sincroni. Tenere presente, tuttavia, che il sistema operativo usato potrebbe non supportare le operazioni di I/O asincrone. Quindi, se si specifica true, l'handle potrebbe essere aperto in modalità sincrona a seconda della piattaforma usata. Quando vengono aperti in modalità asincrona, i metodi BeginRead e BeginWrite offrono prestazioni migliori nelle operazioni di lettura o scrittura su dati di grandi dimensioni, ma potrebbero offrire prestazioni inferiori nelle operazioni di lettura o scrittura su dati di piccole dimensioni. Se l'applicazione è stata progettata per sfruttare le operazioni di I/O asincrone, impostare il parametro useAsync su true. Se le operazioni di I/O asincrone vengono usate in modo corretto è possibile ottenere un incremento delle prestazioni delle applicazioni fino a 10 volte, ma se vengono usate senza riprogettare l'applicazione per le operazioni di I/O asincrone le prestazioni possono ridursi fino a 10 volte.

Exception Condition
ArgumentNullException

path è null.

ArgumentException

path è una stringa vuota (""), contiene solo spazi vuoti oppure contiene uno o più caratteri non validi.

-oppure-

path fa riferimento a dispositivi non basati su file come "con:", "com1:", "lpt1:" e così via in un ambiente NTFS.

NotSupportedException

path fa riferimento a dispositivi non basati su file come "con:", "com1:", "lpt1:" e così via in un ambiente non NTFS.

ArgumentOutOfRangeException

bufferSize è un valore negativo o zero.

-oppure-

mode, access o share contiene un valore non valido.

FileNotFoundException

Il file non è stato trovato, ad esempio se mode è FileMode.Truncate o FileMode.Open e il file specificato da path non esiste. È necessario che il file sia già disponibile in queste modalità.

IOException

Si è verificato un errore di I/O, come nel caso in cui si specifica FileMode.CreateNew e il file specificato da path è già presente.

-oppure-

Il sistema esegue Windows 98 o Windows 98 Second Edition e share è impostato su FileShare.Delete.

-oppure-

Il flusso è stato chiuso.

SecurityException

Il chiamante non dispone dell'autorizzazione richiesta.

DirectoryNotFoundException

Il percorso specificato non è valido, ad esempio si trova in un'unità non mappata.

UnauthorizedAccessException

L'oggetto access richiesto non è consentito dal sistema operativo per l'oggetto path specificato, ad esempio se access è Write o ReadWrite e la directory o il file è impostato per l'accesso in sola lettura.

PathTooLongException

Il percorso specificato, il nome file o entrambi superano la lunghezza massima definita dal sistema. Ad esempio, nelle piattaforme basate su Windows i percorsi devono contenere meno di 248 caratteri e i nomi file meno di 260 caratteri.

.NET Framework non supporta l'accesso diretto ai dischi fisici attraverso percorsi costituiti da nomi di dispositivo, ad esempio "\\.\PHYSICALDRIVE0".

Il path parametro può essere un nome di file, incluso un file in una condivisione UNC Universal Naming Convention ().

System_CAPS_noteNota

path non è necessario essere un file archiviato su disco. può trattarsi di qualsiasi parte di un sistema che supporta l'accesso attraverso i flussi. Ad esempio, a seconda del sistema, questa classe può accedere a un dispositivo fisico.

CanSeek è true per tutti FileStream gli oggetti che incapsulano i file. Se path indica un dispositivo che non supporta la ricerca, la CanSeek proprietà dell'oggetto risultante FileStream è false. Per altre informazioni, vedere CanSeek.

System_CAPS_cautionAttenzione

Quando si compila un set di caratteri con una lingua specifica e si recuperano gli stessi caratteri con una lingua diversa, i caratteri potrebbero non essere interpretati e potrebbero generare un'eccezione viene generata.

Per un elenco di operazioni di directory e file comuni, vedere Attività di I/O comuni.

Esempio di codice seguente viene illustrato come scrivere in modo asincrono i dati in un file e quindi verificare che i dati vengano scritti correttamente. Oggetto State viene creato l'oggetto per passare informazioni dal thread principale per il EndReadCallback e EndWriteCallback metodi.

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.

Universal Windows Platform
Disponibile da 10
.NET Framework
Disponibile da 1.1
Torna all'inizio
Mostra: