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

Convenciones de nomenclatura

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

Variables locales y argumentos de métodos

Las variables locales y los argumentos de métodos deben utilizar camel case. Esto significa que la primera palabra está en minúsculas y las palabras subsiguientes comienzan con una letra mayúscula, sin espacios ni guiones bajos. Esto es diferente de Pascal Case en que la primera letra no está capitalizada.

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

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

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

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

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

Miembros estáticos y campos

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

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
}

Nombramiento de campos privados e inicializadores de objetos

Los campos privados deben seguir la convención camel case pero con un prefijo de guión bajo. Esto ayuda a distinguirlos de las variables locales y argumentos de métodos.

private string _customerName;

private string _customerName;

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

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

Al manejar excepciones, los nombres de métodos deben seguir aún las convenciones Pascal Case. Los nombres de las clases de excepciones 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 decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

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

Convenciones para nombrar las constantes de C

En C#, los nombres de constantes deben ser letras mayúsculas, con palabras separadas por guiones bajos. Esto hace que las constantes se destaquen de otras variables. Aquí hay un ejemplo:

public const double PI = 3.14159;

public const double PI = 3.14159;

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

Convenciones de codificación de C# 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. Aquí hay un ejemplo:

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

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

Usar el formato adecuado hace que el código sea más fácil de leer y seguir.

Evitar la notación húngara

En el desarrollo moderno de C#, la Notación Húngara, donde los nombres de las variables tienen prefijos con tipos de datos (por ejemplo, strName para una cadena o intCount para un entero), no se recomienda. En su lugar, usa nombres significativos que describan el propósito de la variable en lugar de su tipo de datos:

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

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

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 tus 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 C#. Al hacerlo, es importante seguir las convenciones de nomenclatura para tus clases, métodos y variables para mantener la consistencia. A continuación, un ejemplo de una implementación simple de las convenciones de nomenclatura para mejorar la legibilidad del código usando IronPDF mientras se adhieren a 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();
    }
}

Siguiendo estas convenciones de nomenclatura, tu código se mantiene profesional, organizado y fácil de leer mientras usas IronPDF para generar reportes.

Conclusión

Siguiendo estas convenciones de nomenclatura de C#, puedes asegurarte de que tu código esté limpio, legible y sea fácil de mantener. Ya sea usando Pascal Case para los nombres de clase, camel case para variables locales, o usando un prefijo de guión bajo para campos privados, estas convenciones ayudan a establecer una base de código consistente.

Con IronPDF, puedes sumergirte y explorar todas sus capacidades con una prueba gratuita. Esta prueba te permite experimentar y ver de primera mano cómo se integra bien en tu flujo de trabajo. Cuando estés listo para dar el siguiente paso, las licencias comienzan en solo $799.