As convenções de nomenclatura são um conjunto de regras e diretrizes que os desenvolvedores seguem para nomear variáveis, métodos, classes e outras entidades de forma consistente. A padronização dos nomes não só melhora a legibilidade do código, como também ajuda outros desenvolvedores a entender e manter o seu código. A seguir, vamos analisar as convenções de nomenclatura do C# passo a passo, com foco no uso prático e em exemplos. Vamos abordar as convenções de nomenclatura e a biblioteca IronPDF mais adiante neste artigo.

Visão geral das convenções de nomenclatura

Classes e Interfaces

Os nomes das classes devem seguir a convenção de nomenclatura Pascal Case. Isso significa que cada palavra no nome começa com letra maiúscula, sem sublinhados ou espaços. Os nomes das interfaces também devem seguir o formato Pascal Case, mas começar com o prefixo I. Por exemplo:

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

Public Class Customer
	Public Property Balance() As Decimal
End Class

Public Interface ICustomer
	Function GetBalance() As Decimal
End Interface

Observe como o nome da classe Customer e o nome da interface ICustomer ambos seguem o Pascal Case. O prefixo I deixa claro que o tipo ICustomer é uma interface.

Métodos

Os nomes dos métodos também usam o Pascal Case. O nome de cada método deve começar com letra maiúscula, e cada palavra subsequente também deve começar com letra maiúscula. Eis um exemplo de definições 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

Public Function CalculateInterest(ByVal principal As Decimal, ByVal rate As Decimal) As Decimal
	Return principal * rate
End Function

Para o método de ponto de entrada, static void Main() , a convenção é a mesma — use Pascal Case para o nome do método.

Propriedades

Assim como os nomes de métodos, os nomes de propriedades também usam Pascal Case. As propriedades devem ser nomeadas de forma a descrever claramente o que representam:

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

Public Property DateOpened() As DateTime
Public Property Reserves() As Decimal

Variáveis ​​locais e argumentos de método

Variáveis ​​locais e argumentos de métodos devem usar camelCase. Isso significa que a primeira palavra é escrita em minúsculas e as palavras subsequentes começam com letra maiúscula, sem espaços ou sublinhados. Isso difere do caso Pascal, pois a primeira letra não é maiú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

Public Sub SelectCustomer(ByVal customerName As String)
	Dim selectedCustomer = FindCustomer(customerName)
End Sub

Neste exemplo, a variável local selectedCustomer segue a convenção camel case, e o argumento do método customerName também está em camel case.

Argumentos do método

Os nomes dos argumentos do método devem ser descritivos e seguir a convenção de nomenclatura camel case. Isso melhora a legibilidade do código e ajuda os desenvolvedores a entender o que cada argumento representa.

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

Public Sub AddCustomer(ByVal customerName As String, ByVal dateOpened As DateTime)
	' Add customer logic
End Sub

Membros e campos estáticos

Os elementos estáticos em classes, como campos estáticos , constantes e métodos , também seguem convenções de nomenclatura específicas.

Campos Estáticos

Para campos estáticos , a convenção de nomenclatura é usar camel case, mas com um prefixo de sublinhado . Isso os diferencia de outros campos.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Private Shared _totalCustomers As Integer

Constantes

As constantes são geralmente nomeadas usando apenas letras maiúsculas , com as palavras separadas por sublinhados para melhorar a legibilidade. Por exemplo:

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

Public Const MAX_CUSTOMERS As Integer = 100

Organizadores de Eventos

Os nomes dos métodos de manipulador de eventos devem descrever o evento que eles manipulam, geralmente usando o prefixo On seguido pelo nome do evento. Os parâmetros para métodos de manipulador de eventos normalmente incluem o objeto sender e os argumentos do 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

Private Sub OnCustomerAdded(ByVal sender As Object, ByVal e As EventArgs)
	' Event handling logic
End Sub

Neste caso, os parâmetros são nomeados sender e e. Seguir essa convenção de nomenclatura garante que seus organizadores de eventos estejam em conformidade com os padrões da indústria.

Nomeando campos privados e inicializadores de objetos

Os campos privados devem seguir a convenção camel case, mas com um prefixo de sublinhado. Isso ajuda a distingui-las de variáveis ​​locais e argumentos de métodos.

private string _customerName;

private string _customerName;

Private _customerName As String

Private _customerName As String

Ao usar inicializadores de objeto , você pode atribuir valores diretamente às propriedades ao criar uma instância de uma classe:

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
}

Dim seattleCustomer = New Customer With {
	.Balance = 1000,
	.DateOpened = DateTime.Now
}

Neste exemplo, os nomes das propriedades Balance e DateOpened estão em Pascal Case, seguindo a convenção para propriedades.

Tratamento de Exceções e Métodos

Ao lidar com exceções, os nomes dos métodos ainda devem seguir as convenções do Pascal Case. Os nomes das classes de exceção também devem estar em Pascal Case e terminar com o sufixo Exception. Por exemplo:

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

Public Sub ProcessTransaction()
	Try
		' Transaction logic
	Catch ex As InvalidOperationException
		' Handle exception
	End Try
End Sub

Tipos de retorno e definições de método

Certifique-se sempre de que as definições dos seus métodos tenham nomes significativos e tipos de retorno apropriados. O tipo de retorno deve estar claro a partir da assinatura do método. Eis um exemplo:

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

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

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

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

Neste exemplo, o nome do método CalculateTotalBalance é descritivo e segue a convenção de nomeação Pascal Case.

Convenções de Nomenclatura para Constantes C#

Em C#, os nomes de constantes devem ser escritos inteiramente em letras maiúsculas, com as palavras separadas por sublinhados. Isso faz com que as constantes se destaquem das outras variáveis. Eis um exemplo:

public const double PI = 3.14159;

public const double PI = 3.14159;

Public Const PI As Double = 3.14159

Public Const PI As Double = 3.14159

Essa convenção se aplica a diferentes tipos, garantindo que os nomes das constantes sejam consistentes e fáceis de reconhecer no código.

Convenções de Codificação C# para Quebras de Linha e Chaves

C# também possui convenções de codificação para quebras de linha e chaves . Em C#, cada chave de abertura { deve estar na mesma linha que a declaração a que pertence, e a chave de fechamento } deve estar em uma nova linha, alinhada com a declaração correspondente. Eis um exemplo:

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

Public Sub AddCustomer(ByVal customerName As String)
	If Not String.IsNullOrEmpty(customerName) Then
		_customerName = customerName
	End If
End Sub

Usar uma formatação adequada torna o código mais fácil de ler e entender.

Evitando a notação húngara

No desenvolvimento moderno em C#, a notação húngara , onde os nomes das variáveis ​​são prefixados com os tipos de dados (por exemplo, strName para uma string ou intCount para um inteiro), é desencorajada. Em vez disso, use nomes significativos que descrevam a finalidade da variável, e não seu tipo de dados:

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

Public Property CustomerName() As String
Public Property OrderCount() As Integer

Essa abordagem torna o código mais claro e mais fácil de manter.

Utilizando o IronPDF com convenções de nomenclatura

Ao integrar o IronPDF em seus projetos C#, é essencial manter um código limpo e legível, seguindo as convenções de nomenclatura. O IronPDF permite gerar PDFs a partir de conteúdo HTML em suas aplicações C#. Ao fazer isso, é importante seguir as convenções de nomenclatura para suas classes, métodos e variáveis ​​para manter a consistência. Abaixo, segue um exemplo de implementação simples de convenções de nomenclatura para melhorar a legibilidade do código usando o IronPDF , respeitando essas convenções:

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

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

Ao seguir essas convenções de nomenclatura, seu código permanece profissional, organizado e fácil de ler ao usar o IronPDF para gerar relatórios.

Conclusão

Seguindo essas convenções de nomenclatura do C#, você garante que seu código seja limpo, legível e fácil de manter. Seja usando Pascal Case para nomes de classes, Camel Case para variáveis ​​locais ou um prefixo de sublinhado para campos privados, essas convenções ajudam a estabelecer uma base de código consistente.

Com o IronPDF, você pode começar a usar e explorar todas as suas funcionalidades com um período de teste gratuito . Este período de teste permite que você experimente e veja em primeira mão o quão bem ele se integra ao seu fluxo de trabalho. Quando você estiver pronto para dar o próximo passo, as licenças começam em apenas $999.