La gestión efectiva de la memoria y la manipulación de datos son componentes esenciales para construir código de alto rendimiento en el mundo de la programación. Escribir código efectivo y sin errores requiere entender cómo se transmiten datos entre métodos y funciones en lenguajes como C#. Una idea crucial en este procedimiento es "paso por referencia". Exploraremos el significado de paso por referencia en C# y los escenarios de uso apropiados en este artículo.

Cómo usar C# Pasar por referencia

1. Definir un Método con Parámetros Ref.
2. Inicializar una Variable.
3. Llamar al Método con la Palabra Clave Ref.
4. Modificar la Variable Dentro del Método.
5. Observar los Cambios en el Método Principal.
6. Definir otro Método con Parámetro Out para generar PDF.
7. Inicializar y Llamar al Método Out.

¿Qué es Pasar por referencia en C#?

Utilizar una referencia para pasar se refiere al modo en C# para enviar argumentos a funciones o métodos, dando una referencia a la variable original del método llamado en lugar de una copia de su valor. Esto implica que cualquier cambio realizado en el parámetro dentro del método también afectará a la variable original fuera del método.

Las variables de tipo valor en C# (como int, float, bool, etc.) generalmente se suministran por valor, lo que significa que el método recibe una copia del valor de la variable. No obstante, puede indicarle al compilador que pase argumentos por referencia utilizando la palabra clave ref.

Uso de la palabra clave ref

En C#, se pueden utilizar argumentos para parámetros de referencia pasados por referencia utilizando la palabra clave ref. Cualquier modificación realizada a un parámetro que se suministre por referencia usando la palabra clave ref impactará en la variable original.

class Program
{
    static void Main(string[] args)
    {
        int num = 10;
        Console.WriteLine("Before: " + num); // Output: Before: 10
        ModifyByRef(ref num);
        Console.WriteLine("After: " + num);  // Output: After: 20
    }
    
    // Method that modifies the integer by reference
    static void ModifyByRef(ref int x)
    {
        x = x * 2; // Modify the original value by reference
    }
}

class Program
{
    static void Main(string[] args)
    {
        int num = 10;
        Console.WriteLine("Before: " + num); // Output: Before: 10
        ModifyByRef(ref num);
        Console.WriteLine("After: " + num);  // Output: After: 20
    }
    
    // Method that modifies the integer by reference
    static void ModifyByRef(ref int x)
    {
        x = x * 2; // Modify the original value by reference
    }
}

Module Program
    Sub Main(args As String())
        Dim num As Integer = 10
        Console.WriteLine("Before: " & num) ' Output: Before: 10
        ModifyByRef(num)
        Console.WriteLine("After: " & num)  ' Output: After: 20
    End Sub

    ' Method that modifies the integer by reference
    Sub ModifyByRef(ByRef x As Integer)
        x = x * 2 ' Modify the original value by reference
    End Sub
End Module

Module Program
    Sub Main(args As String())
        Dim num As Integer = 10
        Console.WriteLine("Before: " & num) ' Output: Before: 10
        ModifyByRef(num)
        Console.WriteLine("After: " & num)  ' Output: After: 20
    End Sub

    ' Method that modifies the integer by reference
    Sub ModifyByRef(ByRef x As Integer)
        x = x * 2 ' Modify the original value by reference
    End Sub
End Module

El método ModifyByRef en el ejemplo anterior usa la palabra clave ref para tomar un parámetro entero, x, por referencia. Cualquier modificación hecha al parámetro ref x dentro del método tiene un impacto inmediato en la variable num fuera del método cuando se invoca el método con ref num.

La palabra clave out

La palabra clave out se usa para pasar parámetros por referencia al método que llama, al igual que ref. Como resultado, los métodos son capaces de devolver múltiples valores.

class Program
{
    static void Main(string[] args)
    {
        int result;
        Calculate(10, 5, out result);
        Console.WriteLine("Result: " + result); // Output: Result: 15
    }
    
    // Method that calculates the sum of two integers and outputs the result by reference
    static void Calculate(int x, int y, out int result)
    {
        result = x + y; // Assign the sum to the out parameter
    }
}

class Program
{
    static void Main(string[] args)
    {
        int result;
        Calculate(10, 5, out result);
        Console.WriteLine("Result: " + result); // Output: Result: 15
    }
    
    // Method that calculates the sum of two integers and outputs the result by reference
    static void Calculate(int x, int y, out int result)
    {
        result = x + y; // Assign the sum to the out parameter
    }
}

Module Program
    Sub Main(args As String())
        Dim result As Integer
        Calculate(10, 5, result)
        Console.WriteLine("Result: " & result) ' Output: Result: 15
    End Sub

    ' Method that calculates the sum of two integers and outputs the result by reference
    Sub Calculate(x As Integer, y As Integer, ByRef result As Integer)
        result = x + y ' Assign the sum to the out parameter
    End Sub
End Module

Module Program
    Sub Main(args As String())
        Dim result As Integer
        Calculate(10, 5, result)
        Console.WriteLine("Result: " & result) ' Output: Result: 15
    End Sub

    ' Method that calculates the sum of two integers and outputs the result by reference
    Sub Calculate(x As Integer, y As Integer, ByRef result As Integer)
        result = x + y ' Assign the sum to the out parameter
    End Sub
End Module

En este ejemplo, se pasan al método Calculate dos parámetros enteros, x y y, así como un parámetro adicional result denotado por la palabra clave out. El resultado se asigna al parámetro result después de que el procedimiento calcula la suma de x y y. El result no necesita ser inicializado antes de ser enviado al método porque está marcado como out.

Cuándo usar el paso por referencia

Escribir código eficiente y mantenible requiere saber cuándo utilizar paso por referencia. Las siguientes situaciones requieren el uso de paso por referencia:

Modificación de múltiples variables

Pasar los parámetros por referencia puede ser útil cuando un método necesita cambiar varias variables y esos cambios deben reflejarse fuera del método. En lugar de que el procedimiento devuelva múltiples valores, las variables pueden ser enviadas por referencia y modificadas directamente dentro del método.

// Method that modifies multiple variables by reference
static void ModifyMultipleByRef(ref int a, ref int b)
{
    a *= 2; // Double the first variable
    b *= 3; // Triple the second variable
}

// Method that modifies multiple variables by reference
static void ModifyMultipleByRef(ref int a, ref int b)
{
    a *= 2; // Double the first variable
    b *= 3; // Triple the second variable
}

' Method that modifies multiple variables by reference
Shared Sub ModifyMultipleByRef(ByRef a As Integer, ByRef b As Integer)
	a *= 2 ' Double the first variable
	b *= 3 ' Triple the second variable
End Sub

' Method that modifies multiple variables by reference
Shared Sub ModifyMultipleByRef(ByRef a As Integer, ByRef b As Integer)
	a *= 2 ' Double the first variable
	b *= 3 ' Triple the second variable
End Sub

Grandes estructuras de datos

Al prevenir la duplicación innecesaria de datos, pasar grandes estructuras de datos, como arreglos u objetos complejos, por referencia puede mejorar la eficiencia. Sin embargo, el paso por referencia debe usarse con precaución al trabajar con grandes estructuras de datos, ya que puede tener consecuencias inesperadas si no se maneja adecuadamente.

Interoperabilidad con código externo

Puede ser necesario enviar argumentos por referencia para cumplir tanto con la definición del método como con los requisitos del código externo al interactuar con bibliotecas externas o integrar código nativo.

¿Qué es IronPDF?

IronPDF permite a los programadores crear, modificar y renderizar documentos PDF dentro de aplicaciones .NET. Su amplia gama de características facilita el trabajo con archivos PDF. Puedes crear documentos PDF a partir de HTML, imágenes y otros formatos; anotar PDFs con texto, imágenes y otros datos; y dividir, unir y editar documentos PDF preexistentes.

La característica principal de IronPDF es su capacidad para convertir HTML a PDF, asegurando que se conserven los diseños y estilos. Esta funcionalidad es excelente para generar PDFs a partir de contenido basado en la web como informes, facturas y documentación. Convierte archivos HTML, URLs y cadenas HTML en archivos PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' 1. Convert HTML String to PDF
        Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
        Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

        ' 2. Convert HTML File to PDF
        Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
        Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

        ' 3. Convert URL to PDF
        Dim url = "http://ironpdf.com" ' Specify the URL
        Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
        pdfFromUrl.SaveAs("URLToPDF.pdf")
    End Sub
End Module

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' 1. Convert HTML String to PDF
        Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
        Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

        ' 2. Convert HTML File to PDF
        Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
        Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

        ' 3. Convert URL to PDF
        Dim url = "http://ironpdf.com" ' Specify the URL
        Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
        pdfFromUrl.SaveAs("URLToPDF.pdf")
    End Sub
End Module

Características de IronPDF

Anotación de texto e imágenes

IronPDF te permite agregar texto, imágenes y anotaciones a documentos PDF de manera programática. Gracias a esta funcionalidad, puedes anotar archivos PDF con firmas, sellos y comentarios.

Seguridad en PDF

IronPDF te permite especificar diferentes permisos, incluyendo impresión, copia de contenido y edición del documento, y puede cifrar documentos PDF con contraseñas. Esto te ayuda a controlar el acceso a los archivos PDF y proteger datos confidenciales.

Rellenar formularios PDF interactivos

IronPDF te permite rellenar formularios PDF interactivos de manera programática. Esta capacidad es útil para crear documentos personalizados utilizando la entrada del usuario o automatizar el envío de formularios.

Compresión y optimización de PDF

Para minimizar el tamaño del archivo sin sacrificar la calidad, IronPDF ofrece soluciones tanto para la compresión como para la optimización de archivos PDF. Esto reduce la cantidad de almacenamiento necesario para los documentos PDF mientras también mejora el rendimiento.

Compatibilidad multiplataforma

IronPDF está diseñado para funcionar sin problemas con aplicaciones .NET que están destinadas para Windows, Linux y macOS, entre otras plataformas. Se integra con marcos .NET populares como ASP.NET, .NET Core y Xamarin.

Crear un nuevo proyecto de Visual Studio

Es fácil crear un proyecto de consola con Visual Studio. Para crear una Aplicación de Consola, haz lo siguiente en Visual Studio:

Antes de comenzar Visual Studio Development, asegúrate de haberlo instalado en tu computadora.

Iniciar un nuevo proyecto

Selecciona Archivo, luego Nuevo y finalmente Proyecto.

En el lado izquierdo del cuadro "Crear un nuevo proyecto", selecciona tu lenguaje de programación preferido (C#, por ejemplo).

La plantilla "Aplicación de Consola" o "Aplicación de Consola (.NET Core)" se puede seleccionar de la siguiente lista de plantillas de proyectos.

Proporciona un nombre para tu proyecto en el campo "Nombre".

Selecciona la ubicación de almacenamiento donde deseas almacenar el proyecto.

Presiona "Crear" para iniciar el proyecto de aplicación de consola.

Instalación de IronPDF

Bajo Herramientas en las Herramientas de Visual Studio, puedes encontrar la interfaz de Línea de Comandos Visual. Selecciona el Administrador de Paquetes para NuGet. En la pestaña del terminal de administración de paquetes, debes escribir el siguiente comando.

Install-Package IronPdf

Otra alternativa es usar el Administrador de Paquetes. Es posible instalar el paquete directamente en la solución con la opción del Administrador de Paquetes NuGet. Utiliza el cuadro de búsqueda en el sitio web de NuGet para localizar paquetes. El siguiente ejemplo de captura de pantalla ilustra lo fácil que es buscar "IronPDF" en el administrador de paquetes:

La lista de resultados de búsqueda relevantes se puede ver en la imagen anterior. Para permitir la instalación del software en tu máquina, amablemente ajusta estos ajustes.

Una vez que el paquete haya sido descargado e instalado, ahora se puede usar en el proyecto actual.

Uso del paso por referencia con IronPDF

Este es un ejemplo de cómo usar la característica de paso por referencia de IronPDF.

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Create a PDF document
        var pdf = new IronPdf.HtmlToPdf();
        // HTML content to be converted to PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";
        // Create a byte array to store the PDF content
        byte[] pdfBytes;
        // Convert HTML to PDF and pass the byte array by reference
        ConvertHtmlToPdf(pdf, htmlContent, out pdfBytes);
        // Save or process the PDF content
        // For demonstration, let's print the length of the PDF content
        Console.WriteLine("Length of PDF: " + pdfBytes.Length);
    }
    
    // Method that converts HTML content to PDF and stores it in a byte array by reference
    static void ConvertHtmlToPdf(IronPdf.HtmlToPdf pdfConverter, string htmlContent, out byte[] pdfBytes)
    {
        // Convert HTML to PDF and store the result in the byte array
        var pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent);
        pdfBytes = pdfDoc.BinaryData;
    }
}

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Create a PDF document
        var pdf = new IronPdf.HtmlToPdf();
        // HTML content to be converted to PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";
        // Create a byte array to store the PDF content
        byte[] pdfBytes;
        // Convert HTML to PDF and pass the byte array by reference
        ConvertHtmlToPdf(pdf, htmlContent, out pdfBytes);
        // Save or process the PDF content
        // For demonstration, let's print the length of the PDF content
        Console.WriteLine("Length of PDF: " + pdfBytes.Length);
    }
    
    // Method that converts HTML content to PDF and stores it in a byte array by reference
    static void ConvertHtmlToPdf(IronPdf.HtmlToPdf pdfConverter, string htmlContent, out byte[] pdfBytes)
    {
        // Convert HTML to PDF and store the result in the byte array
        var pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent);
        pdfBytes = pdfDoc.BinaryData;
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        ' Create a PDF document
        Dim pdf As New IronPdf.HtmlToPdf()
        ' HTML content to be converted to PDF
        Dim htmlContent As String = "<h1>Hello, IronPDF!</h1>"
        ' Create a byte array to store the PDF content
        Dim pdfBytes As Byte()
        ' Convert HTML to PDF and pass the byte array by reference
        ConvertHtmlToPdf(pdf, htmlContent, pdfBytes)
        ' Save or process the PDF content
        ' For demonstration, let's print the length of the PDF content
        Console.WriteLine("Length of PDF: " & pdfBytes.Length)
    End Sub

    ' Method that converts HTML content to PDF and stores it in a byte array by reference
    Sub ConvertHtmlToPdf(pdfConverter As IronPdf.HtmlToPdf, htmlContent As String, ByRef pdfBytes As Byte())
        ' Convert HTML to PDF and store the result in the byte array
        Dim pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent)
        pdfBytes = pdfDoc.BinaryData
    End Sub
End Module

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        ' Create a PDF document
        Dim pdf As New IronPdf.HtmlToPdf()
        ' HTML content to be converted to PDF
        Dim htmlContent As String = "<h1>Hello, IronPDF!</h1>"
        ' Create a byte array to store the PDF content
        Dim pdfBytes As Byte()
        ' Convert HTML to PDF and pass the byte array by reference
        ConvertHtmlToPdf(pdf, htmlContent, pdfBytes)
        ' Save or process the PDF content
        ' For demonstration, let's print the length of the PDF content
        Console.WriteLine("Length of PDF: " & pdfBytes.Length)
    End Sub

    ' Method that converts HTML content to PDF and stores it in a byte array by reference
    Sub ConvertHtmlToPdf(pdfConverter As IronPdf.HtmlToPdf, htmlContent As String, ByRef pdfBytes As Byte())
        ' Convert HTML to PDF and store the result in the byte array
        Dim pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent)
        pdfBytes = pdfDoc.BinaryData
    End Sub
End Module

La función ConvertHtmlToPdf en este ejemplo toma tres parámetros: contenido HTML, un arreglo de bytes llamado pdfBytes y un objeto de IronPDF HtmlToPdf. La palabra clave out indica que el parámetro pdfBytes se suministra por referencia y se cambiará dentro del método.

El contenido HTML se renderiza como un documento PDF usando IronPDF dentro de la función ConvertHtmlToPdf, y los datos binarios resultantes se almacenan en el arreglo pdfBytes.

Utilizamos Conversión de HTML a PDF de IronPDF nuevamente en la función Main, pasando el arreglo pdfBytes por referencia. Después de la llamada al método, el contenido del PDF de IronPDF se almacena en la ubicación de memoria del arreglo pdfBytes.

Esto te muestra cómo crear y trabajar con documentos PDF de manera eficiente usando IronPDF y paso por referencia en C#.

Conclusión

En resumen, usar IronPDF con paso por referencia en C# mejora significativamente las capacidades de crear y modificar documentos PDF en programas .NET. El uso eficaz de las palabras clave ref y out permite a los desarrolladores transmitir argumentos por referencia con facilidad, haciendo posible modificar variables y contenido dentro de los métodos de manera rápida y eficiente. La amplia gama de funciones de IronPDF, que incluye la capacidad de convertir HTML a PDF, generar PDFs basados en imágenes y realizar tareas extensas de modificación de PDF, permite a los desarrolladores construir fácilmente documentos PDF dinámicos e interactivos.

IronPDF ofrece las herramientas y las APIs necesarias para agilizar los procesos de manejo de documentos, incluyendo la división, unión, anotación y optimización de archivos PDF. Además, la interoperabilidad multiplataforma de IronPDF garantiza que las aplicaciones C# puedan incorporar características PDF con facilidad en una variedad de entornos. Esencialmente, los desarrolladores pueden crear nuevas vías para crear, modificar y mostrar documentos PDF en sus aplicaciones al fusionar la fuerza del paso por referencia de C# con la abundante gama de funciones de IronPDF.

Por último, puedes trabajar eficientemente con Excel, hacer PDFs, realizar OCR y usar códigos de barras. Los precios de cada biblioteca comienzan en $999. Los desarrolladores pueden elegir el mejor modelo con confianza si hay opciones de licencia claras que están ajustadas a las necesidades del proyecto. Con estas ventajas, los desarrolladores pueden resolver una variedad de desafíos con eficiencia y transparencia.