FileStream Classe

Definizione

Spazio dei nomi:

System.IO

Assembly:

System.Runtime.dll

Source:

FileStream.cs

Fornisce un oggetto Stream per un file, con il supporto di operazioni di lettura e scrittura sincrone e asincrone.

public ref class FileStream : System::IO::Stream

public class FileStream : System.IO.Stream

type FileStream = class
    inherit Stream

Public Class FileStream
Inherits Stream

Ereditarietà

Object

MarshalByRefObject

Stream

FileStream

Derivato

System.IO.IsolatedStorage.IsolatedStorageFileStream

Esempio

Nell'esempio seguente vengono illustrati alcuni FileStream costruttori.

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);
            int readLen;
            while ((readLen = fs.Read(b,0,b.Length)) > 0)
            {
                Console.WriteLine(temp.GetString(b,0,readLen));
            }
        }
    }

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

open System
open System.IO
open System.Text

let addText (fs:FileStream) (value: string) =
    let info = UTF8Encoding(true).GetBytes value
    fs.Write(info, 0, info.Length);

let path = @"c:\temp\MyTest.txt"

// Delete the file if it exists.
if File.Exists path then
    File.Delete path

//Create the file.
do
    use 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 i = 1 to 119 do
        Convert.ToChar i
        |> string
        |> addText fs
    
do
    //Open the stream and read it back.
    use fs = File.OpenRead path
    let b = Array.zeroCreate 1024
    let temp = UTF8Encoding true
    let mutable readLen = fs.Read(b,0,b.Length);
    while readLen> 0 do
        printfn $"{temp.GetString(b,0,readLen)}"
        readLen <- fs.Read(b,0,b.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. Questo codice viene eseguito in un'app WPF con un controllo TextBlock denominato UserInput e un pulsante associato a un gestore eventi Click denominato Button_Click. Il percorso del file deve essere modificato in un file esistente nel 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

Per altre informazioni su questa API, vedere Osservazioni supplementari sull'API per FileStream.

Costruttori

FileStream(IntPtr, FileAccess)	Obsoleti. Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura specificata.
FileStream(IntPtr, FileAccess, Boolean)	Obsoleti. 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.
FileStream(IntPtr, FileAccess, Boolean, Int32)	Obsoleti. 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.
FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)	Obsoleti. 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.
FileStream(SafeFileHandle, FileAccess)	Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura specificata.
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.
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.
FileStream(String, FileMode)	Inizializza una nuova istanza della classe FileStream con il percorso e la modalità di creazione specificati.
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.
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.
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.
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.
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.
FileStream(String, FileStreamOptions)	Inizializza una nuova istanza della FileStream classe con il percorso, la modalità di creazione, l'autorizzazione di lettura/scrittura e condivisione, le dimensioni del buffer, le opzioni di file aggiuntive, le dimensioni di preallocazione e l'accesso ad altri FileStream possono avere nello stesso file.

Proprietà

CanRead	Ottiene un valore che indica se il flusso corrente supporta la lettura.
CanSeek	Ottiene un valore che indica se il flusso corrente supporta la ricerca.
CanTimeout	Ottiene un valore che determina se il flusso corrente prevede il timeout. (Ereditato da Stream)
CanWrite	Ottiene un valore che indica se il flusso corrente supporta la scrittura.
Handle	Obsoleti. Ottiene l'handle di file del sistema operativo per il file incapsulato dall'oggetto FileStream.
IsAsync	Ottiene un valore che indica se FileStream è stato aperto in modalità sincrona o asincrona.
Length	Ottiene la lunghezza in byte del flusso.
Name	Ottiene il percorso assoluto del file aperto in FileStream.
Position	Ottiene o imposta la posizione corrente del flusso.
ReadTimeout	Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. (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.
WriteTimeout	Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. (Ereditato da Stream)

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di lettura asincrona. In alternativa, considerare l'utilizzo di ReadAsync(Byte[], Int32, Int32, CancellationToken).
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di scrittura asincrona. In alternativa, considerare l'utilizzo di WriteAsync(Byte[], Int32, Int32, CancellationToken).
Close()	Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente. (Ereditato da Stream)
CopyTo(Stream)	Legge i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (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.
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. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleti. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate da Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate da FileStream e, facoltativamente, le risorse gestite.
DisposeAsync()	Consente di liberare in modo asincrono le risorse non gestite utilizzate da FileStream.
EndRead(IAsyncResult)	Attende il completamento dell'operazione di lettura asincrona in sospeso. Si consiglia di usare ReadAsync(Byte[], Int32, Int32, CancellationToken).
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona, rimanendo bloccato fino al completamento dell'operazione di I/O. Si consiglia di usare WriteAsync(Byte[], Int32, Int32, CancellationToken).
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (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.
Flush()	Cancella i buffer del flusso e fa sì che i dati memorizzati nel buffer vengano scritti nel 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.
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. (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.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
Lock(Int64, Int64)	Impedisce ad altri processi di leggere o scrivere nell'oggetto FileStream.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Obsoleti. Fornisce supporto per un oggetto Contract. (Ereditato da Stream)
Read(Byte[], Int32, Int32)	Legge un blocco di byte dal flusso e scrive i dati in un determinato 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.
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. (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.
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.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Legge almeno un numero minimo di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Legge in modo asincrono almeno un numero minimo di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da Stream)
ReadByte()	Legge un byte dal file e sposta in avanti di un byte la posizione di lettura.
ReadExactly(Byte[], Int32, Int32)	count Legge il numero di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso. (Ereditato da Stream)
ReadExactly(Span<Byte>)	Legge i byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso fino a quando non viene riempito.buffer (Ereditato da Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono count il numero di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso e monitora le richieste di annullamento. (Ereditato da Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente, sposta la posizione all'interno del flusso fino a quando non buffer viene riempito e monitora le richieste di annullamento. (Ereditato da Stream)
Seek(Int64, SeekOrigin)	Imposta la posizione corrente del flusso sul valore dato.
SetLength(Int64)	Imposta la lunghezza del flusso sul valore dato.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Unlock(Int64, Int64)	Consente ad altri processi di accedere a una parte o a tutto il file bloccato in precedenza.
Write(Byte[], Int32, Int32)	Scrive un blocco di byte nel flusso di file.
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.
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. (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.
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.
WriteByte(Byte)	Scrive un byte nella posizione corrente all'interno del flusso di file.

Metodi di estensione

GetAccessControl(FileStream)	Restituisce le informazioni di sicurezza di un file.
SetAccessControl(FileStream, FileSecurity)	Modifica gli attributi di sicurezza di un file esistente.
ConfigureAwait(IAsyncDisposable, Boolean)	Consente di configurare la modalità di esecuzione delle espressioni await per le attività restituite da un elemento disposable asincrono.

Vedi anche

• File
• FileAccess
• FileMode
• FileShare
• I/O di file e flusso
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file
• Procedura: Leggere e scrivere su un file di dati appena creato