C# Naming Conventions (How It Works For Developers)

Naming Conventions Overview

public class Customer
{
    public decimal Balance { get; set; }
}

public interface ICustomer
{
    decimal GetBalance();
}

public class Customer
{
    public decimal Balance { get; set; }
}

public interface ICustomer
{
    decimal GetBalance();
}

public decimal CalculateInterest(decimal principal, decimal rate)
{
    return principal * rate;
}

public decimal CalculateInterest(decimal principal, decimal rate)
{
    return principal * rate;
}

public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }

public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }

Local Variables and Method Arguments

Local variables and method arguments should use camel case. This means the first word is in lowercase, and subsequent words start with a capital letter, with no spaces or underscores. This is different from Pascal Case in that the first letter is not capitalized.

public void SelectCustomer(string customerName)
{
    var selectedCustomer = FindCustomer(customerName);
}

public void SelectCustomer(string customerName)
{
    var selectedCustomer = FindCustomer(customerName);
}

In this example, the local variable selectedCustomer follows the camel case convention, and the method argument customerName is also in camel case.

public void AddCustomer(string customerName, DateTime dateOpened)
{
    // Add customer logic
}

public void AddCustomer(string customerName, DateTime dateOpened)
{
    // Add customer logic
}

Static Members and Fields

Static members in classes, like static fields, constants, and methods, also follow specific naming conventions.

private static int _totalCustomers;

private static int _totalCustomers;

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

private void OnCustomerAdded(object sender, EventArgs e)
{
    // Event handling logic
}

private void OnCustomerAdded(object sender, EventArgs e)
{
    // Event handling logic
}

Naming Private Fields and Object Initializers

Private fields should follow the camel case convention but with an underscore prefix. This helps distinguish them from local variables and method arguments.

private string _customerName;

private string _customerName;

When using object initializers, you can assign values directly to properties when creating an instance of a class:

var seattleCustomer = new Customer
{
    Balance = 1000,
    DateOpened = DateTime.Now
};

var seattleCustomer = new Customer
{
    Balance = 1000,
    DateOpened = DateTime.Now
};

In this example, the property names Balance and DateOpened are in Pascal Case, following the convention for properties.

Exception Handling and Methods

When handling exceptions, method names should still follow Pascal Case conventions. Exception class names should also be in Pascal Case and end with the suffix Exception. For example:

public void ProcessTransaction()
{
    try
    {
        // Transaction logic
    }
    catch (InvalidOperationException ex)
    {
        // Handle exception
    }
}

public void ProcessTransaction()
{
    try
    {
        // Transaction logic
    }
    catch (InvalidOperationException ex)
    {
        // Handle exception
    }
}

public decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

public decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

Naming Conventions for C# Constants

In C#, constant names should be all uppercase letters, with words separated by underscores. This makes constants stand out from other variables. Here’s an example:

public const double PI = 3.14159;

public const double PI = 3.14159;

This convention applies across different types, ensuring that constant names are consistent and easy to recognize in the code.

C# Coding Conventions for Line Breaks and Braces

C# also has coding conventions for line breaks and braces. In C#, each opening brace { should be on the same line as the statement it belongs to, and the closing brace } should be on a new line, aligned with the corresponding statement. Here’s an example:

public void AddCustomer(string customerName)
{
    if (!string.IsNullOrEmpty(customerName))
    {
        _customerName = customerName;
    }
}

public void AddCustomer(string customerName)
{
    if (!string.IsNullOrEmpty(customerName))
    {
        _customerName = customerName;
    }
}

Using proper formatting makes the code easier to read and follow.

Avoiding Hungarian Notation

In modern C# development, Hungarian Notation, where variable names are prefixed with data types (e.g., strName for a string or intCount for an integer), is discouraged. Instead, use meaningful names that describe the purpose of the variable rather than its data type:

public string CustomerName { get; set; }
public int OrderCount { get; set; }

public string CustomerName { get; set; }
public int OrderCount { get; set; }

This approach makes the code clearer and more maintainable.

Using IronPDF with Naming Conventions

When integrating IronPDF into your C# projects, it’s essential to maintain clean, readable code by following naming conventions. IronPDF allows you to generate PDFs from HTML content within your C# applications. While doing so, it’s important to follow naming conventions for your classes, methods, and variables to maintain consistency. Below is an example of a simple implementation of naming conventions to enhance code readability using IronPDF while adhering to these naming conventions:

using IronPdf;

public class PdfReportGenerator
{
    private readonly string _htmlContent;
    private readonly string _filePath;

    public PdfReportGenerator(string htmlContent, string filePath)
    {
        _htmlContent = htmlContent;
        _filePath = filePath;
    }

    public void GenerateReport()
    {
        var pdfRenderer = new ChromePdfRenderer();
        PdfDocument pdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent);
        pdfDocument.SaveAs(_filePath);
    }
}

public static class Program
{
    public static void Main()
    {
        var htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>";
        var filePath = @"C:\Reports\MonthlyReport.pdf";
        PdfReportGenerator reportGenerator = new PdfReportGenerator(htmlContent, filePath);
        reportGenerator.GenerateReport();
    }
}

using IronPdf;

public class PdfReportGenerator
{
    private readonly string _htmlContent;
    private readonly string _filePath;

    public PdfReportGenerator(string htmlContent, string filePath)
    {
        _htmlContent = htmlContent;
        _filePath = filePath;
    }

    public void GenerateReport()
    {
        var pdfRenderer = new ChromePdfRenderer();
        PdfDocument pdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent);
        pdfDocument.SaveAs(_filePath);
    }
}

public static class Program
{
    public static void Main()
    {
        var htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>";
        var filePath = @"C:\Reports\MonthlyReport.pdf";
        PdfReportGenerator reportGenerator = new PdfReportGenerator(htmlContent, filePath);
        reportGenerator.GenerateReport();
    }
}

By sticking to these naming conventions, your code stays professional, organized, and easy to read while using IronPDF for generating reports.

Conclusion

By following these C# naming conventions, you can ensure that your code is clean, readable, and easy to maintain. Whether it's using Pascal Case for class names, camel case for local variables, or using an underscore prefix for private fields, these conventions help establish a consistent codebase.

With IronPDF, you can jump in and explore all its capabilities with a free trial. This trial lets you experiment and see firsthand how well it integrates into your workflow. When you're ready to take the next step, licenses start at just $799.