Convenciones de nomenclatura son un conjunto de reglas y pautas que los desarrolladores siguen para nombrar variables, métodos, clases y otras entidades de manera consistente. Una nomenclatura consistente no solo mejora la legibilidad del código, sino que también ayuda a otros desarrolladores a entender y mantener tu código. A continuación, revisaremos las convenciones de nomenclatura de C# paso a paso, enfocándonos en el uso práctico y ejemplos. Vamos a sumergirnos directamente en las convenciones de nomenclatura y la biblioteca de IronPDF más adelante en el artículo.
Los nombres de las clases deben seguir la convención de nomenclatura Pascal Case. Esto significa que cada palabra en el nombre comienza con una letra mayúscula, sin guiones bajos ni espacios. Los nombres de las interfaces también deben seguir el Pascal Case, pero comenzar con el prefijo I. Por ejemplo:
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 InterfaceObserve cómo el nombre de la clase Customer y el nombre de la interfaz ICustomer ambos siguen Pascal Case. El prefijo I deja claro que el tipo ICustomer es una interfaz.
Los nombres de los métodos también usan Pascal Case. Cada nombre de método debe comenzar con una letra mayúscula, y cada palabra subsiguiente también debe comenzar con una letra mayúscula. Aquí hay un ejemplo de definiciones de métodos:
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 FunctionPara el método punto de entrada, static void Main(), la convención es la misma: usar Pascal Case para el nombre del método.
Como los nombres de métodos, las propiedades también usan Pascal Case. Las propiedades deben nombrarse de manera que describan claramente lo que representan:
public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }Public Property DateOpened() As DateTime
Public Property Reserves() As DecimalLas 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 Sub SelectCustomer(ByVal customerName As String)
Dim selectedCustomer = FindCustomer(customerName)
End SubEn 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.
Los nombres de los argumentos de método deben ser descriptivos y seguir la convención de nomenclatura camel case. Esto mejora la legibilidad del código y ayuda a los desarrolladores a entender qué representa cada argumento.
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 SubLos miembros estáticos en clases, como campos estáticos, constantes y métodos, también siguen convenciones de nomenclatura específicas.
Para campos estáticos, la convención de nomenclatura es usar camel case pero con un prefijo de guión bajo. Esto los diferencia de otros campos.
private static int _totalCustomers;Private Shared _totalCustomers As IntegerLas constantes se nombran típicamente usando todas letras mayúsculas, con palabras separadas por guiones bajos para mejorar la legibilidad. Por ejemplo:
public const int MAX_CUSTOMERS = 100;Public Const MAX_CUSTOMERS As Integer = 100Los nombres de los métodos de manejadores de eventos deben describir el evento que manejan, generalmente usando el prefijo On seguido del nombre del evento. Los parámetros para los métodos manejadores de eventos típicamente incluyen el objeto sender y los argumentos del evento.
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 SubEn este caso, los parámetros están nombrados sender y e. Seguir esta convención de nomenclatura hace que tus manejadores de eventos sean consistentes con los estándares de la industria.
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 _customerName As StringAl 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
};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.
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 Sub ProcessTransaction()
Try
' Transaction logic
Catch ex As InvalidOperationException
' Handle exception
End Try
End SubSiempre asegúrate de que tus 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. Aquí hay un ejemplo:
public decimal CalculateTotalBalance()
{
return _totalCustomers * balancePerCustomer;
}Public Function CalculateTotalBalance() As Decimal
Return _totalCustomers * balancePerCustomer
End FunctionEn este ejemplo, el nombre del método CalculateTotalBalance es descriptivo y sigue la convención de nomenclatura de Pascal Case.
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 PI As Double = 3.14159Esta 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.
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 Sub AddCustomer(ByVal customerName As String)
If Not String.IsNullOrEmpty(customerName) Then
_customerName = customerName
End If
End SubUsar el formato adecuado hace que el código sea más fácil de leer y seguir.
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 Property CustomerName() As String
Public Property OrderCount() As IntegerEste enfoque hace que el código sea más claro y fácil de mantener.
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();
}
}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 ModuleSiguiendo estas convenciones de nomenclatura, tu código se mantiene profesional, organizado y fácil de leer mientras usas IronPDF para generar reportes.
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 desde solo $999.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
