FileStream Classe

Definizione

Fornisce un oggetto Stream per un file, con il supporto di operazioni di lettura e scrittura sincrone e asincrone.Provides a Stream for a file, supporting both synchronous and asynchronous read and write operations.

public ref class FileStream : System::IO::Stream
[System.Runtime.InteropServices.ComVisible(true)]
public class FileStream : System.IO.Stream
type FileStream = class
    inherit Stream
Public Class FileStream
Inherits Stream
Ereditarietà
Attributi

Esempi

Nell'esempio seguente vengono illustrati alcuni dei costruttori di FileStream.The following example demonstrates some of the FileStream constructors.

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

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

int main()
{
   String^ path = "c:\\temp\\MyTest.txt";
   
   // Delete the file if it exists.
   if ( File::Exists( path ) )
   {
      File::Delete( path );
   }

   //Create the file.
   {
      FileStream^ fs = File::Create( path );
      try
      {
         AddText( fs, "This is some text" );
         AddText( fs, "This is some more text," );
         AddText( fs, "\r\nand this is on a new line" );
         AddText( fs, "\r\n\r\nThe following is a subset of characters:\r\n" );
         for ( int i = 1; i < 120; i++ )
         {
            AddText( fs, Convert::ToChar( i ).ToString() );
            
            //Split the output at every 10th character.
            if ( Math::IEEERemainder( Convert::ToDouble( i ), 10 ) == 0 )
            {
               AddText( fs, "\r\n" );
            }
         }
      }
      finally
      {
         if ( fs )
            delete (IDisposable^)fs;
      }
   }
   
   //Open the stream and read it back.
   {
      FileStream^ fs = File::OpenRead( path );
      try
      {
         array<Byte>^b = gcnew array<Byte>(1024);
         UTF8Encoding^ temp = gcnew UTF8Encoding( true );
         while ( fs->Read( b, 0, b->Length ) > 0 )
         {
            Console::WriteLine( temp->GetString( b ) );
         }
      }
      finally
      {
         if ( fs )
            delete (IDisposable^)fs;
      }
   }
}
using System;
using System.IO;
using System.Text;

class Test
{

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

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

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

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

            }
        }

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

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

Public Class Test

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

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

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

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

        Dim i As Integer

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

        Next

        fs.Close()

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

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

        fs.Close()
    End Sub

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

Nell'esempio seguente viene illustrato come scrivere in un file in modo asincrono.The following example shows how to write to a file asynchronously. Questo codice viene eseguito in un'app WPF con un TextBlock denominato UserInput e un pulsante collegato a un gestore eventi Click denominato Button_Click.This code runs in a WPF app that has a TextBlock named UserInput and a button hooked up to a Click event handler that is named Button_Click. Il percorso del file deve essere modificato in un file esistente nel computer.The file path needs to be changed to a file that exists on the computer.

using System;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.IO;

namespace WpfApplication1
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            UnicodeEncoding uniencoding = new UnicodeEncoding();
            string filename = @"c:\Users\exampleuser\Documents\userinputlog.txt";
           
            byte[] result = uniencoding.GetBytes(UserInput.Text);
            
            using (FileStream SourceStream = File.Open(filename, FileMode.OpenOrCreate))
            {
                SourceStream.Seek(0, SeekOrigin.End);
                await SourceStream.WriteAsync(result, 0, result.Length);
            }
        }
    }
}
Imports System.IO
Imports System.Text

Class MainWindow
    Private Async Sub Button_Click(sender As Object, e As RoutedEventArgs)
        Dim uniencoding As UnicodeEncoding = New UnicodeEncoding()
        Dim filename As String = "c:\Users\exampleuser\Documents\userinputlog.txt"

        Dim result As Byte() = uniencoding.GetBytes(UserInput.Text)

        Using SourceStream As FileStream = File.Open(filename, FileMode.OpenOrCreate)
            SourceStream.Seek(0, SeekOrigin.End)
            Await SourceStream.WriteAsync(result, 0, result.Length)
        End Using
    End Sub
End Class

Commenti

Usare la classe FileStream per leggere, scrivere, aprire e chiudere i file in un file system e per modificare altri handle del sistema operativo correlati ai file, incluse le pipe, l'input standard e l'output standard.Use the FileStream class to read from, write to, open, and close files on a file system, and to manipulate other file-related operating system handles, including pipes, standard input, and standard output. È possibile utilizzare i metodi Read, Write, CopyToe Flush per eseguire operazioni sincrone o i metodi ReadAsync, WriteAsync, CopyToAsynce FlushAsync per eseguire operazioni asincrone.You can use the Read, Write, CopyTo, and Flush methods to perform synchronous operations, or the ReadAsync, WriteAsync, CopyToAsync, and FlushAsync methods to perform asynchronous operations. Usare i metodi asincroni per eseguire operazioni di file a elevato utilizzo di risorse senza bloccare il thread principale.Use the asynchronous methods to perform resource-intensive file operations without blocking the main thread. Questa considerazione sulle prestazioni è particolarmente importante in un'applicazione Windows 8.x StoreWindows 8.x Store o desktopdesktop in cui tramite un'operazione di flusso per cui è richiesto molto tempo è possibile bloccare il thread UI e far sembrare che l'applicazione non funzioni.This performance consideration is particularly important in a Windows 8.x StoreWindows 8.x Store app or desktopdesktop app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. FileStream buffer di input e output per ottenere prestazioni migliori.FileStream buffers input and output for better performance.

Importante

Il tipo implementa l'interfaccia IDisposable.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

La proprietà IsAsync rileva se l'handle di file è stato aperto in modo asincrono.The IsAsync property detects whether the file handle was opened asynchronously. Questo valore viene specificato quando si crea un'istanza della classe FileStream usando un costruttore con un parametro isAsync, useAsynco options.You specify this value when you create an instance of the FileStream class using a constructor that has an isAsync, useAsync, or options parameter. Quando la proprietà è true, il flusso usa l'I/O sovrapposto per eseguire operazioni sui file in modo asincrono.When the property is true, the stream utilizes overlapped I/O to perform file operations asynchronously. Tuttavia, non è necessario che la proprietà IsAsync sia true per chiamare il metodo ReadAsync, WriteAsynco CopyToAsync.However, the IsAsync property does not have to be true to call the ReadAsync, WriteAsync, or CopyToAsync method. Quando la proprietà IsAsync è false e si chiamano le operazioni di lettura e scrittura asincrone, il thread dell'interfaccia utente non è ancora bloccato, ma l'operazione di I/O effettiva viene eseguita in modo sincrono.When the IsAsync property is false and you call the asynchronous read and write operations, the UI thread is still not blocked, but the actual I/O operation is performed synchronously.

Il metodo Seek supporta l'accesso casuale ai file.The Seek method supports random access to files. Seek consente lo spostamento della posizione di lettura/scrittura in qualsiasi posizione all'interno del file.Seek allows the read/write position to be moved to any position within the file. Questa operazione viene eseguita con i parametri del punto di riferimento offset di byte.This is done with byte offset reference point parameters. L'offset dei byte è relativo al punto di riferimento della ricerca, che può essere l'inizio, la posizione corrente o la fine del file sottostante, come rappresentato dai tre membri dell'enumerazione SeekOrigin.The byte offset is relative to the seek reference point, which can be the beginning, the current position, or the end of the underlying file, as represented by the three members of the SeekOrigin enumeration.

Nota

I file su disco supportano sempre l'accesso casuale.Disk files always support random access. Al momento della costruzione, il valore della proprietà CanSeek viene impostato su true o false a seconda del tipo di file sottostante. Se il tipo di file sottostante è FILE_TYPE_DISK, come definito in winbase. h, il valore della proprietà CanSeek viene true.At the time of construction, the CanSeek property value is set to true or false depending on the underlying file type.If the underlying file type is FILE_TYPE_DISK, as defined in winbase.h, the CanSeek property value is true. In caso contrario, il valore della proprietà CanSeek viene false.Otherwise, the CanSeek property value is false.

Se un processo termina con una parte di un file bloccato o chiude un file con blocchi in attesa, il comportamento non è definito.If a process terminates with part of a file locked or closes a file that has outstanding locks, the behavior is undefined.

Per le operazioni di directory e altre operazioni sui file, vedere le classi File, Directorye Path.For directory operations and other file operations, see the File, Directory, and Path classes. La classe File è una classe di utilità che ha metodi statici principalmente per la creazione di oggetti FileStream in base ai percorsi di file.The File class is a utility class that has static methods primarily for the creation of FileStream objects based on file paths. La classe MemoryStream crea un flusso da una matrice di byte ed è simile alla classe FileStream.The MemoryStream class creates a stream from a byte array and is similar to the FileStream class.

Per un elenco delle operazioni comuni di file e directory, vedere attività di I/O comuni.For a list of common file and directory operations, see Common I/O Tasks.

Rilevamento delle modifiche alla posizione del flussoDetection of Stream Position Changes

Quando un oggetto FileStream non dispone di un'esenzione esclusiva sul relativo handle, un altro thread può accedere simultaneamente all'handle di file e modificare la posizione del puntatore del file del sistema operativo associato all'handle di file.When a FileStream object does not have an exclusive hold on its handle, another thread could access the file handle concurrently and change the position of the operating system's file pointer that is associated with the file handle. In questo caso, la posizione memorizzata nella cache nell'oggetto FileStream e i dati memorizzati nella cache nel buffer potrebbero essere compromessi.In this case, the cached position in the FileStream object and the cached data in the buffer could be compromised. L'oggetto FileStream esegue periodicamente controlli sui metodi che accedono al buffer memorizzato nella cache per assicurarsi che la posizione dell'handle del sistema operativo corrisponda alla posizione memorizzata nella cache utilizzata dall'oggetto FileStream.The FileStream object routinely performs checks on methods that access the cached buffer to ensure that the operating system's handle position is the same as the cached position used by the FileStream object.

Se viene rilevata una modifica imprevista nella posizione dell'handle in una chiamata al metodo Read, il .NET Framework Elimina il contenuto del buffer e legge nuovamente il flusso dal file.If an unexpected change in the handle position is detected in a call to the Read method, the .NET Framework discards the contents of the buffer and reads the stream from the file again. Ciò può influire sulle prestazioni, a seconda delle dimensioni del file e di qualsiasi altro processo che potrebbe influire sulla posizione del flusso di file.This can affect performance, depending on the size of the file and any other processes that could affect the position of the file stream.

Se viene rilevata una modifica imprevista nella posizione dell'handle in una chiamata al metodo Write, il contenuto del buffer viene ignorato e viene generata un'eccezione IOException.If an unexpected change in the handle position is detected in a call to the Write method, the contents of the buffer are discarded and an IOException exception is thrown.

Un oggetto FileStream non avrà un'esenzione esclusiva per il relativo handle quando viene eseguito l'accesso alla proprietà SafeFileHandle per esporre l'handle oppure all'oggetto FileStream viene assegnata la proprietà SafeFileHandle nel relativo costruttore.A FileStream object will not have an exclusive hold on its handle when either the SafeFileHandle property is accessed to expose the handle or the FileStream object is given the SafeFileHandle property in its constructor.

Costruttori

FileStream(IntPtr, FileAccess)

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura specificata.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission.

FileStream(IntPtr, FileAccess, Boolean)

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura e la proprietà dell'istanza di FileStream.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission and FileStream instance ownership.

FileStream(IntPtr, FileAccess, Boolean, Int32)

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura, la proprietà dell'istanza di FileStream e la dimensione del buffer specificate.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission, FileStream instance ownership, and buffer size.

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

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura, la proprietà dell'istanza di FileStream, la dimensione del buffer e lo stato sincrono o asincrono specificati.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission, FileStream instance ownership, buffer size, and synchronous or asynchronous state.

FileStream(SafeFileHandle, FileAccess)

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura specificata.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission.

FileStream(SafeFileHandle, FileAccess, Int32)

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura e la dimensione del buffer specificate.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission, and buffer size.

FileStream(SafeFileHandle, FileAccess, Int32, Boolean)

Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura, la dimensione del buffer e lo stato sincrono o asincrono specificati.Initializes a new instance of the FileStream class for the specified file handle, with the specified read/write permission, buffer size, and synchronous or asynchronous state.

FileStream(String, FileMode)

Inizializza una nuova istanza della classe FileStream con il percorso e la modalità di creazione specificati.Initializes a new instance of the FileStream class with the specified path and creation mode.

FileStream(String, FileMode, FileAccess)

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione e l'autorizzazione di lettura/scrittura specificati.Initializes a new instance of the FileStream class with the specified path, creation mode, and read/write permission.

FileStream(String, FileMode, FileAccess, FileShare)

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione, l'autorizzazione di lettura/scrittura e l'autorizzazione di condivisione specificati.Initializes a new instance of the FileStream class with the specified path, creation mode, read/write permission, and sharing permission.

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

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione, l'autorizzazione di lettura/scrittura e condivisione e la dimensione del buffer specificati.Initializes a new instance of the FileStream class with the specified path, creation mode, read/write and sharing permission, and buffer size.

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

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.Initializes a new instance of the FileStream class with the specified path, creation mode, read/write and sharing permission, buffer size, and synchronous or asynchronous state.

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

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione, l'autorizzazione di lettura/scrittura e condivisione, l'accesso consentito ad altri FileStream allo stesso file, la dimensione del buffer e le opzioni aggiuntive del file specificati.Initializes a new instance of the FileStream class with the specified path, creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, and additional file options.

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

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione, i diritti di accesso e l'autorizzazione di condivisione, la dimensione del buffer e le opzioni aggiuntive del file specificati.Initializes a new instance of the FileStream class with the specified path, creation mode, access rights and sharing permission, the buffer size, and additional file options.

FileStream(String, FileMode, FileSystemRights, FileShare, Int32, FileOptions, FileSecurity)

Inizializza una nuova istanza della classe FileStream con il percorso, la modalità di creazione, i diritti di accesso e l'autorizzazione di condivisione, la dimensione del buffer, le opzioni aggiuntive del file, il controllo di accesso e la sicurezza di controllo specificati.Initializes a new instance of the FileStream class with the specified path, creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security.

Proprietà

CanRead

Ottiene un valore che indica se il flusso corrente supporta la lettura.Gets a value that indicates whether the current stream supports reading.

CanSeek

Ottiene un valore che indica se il flusso corrente supporta la ricerca.Gets a value that indicates whether the current stream supports seeking.

CanTimeout

Ottiene un valore che determina se il flusso corrente prevede il timeout.Gets a value that determines whether the current stream can time out.

(Ereditato da Stream)
CanWrite

Ottiene un valore che indica se il flusso corrente supporta la scrittura.Gets a value that indicates whether the current stream supports writing.

Handle

Ottiene l'handle di file del sistema operativo per il file incapsulato dall'oggetto FileStream.Gets the operating system file handle for the file that the current FileStream object encapsulates.

IsAsync

Ottiene un valore che indica se FileStream è stato aperto in modalità sincrona o asincrona.Gets a value that indicates whether the FileStream was opened asynchronously or synchronously.

Length

Ottiene la lunghezza in byte del flusso.Gets the length in bytes of the stream.

Name

Ottiene il percorso assoluto del file aperto in FileStream.Gets the absolute path of the file opened in the FileStream.

Position

Ottiene o imposta la posizione corrente del flusso.Gets or sets the current position of this stream.

ReadTimeout

Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out.

(Ereditato da Stream)
SafeFileHandle

Ottiene un oggetto SafeFileHandle che rappresenta l'handle di file del sistema operativo per il file incapsulato dall'oggetto FileStream corrente.Gets a SafeFileHandle object that represents the operating system file handle for the file that the current FileStream object encapsulates.

WriteTimeout

Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out.

(Ereditato da Stream)

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Inizia un'operazione di lettura asincrona.Begins an asynchronous read operation. In alternativa, considerare l'utilizzo di ReadAsync(Byte[], Int32, Int32, CancellationToken).Consider using ReadAsync(Byte[], Int32, Int32, CancellationToken) instead.

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Inizia un'operazione di scrittura asincrona.Begins an asynchronous write operation. In alternativa, considerare l'utilizzo di WriteAsync(Byte[], Int32, Int32, CancellationToken).Consider using WriteAsync(Byte[], Int32, Int32, CancellationToken) instead.

Close()

Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream.

CopyTo(Stream)

Legge i byte dal flusso corrente e li scrive in un altro flusso.Reads the bytes from the current stream and writes them to another stream.

(Ereditato da Stream)
CopyTo(Stream, Int32)

Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Ereditato da Stream)
CopyToAsync(Stream)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Ereditato da Stream)
CopyToAsync(Stream, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Ereditato da Stream)
CopyToAsync(Stream, Int32)

Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Ereditato da Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Legge in modo asincrono i byte dal flusso di file corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento.Asynchronously reads the bytes from the current file stream and writes them to another stream, using a specified buffer size and cancellation token.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Ereditato da MarshalByRefObject)
CreateWaitHandle()

Alloca un oggetto WaitHandle.Allocates a WaitHandle object.

(Ereditato da Stream)
Dispose()

Rilascia tutte le risorse usate da Stream.Releases all resources used by the Stream.

(Ereditato da Stream)
Dispose(Boolean)

Rilascia le risorse non gestite usate da FileStream e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the FileStream and optionally releases the managed resources.

DisposeAsync()

Consente di liberare in modo asincrono le risorse non gestite utilizzate da FileStream.Asynchronously releases the unmanaged resources used by the FileStream.

EndRead(IAsyncResult)

Attende il completamento dell'operazione di lettura asincrona in sospeso.Waits for the pending asynchronous read operation to complete. (In alternativa, si consideri l'uso di ReadAsync(Byte[], Int32, Int32, CancellationToken).)(Consider using ReadAsync(Byte[], Int32, Int32, CancellationToken) instead.)

EndWrite(IAsyncResult)

Termina un'operazione di scrittura asincrona, rimanendo bloccato fino al completamento dell'operazione di I/O.Ends an asynchronous write operation and blocks until the I/O operation is complete. (In alternativa, si consideri l'uso di WriteAsync(Byte[], Int32, Int32, CancellationToken).)(Consider using WriteAsync(Byte[], Int32, Int32, CancellationToken) instead.)

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Finalize()

Garantisce che le risorse vengano liberate e le altre operazioni di pulizia vengano completate quando l'oggetto FileStream viene recuperato da Garbage Collector.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the FileStream.

Flush()

Cancella i buffer del flusso e fa sì che i dati memorizzati nel buffer vengano scritti nel file.Clears buffers for this stream and causes any buffered data to be written to the file.

Flush(Boolean)

Cancella i buffer del flusso e fa sì che i dati memorizzati nei buffer vengano scritti nel file, cancellando anche tutti i buffer di file intermedi.Clears buffers for this stream and causes any buffered data to be written to the file, and also clears all intermediate file buffers.

FlushAsync()

Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Ereditato da Stream)
FlushAsync(CancellationToken)

Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

GetAccessControl()

Ottiene un oggetto FileSecurity che incapsula le voci dell'elenco di controllo di accesso (ACL) per il file descritto dall'oggetto FileStream corrente.Gets a FileSecurity object that encapsulates the access control list (ACL) entries for the file described by the current FileStream object.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
Lock(Int64, Int64)

Impedisce ad altri processi di leggere o scrivere nell'oggetto FileStream.Prevents other processes from reading from or writing to the FileStream.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
ObjectInvariant()

Fornisce supporto per un oggetto Contract.Provides support for a Contract.

(Ereditato da Stream)
Read(Byte[], Int32, Int32)

Legge un blocco di byte dal flusso e scrive i dati in un determinato buffer.Reads a block of bytes from the stream and writes the data in a given buffer.

Read(Span<Byte>)

Legge una sequenza di byte dal flusso di file corrente e fa avanzare la posizione corrente nel flusso di file del numero di byte letti.Reads a sequence of bytes from the current file stream and advances the position within the file stream by the number of bytes read.

ReadAsync(Byte[], Int32, Int32)

Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Legge in modo asincrono una sequenza di byte dal flusso di file corrente e li scrive in una matrice di byte a partire da un offset specificato, fa avanzare la posizione all'interno del flusso di file in base al numero di byte letti e monitora le richieste di annullamento.Asynchronously reads a sequence of bytes from the current file stream and writes them to a byte array beginning at a specified offset, advances the position within the file stream by the number of bytes read, and monitors cancellation requests.

ReadAsync(Memory<Byte>, CancellationToken)

Legge in modo asincrono una sequenza di byte dal flusso di file corrente e li scrive in un'area di memoria, fa avanzare la posizione all'interno del flusso di file in base al numero di byte letti e monitora le richieste di annullamento.Asynchronously reads a sequence of bytes from the current file stream and writes them to a memory region, advances the position within the file stream by the number of bytes read, and monitors cancellation requests.

ReadByte()

Legge un byte dal file e sposta in avanti di un byte la posizione di lettura.Reads a byte from the file and advances the read position one byte.

Seek(Int64, SeekOrigin)

Imposta la posizione corrente del flusso sul valore dato.Sets the current position of this stream to the given value.

SetAccessControl(FileSecurity)

Applica le voci dell'elenco di controllo di accesso (ACL) descritte da un oggetto FileSecurity nel file specificato dall'oggetto FileStream corrente.Applies access control list (ACL) entries described by a FileSecurity object to the file described by the current FileStream object.

SetLength(Int64)

Imposta la lunghezza del flusso sul valore dato.Sets the length of this stream to the given value.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
Unlock(Int64, Int64)

Consente ad altri processi di accedere a una parte o a tutto il file bloccato in precedenza.Allows access by other processes to all or part of a file that was previously locked.

Write(Byte[], Int32, Int32)

Scrive un blocco di byte nel flusso di file.Writes a block of bytes to the file stream.

Write(ReadOnlySpan<Byte>)

Scrive una sequenza di byte da un intervallo di sola lettura nel flusso di file corrente e sposta in avanti la posizione nel flusso di file in base al numero di byte scritti.Writes a sequence of bytes from a read-only span to the current file stream and advances the current position within this file stream by the number of bytes written.

WriteAsync(Byte[], Int32, Int32)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Scrive in modo asincrono una sequenza di byte da un'area di memoria nel flusso di file corrente e sposta in avanti la posizione corrente all'interno del flusso di file in base al numero di byte scritti ed esegue il monitoraggio delle richieste di annullamento.Asynchronously writes a sequence of bytes from a memory region to the current file stream, advances the current position within this file stream by the number of bytes written, and monitors cancellation requests.

WriteByte(Byte)

Scrive un byte nella posizione corrente all'interno del flusso di file.Writes a byte to the current position in the file stream.

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate da Stream.Releases all resources used by the Stream.

(Ereditato da Stream)

Metodi di estensione

GetAccessControl(FileStream)
SetAccessControl(FileStream, FileSecurity)
AsInputStream(Stream)

Converte un flusso gestito in .NET per app di Windows Store in un flusso di input in Windows Runtime.Converts a managed stream in the .NET for Windows Store apps to an input stream in the Windows Runtime.

AsOutputStream(Stream)

Converte un flusso gestito in .NET per app di Windows Store in un flusso di output in Windows Runtime.Converts a managed stream in the .NET for Windows Store apps to an output stream in the Windows Runtime.

AsRandomAccessStream(Stream)

Converte il flusso specificato in un flusso di accesso casuale.Converts the specified stream to a random access stream.

Si applica a

Vedi anche