Dans le parcours du raffinement du code, où des conceptions complexes rencontrent l’ingéniosité humaine, peu de processus s’avèrent aussi éclairants que la revue de code. Au fil du temps, j’ai acquis de la sagesse de mes expériences pour peaufiner cette pratique essentielle.
Dans cette exploration, nous allons analyser le code ensemble, identifiant les aspects clés d’une revue de code professionnelle et respectueuse.
Embarquons dans ce voyage de sagesse en revue de code.
Identifier les Erreurs Nuancées
Initialement, recherchez les oublis fréquents — ces petites erreurs significatives que les développeurs omettent souvent.
public class OrderProcessor
{
private readonly List<Order> _orders;
public OrderProcessor(List<Order> orders)
{
_orders = orders;
}
public void ProcessOrders()
{
foreach (var order in _orders)
{
if (order.Status == "Paid")
{
order.Status = "Shipped";
Console.WriteLine($"Order {order.Id} is now Shipped.");
}
else if (order.orderStatus== "Shipped")
{
order.Status = "Completed";
Console.WriteLine($"Order {order.Id} is now Completed.");
}
}
}
}
public class Order
{
public int order_id { get; set; }
public string orderStatus { get; set; }
public decimal TotalAmount{ get; set; }
}
Réfléchissez aux problèmes potentiels dans le code ci-dessus. Avez-vous remarqué?
- L’absence de gestion des exceptions pourrait perturber la stabilité.
- Le codage en dur des statuts rend le code fragile.
- Les conventions de nommage incohérentes mènent à un code confus.
Observez la version raffinée où nous intégrons des énumérations et maintenons l’uniformité :
using System;
using System.Collections.Generic;
public class OrderProcessor
{
private readonly List<Order> _orders;
public OrderProcessor(List<Order> orders)
{
_orders = orders;
}
public void ProcessOrders()
{
foreach (var order in _orders)
{
try
{
if (order.Status == OrderStatus.Paid)
{
order.Status = OrderStatus.Shipped;
Console.WriteLine($"Order {order.Id} is now Shipped.");
}
else if (order.Status == OrderStatus.Shipped)
{
order.Status = OrderStatus.Completed;
Console.WriteLine($"Order {order.Id} is now Completed.");
}
else
{
Console.WriteLine($"Order {order.Id} has an unknown status: {order.Status}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Error processing order {order.Id}: {ex.Message}");
}
}
}
}
public class Order
{
public int Id { get; set; }
public OrderStatus Status { get; set; }
public decimal TotalAmount { get; set; }
}
public enum OrderStatus
{
Paid,
Shipped,
Completed
}
Reconnaître les Omissions Subtiles
En analysant l’exemple suivant, ne négligez pas la présence de vérifications de nullité, un oubli commun lorsque la rapidité prime sur l’exhaustivité.
public class OrderProcessor
{
public void GetCustomerOrderDetails(Customer customer)
{
if (customer.Orders.Count > 0)
{
foreach (var order in customer.Orders)
{
Console.WriteLine($"Order ID: {order.OrderId}, Amount: {order.Amount}");
}
}
else
{
Console.WriteLine("No orders found.");
}
}
}
L’introduction d’un filet de sécurité avec des vérifications de nullité transforme le code en un module fiable :
public class OrderProcessor
{
public void GetCustomerOrderDetails(Customer customer)
{
if (customer == null)
{
Console.WriteLine("Customer is null.");
return;
}
if (customer.Orders == null)
{
Console.WriteLine("Customer has no orders.");
return;
}
if (customer.Orders.Count > 0)
{
foreach (var order in customer.Orders)
{
Console.WriteLine($"Order ID: {order.OrderId}, Amount: {order.Amount}");
}
}
else
{
Console.WriteLine("No orders found.");
}
}
}
Déterrer les Anti-Patterns
Réfléchissez au bloc de code suivant et reconnaissez les pièges du couplage étroit.
public class OrderService
{
private readonly PaymentService _paymentService;
public OrderService()
{
_paymentService = new PaymentService();
}
public void ProcessOrder(Order order)
{
_paymentService.ProcessPayment(order);
}
}
Le découplage améliore la testabilité et la flexibilité :
public class OrderService
{
private readonly IPaymentService _paymentService;
public OrderService(IPaymentService paymentService)
{
_paymentService = paymentService;
}
public void ProcessOrder(Order order)
{
_paymentService.ProcessPayment(order);
}
}
Éliminer les Nombres Magiques
En révisant, faites attention aux constantes non nommées qui obscurcissent l’intention et compliquent la maintenance :
public double CalculateTax(double income)
{
if (income <= 50000)
return income * 0.10;
if (income <= 100000)
return income * 0.15;
if (income <= 200000)
return income * 0.20;
return income * 0.30;
}
Confinez ces “magies” aux configurations, raffinant la précision avec simplicité :
public double CalculateTax(double income, IConfiguration configuration)
{
double[] incomeSlabs = configuration.GetSection("TaxSettings:IncomeSlabs").Get<double[]>();
double[] taxRates = configuration.GetSection("TaxSettings:TaxRates").Get<double[]>();
for (int i = 0; i < incomeSlabs.Length; i++)
{
if (income <= incomeSlabs[i])
{
return income * taxRates[i];
}
}
return income * taxRates.Last();
}
{
"TaxSettings": {
"IncomeSlabs": [50000, 100000, 200000],
"TaxRates": [0.10, 0.15, 0.20, 0.30]
}
}
Respecter le Principe DRY
La logique répétitive atténue l’innovation, mais la clarté émerge avec la consolidation.
public class DiscountCalculator
{
public double CalculateDiscount(double amount, double discountPercentage)
{
double discount = amount * discountPercentage;
double discountedPrice = amount - discount;
return discountedPrice;
}
public double ApplyDiscount(double amount, double discountPercentage)
{
double discount = amount * discountPercentage;
double discountedPrice = amount - discount;
return discountedPrice;
}
}
Un design refactorisé prône la simplicité :
public class DiscountCalculator
{
public double CalculateDiscount(double amount, double discountPercentage)
{
return CalculateDiscountAmount(amount, discountPercentage);
}
public double ApplyDiscount(double amount, double discountPercentage)
{
double discount = CalculateDiscountAmount(amount, discountPercentage);
return amount - discount;
}
private double CalculateDiscountAmount(double amount, double discountPercentage)
{
return amount * discountPercentage;
}
}
Embrasser le YAGNI
Envisagez la clarté en remettant en question les complexités préventives, ancrées dans l’absence de nécessité.
public class OrderProcessor
{
public void ProcessOrder(Order order, double discount)
{
decimal discountAmount = CalculateDiscount(order, discount);
decimal finalAmount = order.Amount - discountAmount;
Console.WriteLine($"Discount Applied: {discountAmount:C}");
if (!string.IsNullOrEmpty(order.CouponCode))
{
decimal couponDiscount = ApplyCoupon(order.CouponCodeDiscount);
finalAmount -= couponDiscount;
Console.WriteLine($"Coupon {order.CouponCode} applied.");
}
}
private decimal CalculateDiscount(Order order, double discount)
{
return order.Amount * discount;
}
private decimal ApplyCoupon(double couponCodeDiscount)
{
return order.Amount * couponCodeDiscount;
}
}
public class Order
{
public int Id { get; set; }
public decimal Amount { get; set; }
public double CouponCodeDiscount { get; set; }
}
Écartez les ajouts inutiles pour maintenir le focus :
public class OrderProcessor
{
public void ProcessOrder(Order order, double discount)
{
decimal discountAmount = CalculateDiscount(order, discount);
decimal finalAmount = order.Amount - discountAmount;
Console.WriteLine($"Discount Applied: {discountAmount:C}");
}
private decimal CalculateDiscount(Order order, double discount)
{
return order.Amount * discount;
}
}
public class Order
{
public int Id { get; set; }
public decimal Amount { get; set; }
}
Maintenir le Professionnalisme dans les Revues de Code
Élevez l’esprit collaboratif de votre équipe en incarnant le professionnalisme et le respect :
- Interactions Respectueuses : Améliorez le code, pas l’individu.
- Feedback Constructif : Guidez par des suggestions, non des critiques.
- Dialogues Inquisitifs : Incitez l’apprentissage par des questions réfléchies.
- Précision Claire : Articulez des retours spécifiques pour une meilleure compréhension.
- Évaluation Équilibrée : Célébrez les forces tout en abordant les faiblesses.
- Ouverture d’Esprit : Accueillez les points de vue divers pour enrichir les résultats.
- Guidance Patiente : Mentorez avec gentillesse, favorisant la croissance.
- Éviter le Pinaillage : Priorisez les retours impactants sur les minuties.
- Gestion des Préjugés : Concentrez-vous au-delà des préférences personnelles.
- Valoriser le Temps : Partagez des insights réfléchis et concis rapidement.
L’adoption de ces pratiques nourrit une culture de revue de code vibrante et inspirée. Apportez vos perspectives à la conversation : quelles stratégies définissent votre approche de la revue ?
