C# Const (How It Works For Developers)

Declaring Constant Variables

To declare a constant variable, you use the const keyword followed by a data type, and then immediately initialize it. For example, const int myConstValue = 100; defines an integer constant. It's important to note that a constant variable must be initialized when it is declared, as its value is meant to be compile time, and fully evaluated before the program is run.

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);
    }
}

This example illustrates a simple use of a constant integer (const int) within a class. The MaxSize constant is accessible within the same class and can be used directly in the static void Main method.

const vs. readonly Variables

While both const and readonly keywords are used to declare immutable values, there are important differences between them. A const field is a compile-time constant, meaning its value is determined at compile time and embedded directly into the Intermediate Language (IL) code. This makes it static, and it cannot be modified.

On the other hand, a readonly variable can be assigned either at the time of declaration or within a constructor of the class. This allows for some flexibility, as readonly fields can have different values depending on the constructor used to instantiate the class.

public class Program
{
    public const string ConstExample = "Constant"; // const string
    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"; // const string
    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);
    }
}

Scope of const Variables

Constant variables can be declared within a method or as a member of a class. When you declare a const variable within a method, it's known as a local constant. Local constants are only accessible within the method they are declared in.

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

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

In contrast, when a const is declared within a class but outside of any method, it is accessible from any static function of the same one, because const fields are implicitly static. However, attempting to access a const field from an instance method without referencing it through the class name will result in a compilation error.

Compile Time vs. Run Time Constants

The main characteristic of const values is that they are evaluated at compile time. This means that the value of a const field must be known and fully evaluated by the compiler. This is in contrast to variables that are evaluated at run time, whose values are determined during the execution of the program.

For instance, attempting to assign a value to a const field based on a calculation performed at run time will cause a compile-time error. The compiler requires const values to be assigned from constant expressions or literal values that are known at compile time.

const double Pi = Math.PI; // This will cause a compile time error

const double Pi = Math.PI; // This will cause a compile time error

Advanced Use of Constants and Static Members in C#

Beyond the basics of const and readonly in C#, understanding how to work with constant expressions, static constructors, and static fields can elevate your coding practices, especially when dealing with constant values that need to be shared across instances of a class.

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; // Constant expression
}

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; // Constant expression
}

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 Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;

    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }

    private static int FetchMaxUsersFromConfig()
    {
        // Imagine this method reads from a configuration file
        return 100;
    }
}

public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;

    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }

    private static int FetchMaxUsersFromConfig()
    {
        // Imagine this method reads from a configuration file
        return 100;
    }
}

Introduction to IronPDF

IronPDF is a versatile library that enables developers to create, edit, and read PDF documents in .NET applications. This powerful tool simplifies PDF generation by allowing developers to convert HTML to PDF, manipulate content, and extract data from PDF files with ease.

The strength of IronPDF lies in converting HTML to PDF, preserving both layout and style. It’s an ideal tool for generating PDFs from web content, such as reports, invoices, and documentation. HTML files, URLs, and HTML strings can be easily converted into PDF files.

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");
    }
}

using IronPdf;

public class PdfGenerator
{
    // Defining a constant HTML template
    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";

        // Create a new PDF document from HTML template
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);

        // Save the PDF document to a file
        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
{
    // Defining a constant HTML template
    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";

        // Create a new PDF document from HTML template
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);

        // Save the PDF document to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}

Conclusion

In C#, the const keyword is a valuable feature for defining immutable values that are known at compile time. It helps improve the readability and maintainability of your code by clearly indicating which values are constants. Remember, const variables are implicitly static, must be initialized at declaration, and their values must be compile-time constants. Comparatively, readonly variables offer more flexibility but are initialized at run time.

IronPDF stands out not only for its robust features in PDF manipulation but also for its flexible adoption model. For developers and organizations looking to explore its capabilities, IronPDF offers a free trial, providing an excellent opportunity to evaluate its features and integration ease without initial investment.

When ready to move forward with IronPDF for commercial use, licensing options start from $799. This pricing structure is designed to accommodate the needs of different project sizes and types, ensuring that you can choose a license that best suits your development and distribution plans.