C# - Nullables

Bonjour, aspirants programmeurs ! Aujourd'hui, nous allons plonger dans le monde fascinant des Nullables en C#. Ne vous inquiétez pas si vous êtes nouveau dans la programmation - je vais vous guider pas à pas à travers ce concept, tout comme j'ai fait pour des centaines d'étudiants au fil des ans. Mettons-nous ensemble sur cette aventure passionnante !

Qu'est-ce que les Nullables ?

Imaginez que vous remplissez un formulaire et qu'il y a un champ pour votre prénom du milieu. Mais que faire si vous n'avez pas de prénom du milieu ? Dans la vie réelle, vous le laissez vide. En C#, nous avons un concept similaire appelé Nullables.

Les Nullables sont une fonctionnalité spéciale en C# qui permet aux types de valeur (comme int, double, bool) d'avoir un état supplémentaire : null. Normalement, les types de valeur ne peuvent pas être null, mais les Nullables nous offrent cette flexibilité.

Syntaxe de base

Pour déclarer un type Nullable, nous utilisons le symbole ? après le nom du type. Voici un exemple :

int? nullableInt = null;
double? nullableDouble = 3.14;
bool? nullableBool = true;

Dans ce code :

• nullableInt est un entier qui peut être null, et nous l'avons défini comme null.
• nullableDouble est un double qui peut être null, mais nous lui avons donné une valeur.
• nullableBool est un booléen qui peut être null, et nous l'avons défini comme true.

Vérification de la nullité

Lorsque vous travaillez avec des Nullables, il est crucial de vérifier s'ils ont une valeur avant de les utiliser. Nous pouvons le faire en utilisant la propriété HasValue :

int? maybeNumber = null;

if (maybeNumber.HasValue)
{
Console.WriteLine($"La valeur est : {maybeNumber.Value}");
}
else
{
Console.WriteLine("La valeur est null");
}

Ce code vérifie si maybeNumber a une valeur. Si oui, nous affichons la valeur ; sinon, nous disons qu'elle est null.

Utilisation des valeurs Nullables

Pour utiliser la valeur d'un Nullable, nous pouvons accéder à sa propriété Value. Cependant, nous devons être prudent ! Si nous tentons d'accéder à la Value d'un Nullable null, nous obtenirons une exception. Voici une manière sûre de le faire :

int? possibleAge = 25;

int actualAge = possibleAge ?? 0;

Console.WriteLine($"Âge : {actualAge}");

Dans cet exemple, si possibleAge est null, actualAge sera défini à 0. Cela nous amène à notre下一个 sujet...

L'opérateur de coalescence de la nullité (??)

L'opérateur de coalescence de la nullité (??) est comme un gardien amical qui nous aide à gérer les valeurs potentiellement null. C'est une manière abrégée de dire "Utilisez cette valeur si elle n'est pas null, sinon utilisez cette valeur par défaut."

Utilisation de base

Voici comment nous utilisons l'opérateur de coalescence de la nullité :

string name = null;
string displayName = name ?? "Invité";

Console.WriteLine($"Bienvenue, {displayName} !");

Dans ce code, si name est null (ce qui est le cas), displayName sera défini comme "Invité". C'est une manière concise de fournir des valeurs par défaut.

Chaining de l'opérateur de coalescence de la nullité

Nous pouvons chaîner plusieurs opérateurs ?? pour vérifier plusieurs valeurs potentielles :

string firstName = null;
string middleName = null;
string lastName = "Smith";

string fullName = firstName ?? middleName ?? lastName ?? "Inconnu";

Console.WriteLine($"Nom complet : {fullName}");

Ce code utilisera la première valeur non null qu'il trouvera, ou "Inconnu" si toutes sont null.

Utilisation de l'opérateur de coalescence de la nullité avec des appels de méthode

L'opérateur ?? peut également être utilisé avec des appels de méthode :

public string GetUserName()
{
// Imaginez que cette méthode pourrait retourner null
return null;
}

string userName = GetUserName() ?? "UtilisateurParDéfaut";
Console.WriteLine($"Utilisateur : {userName}");

C'est particulièrement utile lors de la gestion de méthodes qui pourraient retourner null.

Exemples pratiques

Jetons un regard sur certains scénarios du monde réel où les Nullables et l'opérateur de coalescence de la nullité sont utiles :

Exemple 1 : Entrée utilisateur

Console.Write("Entrez votre âge (ou appuyez sur Entrée pour ignorer) : ");
string input = Console.ReadLine();

int? age = string.IsNullOrEmpty(input) ? null : int.Parse(input);

string message = age.HasValue
? $"Vous avez {age.Value} ans."
: "Âge non fourni.";

Console.WriteLine(message);

Ce code permet à un utilisateur de saisir son âge ou de passer la question. Nous utilisons un Nullable int pour représenter l'âge, qui peut ou ne pas être fourni.

Exemple 2 : Requêtes de base de données

Imaginez que nous interrogeons une base de données pour obtenir les informations d'un utilisateur :

public class User
{
public string Name { get; set; }
public int? Age { get; set; }
}

User user = GetUserFromDatabase(); // Supposons que cette méthode existe

string ageDisplay = user.Age.HasValue
? $"{user.Age.Value} ans"
: "Âge inconnu";

Console.WriteLine($"Utilisateur : {user.Name ?? "Anonyme"}, {ageDisplay}");

Dans cet exemple, nous utilisons les Nullables pour gérer la possibilité que l'âge de l'utilisateur ne soit pas dans la base de données, et nous utilisons l'opérateur de coalescence de la nullité pour fournir un nom par défaut si celui-ci n'est pas disponible.

Conclusion

Les Nullables et l'opérateur de coalescence de la nullité sont des outils puissants en C# qui nous aident à écrire un code plus robuste et flexible. Ils nous permettent de gérer les situations où les données peuvent être manquantes, rendant nos programmes plus résistants et conviviaux.

Souvenez-vous, la programmation est comme la cuisine - il faut de la pratique pour bien la faire. N'ayez pas peur d'expérimenter avec ces concepts dans vos propres projets. Avant de savoir dire, vous serez un expert en Nullables et en ?? !

Continuez à coder, continuez à apprendre, et surtout, amusez-vous dans votre parcours de programmation !

Credits: Image by storyset