FileStream C# (Comment ça fonctionne 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 les fichiers. Nous allons explorer des exemples pratiques, comprendre comment FileStream fonctionne dans son essence, et apprendre à gérer efficacement les données des fichiers. Ce guide est destiné à ceux qui débutent dans la gestion de fichiers en C#, donc le langage restera convivial pour les débutants tout en fournissant des instructions détaillées sur le travail avec les fichiers en C# et une introduction à la bibliothèque IronPDF également.
Qu'est-ce que FileStream ?
La classe FileStream en C# fournit un moyen de gérer les fichiers en utilisant des octets. Elle fonctionne avec des opérations de lecture et d'écriture sur les fichiers, vous permettant d'interagir directement avec le contenu des fichiers. C'est particulièrement utile lorsque vous travaillez avec des fichiers pour des tâches d'entrée/sortie, surtout en manipulant des tableaux d'octets.
Cas d'utilisation de FileStream
FileStream est idéal pour :
- Lire et écrire des données binaires directement à partir ou vers des fichiers.
- Gérer efficacement de grands fichiers.
- Effectuer des opérations de fichiers asynchrones.
- Gérer les ressources système en utilisant efficacement la mémoire.
Exemple de base
Voici un exemple simple pour ouvrir un fichier, écrire des données, puis les lire en utilisant FileStream :
using System;
using System.IO;
public class Example
{
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!");
// Write data to file
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 class Example
{
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!");
// Write data to file
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 Class Example
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!")
' Write data to file
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
End Class
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 des octets directement, ce qui la rend adaptée à la gestion de grands fichiers ou de données binaires. Nous avons utilisé Encoding pour convertir entre texte et octets.
Écriture de données avec FileStream
Pour écrire des données dans un fichier, vous utiliserez la méthode Write. Voici un exemple qui explique comment cela fonctionne en détail :
using System;
using System.IO;
public class FileWriteExample
{
public static void Main()
{
string path = "output.txt";
// Creating a FileStream object to write data to the file
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 class FileWriteExample
{
public static void Main()
{
string path = "output.txt";
// Creating a FileStream object to write data to the file
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 Class FileWriteExample
Public Shared Sub Main()
Dim path As String = "output.txt"
' Creating a FileStream object to write data to the file
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
End Class
Dans ce code, nous convertissons une chaîne en un tableau d'octets en utilisant le codage 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 en écrivant 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 autorisations d'écriture au FileStream.
Lecture de données avec FileStream
Maintenant, explorons comment lire des données à partir d'un fichier en utilisant FileStream.
using System;
using System.IO;
public class FileReadExample
{
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 class FileReadExample
{
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 Class FileReadExample
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
End Class
Dans cet exemple :
- FileMode.Open ouvre un fichier existant.
- La méthode Read lit un nombre spécifié d'octets (en fonction de la taille du tampon) et les stocke dans le tampon tableau d'octets.
- Nous utilisons
Encoding.UTF8.GetStringpour reconvertir les données binaires en une chaîne de caractères.
Gestion de l'accès aux fichiers avec FileStream
La classe FileStream contrôle l'accès aux fichiers, permettant une gestion affinée des descripteurs de fichiers et des ressources système. Lors de l'utilisation de FileStream, il est essentiel de s'assurer que le flux est correctement supprimé après utilisation, soit en appelant Close() manuellement, soit en utilisant l'instruction using qui supprime automatiquement le flux.
Gestion de la position du fichier
Chaque fois que vous lisez ou écrivez dans un fichier, FileStream suit la position actuelle dans le fichier. Vous pouvez accéder à cette position en utilisant 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 des opérations asynchrones
FileStream peut être utilisé pour des opérations de lecture et d'écriture asynchrones, améliorant les performances en permettant à d'autres processus de s'exécuter pendant que les opérations de fichiers sont effectuées. Voici un exemple basique de lecture asynchrone :
using System;
using System.IO;
using System.Threading.Tasks;
public class AsyncReadExample
{
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 class AsyncReadExample
{
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 Class AsyncReadExample
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
End Class
La méthode ReadAsync lit les données de manière asynchrone. Les paramètres FileAccess.Read et FileMode.Open contrôlent la manière dont le fichier est accédé.
Exemple de gestion 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 système. Voici un modèle pour gérer les exceptions lors de la lecture ou de l'écriture dans les fichiers :
using System;
using System.IO;
public class ExceptionHandlingExample
{
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 class ExceptionHandlingExample
{
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 Class ExceptionHandlingExample
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
End Class
Mise en mémoire tampon et performances
La classe FileStream inclut un mécanisme de mise en mémoire tampon qui permet des performances plus rapides, surtout lorsque vous travaillez avec de grands fichiers. En utilisant un tampon, les données sont stockées temporairement en mémoire, réduisant le besoin d'accès constant au disque.
using System;
using System.IO;
public class BufferingExample
{
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 class BufferingExample
{
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 Class BufferingExample
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
End Class
Ici, FileOptions.WriteThrough garantit que les données sont écrites directement dans le fichier, en contournant la mise en mémoire tampon supplémentaire. Cependant, vous pouvez contrôler la taille du tampon pour un réglage des performances.
Présentation d'IronPDF

IronPDF est une bibliothèque C# PDF robuste pour la création, la modification et la manipulation de documents PDF au sein des applications .NET. Les développeurs peuvent générer des PDF à partir de diverses entrées telles que HTML, des images, et même du texte brut avec IronPDF. Avec des fonctionnalités telles que le filigrane, la fusion, la division et la protection par mot de passe, IronPDF est idéal pour les applications web et de bureau avec un contrôle précis sur la sortie PDF.
IronPDF avec FileStream
Voici un exemple de génération d'un PDF avec IronPDF et en l'enregistrant dans un FileStream. Cela 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 de PDF.
using System;
using System.IO;
using IronPdf;
public class IronPDFExample
{
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 class IronPDFExample
{
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 Class IronPDFExample
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
End Class
Conclusion

La classe FileStream en C# offre une fonctionnalité puissante pour la gestion des entrées et sorties de fichiers. Elle permet aux développeurs de lire et é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 de fichiers, et la gestion des flux fonctionnent ensemble. L'utilisation de FileStream en combinaison avec IronPDF offre aux développeurs la flexibilité de gérer efficacement les PDFs au sein des applications .NET. Que vous génériez des rapports, enregistrez des fichiers ou gériez du contenu dynamique, cette combinaison offre un contrôle raffiné sur la création et le stockage de documents PDF.
IronPDF propose un essai gratuit et une licence à $999, ce qui en fait une solution compétitive pour les besoins Professional de génération de PDF.
Questions Fréquemment Posées
Comment puis-je effectuer des opérations de lecture et d'écriture sur des fichiers en C# ?
Vous pouvez effectuer des opérations de lecture et d'écriture sur des fichiers en C# en utilisant la classe FileStream. Elle vous permet d'ouvrir un fichier et d'utiliser des méthodes comme Read et Write pour gérer les données des fichiers efficacement.
Quels sont les avantages de l'utilisation de FileStream pour la gestion des fichiers en C# ?
FileStream est bénéfique pour gérer des données binaires, traiter de grands fichiers et effectuer des opérations asynchrones sur fichiers efficacement. Il optimise l'utilisation de la mémoire et permet un contrôle précis du traitement des données de fichiers.
Comment FileStream gère-t-il les gros fichiers ?
FileStream gère les gros fichiers en utilisant la mise en tampon, qui stocke temporairement les données en mémoire pour minimiser l'accès au disque. Cela améliore les performances et rend FileStream adapté pour travailler avec de grands fichiers.
FileStream peut-il être utilisé pour des opérations de fichiers asynchrones ?
Oui, FileStream prend en charge les opérations de fichiers asynchrones. Vous pouvez utiliser des méthodes comme ReadAsync et WriteAsync pour améliorer les performances de l'application en permettant un traitement concurrent.
Pourquoi est-il important de disposer correctement des objets FileStream ?
Disposer correctement des objets FileStream est crucial pour libérer des ressources système et éviter les verrous de fichiers. Vous pouvez utiliser une instruction using ou appeler la méthode Dispose pour vous assurer que les ressources sont libérées correctement.
Comment pouvez-vous intégrer la génération de PDF avec la gestion des fichiers en C# ?
Vous pouvez intégrer la génération de PDF avec la gestion des fichiers en C# avec IronPDF. IronPDF vous permet de créer et de manipuler des documents PDF et de les enregistrer en utilisant FileStream, combinant ainsi la gestion des fichiers et la création de PDF sans faille.
Quelles sont les fonctionnalités d'IronPDF pour la manipulation des PDF ?
IronPDF offre des fonctionnalités telles que la création, l'édition et la manipulation de PDF, l'ajout de filigranes, la fusion de documents, la division de fichiers et l'application de la protection par mot de passe, en faisant un outil complet pour la gestion des PDF dans les applications .NET.




