Die Anleitung zu C# Stream - binäre Ströme in C#

1- Die Überblick über Stream

Stream ist eine Klasse zur Beschreibung einer Zeile von aufeinanderfolgender  byte . Zum Beispiel wie die Datenübertragung im Internet: Die übertragenden Daten sind die Zeile der aufeinanderfolgenden  byte von der ersten byte zum letzten byte
Stream ist eine Basicklasse. Die anderen Stream sind aus der Klasse ausgeweitert. Es gibt einigen einfügbaren Klasse im C#. Sie verbreiten aus die Klasse Stream zur unterschiedlichen Zwecke. zum Beispiel:
Die Klasse Die Bezeichnung
BufferedStream Eine Utility-Klasse, die einen anderen Stream zur Leistungsverbesserung einpacken (wrap)
FileStream Zum Lesen/Aufschreiben der Daten in die File benutzen
MemoryStream Stream zum Umgang mit Daten in der Speicherung
UnmanagedMemoryStream  
IsolatedStorageFileStream  
PipeStream  
NetworkStream  
CryptoStream Stream zum Lesen/Aufschreiben der kodierten Daten
DeflateStream  
GZipStream  
Stream ist eine abstrakte Klasse. Sie kann selbst kein Objekt erstellen Sie können ein Objekt Stream aus der Constructor der untergeordneten Klasse. Die Klasse Stream bietet die grundlegenden Methode zum Umgang mit dem Datenstream, besonders die Methode zum Lesen/Aufschreiben einer Byte oder eines Arrays der byte
Es hängt von dem Stream ab. Einige Stream unterstützt Lesen und Aufschreiben und auch Suchen (seek) durch die Bewegung der Mauszeiger auf dem Stream und das Aufschreiben-Lesen der Daten bei der Position von Mauszeiger
Die Property vom  Stream:
Properties Bezeichnung
CanRead Zeigt, ob das Stream beim Lesen unterstützt oder nicht
CanSeek Zeigt, ob das Stream beim Suche unterstützt oder nicht
CanWrite Zeigt, ob das Stream beim Aufschreiben unterstützt oder nicht
Length Rückgabe der Länge des Stream (Anzahl von bytes)
Position Die Postition des Mauszeiger auf Stream
Die Methode vom Stream:

2- Das grundlegende Beispiel von Stream

Mit  Stream können Sie jede byte oder ein Array der  byte im Stream schreiben. Und beim Lesen können Sie jede oder viele  byte lesen und zu einem Array vorläufig zuweisen
Eine byte ist 8 bit, davon ein bit ist 0 oder 1. So entspricht 1 byte eine Zahl vom 0 bis 255 (2^8 - 1).

2.1- Zum Beispiel: das Stream zum Daten-Aufschreiben

Jetzt beginnen wir mit einem einfachen Beispiel: ein Stream zum Aufschreiben der Daten in die File erstellen. Sie können jede byte im Stream oder ein Array der byte im Stream schreiben
StreamWriteDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace CSharpStreamsTutorial
{
    class StreamWriteDemo
    {
        public static void Main(string[] args)
        {
            string path = @"C:\temp\MyTest.txt"; 
  
            // Create directory.
            Directory.CreateDirectory(@"C:\temp");

            // Create Stream object via Constructor of FileStream.
            // FileMode.Create: Create file, if it already exists, it will be overwritten.
            Stream writingStream = new FileStream(path, FileMode.Create);

            try
            {
                // A byte array. (1byte < 2^8)
                // This array corresponds to: {'H','e','l','l','o',' ','W','o','r','l','d'}.
                byte[] bytes = new byte[] { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100 };

                if (writingStream.CanWrite)
                {
                    writingStream.Write(bytes, 0, bytes.Length); 
                  
                    // Write a byte (33 = '!')
                    writingStream.WriteByte(33);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error:" + e);
            }
            finally
            {
                // Close Stream, free resources.
                writingStream.Close();
            }
            Console.ReadLine();

        }

    }
}
Beispiel durchführen:
Beachten Sie: In der Tabelle von Zeichencode CSII entspricht jede Zeichen CSII einer Zahl < 256.
Character Value   Character Value
H 72   W 87
e 101   r 114
l 108   d 100
o 111     32
! 33      
Sie können die ASCII Code bei,,, mehr lernen








:

2.2- Zum Beispiel: das Stream zum Daten-Lesen

Im obengenannten BEispiel haben Sie die Daten in die File C:\temp\MyTest.txt  aufgeschrieben, jetzt können Sie ein Stream zum Lesen aus der File schreiben
StreamReadDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace CSharpStreamsTutorial
{
    class StreamReadDemo
    {
        public static void Main(string[] args)
        {
            String path = @"C:\temp\MyTest.txt";

            if (!File.Exists(path))
            {
                Console.WriteLine("File " + path + " does not exists!");
                return;
            }

            // Create Stream object via constructor of FileStream
            // FileMode.Open: Open file to read.
            using (Stream readingStream = new FileStream(path, FileMode.Open))
            {
                byte[] temp = new byte[10];
                UTF8Encoding encoding = new UTF8Encoding(true);

                int len = 0;

                // Read on stream and asign to temporary array.
                // (Asign to elements of array from index 0, and max 'temp.Length' elements)
                // Returns the number of bytes read.
                while ((len = readingStream.Read(temp, 0, temp.Length)) > 0)
                {
                    // Converts to string.
                    // ('len' elements from index 0).
                    String s = encoding.GetString(temp, 0, len);
                    Console.WriteLine(s);
                }
            }

            Console.ReadLine();
        }
    }

}
Das Beispiel durchführen

3- FileStream

FileStream ist eine Klasse, die von der Klasse Stream ausgeweitert.  FileStream wird benutzt um die Daten in die FIle zu lesen und aufzuschreiben. Sie wird die Eigenschaften (property), die Methode aus  Stream geehrt, gleichzeitig die eigenen Funktionen zum Aufschreiben-Lesen der Daten in die File.
Es gibt einige Mode zum Aufschreiben-Lesen der Daten in die File:
FileMode Die Bezeichnung
Append Die File öffnen wenn sie existiert und bewgen Sie zu Ende der Datei oder die File wird erstellt 
Create Bestimmt dass das Betriebssymtem eine neue File erstellen soll. Wenn die Datei existiert, wird es überschrieben
CreateNew Bestimmt dass das Betriebssymtem eine neue File erstellen soll. Wenn die File existiert, wird die Ausnahme IOException geworfen. das Modus fordert die Recht von  FileIOPermissionAccess.Write
Open Bestimmt dass das Betriebssymtem eine existierende File öffnen soll. Eine Ausnahme System.IO.FileNotFoundException wird geworfen wenn die File existiert nicht
OpenOrCreate Bestimmt dass das Betriebssymtem eine File öffnen soll wenn sie existiert. Wenn nicht, eine neue File wird erstellt 
Truncate Bestimmt dass das Betriebssymtem eine File öffnen soll wenn sie existiert. Wenn die File geöffnet wird, wird sie gekürzt damit ihre Größe  0 byte wird.
Zum Beispiel: FileMode:
FileStreamFileModeDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace CSharpStreamsTutorial
{
    class FileStreamFileModeDemo
    {
        public static void Main(string[] args)
        {
            String path = @"C:\temp\MyTest.txt";

            if (!File.Exists(path))
            {
                Console.WriteLine("File " + path + " does not exists!");

                // Ensure that the parent directory exists.
                Directory.CreateDirectory(@"C:\temp");
            }

            // Create a FileStream to write file.
            // (FileMode.Append: Open file to write to end of file,
            // if file does not exit, create it and write).
            using (FileStream writeFileStream = new FileStream(path, FileMode.Append) )
            {
                string s = "\nHello every body!";

                // Convert string to bytes with UTF8 encoding.
                byte[] bytes = Encoding.UTF8.GetBytes(s);

                // Write bytes to file.
                writeFileStream.Write(bytes, 0, bytes.Length); 
            }
            Console.WriteLine("Finish!");

            Console.ReadLine();
        }
    
    }
}
Das Beispiel durchführen
Mit  FileMode.Append wird die Daten in die File zusätzt, wenn die FIle existierte:

Constructor:

Die Klasse  FileStream hat 11 constructor ( die veralteten Constructor nicht zählen) zur Erstellung eines Objekt FileStream:
FileStream Constructors
FileStream(SafeFileHandle, FileAccess)     

FileStream(SafeFileHandle, FileAccess, Int32)

FileStream(SafeFileHandle, FileAccess, Int32, Boolean)     

FileStream(String, FileMode)

FileStream(String, FileMode, FileAccess)

FileStream(String, FileMode, FileAccess, FileShare)

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

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

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

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

FileStream(String, FileMode, FileSystemRights, FileShare, Int32, FileOptions, FileSecurity)
Allerdings können Sie das Objekt  FileStream durch den anderen Weg erstellen, beispielweise durch  FileInfo. Das ist die Klasse zur Vertretung einer File im System
Die Methode von FileInfo, FileStream zurückgeben Die Bezeichnung
Create() Durch das Default, alle Rechte zum Lesen/Aufschreiben der neuen File werden für alle Benutzer zugewiesen
Open(FileMode)    Die File in dem bestimmten Modus öffnen
Open(FileMode, FileAccess)    Die File öffnen in dem bestimmten Modus zum Lesen, Aufschreiben oder der Recht zum Lesen/Aufschreiben
Open(FileMode, FileAccess, FileShare) Die File öffnen in dem bestimmten Modus zum Lesen, Aufschreiben oder der Recht zum Lesen/Aufschreiben und die Teilungsauswähle
OpenWrite() Die Erstellung eines FileStream um die Daten nur zu aufschreiben
OpenRead() Die Erstellung eines FileStream um die Daten zu lesen
Mehr sehen
Das Beispiel über die Erstellung von  FileStream aus  FileInfo:
FileStreamFileInfoDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace CSharpStreamsTutorial
{
    class FileStreamFileInfoDemo
    {

        public static void Main(string[] args)
        {
            FileInfo afile = new FileInfo(@"C:\temp\MyTest.txt");

            if (afile.Exists)
            {
                Console.WriteLine("File does not exist!");
                Console.Read();
                return;
            }
            // Open file and truncate all bytes.
            using (FileStream stream = afile.Open(FileMode.Truncate))
            {
                String s = "New text";

                byte[] bytes = Encoding.UTF8.GetBytes(s);

                stream.Write(bytes, 0, bytes.Length);
            }

            Console.WriteLine("Finished!");
            Console.Read();

        }
    }

}

4- BufferedStream

BufferedStream ist eine aus Stream ausgeweiterte Klasse. Sie ist ein Pufferstream, der einen anderen Stream zur Vebesserung der Datenaufschreiben,-Lesen einpackt
BufferedStream hat nur 2 Constructor, der einen anderen Stream einpackt
Der Constructor Die Bezeichnung
BufferedStream(Stream) Die Initialization eines Objekt BufferedStream mit der Default-Puffer Größe von 4096 bytes.
BufferedStream(Stream, Int32) Die Initialization eines Objekt BufferedStream mit dem bestimmten Default-Puffer
Ich gebe eine Situation. Sie erstellen ein BufferedStream , der FileStream einpackt, mit dem Zweck vom Aufschreiben der Daten in die File. Die Eingabedaten in BufferedStream liegen vorläufig in dem Speicher und wenn der Puffer voll ist, werden die Daten automatisch in die File gestoßen (Flush). Sie können aktiv durch die Methode Flush() die Daten in die File stoßen. BufferedStream benutzen kann in diesem Fall die Anzahl des Aufschreiben vermeiden. Deshalb verbessert sie die Programmsleistung
Das folgende Beispiel  BufferedStream packt ein Aufschreibenstream:
BufferedStreamWriteFileDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace CSharpStreamsTutorial
{
    class BufferedStreamWriteFileDemo
    {
        public static void Main(string[] args)
        {
            String fileName = @"C:\temp\MyFile.txt";

            FileInfo file = new FileInfo(fileName);

            // Make sure the directory exists.
            file.Directory.Create();

            // Create a new file, if it exists it will be overwritten.
            // Returns FileStream object.
            using (FileStream fileStream = file.Create())
            {
                // Create BufferedStream wrap the FileStream.
                // (Specify the buffer is 10000 bytes).
                using (BufferedStream bs = new BufferedStream(fileStream, 10000))
                {
                    int index = 0;
                    for (index = 1; index < 2000; index++)
                    {
                        String s = "This is line " + index + "\n";

                        byte[] bytes = Encoding.UTF8.GetBytes(s);

                        // Write to buffer, when the buffer is full it will 
                        // automatically push down the file.
                        bs.Write(bytes, 0, bytes.Length);
                    }

                    // Flushing the remaining data in the buffer to the file.
                    bs.Flush();
                } 
                
            }

            Console.WriteLine("Finished!");
            Console.Read();
        }
    }

}
Das Ergebnis des Beispiel

5- MemoryStream

MemoryStream ist eine aus der Stream direkt ausgeweiterte Klasse. Das ist ein stream, deren Daten auf dem Speicher lagern (store)
Auf die Wesen ist  MemoryStream ein Objekt. Er verwaltet einen Puffer (buffer) als ein Array der  byte. Wenn die  byte in diesem Stream aufgeschrieben werden, werden sie in die nächsten Postitionen ab der Position vom Mauszeiger auf dem Array automatisch zuweisen. Wenn der Puffer voll ist, wird ein neuer Array mit der großen Umfang erstellt und die Daten vom alten Array werden kopiert

Constructor:

MemoryStream()   
MemoryStream(Byte[] buffer)
MemoryStream(Byte[] buffer, Boolean writable)
MemoryStream(Byte[] buffer, Int32 index, Int32 count, Boolean writable) 
MemoryStream(Byte[] buffer, Int32 index, Int32 count, Boolean, Boolean publiclyVisible)  
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)  
 MemoryStream(Int32 capacity)
Zum Beispiel
MemoryStreamDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace CSharpStreamsTutorial
{
    class MemoryStreamDemo
    {
        static void Main()
        {
            // Create MemoryStream object with capacity of 100 bytes.
            MemoryStream memoryStream = new MemoryStream(100);

            byte[] javaBytes = Encoding.UTF8.GetBytes("Java");
            byte[] csharpBytes = Encoding.UTF8.GetBytes("CSharp");

            // Write bytes to memory stream.
            memoryStream.Write(javaBytes, 0, javaBytes.Length);
            memoryStream.Write(csharpBytes, 0, csharpBytes.Length);

            // Write out capacity and length.
            // ==> Capacity: 100, Length: 10.
            Console.WriteLine("Capacity: {0} , Length: {1}",
                                  memoryStream.Capacity.ToString(),
                                  memoryStream.Length.ToString());

            // At this time the cursor position is standing after the character 'p'.
            // ==> 10.
            Console.WriteLine("Position: "+ memoryStream.Position);

            // Move the cursor backward 6 bytes, compared to the current position.
            memoryStream.Seek(-6, SeekOrigin.Current);

            // Now cursor position after the character 'a' and before 'C'.
            // ==> 4
            Console.WriteLine("Position: " + memoryStream.Position);

            byte[] vsBytes = Encoding.UTF8.GetBytes(" vs ");

            // Write to memory stream.
            memoryStream.Write(vsBytes, 0, vsBytes.Length);


            byte[] allBytes = memoryStream.GetBuffer();

            string data = Encoding.UTF8.GetString(allBytes);

            // ==> Java vs rp
            Console.WriteLine(data);

            Console.WriteLine("Finish!");
            Console.Read();

             
        }
    }

}
Das Beispiel durchführen

6- UnmanagedMemoryStream

Mit  UnmanagedMemoryStream dürfen Sie die Datenstream, die auf dem Speicher Heap vor dem Benutzung nicht kopieren brauchen, lesen. Es hilft Ihnen bei dem Speichersparen wenn SIe mit vielen Daten arbeiten müssen.

Beachten Sie: Es limitiert 2GB für MemoryStream . Deshalb müssen Sie UnmanagedMemoryStream bei der Limitüberschreitung benutzen
Iich gebe eine Situation: Es gibt die zusammenhanglosen Daten auf dem Speicher. Und SIe können sie durch  UnmanagedMemoryStream zum Management sammeln, indem Sie die Pointer der oben zusammenhanglosen Daten verwalten, anstatt Sie auf Stream zur Verwaltung kopieren

Constructor:

UnmanagedMemoryStream()
UnmanagedMemoryStream(Byte* pointer, Int64 length)
UnmanagedMemoryStream(Byte* pointer, Int64 length, Int64 capacity, FileAccess access)
UnmanagedMemoryStream(SafeBuffer buffer, Int64 offset, Int64 length)  
UnmanagedMemoryStream(SafeBuffer buffer, Int64 offset, Int64 length, FileAccess access)
  • TODO

7- CryptoStream

CryptoStream ist eine Klasse, die für die Verschlüsselung der Datenstream benutzt wird .
Das folgende Beispiel bezeichnet das Stream  CryptoStream packt ein anderen Stream ein (zum Beispiel: Aufschreibenstream der File). Wenn Sie die Daten von byte auf  CryptoStream aufschreiben, werden die byte zur anderen Byte vor dem Verschobung zur Aufschreibenstream verschlüsselt. Da ist die Inhalt der File verschlüsselt.
Beachten Sie: Sie können ein Verschlüsselsalgorithmus bei der Erstellung des Objekts CryptoStream wählen
Bei der umgekehrten Situation packt ein Stream  CryptoStream ein Stream zum File-Lesen ein ( die FIle, deren Inhalt wie oben verschlüsselt wird). Die byte aufs Stream  FileStream sind die verschlüsselten byte (encrypt). Sie werden durch CryptoStream entschlüsselt (decrypt).
Eine wichtige Dinge sollen Sie erinern, dass Nicht alle Verschlüsselsalgorithmus haben 2 Seite der Verschlüsselung und Entschlüsselung
Sehen Sie ein Beispiel:

Hier benutze ich das Algorithmus  DES zur Verschlüsselung und Entschlüsselung. Sie sollen das Array 128 bit als Ihr Schlüssel zur Sicherheit bieten.
DES Algorithm
// Objects provides the DES encryption algorithm.
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

// Use your private key (Must be 128bit = 8byte).
// (Equivalent to 8 ASCII characters)
provider.Key = ASCIIEncoding.ASCII.GetBytes("1234abcd");
provider.IV = ASCIIEncoding.ASCII.GetBytes("12345678");

//  Encryptor
ICryptoTransform encryptor = provider.CreateEncryptor();

// Decrytor.
ICryptoTransform decryptor = provider.CreateDecryptor();
Sehen Sie das volle Beispiel.
CryptoStreamExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Security.Cryptography;

namespace CSharpStreamsTutorial
{
    class CryptoStreamExample
    {
        public static void Main(string[] args) 
        {
            // Provides DES encryption algorithm.
            DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

            // Your secret key (Must by 128bits = 8bytes).
            // (Equivalent to 8 ASCII characters).
            provider.Key = ASCIIEncoding.ASCII.GetBytes("1234abcd");
            provider.IV = ASCIIEncoding.ASCII.GetBytes("12345678");


            String encryedFile = @"C:\temp\EncryptedFile.txt";

            // A stream to write file.
            using (FileStream stream = new FileStream(encryedFile, FileMode.OpenOrCreate, FileAccess.Write))
            { 
                // Encryptor.
                ICryptoTransform encryptor = provider.CreateEncryptor();

                // Create CryptoStream wrap the FileStream.
                // (FileStream in this case used to write the file).
                using (CryptoStream cryptoStream = new CryptoStream(stream,
                                     encryptor, CryptoStreamMode.Write))
                {
                    // A byte array is not encrypted.
                    byte[] data = ASCIIEncoding.ASCII.GetBytes("Bear, I love you. OK?");

                    // Write to cryptoStream.
                    cryptoStream.Write(data, 0, data.Length);
                } 

            }
            Console.WriteLine("Write to file: " + encryedFile);

            // Next read the encrypted file has been created above.
            using (FileStream stream = new FileStream(encryedFile, FileMode.Open, FileAccess.Read))
            {
                // Decryptor.
                ICryptoTransform decryptor = provider.CreateDecryptor();

                // A CryptoStream wrap to FileStream.
                // (FileStream in this case used to read the file).
                using (CryptoStream cryptoStream = new CryptoStream(stream,
                                     decryptor, CryptoStreamMode.Read))
                {
                    byte[] temp = new byte[1024];
                    int read=0;
                    while((read =cryptoStream.Read(temp,0,temp.Length )) >0 )
                    {
                        String s= Encoding.UTF8.GetString(temp,0,read);

                        Console.Write(s);
                    } 
                } 
            }

            // Finished
            Console.Read();
        }
    }

}
Das Beispiel durchführen
Sehen Sie die neu erstellte FIle.

View more categories: