Tutoriel C# Stream - flux binaire en C#

View more categories:

1- Aperçu de Stream

Stream est une classe qui simule un flux bytes pour être aligné une ligne. Comme la transmission de données sur le réseau, les données transmises sont des flux contigus bytes du premier octet au dernier octet.
Stream est une classe de base, l'autre flux s'étend de cette classe. Quelques classes ont été créées dans C#, qui ont été étendues à partir de la classe Stream pour différentes fins, telles que :
Class Description
BufferedStream Un flux utilitaire, il enveloppe (wrap) un autre flux pour améliorer la performance.
FileStream Le flux est utilisé pour lire les données enregistrées sur le fichier.
MemoryStream Crée un flux avec les données de la mémoire.
UnmanagedMemoryStream
IsolatedStorageFileStream
PipeStream
NetworkStream
CryptoStream Lit le flux de données d'écriture qui est crypté
DeflateStream
GZipStream
Stream est une classe abstraite. Elle n'initialise pas un objet par elle -même, vous pouvez donc initialiser un objet Stream à partir des constructeur (Constructor) de la sous classe. La classe Stream fournit des méthodes de fonctionnement de base afin de travailler avec les flux de données, plus précisément ce sont des méthodes de lecture / écriture d'un byte ou d'un ensemble des byte..
Le flux est une classe abstraite, il ne peut pas initialiser un objet par lui-même, vous pouvez initialiser un objet Stream des Constructeurs de la sous-classe. La classe de flux fournit les méthodes de base pour travailler avec les flux de données, à savoir la méthode de lecture / écriture d'un octet ou d'un ensemble d'octets.

 
 

Selon le flux, il y a le flux qui soutien à la fois la lecture et l'écriture et recherche (seek) en déplaçant le curseur sur le flux, lire et écrire des données en position de curseur.
Les propriétés (property) de  Stream :
Attribut Description
CanRead Obtient une valeur indiquant si le flux actuel prend en charge la lecture.
CanSeek Obtient une valeur indiquant si le flux actuel prend en charge la recherche.
CanWrite Obtient une valeur indiquant si le flux actuel prend en charge l'écriture.
Length Permet la longueur en octets (bytes) du flux.
Position Obtient ou définit la position actuelle de ce flux.
Les méthodes  de  Stream :

2- Les exemples de base de Stream

Avec Stream, vous pouvez écrire chaque byte ou un ensemble des  byte dans le flux (stream). Et lorsque vous lisez, vous pouvez lire chaque byte ou plusieurs byte et assigner à un tableau temporaire.
Un byte  est de 8 bite, dont un bit est égal à 0 ou 1. Ainsi, 1 byte correspond à un nombre de 0 à 255 (2 ^ 8-1).

2.1- L'exemple du flux d'entrée

Et maintenant,nous allons commencer par un exemple simple, créez un Stream qui écrit des données au fichier (File). Vous pouvez écrire chaque octet dans le flux ou écrire un ensemble d'octets dans le flux.
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"; 
  
            // 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();

        }

    }
}
Exécutez l'exemple :
Remarque : Dans le tableau de caractères ASCII, chaque caractère CSII correspond à un nombre <256.
Character Value   Character Value
H 72   W 87
e 101   r 114
l 108   d 100
o 111     32
! 33      
Vous pouvez vous faire la référence au tableau des codes ASCII à:

2.2- L'exemple de flux d'entrée

L'exemple ci-dessus vous avez écrit des données dans le fichier C:/ tempMy/Test.txt, vous pouvez maintenant écrire un flux pour lire les données de ce fichier.
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;
            }

            // 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();
        }
    }

}
L'exécution l'exemple :

3- FileStream

File Stream est une classe qui s'est étendue de la classe Stream, File Stream est utilisé pour lire et écrire des données au fichier, il hérite des propriétés, des méthodes de Stream et dispose de fonctions supplémentaires pour lire et enregistrer des données sur le fichier.
Ce sont certains modes pour lire et écrire des données :
FileMode Description
Append Ouvrit le fichier s'il existe déjà, déplacez le curseur jusqu'à la fin du fichier afin qu'il puisse enregistrer le fichier, si le fichier n'existe pas il sera créé.
Create Demande le système d'exploitation de créer un nouveau fichier. Si le fichier existe déjà, il sera écrasé.
CreateNew Demande le système d'exploitation de créer un nouveau fichier. Si le fichier existe déjà IOException sera jeté. Ce mode nécessite le droit FileIOPermissionAccess.Write
Open Demande le système d'exploitation d'ouvrir un fichier existant. Une exception de System.IO FileNotFoundException est jetée si va...-fichier n’existe pas.
OpenOrCreate Demande le système d'exploitation d'ouvrir un fichier si elle existe; sinon, un nouveau fichier sera créé.
Truncate Demande le système d'exploitation d'ouvrir le fichier s'il existe. Et lorsque le fichier est ouvert, il sera coupé le contenu retourné 0 byte.
L'exemple de  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!");

                // 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();
        }
    
    }
}
Exécutez l'exemple :
Avec FileMode.Append, les données seront ajoutées au fichier si le fichier existe déjà :

Constructor:

La classe FileStream possède 11 constructeurs (sans compter des constructeurs obsolètes) utilisés pour initialiser un objet 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)
Cependant, vous avez aussi d'autres façons de créer un objet FileStream, comme par le FileInfo, c'est la classe qui représente un fichier dans le système.
Méthode FileInfo renvoie FileStream. Description
Create() Par défaut, l'accès complet en lecture / écriture aux nouveaux fichiers est accordé à tous les utilisateurs.
Open(FileMode)    Ouvre un fichier dans le mode spécifié.
Open(FileMode, FileAccess)    Ouvre un fichier dans le mode spécifié avec lecture, écriture ou accès en lecture / écriture.
Open(FileMode, FileAccess, FileShare) Ouvre un fichier dans le mode spécifié avec lecture, écriture ou accès en lecture / écriture et l'option de partage spécifiée.
OpenWrite() Crée un fichier FileStream uniquement en écriture.
OpenRead() Crée un fichier FileStream uniquement en lecture.
Voir plus:
  • TODO Link!
L'exemple de création  FileStream via 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;
            }
            // 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();

        }
    }

}

4- BufferedStream

BufferedStream est une classe qui s'est étendue de la classe Stream, c'est un flux (stream) tampon qui enveloppe (wrap) un autre flux et aide à améliorer l'efficacité de la lecture et de l'écriture des données.
BufferedStream a seulement deux méthodes constructeurs (constructor), il enveloppe un autre flux.
Constructeur Description
BufferedStream(Stream) Initialise un objet BufferedStream avec la taille de la mémoire tampon par défaut est 4096 octets.
BufferedStream(Stream, Int32) Initialise un objet BufferedStream avec la taille de la mémoire tampon est spécifié.
Je propose une situation, vous créez un tampon de flux (BufferedStream) couvrant FileStream, dans le but d'écrire des données dans le fichier. Les données écrites dans le tampon du flux seront localisées temporairement en mémoire et, lorsque le tampon est plein, les données sont automatiquement chassées (Flush) au fichier, vous pouvez chasser les données vers le fichier à l'aide de la méthode ( Flush) . L'utilisation de BufferedStream dans ce cas réduit le nombre de fois pour écrire le lecteur, ce qui augmente l'efficacité du programme.
L'exemple ci-dessous est un BufferedStream qui enveloppe un flux pour écrire des données dans le fichier :
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);

            // 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();
        }
    }

}
Les résultats de l'exécution d'exemple:

5- MemoryStream

La classe MemoryStream est directement étendue à partir de la classe Stream, c'est le flux que les données qui sont stockées dans la mémoire.
Essentiellement, MemoryStream est un objet qui gère un tampon (buffer) est un ensemble des byte, tandis que les byte sont écrits dans ce flux seront automatiquement affectés à la position suivante à partir de la position actuelle du curseur sur le tableau. Lorsque le tampon est complet, un nouveau tableau de taille plus grande sera créé et copié les données de l'ancien tableau.

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)
Exemple:
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()
        {
            // Créer 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");

            // Écrire 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 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 ");

            // Écrire 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();

             
        }
    }

}
Exécutez l'exemple:

6- UnmanagedMemoryStream

Utilisez  UnmanagedMemoryStream vous permet de lire le flux de données qui ne sont pas gérés sans les copier pour gérer la mémoire  Heap avant de l'utiliser. Cela vous permet d'économiser de la mémoire si vous devez gérer de nombreuses données.
Notez qu'il y a une limite de 2GB pour  MemoryStream , donc vous devez utiliser  UnmanagedMemoryStream si vous dépassez cette limite.
J'ai émis une situation: il existe des données discrètes disponibles sur la mémoire. Et vous pouvez vous rassembler pour gérer par  UnmanagedMemoryStream en gérant les pointeurs des données discrètes précitées, au lieu de les copier dans le flux à gérer.

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 est une classe utilisée pour chiffrer des flux de données.
L'image ci-dessous illustre que CryptoStream enroule un autre flux (tel que l'écriture d'un fichier de flux), lorsque vous écrivez des données d'octet sur CryptoStream, ces octets seront chiffrés dans un autre octet avant de débiter le flux qui est écrit dans le fichier. Maintenant, le contenu du fichier a été chiffré.

Notez que vous pouvez choisir un algorithme de cryptage lors de la création de l'objet CryptoStream.
 
Dans une situation inverse, CryptoStream enveloppe un fichier de flux de lecture (fichier dont le contenu a été crypté ci-dessus), l'octet dans FileStream a été crypté, il sera déchiffré par CryptoStream.
Une chose importante dont vous devez vous souvenir est que, pas algorithme de chiffrement aussi chiffrement à deux voies et des solutions de chiffrement.
Voyez un exemple:

Ici, j'utilise l'algorithme DES pour chiffrer et décrypter, vous devez fournir un tableau de 128 bits qui est la clé de votre sécurité.
 
DES Algorithm
// Objects fournit l'algorithme de cryptage DES.
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();

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

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

// Decryptor (Decrytor).
ICryptoTransform decryptor = provider.CreateDecryptor();
Voyez l'exemple compet.
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) 
        {
            // 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, lire le fichier a été chiffré, vient de créer dans les étapes ci-dessus.
            using (FileStream stream = new FileStream(encryedFile, FileMode.Open, FileAccess.Read))
            {
                // Objet Décryptor (Decryptor).
                ICryptoTransform decryptor = provider.CreateDecryptor();

                // Créez CryptoStream 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();
        }
    }

}
Exécutez l'exemple:
Afficher le contenu du fichier qui vient de créer.

View more categories: