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

Cet article se concentre sur laClasse FileStream en C# et comment il 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 s'adresse à ceux qui débutent dans la manipulation de fichiers en C#, le langage restera donc adapté aux débutants tout en fournissant des instructions détaillées sur le travail avec des fichiers en C# et une introduction à l'outil de gestion des fichiersBibliothè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 en commençant par la position actuelle(déterminé par l'offset) et écrire le nombre d'octets spécifié.

• 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 de la mémoire tampon) et les stocke dans la mémoire tampon du 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. Lorsque l'on utilise FileStream, il est essentiel de s'assurer que le flux est correctement éliminé après utilisation, soit en appelant Close() la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.

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

Lorsque vous travaillez avec FileStream, la gestion des exceptions est essentielle pour éviter les erreurs d'exécution et gérer correctement les ressources du 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 permettant de créer, d'éditer et de manipuler des documents PDF au sein d'applications .NET. Les développeurs peuventgénérer des PDF à partir de divers éléments d'entrée tels que HTMLla traduction peut également être réalisée à l'aide d'IronPDF, d'images et même de texte brut. 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 à l'aide d'IronPDF et de son enregistrement dans un FileStream. Cela démontre comment IronPDF s'intègre en douceur 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 service deessai gratuit le prix de la traduction est de 1,50 euros et les frais de licence de 749 euros, ce qui en fait une solution compétitive pour les besoins professionnels en matière de génération de PDF.