Convenções de nomenclatura em C# (Como funciona para desenvolvedores)

Visão geral das convenções 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 Class Customer
	Public Property Balance() As Decimal
End Class

Public Interface ICustomer
	Function GetBalance() As Decimal
End Interface

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

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

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.

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

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.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

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

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

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
}

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 decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

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

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

Convenções de nomenclatura para constantes em 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

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 da instrução à qual pertence, e a chave de fechamento } deve estar em uma nova linha, alinhada com a instruçã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

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

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

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 $799.