Tutoriel C# Stream - flux binaire en 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"; 
  
            // Créez le dossier princial.
            Directory.CreateDirectory(@"C:\temp");

            // Créez un objet Stream via Constructor de FileStream.
            // FileMode.Create: Créez un nouveau fichier à enregistrer, si le fichier existe déjà, écraserez ce fichier.
            Stream writingStream = new FileStream(path, FileMode.Create);

            try
            {
                // Un ensemble d'octets. (1 octet <2 ^ 8)
                // Ce tableau correspond à: {'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); 
                  
                    // Ecrivez un octet (33 = '!')
                    writingStream.WriteByte(33);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error:" + e);
            }
            finally
            {
                // Fermez Stream, libérez des ressources
                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;
            }

            // Créez un objet Stream via un constructeur de classe FileStream
            // FileMode.Open: Ouvrez le fichier à lire.
            using (Stream readingStream = new FileStream(path, FileMode.Open))
            {
                byte[] temp = new byte[10];
                UTF8Encoding encoding = new UTF8Encoding(true);

                int len = 0;

                // Lisez des éléments sur Stream et assignez aux éléments du tableau 'temp'.
                // (Assignez au début des positions de 0, chaque fois que la lecture maximale 'temp.Length' élément)
                // En même temps, renvoiez le nombre d'octets vient d'être lu
                while ((len = readingStream.Read(temp, 0, temp.Length)) > 0)
                {
                    // Transformez en chaîne (String).
                    // (des éléments 'len'  commence de la position 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!");

                // Assurez-vous que le répertoire parent existe.
                Directory.CreateDirectory(@"C:\temp");
            }

            // Créez un fichier FileStream pour écrire les données.
            // (FileMode.Append: Ouvrez le fichier pour écrire à la fin du fichier si le fichier ne sort pas, créez-le et écrivez).
            using (FileStream writeFileStream = new FileStream(path, FileMode.Append) )
            {
                string s = "\nHello every body!";

                // Convertissez une chaîne en un tableau d'octets dans le codage UTF8.
                byte[] bytes = Encoding.UTF8.GetBytes(s);

                // ​​​​​​​
                // Écrivez des octets au fichier.
                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;
            }
            // Ouvrez le fichier et tronquez (Truncate) les données actuelles.
            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);

            // Assurez-vous que le répertoire existe.
            file.Directory.Create();

            // Créez un nouveau fichier, s'il existe, il sera écrasé.
            // Renvoiez un object FileStream.
            using (FileStream fileStream = file.Create())
            {
                // Créez un object BufferedStream enveloppe le FileStream.
                // (Spécifiez un tampon a une capacité de 10000 octets).
                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);

                        // Écrivez dans la mémoire tampon (buffer),
                        // lorsque le tampon est plein, il poussera automatiquement les données dans le fichier.
                        bs.Write(bytes, 0, bytes.Length);
                    }

                    // Stockez les données restantes dans la mémoire tampon dans le fichier.
                    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()
        {
            // Créez un objet MemoryStream avec une capacité de 100 octets.
            MemoryStream memoryStream = new MemoryStream(100);

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

            // Écrivez les octets dans memoryStream (flux de mémoire).
            memoryStream.Write(javaBytes, 0, javaBytes.Length);
            memoryStream.Write(csharpBytes, 0, csharpBytes.Length);

            // Écrivez la capacité et la longueur.
            // ==> Capacité: 100, Longueur: 10.
            Console.WriteLine("Capacity: {0} , Length: {1}",
                                  memoryStream.Capacity.ToString(),
                                  memoryStream.Length.ToString());

            // À ce moment, la position du curseur (cursor) est debout après le caractère 'p'.
            // ==> 10.
            Console.WriteLine("Position: "+ memoryStream.Position);

            // Déplacez le curseur vers l'arrière de 6 octets par rapport à la position actuelle.
            memoryStream.Seek(-6, SeekOrigin.Current);

            // Maintenant la position du curseur après le caractère 'a' et avant 'C'.
            // ==> 4.
            Console.WriteLine("Position: " + memoryStream.Position);

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

            // Écrivez des données dans le memoryStream (flux de mémoire).
            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();

             
        }
    }

}

// Des objects fournissent l'algorithme de cryptage DES.
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

// Utilisez votre clé privée (private key) (doit être une chaîne 128bit = 8byte).
// (Équivalent à 8 caractères ASCII)
provider.Key = ASCIIEncoding.ASCII.GetBytes("1234abcd");
provider.IV = ASCIIEncoding.ASCII.GetBytes("12345678");

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

// Decrypteur (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) 
        {
            // Fournit l’algorithme de cryptage DES.
            DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

            // Clé de sécurité (secret key) (doit être une chaîne de 128 bits = 8 bytes).
            // (Équivalent à 8 caractères ASCII)
            provider.Key = ASCIIEncoding.ASCII.GetBytes("1234abcd");
            provider.IV = ASCIIEncoding.ASCII.GetBytes("12345678");


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

            // Un flux pour écrire un fichier.
            using (FileStream stream = new FileStream(encryedFile, FileMode.OpenOrCreate, FileAccess.Write))
            { 
                // Cryptage des sujets (Encryptor).
                ICryptoTransform encryptor = provider.CreateEncryptor();

                // Créer CryptoStream enveloppe le FileStream.
                // (FileStream dans ce cas utilisé pour écrire des données dans le fichier)
                using (CryptoStream cryptoStream = new CryptoStream(stream,
                                     encryptor, CryptoStreamMode.Write))
                {
                    // Un tableau d'octets n'est pas cryptées.
                    byte[] data = ASCIIEncoding.ASCII.GetBytes("Bear, I love you. OK?");

                    // Écrire à cryptoStream.
                    cryptoStream.Write(data, 0, data.Length);
                } 

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

            // Ensuite, lisez le fichier qui a été chiffré et vient de créer dans les étapes ci-dessus.
            using (FileStream stream = new FileStream(encryedFile, FileMode.Open, FileAccess.Read))
            {
                // Décrypteur (Decryptor).
                ICryptoTransform decryptor = provider.CreateDecryptor();

                // Créez CryptoStream qui enveloppe FileStream.
                // (FileStream dans ce cas pour utiliser écrire le fichier).
                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();
        }
    }

}