C# Naming Conventions (How It Works For Developers)

Naming conventions are a set of rules and guidelines developers follow to name variables, methods, classes, and other entities consistently. Consistent naming not only enhances code readability but also helps other developers understand and maintain your code. Below, we will walk through the C# naming conventions step by step, focusing on practical usage and examples. Let’s dive right in about naming conventions and the IronPDF library later in the article.

Naming Conventions Overview

Classes and Interfaces

Class names should follow the Pascal Case naming convention. This means each Word in the name starts with a capital letter, with no underscores or spaces. Interface namesshould also follow Pascal Case but start with the prefix I. For example:

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 Class Customer
	Public Property Balance() As Decimal
End Class
Public Interface ICustomer
	Function GetBalance() As Decimal
End Interface

Notice how the class name Customer and the interface name ICustomer both follow Pascal Case. The I prefix makes it clear that the ICustomer type is an interface.

Methods

Method names also use the Pascal Case. Every method name should start with a capital letter, and each subsequent Word should also start with a capital letter. Here's an example of method definitions:

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

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

Public Function CalculateInterest(ByVal principal As Decimal, ByVal rate As Decimal) As Decimal
	Return principal * rate
End Function

For the entry point method, static void Main(), the convention is the same—use Pascal Case for the method name.

Properties

Like method names, property names also use Pascal Case. Properties should be named to describe what they represent clearly:

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

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

Public Property DateOpened() As DateTime
Public Property Reserves() As Decimal

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

Public Sub SelectCustomer(ByVal customerName As String)
	Dim selectedCustomer = FindCustomer(customerName)
End Sub

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

Method Arguments

The names of method arguments should be descriptive and follow the camel case naming convention. This improves code readability and helps developers understand what each argument represents.

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

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

Public Sub AddCustomer(ByVal customerName As String, ByVal dateOpened As DateTime)
	' Add customer logic
End Sub

Static Members and Fields

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

Static Fields

For static fields, the naming convention is to use camel case but with an underscore prefix. This differentiates them from other fields.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Constants

Constants are typically named using all capital letters, with words separated by underscores to improve readability. For example:

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

Event Handlers

Event handler method names should describe the event they handle, usually by using the On prefix followed by the event name. The parameters for event handler methods typically include the object sender and the event arguments.

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

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

Private Sub OnCustomerAdded(ByVal sender As Object, ByVal e As EventArgs)
	' Event handling logic
End Sub

In this case, the parameters are named sender and e. Following this naming convention makes your event handlers consistent with industry standards.

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;

Private _customerName As String

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

Dim seattleCustomer = New Customer With {
	.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 Sub ProcessTransaction()
	Try
		' Transaction logic
	Catch ex As InvalidOperationException
		' Handle exception
	End Try
End Sub

Return Types and Method Definitions

Always ensure that your method definitions have meaningful names and appropriate return types. The return type should be clear from the method signature. Here’s an example:

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

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

Public Function CalculateTotalBalance() As Decimal
	Return _totalCustomers * balancePerCustomer
End Function

In this example, the method name CalculateTotalBalance is descriptive and follows the Pascal Case naming convention.

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;

Public Const PI As Double = 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;
    }
}

Public Sub AddCustomer(ByVal customerName As String)
	If Not String.IsNullOrEmpty(customerName) Then
		_customerName = customerName
	End If
End Sub

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

Public Property CustomerName() As String
Public Property OrderCount() As Integer

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. Following 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();
    }
}

Imports IronPdf
Public Class PdfReportGenerator
	Private ReadOnly _htmlContent As String
	Private ReadOnly _filePath As String
	Public Sub New(ByVal htmlContent As String, ByVal filePath As String)
		_htmlContent = htmlContent
		_filePath = filePath
	End Sub
	Public Sub GenerateReport()
		Dim pdfRenderer = New ChromePdfRenderer()
		Dim pdfDocument As PdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent)
		pdfDocument.SaveAs(_filePath)
	End Sub
End Class
Public Module Program
	Public Sub Main()
		Dim htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>"
		Dim filePath = "C:\Reports\MonthlyReport.pdf"
		Dim reportGenerator As New PdfReportGenerator(htmlContent, filePath)
		reportGenerator.GenerateReport()
	End Sub
End Module

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 $749.