FileStream Konstruktoren

Definition

Namespace:

System.IO

Assembly:

System.Runtime.dll

Initialisiert eine neue Instanz der FileStream-Klasse.

Überlädt

FileStream(SafeFileHandle, FileAccess)	Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle und mit der angegebenen Lese- und Schreibberechtigung.
FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)	Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung, die Zugriffsmöglichkeiten anderer FileStreams auf die gleiche Datei, die Puffergröße und zusätzliche Dateioptionen.
FileStream(String, FileMode, FileAccess, FileShare, Int32)	Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung sowie die Puffergröße.
FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)	Veraltet. Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung, den Besitz der FileStream-Instanz, die Puffergröße und den synchronen bzw. asynchronen Zustand.
FileStream(String, FileMode, FileAccess, FileShare)	Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung.
FileStream(IntPtr, FileAccess, Boolean, Int32)	Veraltet. Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung, den Besitz der FileStream-Instanz und die Puffergröße.
FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)	Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung, die Puffergröße und den synchronen bzw. asynchronen Zustand.
FileStream(String, FileMode, FileAccess)	Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus und die Lese-/Schreibberechtigung.
FileStream(IntPtr, FileAccess, Boolean)	Veraltet. Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung und für den Besitz der FileStream-Instanz.
FileStream(SafeFileHandle, FileAccess, Int32)	Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung und die Puffergröße.
FileStream(SafeFileHandle, FileAccess, Int32, Boolean)	Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung, die Puffergröße und den synchronen bzw. asynchronen Zustand.
FileStream(String, FileStreamOptions)	Initialisiert eine neue Instanz der -Klasse mit dem FileStream angegebenen Pfad, erstellungsmodus, Lese-/Schreib- und Freigabeberechtigung, Puffergröße, zusätzlichen Dateioptionen, Vorabspeicherungsgröße und dem Zugriff, den andere FileStreams auf dieselbe Datei haben können.
FileStream(String, FileMode)	Initialisiert eine neue Instanz der FileStream-Klasse mit dem angegebenen Pfad und dem angegebenen Erstellungsmodus.
FileStream(IntPtr, FileAccess)	Veraltet. Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle und mit der angegebenen Lese- und Schreibberechtigung.

FileStream(SafeFileHandle, FileAccess)

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle und mit der angegebenen Lese- und Schreibberechtigung.

public:
 FileStream(Microsoft::Win32::SafeHandles::SafeFileHandle ^ handle, System::IO::FileAccess access);

public FileStream (Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.IO.FileAccess access);

new System.IO.FileStream : Microsoft.Win32.SafeHandles.SafeFileHandle * System.IO.FileAccess -> System.IO.FileStream

Public Sub New (handle As SafeFileHandle, access As FileAccess)

Parameter

handle

SafeFileHandle

Ein Dateihandle für die Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die die Eigenschaften CanRead und CanWrite des FileStream-Objekts festlegen.

Ausnahmen

ArgumentException

access ist kein Feld von FileAccess.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

Wenn Close aufgerufen wird, wird das Handle ebenfalls geschlossen, und die Handleanzahl der Datei wird verringert.

FileStream setzt voraus, dass es die exklusive Kontrolle über den Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Datenbeschädigungen führen. Rufen Flush Sie aus Gründen der Datensicherheit vor der Verwendung des Handles auf, und vermeiden Sie das Aufrufen anderer Methoden als Close nach der Verwendung des Handles.

Achtung

Wenn Sie einen Zeichensatz mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne FileShare Parameter.

Eine Liste allgemeiner Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

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

Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung, die Zugriffsmöglichkeiten anderer FileStreams auf die gleiche Datei, die Puffergröße und zusätzliche Dateioptionen.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share, int bufferSize, System::IO::FileOptions options);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare * int * System.IO.FileOptions -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare, bufferSize As Integer, options As FileOptions)

Parameter

path

String

Ein relativer oder absoluter Pfad zu der Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

mode

FileMode

Einer der Enumerationswerte, der bestimmt, wie die Datei geöffnet oder erstellt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie vom FileStream-Objekt auf die Datei zugegriffen werden kann. Dies bestimmt ebenfalls die von den CanRead- und CanWrite-Eigenschaften des FileStream-Objekts zurückgegebenen Werte. CanSeek ist true, wenn path eine Datei auf einem Datenträger darstellt.

share

FileShare

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie die Datei von Prozessen gemeinsam verwendet wird.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

options

FileOptions

Eine bitweise Kombination der Enumerationswerte, die zusätzliche Dateioptionen angibt.

Ausnahmen

ArgumentNullException

path ist null.

ArgumentException

.NET Framework und .NET Core-Versionen älter als 2.1: path ist eine leere Zeichenfolge (""), die nur Leerzeichen enthält oder ein oder mehrere ungültige Zeichen enthält.

- oder -

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer NTFS-Umgebung.

NotSupportedException

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer Nicht-NTFS-Umgebung.

ArgumentOutOfRangeException

bufferSize ist negativ oder 0 (null).

- oder -

mode, access oder share enthält einen ungültigen Wert.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

UnauthorizedAccessException

Der angeforderte access für den angegebenen path wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und die Datei bzw. das Verzeichnis schreibgeschützt ist.

- oder -

Encrypted ist für options angegeben, aber Dateiverschlüsselung wird auf der aktuellen Plattform nicht unterstützt.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

Beispiele

Im folgenden Beispiel werden Daten in eine Datei geschrieben und dann mithilfe des FileStream -Objekts gelesen.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Security::AccessControl;

int main()
{
    try
    {
        // Create a file and write data to it.

        // Create an array of bytes.
        array<Byte>^ messageByte =
            Encoding::ASCII->GetBytes("Here is some data.");

        // Create a file using the FileStream class.
        FileStream^ fWrite = gcnew FileStream("test.txt", FileMode::Create,
            FileAccess::ReadWrite, FileShare::None, 8, FileOptions::None);

        // Write the number of bytes to the file.
        fWrite->WriteByte((Byte)messageByte->Length);

        // Write the bytes to the file.
        fWrite->Write(messageByte, 0, messageByte->Length);

        // Close the stream.
        fWrite->Close();


        // Open a file and read the number of bytes.

        FileStream^ fRead = gcnew FileStream("test.txt", 
            FileMode::Open);

        // The first byte is the string length.
        int length = (int)fRead->ReadByte();

        // Create a new byte array for the data.
        array<Byte>^ readBytes = gcnew array<Byte>(length);

        // Read the data from the file.
        fRead->Read(readBytes, 0, readBytes->Length);

        // Close the stream.
        fRead->Close();

        // Display the data.
        Console::WriteLine(Encoding::ASCII->GetString(readBytes));

        Console::WriteLine("Done writing and reading data.");
    }
    catch (IOException^ ex)
    {
        Console::WriteLine(ex->Message);
    }
}

using System;
using System.IO;
using System.Text;
using System.Security.AccessControl;

namespace FileSystemExample
{
    class FileStreamExample
    {
        public static void Main()
        {
            try
            {
                // Create a file and write data to it.

                // Create an array of bytes.
                byte[] messageByte = Encoding.ASCII.GetBytes("Here is some data.");

                // Create a file using the FileStream class.
                FileStream fWrite = new FileStream("test.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 8, FileOptions.None);

                // Write the number of bytes to the file.
                fWrite.WriteByte((byte)messageByte.Length);

                // Write the bytes to the file.
                fWrite.Write(messageByte, 0, messageByte.Length);

                // Close the stream.
                fWrite.Close();

                // Open a file and read the number of bytes.

                FileStream fRead = new FileStream("test.txt", FileMode.Open);

                // The first byte is the string length.
                int length = (int)fRead.ReadByte();

                // Create a new byte array for the data.
                byte[] readBytes = new byte[length];

                // Read the data from the file.
                fRead.Read(readBytes, 0, readBytes.Length);

                // Close the stream.
                fRead.Close();

                // Display the data.
                Console.WriteLine(Encoding.ASCII.GetString(readBytes));

                Console.WriteLine("Done writing and reading data.");
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            Console.ReadLine();
        }
    }
}

open System.IO
open System.Text

try
    // Create a file and write data to it.

    // Create an array of bytes.
    let messageByte = Encoding.ASCII.GetBytes "Here is some data."

    // Create a file using the FileStream class.
    let fWrite =
        new FileStream("test.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 8, FileOptions.None)

    // Write the number of bytes to the file.
    byte messageByte.Length |> fWrite.WriteByte

    // Write the bytes to the file.
    fWrite.Write(messageByte, 0, messageByte.Length)

    // Close the stream.
    fWrite.Close()

    // Open a file and read the number of bytes.

    let fRead = new FileStream("test.txt", FileMode.Open)

    // The first byte is the string length.
    let length = fRead.ReadByte() |> int

    // Create a new byte array for the data.
    let readBytes = Array.zeroCreate length

    // Read the data from the file.
    fRead.Read(readBytes, 0, readBytes.Length) |> ignore

    // Close the stream.
    fRead.Close()

    // Display the data.
    printfn $"{Encoding.ASCII.GetString readBytes}"

    printfn "Done writing and reading data."

with e ->
    printfn $"{e}"

Imports System.IO
Imports System.Text
Imports System.Security.AccessControl



Module FileStreamExample

    Sub Main()
        Try
            ' Create a file and write data to it.
            ' Create an array of bytes.
            Dim messageByte As Byte() = Encoding.ASCII.GetBytes("Here is some data.")

            ' Create a file using the FileStream class.
            Dim fWrite As New FileStream("test.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 8, FileOptions.None)

            ' Write the number of bytes to the file.
            fWrite.WriteByte(System.Convert.ToByte(messageByte.Length))

            ' Write the bytes to the file.
            fWrite.Write(messageByte, 0, messageByte.Length)

            ' Close the stream.
            fWrite.Close()


            ' Open a file and read the number of bytes.
            Dim fRead As New FileStream("test.txt", FileMode.Open)

            ' The first byte is the string length.
            Dim length As Integer = Fix(fRead.ReadByte())

            ' Create a new byte array for the data.
            Dim readBytes(length) As Byte

            ' Read the data from the file.
            fRead.Read(readBytes, 0, readBytes.Length)

            ' Close the stream.
            fRead.Close()

            ' Display the data.
            Console.WriteLine(Encoding.ASCII.GetString(readBytes))

            Console.WriteLine("Done writing and reading data.")
        Catch e As Exception
            Console.WriteLine(e)
        End Try

        Console.ReadLine()

    End Sub
End Module

Hinweise

Der .NET Framework unterstützt keinen direkten Zugriff auf physische Datenträger über Pfade, die Gerätenamen sind, z. B. "\\.\PHYSICALDRIVE0".

Der fileOptions Parameter wird verwendet, um Zugriff auf komplexere Vorgänge zu ermöglichen, die beim Erstellen eines FileStream Objekts genutzt werden können.

Der path Parameter kann ein Dateiname sein, einschließlich einer Datei auf einer UNC-Freigabe (Universal Naming Convention).

Hinweis

path ist nicht erforderlich, dass es sich um eine Datei handelt, die auf dem Datenträger gespeichert ist; Dies kann ein beliebiger Teil eines Systems sein, der den Zugriff über Streams unterstützt. Abhängig vom System kann diese Klasse beispielsweise auf ein physisches Gerät zugreifen.

CanSeek ist true für alle FileStream Objekte, die Dateien kapseln. Wenn path ein Gerät angibt, das die Suche nicht unterstützt, ist falsedie CanSeek -Eigenschaft für das resultierende FileStream . Weitere Informationen finden Sie unter CanSeek.

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

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

Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung sowie die Puffergröße.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share, int bufferSize);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare * int -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare, bufferSize As Integer)

Parameter

path

String

Ein relativer oder absoluter Pfad zu der Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

mode

FileMode

Einer der Enumerationswerte, der bestimmt, wie die Datei geöffnet oder erstellt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie vom FileStream-Objekt auf die Datei zugegriffen werden kann. Dies bestimmt ebenfalls die von den CanRead- und CanWrite-Eigenschaften des FileStream-Objekts zurückgegebenen Werte. CanSeek ist true, wenn path eine Datei auf einem Datenträger darstellt.

share

FileShare

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie die Datei von Prozessen gemeinsam verwendet wird.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

Ausnahmen

ArgumentNullException

path ist null.

ArgumentException

.NET Framework und .NET Core-Versionen älter als 2.1: path ist eine leere Zeichenfolge (""), die nur Leerzeichen enthält oder ein oder mehrere ungültige Zeichen enthält.

- oder -

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer NTFS-Umgebung.

NotSupportedException

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer Nicht-NTFS-Umgebung.

ArgumentOutOfRangeException

bufferSize ist negativ oder 0 (null).

- oder -

mode, access oder share enthält einen ungültigen Wert.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

UnauthorizedAccessException

Der angeforderte access für den angegebenen path wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und die Datei bzw. das Verzeichnis schreibgeschützt ist.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

Hinweise

Der .NET Framework unterstützt keinen direkten Zugriff auf physische Datenträger über Pfade, die Gerätenamen sind, z. B. "\\.\PHYSICALDRIVE0".

Der path Parameter kann ein Dateiname sein, einschließlich einer Datei auf einer UNC-Freigabe (Universal Naming Convention).

Hinweis

path ist nicht erforderlich, dass es sich um eine Datei handelt, die auf dem Datenträger gespeichert ist; Dies kann ein beliebiger Teil eines Systems sein, der den Zugriff über Streams unterstützt. Abhängig vom System kann diese Klasse beispielsweise auf ein physisches Gerät zugreifen.

CanSeek ist true für alle FileStream Objekte, die Dateien kapseln. Wenn path ein Gerät angibt, das die Suche nicht unterstützt, ist falsedie CanSeek -Eigenschaft für das resultierende FileStream . Weitere Informationen finden Sie unter CanSeek.

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

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

Achtung

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung, den Besitz der FileStream-Instanz, die Puffergröße und den synchronen bzw. asynchronen Zustand.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access, bool ownsHandle, int bufferSize, bool isAsync);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access, bool ownsHandle, int bufferSize, bool isAsync);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess * bool * int * bool -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess, ownsHandle As Boolean, bufferSize As Integer, isAsync As Boolean)

Parameter

handle

IntPtr

nativeint

Ein Dateihandle für die Datei, die von diesem FileStream-Objekt gekapselt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die die Eigenschaften CanRead und CanWrite des FileStream-Objekts festlegen.

ownsHandle

Boolean

true, wenn das Dateihandle im Besitz dieser FileStream-Instanz sein wird, andernfalls false.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

isAsync

Boolean

true, wenn das Handle asynchron geöffnet wurde (im überlappenden E/A-Modus), andernfalls false.

Attribute

ObsoleteAttribute

Ausnahmen

ArgumentOutOfRangeException

access ist kleiner als FileAccess.Read oder größer als FileAccess.ReadWrite oder bufferSize ist kleiner als oder gleich 0.

ArgumentException

Das Handle ist ungültig.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

Dem FileStream -Objekt wird der angegebene Zugriff auf die Datei gewährt. Der Besitz des Handles ist wie angegeben. Wenn dieses FileStream das Handle besitzt, wird durch einen Aufruf der Close -Methode auch das Handle geschlossen. Insbesondere wird die Handleanzahl der Datei verringert. Das FileStream -Objekt erhält die angegebene Puffergröße.

FileStream geht davon aus, dass es die exklusive Kontrolle über das Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Einer Datenbeschädigung führen. Rufen Flush Sie aus Gründen der Datensicherheit auf, bevor Sie das Handle verwenden, und vermeiden Sie den Aufruf anderer Methoden als Close nach der Verwendung des Handles. Alternativ können Sie das Handle lesen und in das Handle schreiben, bevor Sie diesen FileStream Konstruktor aufrufen.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne Parameter FileShare .

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(String, FileMode, FileAccess, FileShare)

Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare)

Parameter

path

String

Ein relativer oder absoluter Pfad zu der Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

mode

FileMode

Einer der Enumerationswerte, der bestimmt, wie die Datei geöffnet oder erstellt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie vom FileStream-Objekt auf die Datei zugegriffen werden kann. Dies bestimmt ebenfalls die von den CanRead- und CanWrite-Eigenschaften des FileStream-Objekts zurückgegebenen Werte. CanSeek ist true, wenn path eine Datei auf einem Datenträger darstellt.

share

FileShare

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie die Datei von Prozessen gemeinsam verwendet wird.

Ausnahmen

ArgumentNullException

path ist null.

ArgumentException

.NET Framework und .NET Core-Versionen älter als 2.1: path ist eine leere Zeichenfolge (""), die nur Leerzeichen enthält oder ein oder mehrere ungültige Zeichen enthält.

- oder -

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer NTFS-Umgebung.

NotSupportedException

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer Nicht-NTFS-Umgebung.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

UnauthorizedAccessException

Der angeforderte access für den angegebenen path wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und die Datei bzw. das Verzeichnis schreibgeschützt ist.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

ArgumentOutOfRangeException

mode enthält einen ungültigen Wert.

Beispiele

Dieses Codebeispiel ist Teil eines größeren Beispiels für die Lock -Methode.

FileStream^ fileStream = gcnew FileStream( "Test#@@#.dat",FileMode::OpenOrCreate,FileAccess::ReadWrite,FileShare::ReadWrite );

using(FileStream fileStream = new FileStream(
    "Test#@@#.dat", FileMode.OpenOrCreate,
    FileAccess.ReadWrite, FileShare.ReadWrite))

use fileStream =
    new FileStream("Test#@@#.dat", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)

Dim aFileStream As New FileStream( _
    "Test#@@#.dat", FileMode.OpenOrCreate, _
    FileAccess.ReadWrite, FileShare.ReadWrite)

Hinweise

Der .NET Framework unterstützt keinen direkten Zugriff auf physische Datenträger über Pfade, die Gerätenamen sind, z. B. "\\.\PHYSICALDRIVE0".

Der path Parameter kann ein Dateiname sein, einschließlich einer Datei auf einer UNC-Freigabe (Universal Naming Convention).

Der Konstruktor erhält Lese-/Schreibzugriff auf die Datei, und er wird freigegebenen Lesezugriff geöffnet (d. a. Anforderungen zum Öffnen der Datei zum Schreiben durch diesen oder einen anderen Prozess schlagen fehl, bis das FileStream Objekt geschlossen wurde, aber Leseversuche erfolgreich sind). Die Puffergröße ist auf die Standardgröße von 4.096 Bytes (4 KB) festgelegt.

Hinweis

path ist nicht erforderlich, dass es sich um eine Datei handelt, die auf dem Datenträger gespeichert ist; Dies kann ein beliebiger Teil eines Systems sein, der den Zugriff über Streams unterstützt. Abhängig vom System kann diese Klasse beispielsweise auf ein physisches Gerät zugreifen.

CanSeek ist true für alle FileStream Objekte, die Dateien kapseln. Wenn path ein Gerät angibt, das die Suche nicht unterstützt, ist falsedie CanSeek -Eigenschaft für das resultierende FileStream . Weitere Informationen finden Sie unter CanSeek.

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(IntPtr, FileAccess, Boolean, Int32)

Achtung

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung, den Besitz der FileStream-Instanz und die Puffergröße.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access, bool ownsHandle, int bufferSize);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access, bool ownsHandle, int bufferSize);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess * bool * int -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess, ownsHandle As Boolean, bufferSize As Integer)

Parameter

handle

IntPtr

nativeint

Ein Dateihandle für die Datei, die von diesem FileStream-Objekt gekapselt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die die Eigenschaften CanRead und CanWrite des FileStream-Objekts festlegen.

ownsHandle

Boolean

true, wenn das Dateihandle im Besitz dieser FileStream-Instanz sein wird, andernfalls false.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

Attribute

ObsoleteAttribute

Ausnahmen

ArgumentOutOfRangeException

bufferSize ist ein negativer Wert.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

Dem FileStream -Objekt wird der angegebene Zugriff auf die Datei gewährt. Der Besitz des Handles ist wie angegeben. Wenn dieses FileStream das Handle besitzt, wird durch einen Aufruf der Close -Methode auch das Handle geschlossen. Insbesondere wird die Handleanzahl der Datei verringert. Das FileStream -Objekt erhält die angegebene Puffergröße.

FileStream geht davon aus, dass es die exklusive Kontrolle über das Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Einer Datenbeschädigung führen. Rufen Flush Sie aus Gründen der Datensicherheit auf, bevor Sie das Handle verwenden, und vermeiden Sie den Aufruf anderer Methoden als Close nach der Verwendung des Handles. Alternativ können Sie das Handle lesen und in das Handle schreiben, bevor Sie diesen FileStream Konstruktor aufrufen.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne Parameter FileShare .

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

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

Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus, die Lese-/Schreib- und Freigabeberechtigung, die Puffergröße und den synchronen bzw. asynchronen Zustand.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share, int bufferSize, bool useAsync);

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

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare * int * bool -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess, share As FileShare, bufferSize As Integer, useAsync As Boolean)

Parameter

path

String

Ein relativer oder absoluter Pfad zu der Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

mode

FileMode

Einer der Enumerationswerte, der bestimmt, wie die Datei geöffnet oder erstellt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie vom FileStream-Objekt auf die Datei zugegriffen werden kann. Dies bestimmt ebenfalls die von den CanRead- und CanWrite-Eigenschaften des FileStream-Objekts zurückgegebenen Werte. CanSeek ist true, wenn path eine Datei auf einem Datenträger darstellt.

share

FileShare

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie die Datei von Prozessen gemeinsam verwendet wird.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

useAsync

Boolean

Gibt an, ob eine asynchrone E/A oder eine synchrone E/A verwendet wird. Beachten Sie jedoch, dass das zugrunde liegende Betriebssystem möglicherweise keine asynchrone E/A unterstützt, sodass das Handle je nach Plattform auch bei der Angabe von true möglicherweise synchron geöffnet wird. Bei asynchronem Öffnen liefern die BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)-Methode und die BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)-Methode bei umfangreichen Lese- oder Schreibvorgängen eine höhere Leistung, sind aber möglicherweise bei kleinen Lese- und Schreibvorgängen wesentlich langsamer. Wenn die Anwendung die Vorteile der asynchronen E/A nutzen kann, legen Sie den useAsync-Parameter auf true fest. Wird die asynchrone E/A richtig eingesetzt, können Anwendungen um ein Zehnfaches beschleunigt werden. Wenn die Anwendung jedoch nicht an eine asynchrone E/A angepasst wurde, kann dies die Leistung auch um das Zehnfache verringern.

Ausnahmen

ArgumentNullException

path ist null.

ArgumentException

.NET Framework und .NET Core-Versionen älter als 2.1: path ist eine leere Zeichenfolge (""), die nur Leerzeichen enthält oder ein oder mehrere ungültige Zeichen enthält.

- oder -

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer NTFS-Umgebung.

NotSupportedException

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer Nicht-NTFS-Umgebung.

ArgumentOutOfRangeException

bufferSize ist negativ oder 0 (null).

- oder -

mode, access oder share enthält einen ungültigen Wert.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

UnauthorizedAccessException

Der angeforderte access für den angegebenen path wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und die Datei bzw. das Verzeichnis schreibgeschützt ist.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Daten asynchron in eine Datei geschrieben und dann überprüft werden, ob die Daten ordnungsgemäß geschrieben wurden. Ein State -Objekt wird erstellt, um Informationen aus dem Hauptthread an die EndReadCallback Methoden und EndWriteCallback zu übergeben.

using namespace System;
using namespace System::IO;
using namespace System::Threading;

// Maintain state information to be passed to 
// EndWriteCallback and EndReadCallback.
ref class State
{
private:

   // fStream is used to read and write to the file.
   FileStream^ fStream;

   // writeArray stores data that is written to the file.
   array<Byte>^writeArray;

   // readArray stores data that is read from the file.
   array<Byte>^readArray;

   // manualEvent signals the main thread 
   // when verification is complete.
   ManualResetEvent^ manualEvent;

public:
   State( FileStream^ fStream, array<Byte>^writeArray, ManualResetEvent^ manualEvent )
   {
      this->fStream = fStream;
      this->writeArray = writeArray;
      this->manualEvent = manualEvent;
      readArray = gcnew array<Byte>(writeArray->Length);
   }


   property FileStream^ FStream 
   {
      FileStream^ get()
      {
         return fStream;
      }

   }

   property array<Byte>^ WriteArray 
   {
      array<Byte>^ get()
      {
         return writeArray;
      }

   }

   property array<Byte>^ ReadArray 
   {
      array<Byte>^ get()
      {
         return readArray;
      }

   }

   property ManualResetEvent^ ManualEvent 
   {
      ManualResetEvent^ get()
      {
         return manualEvent;
      }

   }

};

ref class FStream
{
private:

   // 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 = dynamic_cast<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();
   }


public:

   // 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 = dynamic_cast<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, gcnew AsyncCallback( &FStream::EndReadCallback ), tempState );
      
      // Concurrently do other work, such as 
      // logging the write operation.
   }

};


int main()
{
   
   // Create a synchronization object that gets 
   // signaled when verification is complete.
   ManualResetEvent^ manualEvent = gcnew ManualResetEvent( false );
   
   // Create the data to write to the file.
   array<Byte>^writeArray = gcnew array<Byte>(100000);
   (gcnew Random)->NextBytes( writeArray );
   FileStream^ fStream = gcnew 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 ? (String^)"" : "not " );
   
   // Asynchronously write to the file.
   IAsyncResult^ asyncResult = fStream->BeginWrite( writeArray, 0, writeArray->Length, gcnew AsyncCallback( &FStream::EndWriteCallback ), gcnew State( fStream,writeArray,manualEvent ) );
   
   // Concurrently do other work and then wait 
   // for the data to be written and verified.
   manualEvent->WaitOne( 5000, false );
}

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

open System
open System.IO
open System.Threading

// Maintain state information to be passed to
// EndWriteCallback and EndReadCallback.
type State(fStream: FileStream, writeArray: byte[], manualEvent: ManualResetEvent) =
    // readArray stores data that is read from the file.
    let readArray = Array.zeroCreate writeArray.Length

    member _.FStream = fStream
    member _.WriteArray = writeArray
    member _.ReadArray = readArray
    member _.ManualEvent = manualEvent

// 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.
let endReadCallback (asyncResult: IAsyncResult) =
    let tempState = asyncResult.AsyncState :?> State
    let readCount = tempState.FStream.EndRead asyncResult

    let mutable i = 0
    let mutable errored = false

    while i < readCount do
        if tempState.ReadArray[i] <> tempState.WriteArray[i] then
            printfn "Error writing data."
            tempState.FStream.Close()
            errored <- true
            i <- readCount

        i <- i + 1

    printfn $"The data was written to {tempState.FStream.Name} and verified."
    tempState.FStream.Close()
    // Signal the main thread that the verification is finished.
    tempState.ManualEvent.Set() |> ignore


// 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.
let endWriteCallback (asyncResult: IAsyncResult) =
    let tempState = asyncResult.AsyncState :?> State
    let fStream = tempState.FStream
    fStream.EndWrite asyncResult

    // Asynchronously read back the written data.
    fStream.Position <- 0

    let asyncResult =
        fStream.BeginRead(tempState.ReadArray, 0, tempState.ReadArray.Length, AsyncCallback endReadCallback, tempState)

    // Concurrently do other work, such as
    // logging the write operation.
    ()


// Create a synchronization object that gets
// signaled when verification is complete.
let manualEvent = new ManualResetEvent false

// Create random data to write to the file.
let writeArray = Array.zeroCreate 100000
Random.Shared.NextBytes writeArray

let fStream =
    new FileStream("Test#@@#.dat", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 4096, true)

// Check that the FileStream was opened asynchronously.

if fStream.IsAsync then "" else "not "
|> printfn "fStream was %sopened asynchronously."

// Asynchronously write to the file.
let asyncResult =
    fStream.BeginWrite(
        writeArray,
        0,
        writeArray.Length,
        AsyncCallback endWriteCallback,
        State(fStream, writeArray, manualEvent)
    )

// Concurrently do other work and then wait
// for the data to be written and verified.
manualEvent.WaitOne(5000, false) |> ignore

Imports System.IO
Imports System.Threading

Class FStream

    Shared Sub Main()

        ' Create a synchronization object that gets 
        ' signaled when verification is complete.
        Dim manualEvent As New ManualResetEvent(False)

        ' Create random data to write to the file.
        Dim writeArray(100000) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(writeArray)

        Dim fStream As New FileStream("Test#@@#.dat", _
            FileMode.Create, FileAccess.ReadWrite, _
            FileShare.None, 4096, True)

        ' Check that the FileStream was opened asynchronously.
        If fStream.IsAsync = True
            Console.WriteLine("fStream was opened asynchronously.")
        Else
            Console.WriteLine("fStream was not opened asynchronously.")
        End If

        ' Asynchronously write to the file.
        Dim asyncResult As IAsyncResult = fStream.BeginWrite( _
            writeArray, 0, writeArray.Length, _
            AddressOf 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)
    End Sub

    ' 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.
    Private Shared Sub EndWriteCallback(asyncResult As IAsyncResult)
        Dim tempState As State = _
            DirectCast(asyncResult.AsyncState, State)
        Dim fStream As FileStream = tempState.FStream
        fStream.EndWrite(asyncResult)

        ' Asynchronously read back the written data.
        fStream.Position = 0
        asyncResult = fStream.BeginRead( _ 
            tempState.ReadArray, 0 , tempState.ReadArray.Length, _
            AddressOf EndReadCallback, tempState)

        ' Concurrently do other work, such as 
        ' logging the write operation.
    End Sub

    ' 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.
   Private Shared Sub EndReadCallback(asyncResult As IAsyncResult)
        Dim tempState As State = _
            DirectCast(asyncResult.AsyncState, State)
        Dim readCount As Integer = _
            tempState.FStream.EndRead(asyncResult)

        Dim i As Integer = 0
        While(i < readCount)
            If(tempState.ReadArray(i) <> tempState.WriteArray(i))
                Console.WriteLine("Error writing data.")
                tempState.FStream.Close()
                Return
            End If
            i += 1
        End While

        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()
    End Sub

    ' Maintain state information to be passed to 
    ' EndWriteCallback and EndReadCallback.
    Private Class State

        ' fStreamValue is used to read and write to the file.
        Dim fStreamValue As FileStream

        ' writeArrayValue stores data that is written to the file.
        Dim writeArrayValue As Byte()

        ' readArrayValue stores data that is read from the file.
        Dim readArrayValue As Byte()

        ' manualEvent signals the main thread 
        ' when verification is complete.
        Dim manualEventValue As ManualResetEvent 

        Sub New(aStream As FileStream, anArray As Byte(), _
            manualEvent As ManualResetEvent)

            fStreamValue     = aStream
            writeArrayValue  = anArray
            manualEventValue = manualEvent
            readArrayValue   = New Byte(anArray.Length - 1){}
        End Sub    

            Public ReadOnly Property FStream() As FileStream
                Get
                    Return fStreamValue
                End Get
            End Property

            Public ReadOnly Property WriteArray() As Byte()
                Get
                    Return writeArrayValue
                End Get
            End Property

            Public ReadOnly Property ReadArray() As Byte()
                Get
                    Return readArrayValue
                End Get
            End Property

            Public ReadOnly Property ManualEvent() As ManualResetEvent
                Get
                    Return manualEventValue
                End Get
            End Property
    End Class 
   
End Class

Hinweise

Der .NET Framework unterstützt keinen direkten Zugriff auf physische Datenträger über Pfade, die Gerätenamen sind, z. B. "\\.\PHYSICALDRIVE0".

Der path Parameter kann ein Dateiname sein, einschließlich einer Datei auf einer UNC-Freigabe (Universal Naming Convention).

Hinweis

path ist nicht erforderlich, dass es sich um eine Datei handelt, die auf dem Datenträger gespeichert ist; Dies kann ein beliebiger Teil eines Systems sein, der den Zugriff über Streams unterstützt. Abhängig vom System kann diese Klasse beispielsweise auf ein physisches Gerät zugreifen.

CanSeek ist true für alle FileStream Objekte, die Dateien kapseln. Wenn path ein Gerät angibt, das die Suche nicht unterstützt, ist falsedie CanSeek -Eigenschaft für das resultierende FileStream . Weitere Informationen finden Sie unter CanSeek.

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• File
• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(String, FileMode, FileAccess)

Initialisiert eine neue Instanz der FileStream-Klasse mit den Angaben für den Pfad, den Erstellungsmodus und die Lese-/Schreibberechtigung.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access);

public FileStream (string path, System.IO.FileMode mode, System.IO.FileAccess access);

new System.IO.FileStream : string * System.IO.FileMode * System.IO.FileAccess -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode, access As FileAccess)

Parameter

path

String

Ein relativer oder absoluter Pfad zu der Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

mode

FileMode

Einer der Enumerationswerte, der bestimmt, wie die Datei geöffnet oder erstellt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die bestimmt, wie vom FileStream-Objekt auf die Datei zugegriffen werden kann. Dies bestimmt ebenfalls die von den CanRead- und CanWrite-Eigenschaften des FileStream-Objekts zurückgegebenen Werte. CanSeek ist true, wenn path eine Datei auf einem Datenträger darstellt.

Ausnahmen

ArgumentNullException

path ist null.

ArgumentException

.NET Framework und .NET Core-Versionen älter als 2.1: path ist eine leere Zeichenfolge (""), die nur Leerzeichen enthält oder ein oder mehrere ungültige Zeichen enthält.

- oder -

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer NTFS-Umgebung.

NotSupportedException

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer Nicht-NTFS-Umgebung.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

UnauthorizedAccessException

Der angeforderte access für den angegebenen path wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und die Datei bzw. das Verzeichnis schreibgeschützt ist.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

ArgumentOutOfRangeException

mode enthält einen ungültigen Wert.

Hinweise

Der .NET Framework unterstützt keinen direkten Zugriff auf physische Datenträger über Pfade, die Gerätenamen sind, z. B. "\\.\PHYSICALDRIVE0 ".

Der path Parameter kann ein Dateiname sein, einschließlich einer Datei auf einer UNC-Freigabe (Universal Naming Convention).

Der Konstruktor erhält Lese-/Schreibzugriff auf die Datei, und er wird geöffnet, um den Lesezugriff gemeinsam zu nutzen (d. a. Anforderungen zum Öffnen der Datei zum Schreiben durch diesen oder einen anderen Prozess schlagen fehl, bis das FileStream Objekt geschlossen wurde, aber Leseversuche erfolgreich sind). Die Puffergröße ist auf die Standardgröße von 4096 Bytes (4 KB) festgelegt.

Hinweis

path ist nicht erforderlich, um eine datei zu sein, die auf dem Datenträger gespeichert ist; Es kann sich um einen beliebigen Teil eines Systems sein, der den Zugriff über Streams unterstützt. Je nach System kann diese Klasse beispielsweise auf ein physisches Gerät zugreifen.

CanSeek ist true für alle FileStream Objekte, die Dateien kapseln. Wenn path ein Gerät angibt, das die Suche nicht unterstützt, ist falsedie CanSeek Eigenschaft für das resultierende FileStream . Weitere Informationen finden Sie unter CanSeek.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne FileShare Parameter.

Achtung

Wenn Sie einen Zeichensatz mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste allgemeiner Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(IntPtr, FileAccess, Boolean)

Achtung

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung und für den Besitz der FileStream-Instanz.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access, bool ownsHandle);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access, bool ownsHandle);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess * bool -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess, ownsHandle As Boolean)

Parameter

handle

IntPtr

nativeint

Ein Dateihandle für die Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die die Eigenschaften CanRead und CanWrite des FileStream-Objekts festlegen.

ownsHandle

Boolean

true, wenn das Dateihandle im Besitz dieser FileStream-Instanz sein wird, andernfalls false.

Attribute

ObsoleteAttribute

Ausnahmen

ArgumentException

access ist kein Feld von FileAccess.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

Dem FileStream -Objekt wird der angegebene Zugriff auf die Datei gewährt. Der Besitz des Handles ist wie angegeben. Wenn dieser Prozess den Handle besitzt, schließt ein Aufruf der Close -Methode auch das Handle, und die Handleanzahl der Datei wird verringert. Das FileStream Objekt erhält die Standardpuffergröße von 4096 Bytes.

FileStream setzt voraus, dass es die exklusive Kontrolle über den Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Datenbeschädigungen führen. Rufen Flush Sie aus Gründen der Datensicherheit vor der Verwendung des Handles auf, und vermeiden Sie das Aufrufen anderer Methoden als Close nach der Verwendung des Handles.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne FileShare Parameter.

Achtung

Wenn Sie einen Zeichensatz mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste allgemeiner Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(SafeFileHandle, FileAccess, Int32)

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung und die Puffergröße.

public:
 FileStream(Microsoft::Win32::SafeHandles::SafeFileHandle ^ handle, System::IO::FileAccess access, int bufferSize);

public FileStream (Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.IO.FileAccess access, int bufferSize);

new System.IO.FileStream : Microsoft.Win32.SafeHandles.SafeFileHandle * System.IO.FileAccess * int -> System.IO.FileStream

Public Sub New (handle As SafeFileHandle, access As FileAccess, bufferSize As Integer)

Parameter

handle

SafeFileHandle

Ein Dateihandle für die Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

access

FileAccess

Eine FileAccess-Konstante, die die CanRead- und CanWrite-Eigenschaften des FileStream-Objekts festlegt.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

Ausnahmen

ArgumentException

Der handle-Parameter ist ein ungültiges Handle.

- oder -

Der handle-Parameter ist ein synchrones Handle und wurde asynchron verwendet.

ArgumentOutOfRangeException

Der bufferSize-Parameter ist negativ.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

FileStream setzt voraus, dass es die exklusive Kontrolle über den Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Datenbeschädigungen führen. Rufen Flush Sie aus Gründen der Datensicherheit vor der Verwendung des Handles auf, und vermeiden Sie das Aufrufen anderer Methoden als Close nach der Verwendung des Handles. Alternativ können Sie lesen und in das Handle schreiben, bevor Sie diesen FileStream Konstruktor aufrufen.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne FileShare Parameter.

Achtung

Wenn Sie einen Zeichensatz mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste allgemeiner Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(SafeFileHandle, FileAccess, Int32, Boolean)

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle mit den Angaben für die Lese-/Schreibberechtigung, die Puffergröße und den synchronen bzw. asynchronen Zustand.

public:
 FileStream(Microsoft::Win32::SafeHandles::SafeFileHandle ^ handle, System::IO::FileAccess access, int bufferSize, bool isAsync);

public FileStream (Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.IO.FileAccess access, int bufferSize, bool isAsync);

new System.IO.FileStream : Microsoft.Win32.SafeHandles.SafeFileHandle * System.IO.FileAccess * int * bool -> System.IO.FileStream

Public Sub New (handle As SafeFileHandle, access As FileAccess, bufferSize As Integer, isAsync As Boolean)

Parameter

handle

SafeFileHandle

Ein Dateihandle für die Datei, die von diesem FileStream-Objekt gekapselt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die die Eigenschaften CanRead und CanWrite des FileStream-Objekts festlegen.

bufferSize

Int32

Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Die Standardpuffergröße ist 4096.

isAsync

Boolean

true, wenn das Handle asynchron geöffnet wurde (im überlappenden E/A-Modus), andernfalls false.

Ausnahmen

ArgumentException

Der handle-Parameter ist ein ungültiges Handle.

- oder -

Der handle-Parameter ist ein synchrones Handle und wurde asynchron verwendet.

ArgumentOutOfRangeException

Der bufferSize-Parameter ist negativ.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

Sie legen den isAsync Parameter auf fest true , um das Dateihandle asynchron zu öffnen. Wenn der Parameter ist true, verwendet der Stream überlappende E/A, um Dateivorgänge asynchron auszuführen. Der Parameter muss jedoch nicht seintrue, um die ReadAsync- oder WriteAsyncCopyToAsync -Methode aufzurufen. Wenn der isAsync Parameter ist false und Sie die asynchronen Lese- und Schreibvorgänge aufrufen, wird der UI-Thread weiterhin nicht blockiert, aber der tatsächliche E/A-Vorgang wird synchron ausgeführt.

FileStream setzt voraus, dass es die exklusive Kontrolle über den Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Datenbeschädigungen führen. Rufen Flush Sie aus Gründen der Datensicherheit vor der Verwendung des Handles auf, und vermeiden Sie das Aufrufen anderer Methoden als Close nach der Verwendung des Handles. Alternativ können Sie lesen und in das Handle schreiben, bevor Sie diesen FileStream Konstruktor aufrufen.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne FileShare Parameter.

Achtung

Wenn Sie einen Zeichensatz mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste allgemeiner Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(String, FileStreamOptions)

Initialisiert eine neue Instanz der FileStream -Klasse mit dem angegebenen Pfad, erstellungsmodus, Lese-/Schreib- und Freigabeberechtigung, Puffergröße, zusätzlichen Dateioptionen, Vorabspeicherungsgröße und dem Zugriff, den andere FileStreams auf dieselbe Datei haben können.

public:
 FileStream(System::String ^ path, System::IO::FileStreamOptions ^ options);

public FileStream (string path, System.IO.FileStreamOptions options);

new System.IO.FileStream : string * System.IO.FileStreamOptions -> System.IO.FileStream

Public Sub New (path As String, options As FileStreamOptions)

Parameter

path

String

Ein relativer oder absoluter Pfad für die Datei, die von der aktuellen FileStream Instanz gekapselt wird.

options

FileStreamOptions

Ein -Objekt, das die zu verwendenden optionalen FileStream Parameter beschreibt.

Ausnahmen

ArgumentNullException

path oder options ist null.

ArgumentException

path ist eine leere Zeichenfolge, enthält nur Leerzeichen oder enthält mindestens ein ungültiges Zeichen.

Oder

path bezieht sich auf ein Nicht-Dateigerät, z CON:. B. , COM1:oder LPT1:, in einer NTFS-Umgebung.

NotSupportedException

path bezieht sich auf ein Nicht-Dateigerät, z CON:. B. , COM1:, LPT1:usw. in einer Nicht-NTFS-Umgebung.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn Mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

Oder

Der Datenträger war voll (wenn PreallocationSize bereitgestellt wurde und path auf eine normale Datei verweist).

Oder

Die Datei war zu groß (wenn PreallocationSize bereitgestellt wurde und path auf eine normale Datei verweist).

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

UnauthorizedAccessException

Der angeforderte Access für den angegebenen path wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn Access auf Write oder ReadWrite festgelegt und die Datei bzw. das Verzeichnis schreibgeschützt ist.

- oder -

Encrypted wird für Options angegeben, aber die Dateiverschlüsselung wird auf der aktuellen Plattform nicht unterstützt.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

Hinweise

Die Angabe eines Werts für PreallocationSize bietet einen Hinweis auf die Größe der Vorabzuordnung, aber keine starke Garantie. Vollständige Nutzungsdetails finden Sie in der Dokumentation für PreallocationSize.

FileStream(String, FileMode)

Initialisiert eine neue Instanz der FileStream-Klasse mit dem angegebenen Pfad und dem angegebenen Erstellungsmodus.

public:
 FileStream(System::String ^ path, System::IO::FileMode mode);

public FileStream (string path, System.IO.FileMode mode);

new System.IO.FileStream : string * System.IO.FileMode -> System.IO.FileStream

Public Sub New (path As String, mode As FileMode)

Parameter

path

String

Ein relativer oder absoluter Pfad zu der Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

mode

FileMode

Einer der Enumerationswerte, der bestimmt, wie die Datei geöffnet oder erstellt wird.

Ausnahmen

ArgumentException

.NET Framework und .NET Core-Versionen älter als 2.1: path ist eine leere Zeichenfolge (""), die nur Leerzeichen enthält oder ein oder mehrere ungültige Zeichen enthält.

- oder -

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer NTFS-Umgebung.

NotSupportedException

path verweist auf ein Nicht-Datei-Gerät, etwa "con:", "com1:", "lpt1:" usw., in einer Nicht-NTFS-Umgebung.

ArgumentNullException

path ist null.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

FileNotFoundException

Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein.

UnauthorizedAccessException

path gibt eine schreibgeschützte Datei an.

IOException

Es ist ein E/A-Fehler aufgetreten, beispielsweise weil FileMode.CreateNew angegeben wurde, die durch path angegebene Datei aber bereits vorhanden ist.

- oder -

Der Stream wurde geschlossen.

DirectoryNotFoundException

Der angegebene Pfad ist ungültig, z. B. befindet er sich auf einem nicht zugeordneten Laufwerk.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

ArgumentOutOfRangeException

mode enthält einen ungültigen Wert.

Beispiele

Das folgende Codebeispiel zeigt, wie Daten in eine Datei geschrieben werden, byte byte, und dann überprüfen, ob die Daten ordnungsgemäß geschrieben wurden.

using namespace System;
using namespace System::IO;
int main()
{
   String^ fileName =  "Test@##@.dat";
   
   // Create random data to write to the file.
   array<Byte>^dataArray = gcnew array<Byte>(100000);
   (gcnew Random)->NextBytes( dataArray );
   FileStream^ fileStream = gcnew FileStream( fileName,FileMode::Create );
   try
   {
      
      // Write the data to the file, byte by byte.
      for ( int i = 0; i < dataArray->Length; i++ )
      {
         fileStream->WriteByte( dataArray[ i ] );

      }
      
      // Set the stream position to the beginning of the file.
      fileStream->Seek( 0, SeekOrigin::Begin );
      
      // Read and verify the data.
      for ( int i = 0; i < fileStream->Length; i++ )
      {
         if ( dataArray[ i ] != fileStream->ReadByte() )
         {
            Console::WriteLine( "Error writing data." );
            return  -1;
         }

      }
      Console::WriteLine( "The data was written to {0} "
      "and verified.", fileStream->Name );
   }
   finally
   {
      fileStream->Close();
   }

}

using System;
using System.IO;

class FStream
{
    static void Main()
    {
        const string fileName = "Test#@@#.dat";

        // Create random data to write to the file.
        byte[] dataArray = new byte[100000];
        new Random().NextBytes(dataArray);

        using(FileStream
            fileStream = new FileStream(fileName, FileMode.Create))
        {
            // Write the data to the file, byte by byte.
            for(int i = 0; i < dataArray.Length; i++)
            {
                fileStream.WriteByte(dataArray[i]);
            }

            // Set the stream position to the beginning of the file.
            fileStream.Seek(0, SeekOrigin.Begin);

            // Read and verify the data.
            for(int i = 0; i < fileStream.Length; i++)
            {
                if(dataArray[i] != fileStream.ReadByte())
                {
                    Console.WriteLine("Error writing data.");
                    return;
                }
            }
            Console.WriteLine("The data was written to {0} " +
                "and verified.", fileStream.Name);
        }
    }
}

open System
open System.IO


let fileName = "Test#@@#.dat"

// Create random data to write to the file.
let dataArray = Array.zeroCreate 100000
Random.Shared.NextBytes dataArray

do
    use fileStream = new FileStream(fileName, FileMode.Create)
    // Write the data to the file, byte by byte.
    for i = 0 to dataArray.Length - 1 do
        fileStream.WriteByte dataArray[i]

    // Set the stream position to the beginning of the file.
    fileStream.Seek(0, SeekOrigin.Begin) |> ignore

    // Read and verify the data.
    for i in 0L .. fileStream.Length - 1L do
        if dataArray[int i] <> (fileStream.ReadByte() |> byte) then
            printfn "Error writing data."
            exit 1

    printfn $"The data was written to {fileStream.Name} and verified."

Imports System.IO
Imports System.Text

Class FStream

    Shared Sub Main()

        Const fileName As String = "Test#@@#.dat"

        ' Create random data to write to the file.
        Dim dataArray(100000) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(dataArray)

        Dim fileStream As FileStream = _
            new FileStream(fileName, FileMode.Create)
        Try

            ' Write the data to the file, byte by byte.
            For i As Integer = 0 To dataArray.Length - 1
                fileStream.WriteByte(dataArray(i))
            Next i

            ' Set the stream position to the beginning of the stream.
            fileStream.Seek(0, SeekOrigin.Begin)

            ' Read and verify the data.
            For i As Integer = 0 To _
                CType(fileStream.Length, Integer) - 1

                If dataArray(i) <> fileStream.ReadByte() Then
                    Console.WriteLine("Error writing data.")
                    Return
                End If
            Next i
            Console.WriteLine("The data was written to {0} " & _
                "and verified.", fileStream.Name)
        Finally
            fileStream.Close()
        End Try
    
    End Sub
End Class

Hinweise

Der .NET Framework unterstützt keinen direkten Zugriff auf physische Datenträger über Pfade, die Gerätenamen sind, z. B. "\\.\PHYSICALDRIVE0".

Der path Parameter kann ein Dateiname sein, einschließlich einer Datei auf einer UNC-Freigabe (Universal Naming Convention).

Der Konstruktor erhält Lese-/Schreibzugriff auf die Datei, und er wird freigegebenen Lesezugriff geöffnet (d. a. Anforderungen zum Öffnen der Datei zum Schreiben durch diesen oder einen anderen Prozess schlagen fehl, bis das FileStream Objekt geschlossen wurde, aber Leseversuche erfolgreich sind).

Sie können diesen Konstruktor nicht verwenden, um schreibgeschützte Dateien zu öffnen. Stattdessen müssen Sie einen Konstruktor verwenden, der einen FileAccess Parameter akzeptiert, dessen Wert auf FileAccess.Readfestgelegt ist.

Die Puffergröße ist auf die Standardgröße von 4.096 Bytes (4 KB) festgelegt.

Hinweis

path ist nicht erforderlich, dass es sich um eine Datei handelt, die auf dem Datenträger gespeichert ist; Dies kann ein beliebiger Teil eines Systems sein, der den Zugriff über Streams unterstützt. Abhängig vom System kann diese Klasse beispielsweise auf ein physisches Gerät zugreifen.

CanSeek ist true für alle FileStream Objekte, die Dateien kapseln. Wenn path ein Gerät angibt, das die Suche nicht unterstützt, ist falsedie CanSeek -Eigenschaft für das resultierende FileStream . Weitere Informationen finden Sie unter CanSeek.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne Parameter FileShare .

Bei Konstruktoren ohne Parameter FileAccess ist der Standardzugriff der Standardzugriff, wenn der mode Parameter auf AppendWrite festgelegt ist. Andernfalls wird der Zugriff auf ReadWritefestgelegt.

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• InvalidPathChars
• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei

FileStream(IntPtr, FileAccess)

Achtung

This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.

Initialisiert eine neue Instanz der FileStream-Klasse für das angegebene Dateihandle und mit der angegebenen Lese- und Schreibberechtigung.

public:
 FileStream(IntPtr handle, System::IO::FileAccess access);

[System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.")]
public FileStream (IntPtr handle, System.IO.FileAccess access);

[<System.Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.")>]
new System.IO.FileStream : nativeint * System.IO.FileAccess -> System.IO.FileStream

Public Sub New (handle As IntPtr, access As FileAccess)

Parameter

handle

IntPtr

nativeint

Ein Dateihandle für die Datei, die vom aktuellen FileStream-Objekt gekapselt wird.

access

FileAccess

Eine bitweise Kombination der Enumerationswerte, die die Eigenschaften CanRead und CanWrite des FileStream-Objekts festlegen.

Attribute

ObsoleteAttribute

Ausnahmen

ArgumentException

access ist kein Feld von FileAccess.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

IOException

Ein E/A-Fehler, z. B. ein Datenträgerfehler, ist aufgetreten.

- oder -

Der Stream wurde geschlossen.

UnauthorizedAccessException

Der angeforderte access für das angegebene Dateihandle wird vom Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn access auf Write oder ReadWrite festgelegt und das Dateihandle schreibgeschützt ist.

Hinweise

Wenn Close aufgerufen wird, wird auch das Handle geschlossen, und die Handleanzahl der Datei wird verringert.

FileStream geht davon aus, dass es die exklusive Kontrolle über das Handle hat. Lesen, Schreiben oder Suchen, während ein FileStream ebenfalls ein Handle enthält, kann zu Einer Datenbeschädigung führen. Rufen Flush Sie aus Gründen der Datensicherheit auf, bevor Sie das Handle verwenden, und vermeiden Sie den Aufruf anderer Methoden als Close nach der Verwendung des Handles.

Achtung

Wenn Sie eine Reihe von Zeichen mit einer bestimmten kulturellen Einstellung kompilieren und dieselben Zeichen mit einer anderen kulturellen Einstellung abrufen, sind die Zeichen möglicherweise nicht interpretierbar und können eine Ausnahme auslösen.

FileShare.Read ist die Standardeinstellung für diese FileStream Konstruktoren ohne Parameter FileShare .

Eine Liste der allgemeinen Datei- und Verzeichnisvorgänge finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

• Datei- und Stream-E/A
• How to: Lesen von Text aus einer Datei
• How to: Schreiben von Text in eine Datei