FileStream-Konstruktor (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.
Namespace: System.IO
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public Sub New ( _
path As String, _
mode As FileMode, _
access As FileAccess, _
share As FileShare, _
bufferSize As Integer, _
useAsync As Boolean _
)
'Usage
Dim path As String
Dim mode As FileMode
Dim access As FileAccess
Dim share As FileShare
Dim bufferSize As Integer
Dim useAsync As Boolean
Dim instance As New FileStream(path, mode, access, share, bufferSize, useAsync)
public FileStream (
string path,
FileMode mode,
FileAccess access,
FileShare share,
int bufferSize,
bool useAsync
)
public:
FileStream (
String^ path,
FileMode mode,
FileAccess access,
FileShare share,
int bufferSize,
bool useAsync
)
public FileStream (
String path,
FileMode mode,
FileAccess access,
FileShare share,
int bufferSize,
boolean useAsync
)
public function FileStream (
path : String,
mode : FileMode,
access : FileAccess,
share : FileShare,
bufferSize : int,
useAsync : boolean
)
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.
- access
Eine FileAccess-Konstante, die bestimmt, welcher Zugriff auf die Datei für das FileStream-Objekt zulässig ist. Dies ruft die CanRead-Eigenschaft und die CanWrite-Eigenschaft des FileStream-Objekts ab. CanSeek ist true, wenn path eine Datenträgerdatei angibt.
- share
Eine FileShare-Konstante zur Bestimmung der Art, in der Prozesse gemeinsam auf die Datei zugreifen.
- bufferSize
Ein positiver Int32-Wert größer als 0 (null), der die Puffergröße angibt. Bei bufferSize-Werten zwischen 0 (null) und 8 wird die tatsächliche Puffergröße auf 8 Bytes festgelegt.
- useAsync
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-Methode und die BeginWrite-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
| Ausnahmetyp | Bedingung |
|---|---|
path ist NULL (Nothing in Visual Basic). |
|
path ist eine leere Zeichenfolge (""), die nur Leerraum oder mindestens ein ungültiges Zeichen enthält. - oder - path verweist auf ein Gerät, das keine Datei ist, z. B. "con:", "com1:", "lpt1:" usw. in einer NTFS-Umgebung. |
|
path verweist auf ein Gerät, das keine Datei ist, z. B. "con:", "com1:", "lpt1:" usw. in einer Nicht-NTFS-Umgebung. |
|
ArgumentException |
path ist eine leere Zeichenfolge (""), die nur Leerraum oder mindestens ein ungültiges Zeichen enthält. |
bufferSize ist negativ oder 0 (null). - oder - mode, access oder share enthalten einen ungültigen Wert. |
|
Die Datei kann nicht gefunden werden. Dies ist z. B. der Fall, wenn mode auf FileMode.Truncate oder FileMode.Open festgelegt wurde und die durch path angegebene Datei nicht vorhanden ist. Die Datei muss bereits in diesen Modi vorhanden sein. |
|
Es ist ein E/A-Fehler aufgetreten, beispielsweise wurde FileMode.CreateNew angegeben, und die durch path angegebene Datei ist bereits vorhanden. - oder - Das System führt Windows 98 oder Windows 98 SE aus, und share ist auf FileShare.Delete festgelegt. - oder - Der Stream wurde geschlossen. |
|
Der Aufrufer verfügt nicht über die erforderliche Berechtigung. |
|
Der angegebene Pfad ist ungültig. Dies ist z. B. der Fall, wenn das Laufwerk des Pfads nicht zugeordnet ist. |
|
Der angeforderte access für den angegebenen path wird durch das Betriebssystem nicht zugelassen. Dies ist z. B. der Fall, wenn Write oder ReadWrite für access festgelegt ist, die Datei bzw. das Verzeichnis jedoch schreibgeschützt ist. |
|
Der angegebene Pfad und/oder der Dateiname überschreiten die vom System vorgegebene Höchstlänge. Beispielsweise dürfen auf Windows-Plattformen Pfade nicht länger als 247 Zeichen und Dateinamen nicht länger als 259 Zeichen sein. |
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 (Universal Naming Convention)-Freigabe.
Hinweis
path muss keine Datei sein, die auf der Festplatte gespeichert ist. Es kann ein beliebiger Teil eines Systems sein, das den Zugriff über Streams unterstützt. Je nach System kann diese Klasse z. B. auf ein physikalisches Gerät zugreifen.
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 hierzu finden Sie unter CanSeek.
Warnung
Wenn Sie einen Zeichensatz mit einer bestimmten Kultureinstellung kompilieren und die gleichen Zeichen mit einer anderen Kultureinstellung abrufen, können diese möglicherweise nicht interpretiert werden, und es wird eine Ausnahme ausgelöst.
In der folgenden Tabelle sind Beispiele für andere typische oder verwandte E/A-Aufgaben aufgeführt.
Aufgabe |
Beispiel in diesem Thema |
|---|---|
Eine Textdatei erstellen. |
|
In eine Textdatei schreiben. |
|
Aus einer Textdatei lesen. |
|
Text an eine Datei anfügen. |
|
Eine Datei umbenennen oder verschieben. |
|
Eine Datei löschen. |
|
Eine Datei kopieren. |
|
Die Größe einer Datei abrufen. |
|
Die Attribute einer Datei abrufen. |
|
Die Attribute einer Datei festlegen. |
|
Bestimmen, ob eine Datei vorhanden ist. |
|
Aus einer Binärdatei lesen. |
Gewusst wie: Lesen und Schreiben einer neu erstellten Datendatei |
In eine Binärdatei schreiben. |
Gewusst wie: Lesen und Schreiben einer neu erstellten Datendatei |
Abrufen einer Dateierweiterung. |
|
Abrufen des vollqualifizierten Pfads einer Datei. |
|
Abrufen des Dateinamens sowie der Dateierweiterung aus einem Pfad. |
|
Ändern der Erweiterung einer Datei. |
Beispiel
Das folgende Codebeispiel veranschaulicht das asynchrone Schreiben von Daten in eine Datei und das anschließende Überprüfen der geschriebenen Daten auf ihre Richtigkeit. Ein State-Objekt wird erstellt, um Informationen aus dem Hauptthread an die EndReadCallback-Methode und die EndWriteCallback-Methode zu übergeben.
Imports System
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
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; } }
}
}
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 );
}
import System.*;
import System.IO.*;
import System.Threading.*;
class FStream
{
public static void main(String[] args)
{
// Create a synchronization object that gets
// signaled when verification is complete.
ManualResetEvent manualEvent = new ManualResetEvent(false);
// Create random data to write to the file.
ubyte writeArray[] = new ubyte[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.get_IsAsync()) ? "" : "not ");
FStream classfStream = new FStream();
// Asynchronously write to the file.
IAsyncResult asyncResult = fStream.BeginWrite(writeArray, 0,
writeArray.length, new AsyncCallback(EndWriteCallback),
classfStream.new State(fStream, writeArray, manualEvent));
// Concurrently do other work and then wait
// for the data to be written and verified.
manualEvent.WaitOne(5000, false);
} //main
// 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.get_AsyncState()));
FileStream fStream = tempState.get_FStream();
fStream.EndWrite(asyncResult);
// Asynchronously read back the written data.
fStream.set_Position(0);
asyncResult = fStream.BeginRead(tempState.get_ReadArray(), 0,
tempState.get_ReadArray().length ,
new AsyncCallback(EndReadCallback), tempState);
// Concurrently do other work, such as
// logging the write operation.
} //EndWriteCallback
// 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.get_AsyncState()));
int readCount = tempState.get_FStream().EndRead(asyncResult);
int i = 0;
while((i < readCount)) {
if ( tempState.get_ReadArray()[i] !=
tempState.get_WriteArray()[i++] ) {
Console.WriteLine("Error writing data.");
tempState.get_FStream().Close();
return;
}
}
Console.WriteLine("The data was written to {0} and verified.",
tempState.get_FStream().get_Name());
tempState.get_FStream().Close();
// Signal the main thread that the verification is finished.
tempState.get_ManualEvent().Set();
} //EndReadCallback
// Maintain state information to be passed to
// EndWriteCallback and EndReadCallback.
class State
{
// fStream is used to read and write to the file.
private FileStream fStream;
// writeArray stores data that is written to the file.
private ubyte writeArray[];
// readArray stores data that is read from the file.
private ubyte readArray[];
// manualEvent signals the main thread
// when verification is complete.
private ManualResetEvent manualEvent;
public State(FileStream fStream, ubyte writeArray[],
ManualResetEvent manualEvent)
{
this.fStream = fStream;
this.writeArray = writeArray;
this.manualEvent = manualEvent;
readArray = new ubyte[writeArray.length ];
} //State
/** @property
*/
public FileStream get_FStream()
{
return fStream ;
}//get_FStream
/** @property
*/
public ubyte[] get_WriteArray()
{
return writeArray ;
}//get_WriteArray
/** @property
*/
public ubyte[] get_ReadArray()
{
return readArray;
}//get_ReadArray
/** @property
*/
public ManualResetEvent get_ManualEvent()
{
return manualEvent;
}//get_ManualEvent
} //State
} //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
File-Klasse
Weitere Ressourcen
Datei- und Stream-E/A
Gewusst wie: Lesen aus einer Textdatei
Gewusst wie: Schreiben von Text in eine Datei