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

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"; 
  
            // Die Erstellung vom Vaterverzeichnis.
            Directory.CreateDirectory(@"C:\temp");

            // Die Erstellung eines Objekt Stream durch den Constructor vom FileStream.
            // FileMode.Create: Die Erstellung von der File zum Aufschreiben. 
            // Wenn die File existiert, schreib diese File auf (override).
            Stream writingStream = new FileStream(path, FileMode.Create);

            try
            {
                // Ein Array von byte (1byte < 2^8).
                // Der Array entspricht: {'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); 
                  
                    // Eine Byte (33 = '!') aufschreiben
                    writingStream.WriteByte(33);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error:" + e);
            }
            finally
            {
                // Stream schließen, die Ressources freien
                writingStream.Close();
            }
            Console.ReadLine();

        }

    }
}

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;
            }

            // Die Erstellung eines Objekt Stream durch Constructor der Klasse FileStream.
            // FileMode.Open: Die File zum Lesen öffnen.
            using (Stream readingStream = new FileStream(path, FileMode.Open))
            {
                byte[] temp = new byte[10];
                UTF8Encoding encoding = new UTF8Encoding(true);

                int len = 0;

                // Die Elemente auf Stream lesen und in dieser Elemente des Array 'temp' angewiesen.
                // (In die Elemente des Array ab Index 0 anweisen, und max 'temp.Length' Elemente )
                // Gleichzeitig die gelesen Byte zurückgeben.
                while ((len = readingStream.Read(temp, 0, temp.Length)) > 0)
                {
                    // Zum String umwandeln.
                    // ('len' Elemente ab Index 0).
                    String s = encoding.GetString(temp, 0, len);
                    Console.WriteLine(s);
                }
            }

            Console.ReadLine();
        }
    }

}

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!");

                // Stellen Sicher, dass der Vaterverzeichnis existiert.
                Directory.CreateDirectory(@"C:\temp");
            }

            // Die Erstellung eines FileStream um die Daten aufzuschreiben.
            // (FileMode.Append: Die Öffnung der File um am Ende der File 
            // weiter zu schreiben wenn die File existiert nicht, wird neu erstellt).
            using (FileStream writeFileStream = new FileStream(path, FileMode.Append) )
            {
                string s = "\nHello every body!";

                // Ein String zum Array von byte nach UTF8 encoding umwandeln.
                byte[] bytes = Encoding.UTF8.GetBytes(s);

                // Die Byte in File aufschreiben
                writeFileStream.Write(bytes, 0, bytes.Length); 
            }
            Console.WriteLine("Finish!");

            Console.ReadLine();
        }
    
    }
}

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)

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;
            }
            // Die File öffnen und alle Daten abschneiden (Truncate) 
            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();

        }
    }

}

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);

            // Stellen Sie sicher, der Verzeichnis existiert.
            file.Directory.Create();

            // Die Erstellung der neuen File. Wenn sie existiert, 
            // wird sie überschreibt. Ein Objekt FileStream zurückgeben
            using (FileStream fileStream = file.Create())
            {
                // Ein Objekt BufferedStream packend FileStream.
                // (Den Puffer mit der Kapazität von 10000 bytes bestimmen).
                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);

                        // In dem Puffer aufschreiben (buffer),
                        // wenn der Puffer voll ist, wird er automatisch in die File schieben.
                        bs.Write(bytes, 0, bytes.Length);
                    }

                    // Die restlichen Daten auf dem Puffer in die File schieben
                    bs.Flush();
                } 
                
            }

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

}

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()
        {
            // Ein Objekt MemoryStream mit der Kapazität von 100 bytes erstellen.
            MemoryStream memoryStream = new MemoryStream(100);

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

            // Die Byte in memoryStream aufschreiben.
            memoryStream.Write(javaBytes, 0, javaBytes.Length);
            memoryStream.Write(csharpBytes, 0, csharpBytes.Length);

            // Die Kapazität und die Länge vom Stream aufschreiben .
            // ==> Capacity: 100, Length: 10.
            Console.WriteLine("Capacity: {0} , Length: {1}",
                                  memoryStream.Capacity.ToString(),
                                  memoryStream.Length.ToString());

            // Jetzt ist die Stelle vom Zeiger (cursor) hinter dem Zeichen  'p'.
            // ==> 10.
            Console.WriteLine("Position: "+ memoryStream.Position);

            // Den Zeiger 6 Byte zurückgehen.
            memoryStream.Seek(-6, SeekOrigin.Current);

            // Jetzt ist die Stelle vom Zeiger (cursor) hinter dem Zeichen  'a' und vor dem Zeichen 'C'.
            // ==> 4.
            Console.WriteLine("Position: " + memoryStream.Position);

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

            // Die Daten in memoryStream aufschreiben
            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 Objekt versorgt das DES Encrypting Algorithmus.
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

// Benutzen Sie den private Key von Ihnen (es muss ein String 128bit = 8byte sein).
// (mit 8 Zeichen ASCII äquivalent)
provider.Key = ASCIIEncoding.ASCII.GetBytes("1234abcd");
provider.IV = ASCIIEncoding.ASCII.GetBytes("12345678");

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

// Der Decrytor).
ICryptoTransform decryptor = provider.CreateDecryptor();

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) 
        {
            // Das DES encryting Algorithmus.
            DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

            // Der secret key (ein String 128bit = 8byte).
            // (mit 8 Zeichen ASCII äquivalent)
            provider.Key = ASCIIEncoding.ASCII.GetBytes("1234abcd");
            provider.IV = ASCIIEncoding.ASCII.GetBytes("12345678");


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

            // Ein Stream zum File Schreiben.
            using (FileStream stream = new FileStream(encryedFile, FileMode.OpenOrCreate, FileAccess.Write))
            { 
                // Der Encryptor.
                ICryptoTransform encryptor = provider.CreateEncryptor();

                // Die Erstellung eines CryptoStream einpackend FileStream.
                // (FileStream in diesem Fall zum Datenaufschreiben in die File).
                using (CryptoStream cryptoStream = new CryptoStream(stream,
                                     encryptor, CryptoStreamMode.Write))
                {
                    // Ein Byte Array wird noch nicht encrypting gemacht.
                    byte[] data = ASCIIEncoding.ASCII.GetBytes("Bear, I love you. OK?");

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

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

            // Zunächst die oben encrypten File lesen.
            using (FileStream stream = new FileStream(encryedFile, FileMode.Open, FileAccess.Read))
            {
                // Der Decryptor.
                ICryptoTransform decryptor = provider.CreateDecryptor();

                // Einen CryptoStream packend FileStream.
                // (FileStream in dieser File zum File Lesen).
                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();
        }
    }

}