0Pricing
C# Academy · Leçon

Types de références nullables (sensibilisation) et annotations (modèles C# 6)

C# 6 ne possède pas de types de références nullables (string?). Apprenez à gérer les valeurs nulles en toute sécurité : contrôles des entrées, documentation claire, assistant Require.NotNull et comparaison avec Nullable pour les types valeur.

Types de références nullables (sensibilisation) et annotations (modèles C# 6) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Prise en compte de NRT et solution de repli

Idée : les types référence pouvant être null (par exemple, string?) ajoutent des vérifications du compilateur dans les versions récentes de C#.

  • C# 6 ne prend pas en charge string?
  • Utilisez des garde-fous, une documentation claire et de simples assistants
  • Renvoyez une valeur non nulle par défaut

Se prémunir contre les valeurs nulles

Ajoutez des vérifications ArgumentNullException pour les paramètres de type référence ; traitez ensuite les valeurs comme non nulles.

using System;

public static class Greeter
{
  // Contract: name must not be null (C# 6 has no string? to enforce)
  public static string Hello(string name)
  {
    if (name == null) throw new ArgumentNullException("name"); // guard
    return "Hello " + name.ToUpper(); // safe after guard
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine(Greeter.Hello("Ada"));
    try
    {
      Console.WriteLine(Greeter.Hello(null)); // will throw (by design)
    }
    catch (Exception ex)
    {
      Console.WriteLine("Caught: " + ex.GetType().Name);
    }
  }
}

Assistant Require.NotNull

Créez un petit assistant Require.NotNull pour réduire le code répétitif et rendre l’intention évidente.

using System;

public static class Require
{
  // Works for reference types; returns the validated value
  public static T NotNull<T>(T value, string name) where T : class
  {
    if (value == null) throw new ArgumentNullException(name);
    return value;
  }
}

public sealed class Email
{
  public string Address { get; private set; }

  public Email(string address)
  {
    Address = Require.NotNull(address, "address").Trim();
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Email e = new Email("user@mail.com");
    Console.WriteLine(e.Address);
  }
}

Nullable&lt;T&gt; et références

Nullable<T> (par exemple, int?) est destiné aux types valeur. Les types référence peuvent déjà être null ; utilisez des vérifications dans C# 6.

using System;

public class Program
{
  public static void Main(string[] args)
  {
    int x = 5;              // value type (non-nullable)
    int? maybe = null;      // Nullable<T> works for value types
    Console.WriteLine("x=" + x);
    Console.WriteLine("maybe has value? " + maybe.HasValue);
    Console.WriteLine("maybe or default: " + (maybe ?? -1));
  }
}

Documenter les contrats de nullité

Indiquez la nullité dans la documentation XML et soyez cohérent : renvoyez toujours une valeur non nulle ou documentez clairement les cas où null est possible.

using System;

/// <summary>
/// Parses "key=value" and returns the value part.
/// Returns null if the format is invalid.
/// </summary>
public static class Parser
{
  // Explicitly document when null can be returned.
  public static string TryGetValue(string line)
  {
    if (line == null) throw new ArgumentNullException("line");
    int idx = line.IndexOf("=");
    if (idx < 0 || idx == line.Length - 1) return null; // documented nullable return
    return line.Substring(idx + 1);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine(Parser.TryGetValue("a=1"));
    Console.WriteLine(Parser.TryGetValue("oops")); // prints nothing (null)
  }
}

Liste de vérification de la sécurité vis-à-vis de null (C# 6)

Liste de vérification :

  • Vérifiez les entrées avec ArgumentNullException.
  • Renvoyez une valeur non nulle par défaut ; documentez les retours pouvant être null.
  • Utilisez de petits assistants (Require.NotNull) pour garder un code clair.
  • Privilégiez, lorsque c’est pertinent, les surcharges qui évitent null (par exemple, une chaîne vide plutôt que null).

Sécurité vis-à-vis de null en C# 6

Vérification rapide : dans C# 6 (sans types référence pouvant être null), quelle bonne pratique permet de réduire les bogues liés à null dans les interfaces de programmation publiques ?

Récapitulatif

Récapitulatif : les NRT sont une fonctionnalité plus récente. Dans C# 6, restez en sécurité avec des garde-fous, une documentation claire, des méthodes auxiliaires et des contrats de retour non nuls prévisibles.

Questions Fréquemment Posées

La leçon « Types de références nullables (sensibilisation) et annotations (modèles C# 6) » est-elle gratuite ?

Oui — le texte complet de « Types de références nullables (sensibilisation) et annotations (modèles C# 6) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Types de références nullables (sensibilisation) et annotations (modèles C# 6) » ?

C# 6 ne possède pas de types de références nullables (string?). Apprenez à gérer les valeurs nulles en toute sécurité : contrôles des entrées, documentation claire, assistant Require.NotNull et compa… Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.

Combien de temps prend la leçon « Types de références nullables (sensibilisation) et annotations (modèles C# 6) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Méthodes et types génériques ; contraintes
  2. Variance (in/out) avec les interfaces et les délégués
  3. Types de références nullables (sensibilisation) et annotations (modèles C# 6)
← Retour à C# Academy