C# Language
Strom

Streams verwenden

Ein Stream ist ein Objekt, das eine einfache Übertragung von Daten ermöglicht. Sie selbst fungieren nicht als Datencontainer.

Die Daten, mit denen wir arbeiten, haben die Form eines Byte-Arrays ( byte [] ). Die Funktionen zum Lesen und Schreiben sind alle byteorientiert, zB WriteByte() .

Es gibt keine Funktionen für den Umgang mit ganzen Zahlen, Strings usw. Dies macht den Stream sehr universell, aber weniger einfach zu handhaben, wenn Sie beispielsweise nur Text übertragen möchten. Streams können besonders hilfreich sein, wenn Sie mit großen Datenmengen arbeiten.

Wir müssen verschiedene Arten von Streams verwenden, von denen aus geschrieben / gelesen werden muss (z. B. der Hintergrundspeicher). Wenn die Quelle beispielsweise eine Datei ist, müssen wir FileStream :

string filePath = @"c:\Users\exampleuser\Documents\userinputlog.txt";
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    // do stuff here...

    fs.Close();
}

In ähnlicher Weise wird MemoryStream verwendet, wenn der Sicherungsspeicher Arbeitsspeicher ist:

// Read all bytes in from a file on the disk.
byte[] file = File.ReadAllBytes(“C:\\file.txt”);

// Create a memory stream from those bytes.
using (MemoryStream memory = new MemoryStream(file))
{
   // do stuff here...
}

In ähnlicher Weise wird System.Net.Sockets.NetworkStream für den Netzwerkzugriff verwendet.

Alle Streams werden von der generischen Klasse System.IO.Stream . Daten können nicht direkt aus Streams gelesen oder geschrieben werden. Das .NET Framework bietet StreamReader wie StreamReader , StreamWriter , BinaryReader und BinaryWriter , die zwischen BinaryWriter Typen und der Low-Level-Stream-Schnittstelle konvertieren und die Daten für Sie in den oder aus dem Stream übertragen.

Das Lesen und Schreiben von Streams kann über StreamReader und StreamWriter . Beim Schließen sollte man vorsichtig sein. Standardmäßig wird auch der enthaltene Stream geschlossen und für die weitere Verwendung unbrauchbar. Dieses Standardverhalten kann geändert werden, indem ein Konstruktor verwendet wird, der über bool leaveOpen Parameter bool leaveOpen und seinen Wert auf true .

StreamWriter :

FileStream fs = new FileStream("sample.txt", FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
string NextLine = "This is the appended line.";
sw.Write(NextLine);
sw.Close();
//fs.Close(); There is no need to close fs. Closing sw will also close the stream it contains.

StreamReader :

using (var ms = new MemoryStream())
{
    StreamWriter sw = new StreamWriter(ms);
    sw.Write(123);
    //sw.Close();     This will close ms and when we try to use ms later it will cause an exception
    sw.Flush();     //You can send the remaining data to stream. Closing will do this automatically
    // We need to set the position to 0 in order to read 
    // from the beginning.
    ms.Position = 0;
    StreamReader sr = new StreamReader(ms);
    var myStr = sr.ReadToEnd();
    sr.Close();
    ms.Close();
}

Da Klassen Stream , StreamReader , StreamWriter usw. die IDisposable Schnittstelle implementieren, können wir die Dispose() -Methode für Objekte dieser Klassen aufrufen.