C# Stream - binäre Ströme in C#

1- Stream Overview

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:
Class Description
BufferedStream A utility stream, it wrapped another stream, which helps improve performance
FileStream Stream used to read and write data to the file.
MemoryStream Creates a stream whose backing store is memory.
UnmanagedMemoryStream  
IsolatedStorageFileStream  
PipeStream  
NetworkStream  
CryptoStream Defines a stream that links data streams to cryptographic transformations.
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
The properties of the Stream:
Attributes 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- The basic examples for 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- Write stream example

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 from subclass 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)
              // Corresponding 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- Write stream example

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 Description
Append Opens the file if it exists and seeks to the end of the file, or creates a new file
Create Specifies that the operating system should create a new file. If the file already exists, it will be overwritten.
CreateNew Specifies that the operating system should create a new file.If the file already exists, an IOException exception is thrown. This mode requires FileIOPermissionAccess.Write permission.
Open Specifies that the operating system should open an existing file. A System.IO.FileNotFoundException exception is thrown if the file does not exist.
OpenOrCreate Specifies that the operating system should open a file if it exists; otherwise, a new file should be created
Truncate Specifies that the operating system should open an existing file. When the file is opened, it should be truncated so that its size is zero bytes.
FileMode example:
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();
        }
    
    }
}
Running the example:
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
Methods of FileInfo, returns FileStream Description
Create() By default, full read/write access to new files is granted to all users.
Open(FileMode)    Opens a file in the specified mode.
Open(FileMode, FileAccess)    Opens a file in the specified mode with read, write, or read/write access.
Open(FileMode, FileAccess, FileShare) Opens a file in the specified mode with read, write, or read/write access and the specified sharing option.
OpenWrite() Creates a write-only FileStream.
OpenRead() Creates a read-only FileStream.
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
Constructor Description
BufferedStream(Stream) Initializes a new instance of the BufferedStream class with a default buffer size of 4096 bytes.
BufferedStream(Stream, Int32) Initializes a new instance of the BufferedStream class with the specified buffer size.
Ich gebe eine Situation. Sie erstellen ein B ufferedStream , 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)
Example:
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 location
            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();

             
        }
    }

}
Running the example:

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.
                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.

            // A Stream to read file.
            using (FileStream stream = new FileStream(encryedFile, FileMode.Open, FileAccess.Read))
            {
                // Decryptor.
                ICryptoTransform decryptor = provider.CreateDecryptor();

                // A CryptoStream wrap to FileStream.
                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();
        }
    }

}
Running the example:
Sehen Sie die neu erstellte FIle.