FileStream-Konstruktor (String, FileMode)

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

Namespace: System.IO
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Sub New ( _
    path As String, _
    mode As FileMode _
)
'Usage
Dim path As String
Dim mode As FileMode

Dim instance As New FileStream(path, mode)

public FileStream (
    string path,
    FileMode mode
)

public:
FileStream (
    String^ path, 
    FileMode mode
)

public FileStream (
    String path, 
    FileMode mode
)

public function FileStream (
    path : String, 
    mode : FileMode
)

Parameter

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

• mode
  Eine FileMode-Konstante, die bestimmt, auf welche Weise die Datei geöffnet oder erstellt werden soll.

Ausnahmen

Hinweise

In .NET Framework wird der direkte Zugriff auf physikalische Datenträger über Pfade, bei denen es sich um Gerätenamen handelt, z. B. "\\.\PHYSICALDRIVE0", nicht unterstützt.

Der path-Parameter kann ein Dateiname sein, u. a. eine Datei in einer UNC-Freigabe (Universal Naming Convention).

Der Konstruktor verfügt über Lese-/Schreibzugriff auf die Datei, und diese wird mit einer Freigabe für den Lesezugriff geöffnet (d. h., dass Anforderungen durch diesen oder einen anderen Prozess, die Datei für das Schreiben zu öffnen, fehlschlagen, bis das FileStream-Objekt geschlossen wird; Lesevorgänge sind jedoch möglich). Die Puffergröße wird auf die Standardgröße von 4096 Bytes (4 KB) festgelegt.

CanSeek ist für alle FileStream-Objekte true, die Dateien kapseln. Wenn path ein Gerät angibt, das Suchvorgänge nicht unterstützt, dann ist die CanSeek-Eigenschaft für den resultierenden FileStreamfalse. Weitere Informationen finden Sie unter CanSeek.

FileShare.Read ist der Standard für FileStream-Konstruktoren ohne FileShare-Parameter.

In der folgenden Tabelle sind Beispiele für andere typische oder verwandte E/A-Aufgaben aufgeführt.

Beispiel

Im folgenden Codebeispiel wird das byteweise Schreiben von Daten in eine Datei und das anschließende Überprüfen der geschriebenen Daten auf ihre Richtigkeit veranschaulicht.

Imports Microsoft.VisualBasic
Imports System
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

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

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

}

import System.*;
import System.IO.*;

class FStream
{   
    public static void main(String[] args)
    {
        final String fileName = "Test#@@#.dat";

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

        FileStream fileStream = new 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.get_Length();i++) {
                if ( dataArray[i] != fileStream.ReadByte()  ) {
                    Console.WriteLine("Error writing data.");
                    return;
                }
            } 
            Console.WriteLine("The data was written to {0} "
                + "and verified.", fileStream.get_Name());
        }
        finally {
            fileStream.Dispose();
        }        
    } //main
} //FStream

.NET Framework-Sicherheit

• FileIOPermission  für das Lesen, Schreiben und Anfügen von Dateien. Zugeordnete Enumerationen: FileIOPermissionAccess.Read, FileIOPermissionAccess.Write und FileIOPermissionAccess.Append.

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

FileStream-Klasse
FileStream-Member
System.IO-Namespace
InvalidPathChars

Weitere Ressourcen

Datei- und Stream-E/A
Gewusst wie: Lesen aus einer Textdatei
Gewusst wie: Schreiben von Text in eine Datei