Convenciones de nomenclatura de C# (cómo funciona para los desarrolladores)

Las convenciones de nomenclatura son un conjunto de reglas y directrices que los desarrolladores siguen para nombrar variables, métodos, clases y otras entidades de manera consistente. Una nomenclatura coherente no solo mejora la legibilidad del código, sino que también ayuda a otros desarrolladores a entenderlo y mantenerlo. A continuación, repasaremos paso a paso las convenciones de nomenclatura de C#, centrándonos en ejemplos y usos prácticos. Vamos a profundizar en las convenciones de nomenclatura y la biblioteca IronPDF más adelante en el artículo.

Descripción general de las convenciones de nomenclatura

Clases e interfaces

Los nombres de las clases deben seguir la convención de nombres Pascal Case. Esto significa que cada palabra del nombre empieza con mayúscula, sin guiones bajos ni espacios. Los nombres de las interfaces también deben seguir el caso Pascal, pero empezar con el prefijo I. Por ejemplo:

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

Observe cómo el nombre de la clase Customer y el nombre de la interfaz ICustomer siguen el caso Pascal. El prefijo I deja claro que el tipo ICustomer es una interfaz.

Métodos

Los nombres de métodos también utilizan el caso Pascal. Cada nombre de método debe empezar con mayúscula, y cada palabra subsiguiente también debe empezar con mayúscula. He aquí un ejemplo de definición de métodos:

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

Para el método de punto de entrada, static void Main(), la convención es la misma: use Pascal Case para el nombre del método.

Propiedades

Al igual que los nombres de los métodos, los nombres de las propiedades también utilizan Pascal Case. Las propiedades deben nombrarse de forma que describan claramente lo que representan:

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

Variables locales y argumentos de métodos

Las variables locales y los argumentos del método deben usar camel case. Esto significa que la primera palabra se escribe en minúscula y las siguientes comienzan con mayúscula, sin espacios ni guiones bajos. Se diferencia del caso Pascal en que la primera letra no se escribe en mayúscula.

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

En este ejemplo, la variable local selectedCustomer sigue la convención de camel case, y el argumento del método customerName también está en camel case.

Argumentos del método

Los nombres de los argumentos de los métodos deben ser descriptivos y seguir la convención de nomenclatura en mayúsculas y minúsculas. Esto mejora la legibilidad del código y ayuda a los desarrolladores a entender lo que representa cada argumento.

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

Miembros y campos estáticos

Los miembros estáticos en las clases, como campos estáticos, constantes y métodos, también siguen convenciones de nomenclatura específicas.

Campos estáticos

Para los campos estáticos, la convención de nombres es usar camel case pero con un prefijo de guion bajo. Esto las diferencia de otros campos.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Constantes

Los constantes se nombran típicamente utilizando letras mayúsculas, con palabras separadas por guiones bajos para mejorar la legibilidad. Por ejemplo:

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

Manejadores de eventos

Los nombres de los métodos del controlador de eventos deben describir el evento que manejan, generalmente utilizando el prefijo On seguido del nombre del evento. Los parámetros de los métodos de control de eventos suelen incluir el remitente del objeto y los argumentos del evento.

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

En este caso, los parámetros se llaman sender y e. Seguir esta convención de nomenclatura hace que sus manejadores de eventos sean coherentes con los estándares del sector.

Asignación de nombres a campos privados e inicializadores de objetos

Los campos privados deben seguir la convención de mayúsculas y minúsculas pero con un prefijo de guión bajo. Esto ayuda a distinguirlas de las variables locales y los argumentos de métodos.

private string _customerName;

private string _customerName;

Private _customerName As String

Al usar inicializadores de objetos, puedes asignar valores directamente a las propiedades al crear una instancia de una clase:

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
}

En este ejemplo, los nombres de las propiedades Balance y DateOpened están en Pascal Case, siguiendo la convención para propiedades.

Manejo de excepciones y métodos

Cuando se traten excepciones, los nombres de los métodos deben seguir las convenciones de Pascal Case. Los nombres de las clases de excepción también deben estar en Pascal Case y terminar con el sufijo Exception. Por ejemplo:

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

Tipos de retorno y definiciones de métodos

Siempre asegúrese de que sus definiciones de métodos tengan nombres significativos y tipos de retorno apropiados. El tipo de retorno debe ser claro a partir de la firma del método. He aquí un ejemplo:

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

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

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

En este ejemplo, el nombre del método CalculateTotalBalance es descriptivo y sigue la convención de nomenclatura Pascal Case.

Convenciones de nomenclatura para las constantes C#

En C#, los nombres de constantes deben estar en letras mayúsculas, con palabras separadas por guiones bajos. Esto hace que las constantes destaquen sobre otras variables. He aquí un ejemplo:

public const double PI = 3.14159;

public const double PI = 3.14159;

Public Const PI As Double = 3.14159

Esta convención se aplica a distintos tipos, asegurando que los nombres de constantes sean consistentes y fáciles de reconocer en el código.

C# Convenciones de codificación para saltos de línea y llaves

C# también tiene convenciones de codificación para saltos de línea y llaves. En C#, cada llave de apertura { debe estar en la misma línea que la declaración a la que pertenece, y la llave de cierre } debe estar en una nueva línea, alineada con la declaración correspondiente. He aquí un ejemplo:

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

El uso de un formato adecuado facilita la lectura y el seguimiento del código.

Evitar la notación húngara

En el desarrollo moderno de C#, se desaconseja el Hungarian Notation, donde los nombres de las variables están precedidos por tipos de datos (por ejemplo, strName para una cadena o intCount para un entero). En su lugar, use nombres significativos que describan el propósito de la variable en lugar de su tipo de dato:

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

Este enfoque hace que el código sea más claro y fácil de mantener.

Uso de IronPDF con convenciones de nomenclatura

Al integrar IronPDF en sus proyectos de C#, es esencial mantener un código limpio y legible siguiendo las convenciones de nomenclatura. IronPDF te permite generar PDFs a partir de contenido HTML dentro de tus aplicaciones en C#. Al hacerlo, es importante seguir las convenciones de nomenclatura para sus clases, métodos y variables para mantener la coherencia. A continuación se muestra un ejemplo de implementación sencilla de las convenciones de nomenclatura para mejorar la legibilidad del código utilizando IronPDF y respetando estas convenciones de nomenclatura:

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

Si se siguen estas convenciones de nomenclatura, el código será profesional, organizado y fácil de leer cuando se utilice IronPDF para generar informes.

Conclusión

Si sigue estas convenciones de nomenclatura de C#, se asegurará de que su código sea limpio, legible y fácil de mantener. Ya se trate de utilizar Pascal Case para los nombres de clase, camel case para las variables locales o un prefijo de guión bajo para los campos privados, estas convenciones ayudan a establecer una base de código coherente.

Con IronPDF, puedes comenzar a explorar todas sus capacidades con una prueba gratuita. Esta versión de prueba te permite experimentar y comprobar de primera mano lo bien que se integra en tu flujo de trabajo. Cuando estés listo para dar el siguiente paso, las licencias comienzan desde solo $749.