FileStream C# (Cómo funciona para desarrolladores)

Este artículo se centrará en la clase FileStream en C# y cómo te ayuda a realizar operaciones de lectura y escritura en archivos. Exploraremos ejemplos prácticos, comprenderemos el funcionamiento básico de FileStream y aprenderemos a gestionar los datos de archivos de forma eficaz. Esta guía está dirigida a aquellos que son nuevos en el manejo de archivos en C#, por lo que el lenguaje se mantendrá accesible para principiantes, mientras proporciona instrucciones detalladas sobre cómo trabajar con archivos en C# y una introducción a la biblioteca IronPDF también.

¿Qué es FileStream?

La clase FileStream de C# permite manejar archivos mediante bytes. Funciona con operaciones de lectura y escritura de archivos, lo que permite interactuar directamente con el contenido de los archivos. Esto es particularmente útil cuando se trabaja con archivos para tareas de entrada/salida, especialmente cuando se manipulan matrices de bytes.

Casos de uso de FileStream

FileStream es ideal para:

• Lectura y escritura de datos binarios directamente desde o hacia archivos.
• Manejo eficaz de archivos de gran tamaño.
• Realización de operaciones de archivo asíncronas.
• Gestión de los recursos del sistema mediante el uso eficiente de la memoria.

Ejemplo básico

He aquí un ejemplo sencillo para abrir un archivo, escribir datos y luego leerlos utilizando 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

Este ejemplo muestra la creación de un objeto FileStream para gestionar operaciones de lectura y escritura de archivos. La clase FileStream lee y escribe bytes directamente, lo que la hace adecuada para manejar archivos grandes o datos binarios. Utilizamos Encoding para convertir entre texto y bytes.

Escribir datos con FileStream

Para escribir datos en un archivo, utilizarás el método Write. Aquí tienes un ejemplo que explica cómo funciona con más detalle:

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

En este código, convertimos una cadena en una matriz de bytes utilizando la codificación UTF8. El método Write escribe el arreglo de bytes en el archivo comenzando desde la posición actual (determinada por el desplazamiento) y escribiendo el número especificado de bytes.

• FileMode.Create crea un nuevo archivo, sobrescribiendo cualquier archivo existente con el mismo nombre.
• FileAccess.Write concede permisos de escritura al FileStream.

Lectura de datos con FileStream

Ahora, vamos a explorar cómo leer datos de un archivo utilizando 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

En este ejemplo:

• FileMode.Open abre un archivo existente.
• El método Read lee un número específico de bytes (basado en el tamaño del búfer) y los almacena en el búfer de la matriz de bytes.
• Utilizamos Encoding.UTF8.GetString para convertir los datos de bytes en una cadena.

Gestión del acceso a archivos con FileStream

La clase FileStream controla el acceso a los archivos, lo que permite un manejo preciso de los mismos y la gestión de los recursos del sistema. Al utilizar FileStream, es vital asegurarse de que el flujo se elimine correctamente después de su uso, ya sea llamando a Close() manualmente o utilizando la declaración que elimina automáticamente el flujo.

Manejo de la posición del archivo

Cada vez que lees o escribes en un archivo, FileStream mantiene un registro de la posición actual dentro del archivo. Puedes acceder a esta posición utilizando la propiedad 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

Uso de FileStream para operaciones asíncronas

FileStream puede utilizarse para operaciones asíncronas de lectura y escritura, lo que mejora el rendimiento al permitir que se ejecuten otros procesos mientras se realizan las operaciones de archivo. He aquí un ejemplo básico de lectura asíncrona:

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

El método ReadAsync lee los datos de forma asíncrona. Los parámetros FileAccess.Read y FileMode.Open controlan cómo se accede al archivo.

Ejemplo de manejo de excepciones

Al trabajar con FileStream, manejar excepciones es esencial para evitar errores en tiempo de ejecución y gestionar adecuadamente los recursos del sistema. He aquí un patrón para manejar excepciones al leer o escribir en archivos:

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

Almacenamiento en búfer y rendimiento

La clase FileStream incluye un mecanismo de almacenamiento en búfer que permite un rendimiento más rápido, especialmente cuando se trabaja con archivos de gran tamaño. Mediante un búfer, los datos se almacenan temporalmente en la memoria, lo que reduce la necesidad de acceder constantemente al disco.

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

En este caso, FileOptions.WriteThrough garantiza que los datos se escriban directamente en el archivo, evitando el almacenamiento en búfer adicional. Sin embargo, se puede controlar el tamaño del búfer para ajustar el rendimiento.

Presentación de IronPDF

IronPDF es una robusta biblioteca PDF para C# que permite crear, editar y manipular documentos PDF dentro de aplicaciones .NET. Los desarrolladores pueden generar PDFs a partir de varias entradas, como HTML, imágenes e incluso texto sin formato utilizando IronPDF. Con funciones como marcas de agua, fusión, división y protección por contraseña, IronPDF es ideal para aplicaciones web y de escritorio con un control preciso sobre el resultado PDF.

IronPDF con FileStream

A continuación se muestra un ejemplo de cómo generar un PDF utilizando IronPDF y guardarlo en un FileStream. Esto demuestra cómo IronPDF se integra sin problemas con FileStream, permitiendo a los desarrolladores controlar programáticamente la creación y el guardado de PDFs.

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

Conclusión

La clase FileStream en C# ofrece una potente funcionalidad para gestionar la entrada y salida de archivos. Permite a los desarrolladores leer y escribir datos de forma eficiente, controlar la posición actual dentro de un archivo y trabajar de forma asíncrona mediante la comprensión de cómo funcionan conjuntamente las matrices de bytes, las rutas de archivos y la gestión de flujos. El uso de FileStream en combinación con IronPDF proporciona a los desarrolladores la flexibilidad necesaria para gestionar archivos PDF de forma eficaz en aplicaciones .NET. Ya se trate de generar informes, guardar archivos o manejar contenido dinámico, esta combinación ofrece un control preciso sobre la creación y el almacenamiento de documentos PDF.

IronPDF ofrece una prueba gratuita y una tarifa de licencia $749, lo que lo convierte en una solución competitiva para las necesidades profesionales de generación de PDF.