El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

En aquest tema, explorarem els estàndards de codificació i les millors pràctiques que hauríem de seguir quan escrivim codi en C#. Seguir aquests estàndards no només fa que el codi sigui més llegible i mantenible, sinó que també ajuda a evitar errors comuns i millora la col·laboració en equips de desenvolupament.

Estàndards de Codificació

1.1. Nomenclatura

1.1.1. Noms de Classes i Mètodes

Classes: Utilitza el format PascalCase.

public class CustomerAccount
{
    // ...
}

Mètodes: També utilitza el format PascalCase.

public void CalculateInterest()
{
    // ...
}

1.1.2. Noms de Variables i Camps

Variables locals i paràmetres: Utilitza el format camelCase.
```
int accountBalance;
string customerName;
```

Camps privats: Utilitza el format _camelCase.

private int _accountBalance;
private string _customerName;

1.1.3. Noms de Constants

Constants: Utilitza el format PascalCase.
```
public const int MaxRetryAttempts = 3;
```

1.2. Format i Espaiat

1.2.1. Indentació

Utilitza quatre espais per a la indentació. No utilitzis tabuladors.

public void ProcessTransaction()
{
    if (transactionIsValid)
    {
        // Process the transaction
    }
}

1.2.2. Espaiat

Deixa una línia en blanc entre mètodes per millorar la llegibilitat.

public void MethodOne()
{
    // ...
}

public void MethodTwo()
{
    // ...
}

1.3. Comentaris

1.3.1. Comentaris de Línia

Utilitza comentaris de línia per explicar el codi complex o no evident.

// Calcula l'interès basat en el saldo actual
public void CalculateInterest()
{
    // ...
}

1.3.2. Comentaris de Bloc

Utilitza comentaris de bloc per a descripcions més llargues o per desactivar codi.

/*
 * Aquest mètode processa la transacció
 * i actualitza el saldo del compte.
 */
public void ProcessTransaction()
{
    // ...
}

Millors Pràctiques

2.1. Escrivint Codi Neteja

2.1.1. Mètodes Curts i Concrets

Mantingues els mètodes curts i amb una sola responsabilitat.

public void SaveCustomerData(Customer customer)
{
    ValidateCustomer(customer);
    SaveToDatabase(customer);
}

2.1.2. Evita la Duplicació de Codi

Reutilitza codi mitjançant mètodes i classes.

public void ProcessOrder(Order order)
{
    ValidateOrder(order);
    SaveOrder(order);
}

private void ValidateOrder(Order order)
{
    // Validació de l'ordre
}

private void SaveOrder(Order order)
{
    // Guardar l'ordre a la base de dades
}

2.2. Gestió d'Errors

2.2.1. Utilitza Excepcions

Utilitza excepcions per gestionar errors i condicions excepcionals.

public void ProcessPayment(Payment payment)
{
    if (payment == null)
    {
        throw new ArgumentNullException(nameof(payment));
    }

    // Processar el pagament
}

2.2.2. Captura Excepcions Específiques

Captura excepcions específiques en lloc de capturar excepcions generals.

try
{
    // Codi que pot generar una excepció
}
catch (InvalidOperationException ex)
{
    // Gestió específica per InvalidOperationException
}

2.3. Documentació

2.3.1. Comentaris XML

Utilitza comentaris XML per documentar mètodes i classes.

/// <summary>
/// Calcula l'interès basat en el saldo actual.
/// </summary>
/// <param name="balance">El saldo actual.</param>
/// <returns>L'interès calculat.</returns>
public decimal CalculateInterest(decimal balance)
{
    // ...
}

2.4. Proves

2.4.1. Escriu Proves Unitàries

Escriu proves unitàries per assegurar-te que el codi funciona correctament.

[TestMethod]
public void CalculateInterest_ShouldReturnCorrectInterest()
{
    // Arrange
    var account = new BankAccount();
    account.Deposit(1000);

    // Act
    var interest = account.CalculateInterest();

    // Assert
    Assert.AreEqual(50, interest);
}

Exercicis Pràctics

Exercici 1: Refactorització de Codi

Refactoritza el següent codi per seguir els estàndards de codificació i millors pràctiques:

public class bankaccount
{
    public decimal balance;
    public void deposit(decimal amount)
    {
        balance += amount;
    }
    public void withdraw(decimal amount)
    {
        if (balance >= amount)
        {
            balance -= amount;
        }
    }
}

Solució:

public class BankAccount
{
    private decimal _balance;

    public void Deposit(decimal amount)
    {
        _balance += amount;
    }

    public void Withdraw(decimal amount)
    {
        if (_balance >= amount)
        {
            _balance -= amount;
        }
    }
}

Exercici 2: Escriure Proves Unitàries

Escriu una prova unitària per al mètode Withdraw de la classe BankAccount.

Solució:

[TestMethod]
public void Withdraw_ShouldDecreaseBalance_WhenAmountIsAvailable()
{
    // Arrange
    var account = new BankAccount();
    account.Deposit(1000);

    // Act
    account.Withdraw(500);

    // Assert
    Assert.AreEqual(500, account.GetBalance());
}

Conclusió

Seguir els estàndards de codificació i les millors pràctiques és essencial per escriure codi net, llegible i mantenible. Aquests estàndards no només milloren la qualitat del codi, sinó que també faciliten la col·laboració en equips de desenvolupament. Practica aquests principis en els teus projectes per convertir-te en un programador més eficient i efectiu.

Estàndards de Codificació i Millors Pràctiques