FileStream Classe

Definizione

Spazio dei nomi:

System.IO

Assembly:

System.Runtime.dll

Origine:

FileStream.cs

Fornisce un Stream per un file, che supporta sia operazioni di lettura e scrittura sincrone che 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 costruttori di FileStream.

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 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 sull'API supplementare 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 specificata e FileStream proprietà dell'istanza.
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 specificata, FileStream proprietà dell'istanza e le dimensioni del buffer.
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 specificata, FileStream proprietà dell'istanza, le dimensioni del buffer e lo stato sincrono o asincrono.
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 specificata e le dimensioni del buffer.
FileStream(SafeFileHandle, FileAccess, Int32, Boolean)	Inizializza una nuova istanza della classe FileStream per l'handle di file specificato, con l'autorizzazione di lettura/scrittura specificata, le dimensioni del buffer e lo stato sincrono o asincrono.
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 le dimensioni 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, le dimensioni del buffer e lo stato sincrono o asincrono.
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 ad altri fileStream può avere sullo stesso file, sulle dimensioni del buffer e sulle opzioni aggiuntive del file.
FileStream(String, FileStreamOptions)	Inizializza una nuova istanza della classe FileStream 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 della 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 può verificarsi un 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 corrente.
IsAsync	Ottiene un valore che indica se il FileStream è stato aperto in modo asincrono o sincrono.
Length	Ottiene la lunghezza in byte del flusso.
Name	Ottiene il percorso assoluto del file aperto nel FileStream.
Position	Ottiene o imposta la posizione corrente del flusso.
ReadTimeout	Ottiene o imposta un valore, espresso in millisecondi, che determina per quanto tempo il flusso tenterà di leggere 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, espresso in millisecondi, che determina per quanto tempo il flusso tenterà di scrivere prima del timeout. (Ereditato da Stream)

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di lettura asincrona. È consigliabile usare invece ReadAsync(Byte[], Int32, Int32, CancellationToken).
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di scrittura asincrona. È consigliabile usare invece WriteAsync(Byte[], Int32, Int32, CancellationToken).
Close()	Chiude il flusso corrente e rilascia tutte le risorse (ad esempio socket e handle di file) associate al flusso corrente. Invece di 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 i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del 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 i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del 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 del buffer e un token di annullamento specificati.
CreateObjRef(Type)	Crea un oggetto che contiene tutte le informazioni pertinenti necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleti. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate dal Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate dal FileStream e, facoltativamente, rilascia le risorse gestite.
DisposeAsync()	Rilascia in modo asincrono le risorse non gestite usate dal FileStream.
EndRead(IAsyncResult)	Attende il completamento dell'operazione di lettura asincrona in sospeso. Prendere invece in considerazione l'uso di ReadAsync(Byte[], Int32, Int32, CancellationToken).
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona e blocca fino al completamento dell'operazione di I/O. Prendere invece in considerazione l'uso di WriteAsync(Byte[], Int32, Int32, CancellationToken).
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Finalize()	Assicura che le risorse vengano liberate e che vengano eseguite altre operazioni di pulizia quando il Garbage Collector recupera il FileStream.
Flush()	Cancella i buffer per questo flusso e fa in modo che tutti i dati memorizzati nel buffer vengano scritti nel file.
Flush(Boolean)	Cancella i buffer per questo flusso e determina la scrittura di tutti i dati memorizzati nel buffer nel file e cancella anche tutti i buffer di file intermedi.
FlushAsync()	Cancella in modo asincrono tutti i buffer per questo flusso e determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da Stream)
FlushAsync(CancellationToken)	Cancella in modo asincrono tutti i buffer per questo flusso, determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene il 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 nel FileStream.
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Obsoleti. Fornisce il supporto per un 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 sposta in avanti la posizione all'interno del flusso di file in base al numero di byte letti.
ReadAsync(Byte[], Int32, Int32)	Legge in modo asincrono una sequenza 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)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso di file corrente e le scrive in una matrice di byte a partire da un offset specificato, sposta in avanti 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, sposta in avanti 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 la posizione di lettura un byte.
ReadExactly(Byte[], Int32, Int32)	Legge count 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 il buffer non viene riempito. (Ereditato da Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono count 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 il buffer non viene riempito e monitora le richieste di annullamento. (Ereditato da Stream)
Seek(Int64, SeekOrigin)	Imposta la posizione corrente del flusso sul valore specificato.
SetLength(Int64)	Imposta la lunghezza del flusso sul valore specificato.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Unlock(Int64, Int64)	Consente l'accesso da parte di altri processi a tutti o a una parte di un 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 corrente all'interno del 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 sposta in avanti la posizione corrente all'interno del 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, sposta in avanti la posizione corrente all'interno del flusso 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, sposta in avanti la posizione corrente all'interno del flusso di file in base al numero di byte scritti e monitora le richieste di annullamento.
WriteByte(Byte)	Scrive un byte nella posizione corrente nel 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.
CopyToAsync(Stream, PipeWriter, CancellationToken)	Legge in modo asincrono i byte dal Stream e li scrive nel PipeWriterspecificato usando un token di annullamento.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura il modo in cui verranno eseguite le attese nelle attività restituite da un oggetto eliminabile asincrono.

Vedi anche

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