FileStream C# (Comment ça marche pour les développeurs)

Cet article se concentrera sur la classe FileStream en C# et comment elle vous aide à effectuer des opérations de lecture et d'écriture sur des fichiers. Nous explorerons des exemples pratiques, comprendrons le fonctionnement de base de FileStream et apprendrons à gérer efficacement les données des fichiers. Ce guide est destiné à ceux qui sont nouveaux dans la gestion de fichiers en C#, donc le langage restera accessible aux débutants tout en fournissant des instructions détaillées sur la manière de travailler avec des fichiers en C# et une introduction à la bibliothèque IronPDF également.

Qu'est-ce que FileStream ?

La classe FileStream de C# permet de gérer des fichiers à l'aide d'octets. Il fonctionne avec des opérations de lecture et d'écriture sur les fichiers, ce qui vous permet d'interagir directement avec le contenu des fichiers. Ces outils sont particulièrement utiles lorsque l'on travaille avec des fichiers pour des tâches d'entrée/sortie, notamment lors de la manipulation de tableaux d'octets.

Cas d'utilisation de FileStream

FileStream est idéal pour :

• Lecture et écriture de données binaires directement depuis ou vers des fichiers.
• Traitement efficace de fichiers volumineux.
• Effectuer des opérations de fichiers asynchrones.
• Gérer les ressources du système en utilisant efficacement la mémoire.

Exemple de base

Voici un exemple simple pour ouvrir un fichier, écrire des données et les lire à l'aide de FileStream :

using System;
using System.IO;
public static void Main()
{
    string path = "example.txt";
    // Creating a FileStream object to handle the file. The file handle is acquired here.
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        byte[] data = System.Text.Encoding.UTF8.GetBytes("Hello, FileStream!");
        fileStream.Write(data, 0, data.Length);
    }
    // Read from the file
    using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
    {
        byte[] buffer = new byte[1024];
        int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
        string text = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine(text);
    }
}

using System;
using System.IO;
public static void Main()
{
    string path = "example.txt";
    // Creating a FileStream object to handle the file. The file handle is acquired here.
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        byte[] data = System.Text.Encoding.UTF8.GetBytes("Hello, FileStream!");
        fileStream.Write(data, 0, data.Length);
    }
    // Read from the file
    using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
    {
        byte[] buffer = new byte[1024];
        int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
        string text = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine(text);
    }
}

Imports System
Imports System.IO
Public Shared Sub Main()
	Dim path As String = "example.txt"
	' Creating a FileStream object to handle the file. The file handle is acquired here.
	Using fileStream As New FileStream(path, FileMode.Create, FileAccess.Write)
		Dim data() As Byte = System.Text.Encoding.UTF8.GetBytes("Hello, FileStream!")
		fileStream.Write(data, 0, data.Length)
	End Using
	' Read from the file
	Using fileStream As New FileStream(path, FileMode.Open, FileAccess.Read)
		Dim buffer(1023) As Byte
		Dim bytesRead As Integer = fileStream.Read(buffer, 0, buffer.Length)
		Dim text As String = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead)
		Console.WriteLine(text)
	End Using
End Sub

Cet exemple montre la création d'un objet FileStream pour gérer les opérations de lecture et d'écriture de fichiers. La classe FileStream lit et écrit directement des octets, ce qui la rend adaptée à la manipulation de fichiers volumineux ou de données binaires. Nous avons utilisé Encoding pour convertir le texte en octets.

Écrire des données avec FileStream

Pour écrire des données dans un fichier, vous utiliserez la méthode Write. Voici un exemple qui explique le fonctionnement plus en détail :

using System;
using System.IO;
public static void Main()
{
    string path = "output.txt";
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        byte[] buffer = System.Text.Encoding.UTF8.GetBytes("Writing data to FileStream.");
        int offset = 0;
        int count = buffer.Length;
        // Writing data to the file
        fileStream.Write(buffer, offset, count);
    }
}

using System;
using System.IO;
public static void Main()
{
    string path = "output.txt";
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        byte[] buffer = System.Text.Encoding.UTF8.GetBytes("Writing data to FileStream.");
        int offset = 0;
        int count = buffer.Length;
        // Writing data to the file
        fileStream.Write(buffer, offset, count);
    }
}

Imports System
Imports System.IO
Public Shared Sub Main()
	Dim path As String = "output.txt"
	Using fileStream As New FileStream(path, FileMode.Create, FileAccess.Write)
		Dim buffer() As Byte = System.Text.Encoding.UTF8.GetBytes("Writing data to FileStream.")
		Dim offset As Integer = 0
		Dim count As Integer = buffer.Length
		' Writing data to the file
		fileStream.Write(buffer, offset, count)
	End Using
End Sub

Dans ce code, nous convertissons une chaîne en un tableau d'octets en utilisant l'encodage UTF8. La méthode Write écrit le tableau d'octets dans le fichier à partir de la position actuelle (déterminée par le décalage) et écrit le nombre spécifié d'octets.

• FileMode.Create crée un nouveau fichier, écrasant tout fichier existant portant le même nom.
• FileAccess.Write accorde les droits d'écriture au FileStream.

Lecture de données avec FileStream

Voyons maintenant comment lire les données d'un fichier à l'aide de FileStream.

using System;
using System.IO;
public static void Main()
{
    // File path
    string path = "output.txt";
    // File Stream Object
    using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
    {
        byte[] buffer = new byte[1024];
        int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
    // Output Stream
        string output = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine(output);
    }
}

using System;
using System.IO;
public static void Main()
{
    // File path
    string path = "output.txt";
    // File Stream Object
    using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
    {
        byte[] buffer = new byte[1024];
        int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
    // Output Stream
        string output = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine(output);
    }
}

Imports System
Imports System.IO
Public Shared Sub Main()
	' File path
	Dim path As String = "output.txt"
	' File Stream Object
	Using fileStream As New FileStream(path, FileMode.Open, FileAccess.Read)
		Dim buffer(1023) As Byte
		Dim bytesRead As Integer = fileStream.Read(buffer, 0, buffer.Length)
	' Output Stream
		Dim output As String = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead)
		Console.WriteLine(output)
	End Using
End Sub

Dans cet exemple :

• FileMode.Open ouvre un fichier existant.
• La méthode Read lit un nombre spécifié d'octets (basé sur la taille du tampon) et les stocke dans le tampon de tableau d'octets.
• Nous utilisons Encoding.UTF8.GetString pour reconvertir les données en octets en chaînes de caractères.

Gérer l'accès aux fichiers avec FileStream

La classe FileStream contrôle l'accès aux fichiers, ce qui permet une gestion fine des fichiers et des ressources système. Lors de l'utilisation de FileStream, il est essentiel de s'assurer que le flux est correctement libéré après utilisation, soit en appelant manuellement Close(), soit en utilisant l'instruction qui libère automatiquement le flux.

Gestion de la position du fichier

Chaque fois que vous lisez ou écrivez dans un fichier, le FileStream garde une trace de la position actuelle dans le fichier. Vous pouvez accéder à cette position à l'aide de la propriété Position :

fileStream.Position = 0; // Move to the beginning of the file

fileStream.Position = 0; // Move to the beginning of the file

fileStream.Position = 0 ' Move to the beginning of the file

Utilisation de FileStream pour les opérations asynchrones

FileStream peut être utilisé pour des opérations de lecture et d'écriture asynchrones, ce qui améliore les performances en permettant à d'autres processus de s'exécuter pendant que les opérations sur les fichiers sont effectuées. Voici un exemple de base de lecture asynchrone :

using System;
using System.IO;
using System.Threading.Tasks;
public static async Task Main()
{
    // Specified Path
    string path = "output.txt";
    using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None, 4096, true))
    {
        byte[] buffer = new byte[1024];
        int bytesRead = await fileStream.ReadAsync(buffer, 0, buffer.Length);
        string result = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine(result);
    }
}

using System;
using System.IO;
using System.Threading.Tasks;
public static async Task Main()
{
    // Specified Path
    string path = "output.txt";
    using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None, 4096, true))
    {
        byte[] buffer = new byte[1024];
        int bytesRead = await fileStream.ReadAsync(buffer, 0, buffer.Length);
        string result = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine(result);
    }
}

Imports System
Imports System.IO
Imports System.Threading.Tasks
Public Shared Async Function Main() As Task
	' Specified Path
	Dim path As String = "output.txt"
	Using fileStream As New FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None, 4096, True)
		Dim buffer(1023) As Byte
		Dim bytesRead As Integer = Await fileStream.ReadAsync(buffer, 0, buffer.Length)
		Dim result As String = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead)
		Console.WriteLine(result)
	End Using
End Function

La méthode ReadAsync lit les données de manière asynchrone. Les paramètres FileAccess.Read et FileMode.Open contrôlent le mode d'accès au fichier.

Exemple de traitement des exceptions

Lors de l'utilisation de FileStream, la gestion des exceptions est essentielle pour éviter les erreurs d'exécution et gérer correctement les ressources système. Voici un modèle pour gérer les exceptions lors de la lecture ou de l'écriture de fichiers :

using System;
using System.IO;
public static void Main()
{
    string path = "nonexistentfile.txt";
    try
    {
        using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
        {
            byte[] buffer = new byte[1024];
            int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
            Console.WriteLine("Bytes Read: " + bytesRead);
        }
    }
    catch (FileNotFoundException e)
    {
        Console.WriteLine($"Exception: {e.Message}");
    }
}

using System;
using System.IO;
public static void Main()
{
    string path = "nonexistentfile.txt";
    try
    {
        using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
        {
            byte[] buffer = new byte[1024];
            int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
            Console.WriteLine("Bytes Read: " + bytesRead);
        }
    }
    catch (FileNotFoundException e)
    {
        Console.WriteLine($"Exception: {e.Message}");
    }
}

Imports System
Imports System.IO
Public Shared Sub Main()
	Dim path As String = "nonexistentfile.txt"
	Try
		Using fileStream As New FileStream(path, FileMode.Open, FileAccess.Read)
			Dim buffer(1023) As Byte
			Dim bytesRead As Integer = fileStream.Read(buffer, 0, buffer.Length)
			Console.WriteLine("Bytes Read: " & bytesRead)
		End Using
	Catch e As FileNotFoundException
		Console.WriteLine($"Exception: {e.Message}")
	End Try
End Sub

Mise en mémoire tampon et performances

La classe FileStream comprend un mécanisme de mise en mémoire tampon qui permet d'obtenir des performances plus rapides, en particulier lorsque l'on travaille avec des fichiers volumineux. En utilisant une mémoire tampon, les données sont temporairement stockées dans la mémoire, ce qui réduit la nécessité d'un accès constant au disque.

using System;
using System.IO;
public static void Main()
{
    string path = "bufferedfile.txt";
    byte[] data = System.Text.Encoding.UTF8.GetBytes("Buffered FileStream example.");
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough))
    {
        fileStream.Write(data, 0, data.Length);
    }
}

using System;
using System.IO;
public static void Main()
{
    string path = "bufferedfile.txt";
    byte[] data = System.Text.Encoding.UTF8.GetBytes("Buffered FileStream example.");
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough))
    {
        fileStream.Write(data, 0, data.Length);
    }
}

Imports System
Imports System.IO
Public Shared Sub Main()
	Dim path As String = "bufferedfile.txt"
	Dim data() As Byte = System.Text.Encoding.UTF8.GetBytes("Buffered FileStream example.")
	Using fileStream As New FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough)
		fileStream.Write(data, 0, data.Length)
	End Using
End Sub

Ici, FileOptions.WriteThrough garantit que les données sont écrites directement dans le fichier, sans mise en mémoire tampon supplémentaire. Toutefois, vous pouvez contrôler la taille de la mémoire tampon pour améliorer les performances.

Présentation d'IronPDF

IronPDF est une bibliothèque PDF C# robuste pour créer, éditer et manipuler des documents PDF au sein des applications .NET. Les développeurs peuvent générer des PDFs à partir de diverses entrées telles que HTML, des images, et même du texte brut en utilisant IronPDF. Avec des fonctionnalités telles que le filigrane, la fusion, le fractionnement et la protection par mot de passe, IronPDF est idéal pour les applications web et de bureau avec un contrôle précis de la sortie PDF.

IronPDF avec FileStream

Voici un exemple de génération d'un PDF en utilisant IronPDF et de son enregistrement dans un FileStream. Ceci démontre comment IronPDF s'intègre parfaitement avec FileStream, permettant aux développeurs de contrôler de manière programmatique la création et l'enregistrement des PDF.

using System;
using System.IO;
using IronPdf;
public static void Main()
{
    // Define the file path
    string path = "output.pdf";
    // Create an HTML string that we want to convert to PDF
    var htmlContent = "<h1>IronPDF Example</h1><p>This PDF was generated using IronPDF and saved with FileStream.</p>";
    // Initialize IronPDF's ChromePdfRenderer to render HTML as PDF
    var renderer = new ChromePdfRenderer();
    // Generate the PDF from the HTML string
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
    // Use FileStream to save the generated PDF
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        pdfDocument.SaveAs(fileStream);
    }
    Console.WriteLine("PDF created and saved successfully.");
}

using System;
using System.IO;
using IronPdf;
public static void Main()
{
    // Define the file path
    string path = "output.pdf";
    // Create an HTML string that we want to convert to PDF
    var htmlContent = "<h1>IronPDF Example</h1><p>This PDF was generated using IronPDF and saved with FileStream.</p>";
    // Initialize IronPDF's ChromePdfRenderer to render HTML as PDF
    var renderer = new ChromePdfRenderer();
    // Generate the PDF from the HTML string
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
    // Use FileStream to save the generated PDF
    using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        pdfDocument.SaveAs(fileStream);
    }
    Console.WriteLine("PDF created and saved successfully.");
}

Imports System
Imports System.IO
Imports IronPdf
Public Shared Sub Main()
	' Define the file path
	Dim path As String = "output.pdf"
	' Create an HTML string that we want to convert to PDF
	Dim htmlContent = "<h1>IronPDF Example</h1><p>This PDF was generated using IronPDF and saved with FileStream.</p>"
	' Initialize IronPDF's ChromePdfRenderer to render HTML as PDF
	Dim renderer = New ChromePdfRenderer()
	' Generate the PDF from the HTML string
	Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
	' Use FileStream to save the generated PDF
	Using fileStream As New FileStream(path, FileMode.Create, FileAccess.Write)
		pdfDocument.SaveAs(fileStream)
	End Using
	Console.WriteLine("PDF created and saved successfully.")
End Sub

Conclusion

La classe FileStream en C# offre de puissantes fonctionnalités pour gérer l'entrée et la sortie de fichiers. Il permet aux développeurs de lire et d'écrire des données efficacement, de contrôler la position actuelle dans un fichier et de travailler de manière asynchrone en comprenant comment les tableaux d'octets, les chemins d'accès aux fichiers et la gestion des flux fonctionnent ensemble. L'utilisation de FileStream en combinaison avec IronPDF offre aux développeurs la flexibilité nécessaire pour gérer efficacement les PDF au sein des applications .NET. Qu'il s'agisse de générer des rapports, d'enregistrer des fichiers ou de gérer du contenu dynamique, cette combinaison offre un contrôle précis sur la création et le stockage de documents PDF.

IronPDF offre un essai gratuit et un tarif de licence $749, ce qui en fait une solution compétitive pour les besoins professionnels de génération de PDF.