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

Convenciones de nomenclatura son un conjunto de reglas y directrices que los desarrolladores siguen para nombrar variables, métodos, clases y otras entidades de forma coherente. 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. Entremos de lleno en el tema de las convenciones de nomenclatura y lasBiblioteca 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 nomenclatura 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 los 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: utilizar Pascal Case para el nombre del método.

Propiedades

Al igual que los nombres de métodos, los nombres de 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 de métodos** deben escribirse en mayúsculas. 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 las mayúsculas y minúsculas, y el argumento del método customerName también está en mayúsculas y minúsculas.

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 de las clases, como los campos estáticos, las constantes y los métodos, también siguen unas convenciones de nomenclatura específicas.

Campos estáticos

Para los campos estáticos, la convención de nomenclatura es utilizar camel case pero con un prefijo underscore. Esto las diferencia de otros campos.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Constantes

Las constantes se nombran normalmente utilizando todas las 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 de gestión de eventos deben describir el evento que gestionan, normalmente 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

Cuando se utilizan inicializadores de objetos, se pueden 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 propiedad 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

Asegúrese siempre de que sus definiciones de métodos tienen nombres significativos y tipos de retorno apropiados. El tipo de retorno debe quedar claro en 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 constantes deben ir todos en mayúsculas, con las 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 diferentes tipos, garantizando que los nombres constantes sean coherentes 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 corchetes. En C#, cada apertura brace{ debe ir en la misma línea que el enunciado al que pertenece, y el cierre brace} debe ir en una nueva línea, alineado con el enunciado 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#, la notación húngara, en la que los nombres de las variables llevan antepuestos los tipos de datos(por ejemplo, strName para una cadena o intCount para un número entero)se desaconseja el uso de ,. En su lugar, utilice nombres significativos que describan el propósito de la variable más que su tipo de datos:

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 integrarIronPDF en sus proyectos de C#, es esencial mantener un código limpio y legible siguiendo las convenciones de nomenclatura. IronPDF le permite generarPDF a partir de contenido HTML dentro de sus aplicaciones 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, puede lanzarse y explorar todas sus capacidades con unprueba 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.