Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. Convenciones de Nomenclatura C#
.NET AYUDA

Convenciones de Nomenclatura C# (Cómo Funciona para Desarrolladores)

Curtis Chau
Curtis Chau
Actualizado:

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 names should 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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 clearly describe what they represent:

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
$vbLabelText   $csharpLabel

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);
}
Public Sub SelectCustomer(ByVal customerName As String)
	Dim selectedCustomer = FindCustomer(customerName)
End Sub
$vbLabelText   $csharpLabel

In this example, the local variable selectedCustomer follows the camel case convention, and the method argument customerName is also in 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
}
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

This approach makes the code clearer and more maintainable.

Using IronPDF with Naming Conventions

C# Naming Conventions (How It Works For Developers): Figure 1 - IronPDF: The C# PDF Library

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();
    }
}
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
$vbLabelText   $csharpLabel

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

Conclusion

C# Naming Conventions (How It Works For Developers): Figure 2 - IronPDF licensing page

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.

Preguntas Frecuentes

¿Cuáles son las convenciones generales de nomenclatura para clases e interfaces en C#?

En C#, las clases e interfaces deben ser nombradas usando Pascal Case, donde cada palabra comienza con una letra mayúscula. Las interfaces también deben incluir un prefijo 'I', como 'ICustomer'.

¿Cómo asegurar que los nombres de métodos en C# sigan las mejores prácticas?

Los nombres de los métodos en C# deben seguir la convención Pascal Case, comenzando cada palabra con una letra mayúscula. Esta convención se aplica a todos los métodos, incluido el método de entrada Main.

¿Cuál es la forma recomendada de nombrar las variables locales en C#?

Las variables locales y los argumentos de método en C# deben ser nombrados usando camel case, lo que significa que la primera palabra está en minúsculas y cada palabra subsiguiente comienza con una letra mayúscula.

¿Cómo deben nombrarse los campos estáticos en C#?

Los campos estáticos en C# deben ser nombrados usando camel case con un prefijo de guion bajo para diferenciarlos de otros campos.

¿Cuál es la convención de nomenclatura para las constantes en C#?

Las constantes en C# deben ser nombradas usando todas las letras en mayúscula, con las palabras separadas por guiones bajos, para hacerlas fácilmente distinguibles.

¿Cómo puedo usar una biblioteca mientras adhiero a las convenciones de nomenclatura de C#?

Al usar bibliotecas en C#, como IronPDF, mantén un código limpio y legible siguiendo las convenciones de nomenclatura. Esto incluye usar Pascal Case para clases y métodos y camel case para variables. Por ejemplo, puedes generar PDFs desde HTML usando IronPDF mientras mantienes prácticas de nomenclatura consistentes.

¿Por qué la Notación Húngara no se recomienda en C#?

La Notación Húngara no se recomienda en el desarrollo moderno de C# porque puede hacer que el código sea menos legible. En su lugar, usa nombres significativos que describan el propósito de las variables y adhieren a las convenciones de nomenclatura establecidas.

¿Cómo deberían nombrarse los métodos manejadores de eventos en C#?

Los métodos manejadores de eventos en C# deben ser nombrados para describir el evento que manejan, típicamente usando el prefijo 'On' seguido del nombre del evento. Esto ayuda a clarificar el propósito del método.

¿Qué convenciones de nomenclatura deben seguirse para los campos privados en C#?

Los campos privados en C# deben ser nombrados usando camel case con un prefijo de guion bajo. Esto ayuda a diferenciarlos de las variables locales y los argumentos de método.

¿Cómo ayudan las convenciones de nomenclatura a los desarrolladores de C#?

Las convenciones de nomenclatura mejoran la legibilidad y mantenibilidad del código, haciendo más fácil para los desarrolladores entender y trabajar con el código. La nomenclatura consistente en proyectos de C#, incluidos aquellos que usan bibliotecas como IronPDF, asegura una base de código profesional y limpia.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita