En C#, utilisez TryParse au lieu de Parse lors de la conversion de données utilisateur ou externes afin d’éviter les erreurs à l’exécution.
// Utilisation risquée
int age = int.Parse(input);
// Utilisation sûre
if (int.TryParse(input, out int result))
{
Console.WriteLine(result);
}
else
{
Console.WriteLine("Nombre invalide");
}
En C#, l’opérateur de coalescence nulle (??) permet d’attribuer une valeur par défaut lorsqu’une variable est null.
string? userName = null;
// Ancienne méthode
string name1 = userName != null ? userName : "Invité";
// Méthode recommandée
string name2 = userName ?? "Invité";
Console.WriteLine(name1); // Invité
Console.WriteLine(name2); // Invité
En C#, utilisez IEnumerable<T> si vous avez seulement besoin de lire et de parcourir des données. Utilisez List<T> si vous devez ajouter, supprimer ou accéder aux éléments par index.
// Lecture seule : parcourir
IEnumerable<int> numbers = new[] { 10, 20, 30 };
foreach (var n in numbers)
{
Console.WriteLine(n);
}
// Liste : modifier ou accéder par index
List<int> list = new List<int> { 10, 20, 30 };
list.Add(40);
Console.WriteLine(list[0]); // 10
En C#, l’opérateur ?. permet d’accéder de manière sécurisée à une propriété ou une méthode. Si l’objet est null, aucune erreur ne se produit et le résultat est null.
Person? person = null;
// Ancienne méthode
string name1 = person != null ? person.Name : null;
// Méthode recommandée
string? name2 = person?.Name;
Console.WriteLine(name1); // null
Console.WriteLine(name2); // null
En C#, var doit être utilisé lorsque le type est clairement compréhensible à partir de la valeur assignée. Cela rend le code plus lisible.
// Lisible : le type est évident
var numbers = new List<int>();
var name = "Claire";
var total = numbers.Count;
// Non recommandé : le type n’est pas clair
var result = GetData();
// Alternative recommandée
List<User> users = GetUsers();
En C#, utilisez is et is not pour des vérifications de type plus lisibles et des correspondances de modèles.
// Ancienne approche (utilisation de "as" et vérification de null)
object obj = "Bonjour, le monde!";
if (obj is string)
{
Console.WriteLine(((string)obj).ToUpper()); // BONJOUR, LE MONDE!
}
// Méthode recommandée (utilisation de is)
if (obj is string str)
{
Console.WriteLine(str.ToUpper()); // BONJOUR, LE MONDE!
}
// Utilisation de "is not" pour la négation
if (obj is not int)
{
Console.WriteLine("Ce n’est pas un entier");
}
En C#, nameof() retourne le nom d’une variable, d’une propriété ou d’une méthode sous forme de texte. Cela permet d’éviter les erreurs liées aux chaînes écrites en dur.
int age = 25;
// Ancienne méthode
if (age < 0)
{
throw new ArgumentException("age");
}
// Méthode recommandée
if (age < 0)
{
throw new ArgumentException(nameof(age));
}
Console.WriteLine(nameof(age)); // age
En C#, modifier une collection à l’intérieur d’une boucle foreach provoque une erreur à l’exécution. Il faut parcourir une copie ou utiliser une autre boucle.
// Ceci provoque une erreur
foreach (var item in items)
{
items.Remove(item);
}
// Approche sûre : parcourir une copie
foreach (var item in items.ToList())
{
items.Remove(item);
}
// Alternative : utiliser une boucle for
for (int i = items.Count - 1; i >= 0; i--)
{
items.RemoveAt(i);
}
En C#, il est préférable d’éviter de capturer l’Exception générale. Capturez uniquement les exceptions que vous prévoyez de gérer.
// Utilisation risquée : masque le vrai problème
try
{
int number = int.Parse(input);
}
catch (Exception)
{
Console.WriteLine("Une erreur est survenue");
}
// Utilisation recommandée : exception spécifique
try
{
int number = int.Parse(input);
}
catch (FormatException)
{
Console.WriteLine("Nombre non valide");
}
L’utilisation de DateTime.UtcNow au lieu de DateTime.Now permet d’éviter les erreurs liées aux fuseaux horaires.
// Heure locale (dépend du fuseau du serveur)
DateTime localTime = DateTime.Now;
// Temps universel (recommandé)
DateTime utcTime = DateTime.UtcNow;
Console.WriteLine(localTime);
Console.WriteLine(utcTime);