C# Const (Cómo funciona para desarrolladores)

En C#, un const palabra clave es una potente herramienta para definir campos o valores constantes que se conocen en tiempo de compilación. Estos valores son inmutables, es decir, una vez establecidos, su valor no puede modificarse a lo largo del programa. Utilizar const puede hacer que su código sea más legible y fácil de mantener al proporcionar una indicación clara de los valores que deben permanecer constantes. En este artículo, hablaremos de la palabra clave const y de Biblioteca IronPDF.

Declaración de variables constantes

Para declarar una variable constante, se utiliza la palabra clave const seguida de un tipo de datos y, a continuación, se inicializa inmediatamente. Por ejemplo, const int miValorConst = 100; define una constante entera. Es importante tener en cuenta que una variable constante debe ser inicializada cuando se declara, ya que su valor está destinado a ser en tiempo de compilación, y totalmente evaluado antes de que el programa se ejecuta.

public class Program
{
    public const int MaxSize = 10;
    static void Main(string [] args)
    {
        Console.WriteLine(MaxSize);
    }
}

public class Program
{
    public const int MaxSize = 10;
    static void Main(string [] args)
    {
        Console.WriteLine(MaxSize);
    }
}

Public Class Program
	Public Const MaxSize As Integer = 10
	Shared Sub Main(ByVal args() As String)
		Console.WriteLine(MaxSize)
	End Sub
End Class

Este ejemplo ilustra un uso sencillo de una constante entera (const int) dentro de una clase. La constante MaxSize es accesible dentro de la misma clase y puede ser utilizada directamente en el método static void Main.

Variables const vs. readonly

Aunque las palabras clave const y readonly se utilizan para declarar valores inmutables, existen diferencias importantes entre ellas. Un campo const es una constante en tiempo de compilación, lo que significa que su valor se determina en tiempo de compilación y se incrusta directamente en el Lenguaje Intermedio (IL) código. Esto hace que sea estática y no se pueda modificar.

En cambio, una variable readonly puede asignarse en el momento de la declaración o dentro de un constructor de la clase. Esto permite cierta flexibilidad, ya que los campos readonly pueden tener valores diferentes dependiendo del constructor utilizado para instanciar la clase.

public class Program
{
    public const string ConstExample = "Constant"; //  cadena constante
    public readonly string ReadonlyExample;
    public Program()
    {
        ReadonlyExample = "Initialized at runtime";
    }
    static void Main(string [] args)
    {
        Program p = new Program();
        Console.WriteLine(ConstExample);
        Console.WriteLine(p.ReadonlyExample);
    }
}

public class Program
{
    public const string ConstExample = "Constant"; //  cadena constante
    public readonly string ReadonlyExample;
    public Program()
    {
        ReadonlyExample = "Initialized at runtime";
    }
    static void Main(string [] args)
    {
        Program p = new Program();
        Console.WriteLine(ConstExample);
        Console.WriteLine(p.ReadonlyExample);
    }
}

Public Class Program
	Public Const ConstExample As String = "Constant" '  cadena constante
	Public ReadOnly ReadonlyExample As String
	Public Sub New()
		ReadonlyExample = "Initialized at runtime"
	End Sub
	Shared Sub Main(ByVal args() As String)
		Dim p As New Program()
		Console.WriteLine(ConstExample)
		Console.WriteLine(p.ReadonlyExample)
	End Sub
End Class

Alcance de las variables const

Las variables constantes pueden declararse dentro de un método o como miembro de una clase. Cuando declaras una variable const dentro de un método, se conoce como constante local. Las constantes locales sólo son accesibles dentro del método en el que se declaran.

public class Program
{
    static void DemoMethod()
    {
        const int LocalConst = 5; //  constante local
        Console.WriteLine(LocalConst);
    }
}

public class Program
{
    static void DemoMethod()
    {
        const int LocalConst = 5; //  constante local
        Console.WriteLine(LocalConst);
    }
}

Public Class Program
	Private Shared Sub DemoMethod()
		Const LocalConst As Integer = 5 '  constante local
		Console.WriteLine(LocalConst)
	End Sub
End Class

En cambio, cuando un const se declara dentro de una clase pero fuera de cualquier método, es accesible desde cualquier función estática de la misma, porque los campos const son implícitamente estáticos. Sin embargo, si se intenta acceder a un campo const desde un método de instancia sin referenciarlo a través del nombre de la clase, se producirá un error de compilación.

Constantes en tiempo de compilación frente a constantes en tiempo de ejecución

La principal característica de los valores const es que se evalúan en tiempo de compilación. Esto significa que el valor de un campo const debe ser conocido y evaluado completamente por el compilador. Esto contrasta con las variables que se evalúan en tiempo de ejecución, cuyos valores se determinan durante la ejecución del programa.

Por ejemplo, si se intenta asignar un valor a un campo const basándose en un cálculo realizado en tiempo de ejecución, se producirá un error de compilación. El compilador requiere que los valores const se asignen a partir de expresiones constantes o valores literales conocidos en tiempo de compilación.

const double Pi = Math.PI; //  Esto provocará un error de compilación

const double Pi = Math.PI; //  Esto provocará un error de compilación

Const Pi As Double = Math.PI '  Esto provocará un error de compilación

Uso avanzado de constantes y miembros estáticos en C#

Más allá de los conceptos básicos de const y readonly en C#, entender cómo trabajar con expresiones constantes, constructores estáticos y campos estáticos puede elevar tus prácticas de codificación, especialmente cuando se trata de valores constantes que necesitan ser compartidos a través de instancias de una clase.

Expresiones constantes

Una expresión constante en C# es una expresión que puede evaluarse completamente en tiempo de compilación. Por lo tanto, al declarar una variable const, el lado derecho de su declaración debe ser una expresión constante. Esto garantiza que el valor const sea fijo y pueda incrustarse directamente en el código compilado, dando lugar a aplicaciones altamente optimizadas y eficientes.

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; //  Expresión constante
}

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; //  Expresión constante
}

Public Class Calculator
	Public Const Multiplier As Integer = 2
	Public Const DoubleMultiplier As Integer = Multiplier * 2 '  Expresión constante
End Class

En este ejemplo, DoubleMultiplier es una expresión constante porque se calcula utilizando otro valor constante, lo que la hace elegible para ser una constante en tiempo de compilación.

Constructor estático

Un constructor estático en C# es un constructor especial que inicializa los campos estáticos de la clase. Se llama automáticamente antes de que se cree la primera instancia o se haga referencia a cualquier miembro estático. Los constructores estáticos son útiles para la inicialización compleja de datos estáticos o para realizar acciones que deben ocurrir una vez por tipo en lugar de por instancia.

public class Program
{
    public static readonly string StartTime;
    static Program()
    {
        StartTime = DateTime.Now.ToString("T");
    }
    public static void DisplayStartTime()
    {
        Console.WriteLine($"Program started at: {StartTime}");
    }
}

public class Program
{
    public static readonly string StartTime;
    static Program()
    {
        StartTime = DateTime.Now.ToString("T");
    }
    public static void DisplayStartTime()
    {
        Console.WriteLine($"Program started at: {StartTime}");
    }
}

Public Class Program
	Public Shared ReadOnly StartTime As String
	Shared Sub New()
		StartTime = DateTime.Now.ToString("T")
	End Sub
	Public Shared Sub DisplayStartTime()
		Console.WriteLine($"Program started at: {StartTime}")
	End Sub
End Class

El constructor estático inicializa el campo StartTime con la hora actual. Este valor es accesible a través del método estático DisplayStartTime, mostrando cómo los constructores estáticos se pueden utilizar para inicializar campos de sólo lectura con valores que no se conocen hasta el tiempo de ejecución.

Campos estáticos y las palabras clave readonly y static

Los campos estáticos pertenecen a la clase en lugar de a cualquier instancia de la clase y se declaran utilizando la palabra clave static. Cuando se combina con la palabra clave readonly, un campo estático puede inicializarse en el punto de declaración o dentro de un constructor estático y no puede modificarse posteriormente.

public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;
    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }
    private static int FetchMaxUsersFromConfig()
    {
        //  Imagina que este método lee de un fichero de configuración
        return 100;
    }
}

public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;
    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }
    private static int FetchMaxUsersFromConfig()
    {
        //  Imagina que este método lee de un fichero de configuración
        return 100;
    }
}

Public Class Configuration
	Public Shared ReadOnly MaxUsers As Integer
	Public Const TimeoutSeconds As Integer = 30
	Shared Sub New()
		MaxUsers = FetchMaxUsersFromConfig()
	End Sub
	Private Shared Function FetchMaxUsersFromConfig() As Integer
		'  Imagina que este método lee de un fichero de configuración
		Return 100
	End Function
End Class

Este ejemplo demuestra el uso de un constructor que es estático para inicializar un campo estático readonly, MaxUsers, con un valor que se recupera en tiempo de ejecución, posiblemente de un fichero de configuración. El campo const, TimeoutSeconds, representa una constante en tiempo de compilación que se incrusta directamente en el código.

Introducción a IronPDF

IronPDF es una biblioteca versátil que permite a los desarrolladores crear, editar y leer documentos PDF en aplicaciones .NET. Esta potente herramienta simplifica la generación de PDF permitiendo a los desarrolladores convertir HTML a PDF, manipular contenidos y extraer datos de archivos PDF con facilidad.

Introducción a IronPDF y ejemplos prácticos

Para demostrar cómo puede integrarse IronPDF en un proyecto .NET, veamos un ejemplo sencillo en el que utilizamos una constante para definir la cadena HTML que queremos convertir en un documento PDF.

using IronPdf;
public class PdfGenerator
{
    //  Definir una plantilla HTML constante
    public const string HtmlTemplate = @"
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>";
    public static void CreatePdf(string filePath)
    {
        IronPdf.License.LicenseKey = "License";
        //  Crear un nuevo documento PDF a partir de una plantilla HTML
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);
        //  Guardar el documento PDF en un archivo
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}
class Program
{
    static void Main(string [] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}

using IronPdf;
public class PdfGenerator
{
    //  Definir una plantilla HTML constante
    public const string HtmlTemplate = @"
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>";
    public static void CreatePdf(string filePath)
    {
        IronPdf.License.LicenseKey = "License";
        //  Crear un nuevo documento PDF a partir de una plantilla HTML
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);
        //  Guardar el documento PDF en un archivo
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}
class Program
{
    static void Main(string [] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}

Imports IronPdf
Public Class PdfGenerator
	'  Definir una plantilla HTML constante
	Public Const HtmlTemplate As String = "
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>"
	Public Shared Sub CreatePdf(ByVal filePath As String)
		IronPdf.License.LicenseKey = "License"
		'  Crear un nuevo documento PDF a partir de una plantilla HTML
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(HtmlTemplate)
		'  Guardar el documento PDF en un archivo
		pdf.SaveAs(filePath)
		Console.WriteLine($"PDF generated successfully at {filePath}")
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		PdfGenerator.CreatePdf("example.pdf")
	End Sub
End Class

En este ejemplo, la constante HtmlTemplate se define con contenido HTML simple que sirve de fuente para nuestro documento PDF. El método CreatePdf utiliza la clase ChromePdfRenderer de IronPDF para convertir este HTML en un PDF y guardarlo en la ruta de archivo especificada. Esto muestra la facilidad con la que IronPDF puede utilizarse para generar PDFs a partir de contenido HTML estático, aprovechando la palabra clave const para definir plantillas HTML inmutables.

Salida

Aquí está el archivo PDF de salida:

Conclusión

En C#, la palabra clave const es una característica valiosa para definir valores inmutables que se conocen en tiempo de compilación. Ayuda a mejorar la legibilidad y el mantenimiento del código al indicar claramente qué valores son constantes. Recuerde que las variables const son implícitamente estáticas, deben inicializarse en la declaración y sus valores deben ser constantes en tiempo de compilación. Comparativamente, las variables readonly ofrecen más flexibilidad pero se inicializan en tiempo de ejecución.

IronPDF destaca no sólo por sus sólidas funciones de manipulación de PDF, sino también por su flexible modelo de adopción. Para los desarrolladores y las organizaciones que deseen explorar sus capacidades, IronPDF ofrece un prueba gratuita que ofrece una excelente oportunidad para evaluar sus características y facilidad de integración sin inversión inicial.

Cuando esté listo para avanzar con IronPDF para uso comercial, las opciones de licencia comienzan desde $749. Esta estructura de precios está diseñada para adaptarse a las necesidades de distintos tamaños y tipos de proyectos, garantizando que pueda elegir la licencia que mejor se adapte a sus planes de desarrollo y distribución.