FileStream-Klasse

Macht einen Stream um eine Datei verfügbar, wobei synchrone und asynchrone Lese- und Schreibvorgänge unterstützt werden.

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

Syntax

'Declaration
<ComVisibleAttribute(True)> _
Public Class FileStream
    Inherits Stream
'Usage
Dim instance As FileStream

[ComVisibleAttribute(true)] 
public class FileStream : Stream

[ComVisibleAttribute(true)] 
public ref class FileStream : public Stream

/** @attribute ComVisibleAttribute(true) */ 
public class FileStream extends Stream

ComVisibleAttribute(true) 
public class FileStream extends Stream

Hinweise

Verwenden Sie die FileStream-Klasse für den Schreib- und Lesezugriff auf Dateien in einem Dateisystem, zum Öffnen und Schließen dieser Dateien sowie zum Bearbeiten weiterer dateibezogener Betriebssystemhandles, z. B. Pipes, Standardeingaben und Standardausgaben. Sie können Lese- und Schreibvorgänge als synchrone oder asynchrone Operationen festlegen. FileStream puffert Eingaben und Ausgaben, um die Leistung zu verbessern.

FileStream-Objekte unterstützen unter Verwendung der Seek-Methode den wahlfreien Zugriff auf Dateien. Seek ermöglicht das Verschieben der Lese-/Schreibposition an eine beliebige Stelle in der Datei. Dies erfolgt durch Parameter für den Bezugspunkt des Byteoffset. Der Byteoffset bezieht sich auf den Bezugspunkt für die Suche. Dies kann der Anfang, die aktuelle Position oder das Ende der zugrunde liegenden Datei sein, wie durch die drei Eigenschaften der SeekOrigin-Klasse dargestellt.

Obwohl die synchronen Methoden Read und Write sowie die asynchronen Methoden BeginRead, BeginWrite, EndRead und EndWrite sowohl im synchronen als auch im asynchronen Modus verwendet werden können, wirkt sich der Modus auf die Leistung dieser Methoden aus. FileStream öffnet Dateien standardmäßig synchron, stellt jedoch zum asynchronen Öffnen von Dateien den FileStream(String,FileMode,FileAccess,FileShare,Int32,Boolean)-Konstruktor bereit.

Wenn ein Prozess mit einer teilweise gesperrten Datei beendet wird oder eine Datei mit ausstehenden Sperren schließt, ist das Verhalten nicht definiert.

Stellen Sie sicher, dass die Dispose-Methode für alle FileStream-Objekte aufgerufen wird, insbesondere in Umgebungen mit begrenztem Speicherplatz. Bei der Durchführung von E/A-Vorgängen kann eine Ausnahme ausgelöst werden, falls kein Speicherplatz verfügbar ist und falls die Dispose-Methode nicht vor der Finalisierung von FileStream aufgerufen wird.

Informationen zu Verzeichnis- und anderen Dateioperationen finden Sie unter den Klassen File, Directory und Path. Die File-Klasse ist eine Unterstützungsklasse mit statischen Methoden, die vorrangig zum Erstellen von FileStream-Objekten anhand von Dateipfaden und den Standardeingabe-, Standardausgabe- und Standardfehlergeräten eingesetzt werden. Die MemoryStream-Klasse erstellt einen Stream aus einem Bytearray und kann ähnlich wie FileStream verwendet werden.

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

Erkennung von Änderungen an der Streamposition

Wenn ein FileStream-Objekt keinen exklusiven Zugriff auf das Handle besitzt, kann gleichzeitig ein anderer Thread auf das Dateihandle zugreifen und die Position des vom Betriebssystem verwendeten Dateizeigers ändern, der diesem Dateihandle zugeordnet ist. Das kann dazu führen, dass die zwischengespeicherte Position im FileStream und die zwischengespeicherten Daten im Puffer manipuliert werden. Das FileStream-Objekt führt routinemäßig eine Prüfung aller Methoden aus, die auf den zwischengespeicherten Puffer zugreifen. Dadurch wird sichergestellt, dass die vom Betriebssystem verwendete Handleposition und die vom FileStream-Objekt verwendete zwischengespeicherte Position übereinstimmen.

Wenn beim Aufruf der Read-Methode eine unerwartete Änderung der Handleposition ermittelt wird, wird der Inhalt des Puffers von .NET Framework verworfen und der Stream erneut aus der Datei gelesen. Dies kann sich nicht nur auf die Leistung, sondern je nach Dateigröße und möglichen anderen Prozessen auch auf die Position des Dateistreams auswirken.

Wenn beim Aufruf der Write-Methode eine unerwartete Änderung der Handleposition ermittelt wird, wird der Inhalt des Puffers verworfen und eine IOException ausgelöst.

In folgenden Fällen besitzt ein FileStream-Objekt keinen exklusiven Zugriff auf das Handle: wenn auf die SafeFileHandle-Eigenschaft zugriffen wird, um das Handle verfügbar zu machen, oder wenn im Konstruktor des FileStream-Objekts die SafeFileHandle-Eigenschaft definiert wurde.

Beispiel

Im folgenden Beispiel werden einige der FileStream-Konstruktoren veranschaulicht.

Imports System
Imports System.IO
Imports System.Text

Public Class Test

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

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

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

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

        Dim i As Integer

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

            'Split the output at every 10th character.
            If Math.IEEERemainder(Convert.ToDouble(i), 10) = 0 Then
                AddText(fs, Environment.NewLine)
            End If
        Next

        fs.Close()

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

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

        fs.Close()
    End Sub

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

using System;
using System.IO;
using System.Text;

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

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

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

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

                //Split the output at every 10th character.
                if (Math.IEEERemainder(Convert.ToDouble(i), 10) == 0) 
                {
                    AddText(fs, "\r\n");
                }
            }
        }

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

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

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

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

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

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

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

class Test
{
    public static void main(String[] args)
    {
        String path = "c:\\temp\\MyTest.txt";

        // Delete the file if it exists.
        if (File.Exists(path)) {
            File.Delete(path);
        }
        
        //Create the file.
        {
            FileStream fs = File.Create(path);
            try {
                AddText(fs, "This is some text");
                AddText(fs, "This is some more text,");
                AddText(fs, "\r\nand this is on a new line");
                AddText(fs, 
                    "\r\n\r\nThe following is a subset of characters:\r\n");
                for (int i = 1; i < 120; i++) {
                    AddText(fs, System.Convert.ToString((char)i));

                    //Split the output at every 10th character.
                    if (Math.IEEEremainder(Convert.ToDouble(i), 10) == 0) {
                        AddText(fs, "\r\n");
                    }
                }
            }
            finally {
                fs.Dispose();
            }
        }
        //Open the stream and read it back.
        {
            FileStream fs = File.OpenRead(path);
            try {
                ubyte b[] = new ubyte[1024];
                UTF8Encoding temp = new UTF8Encoding(true);
                while (fs.Read(b, 0, b.length) > 0) {
                    Console.WriteLine(temp.GetString(b));
                }
            }
            finally {
                fs.Dispose();
            }
        }
    } //main

    private static void AddText(FileStream fs, String value)
    {
        ubyte info[] = (new UTF8Encoding(true)).GetBytes(value);
        fs.Write(info, 0, info.length);
    } //AddText
} //Test

Im folgenden Beispiel wird eine Datei geöffnet bzw. erstellt, sofern sie noch nicht vorhanden ist. Anschließend werden am Ende der Datei Informationen angefügt.

Imports System
Imports System.IO
Imports System.Text

Class FSOpenWrite

    Public Shared Sub Main()
        Dim fs As New FileStream("c:\Variables.txt", FileMode.Append, FileAccess.Write, FileShare.Write)
        fs.Close()
        Dim sw As New StreamWriter("c:\Variables.txt", True, Encoding.ASCII)
        Dim NextLine As String = "This is the appended text."
        sw.Write(NextLine)
        sw.Close()
    End Sub 'Main
End Class 'FSOpenWrite

using System;
using System.IO;
using System.Text;

class FSOpenWrite
{
    public static void Main()
    {
        FileStream fs=new FileStream("c:\\Variables.txt", FileMode.Append, FileAccess.Write, FileShare.Write);
        fs.Close();
        StreamWriter sw=new StreamWriter("c:\\Variables.txt", true, Encoding.ASCII);
        string NextLine="This is the appended line.";
        sw.Write(NextLine);
        sw.Close();
    }
}

using namespace System;
using namespace System::IO;
using namespace System::Text;
int main()
{
   FileStream^ fs = gcnew FileStream( "c:\\Variables.txt",FileMode::Append,FileAccess::Write,FileShare::Write );
   fs->Close();
   StreamWriter^ sw = gcnew StreamWriter( "c:\\Variables.txt",true,Encoding::ASCII );
   String^ NextLine = "This is the appended line.";
   sw->Write( NextLine );
   sw->Close();
}

Vererbungshierarchie

System.Object
   System.MarshalByRefObject
     System.IO.Stream
      System.IO.FileStream
         System.IO.IsolatedStorage.IsolatedStorageFileStream

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, 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-Member
System.IO-Namespace
File-Klasse
FileAccess-Enumeration
FileMode-Enumeration
FileShare-Enumeration

Weitere Ressourcen

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