0Pricing
C# Academy · Leçon

Modèles de contrôle et de validation

Validez rapidement les entrées avec des clauses de contrôle, déclenchez les exceptions appropriées et utilisez des vérifications de type TryParse pour les données utilisateur.

Modèles de contrôle et de validation 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.

Pourquoi utiliser des protections

Objectif : rendre les méthodes sûres et lisibles.

  • Utilisez des clauses de protection au début
  • Levez des exceptions précises (ArgumentNullException, ArgumentOutOfRangeException)
  • Utilisez TryParse pour les données saisies par l’utilisateur
  • Échouez rapidement ; évitez les imbrications profondes

Démonstration des protections initiales

Ajoutez de petites vérifications au début pour valider les paramètres ; levez des exceptions précises afin que les appelants sachent ce qui s’est mal passé.

using System;

// Demo: validate inputs at the top; keep main logic flat.
public class Program
{
  // Compute price with simple rules; guard early.
  public static decimal ComputePrice(string sku, int qty, decimal unitPrice)
  {
    if (sku == null) throw new ArgumentNullException("sku");
    if (sku.Length == 0) throw new ArgumentException("sku must not be empty", "sku");
    if (qty <= 0) throw new ArgumentOutOfRangeException("qty", "qty must be > 0");
    if (unitPrice < 0m) throw new ArgumentOutOfRangeException("unitPrice", "unitPrice must be >= 0");

    // Main logic stays simple
    decimal subtotal = qty * unitPrice;
    if (qty >= 10) subtotal = subtotal * 0.9m; // small bulk discount
    return subtotal;
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(ComputePrice("ABC", 2, 5m));   // ok
    try { Console.WriteLine(ComputePrice("", 2, 5m)); } catch (Exception ex) { Console.WriteLine(ex.GetType().Name); }
  }
}

Classe auxiliaire Guard

Regroupez les vérifications courantes dans une petite classe Guard afin de garder des corps de méthodes propres et cohérents.

using System;

// Minimal static helper for common validations (beginner friendly).
public static class Guard
{
  public static void NotNull(object value, string name)
  {
    if (value == null) throw new ArgumentNullException(name);
  }

  public static void NotNullOrEmpty(string value, string name)
  {
    if (value == null) throw new ArgumentNullException(name);
    if (value.Length == 0) throw new ArgumentException(name + " must not be empty", name);
  }

  public static void InRange(int value, int minInclusive, int maxInclusive, string name)
  {
    if (value < minInclusive || value > maxInclusive)
      throw new ArgumentOutOfRangeException(name, "Expected " + minInclusive + ".." + maxInclusive);
  }
}

public class Program
{
  static int ScoreFor(string userId, int level)
  {
    Guard.NotNullOrEmpty(userId, "userId");
    Guard.InRange(level, 1, 10, "level");
    // pretend logic
    return level * 100;
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(ScoreFor("u42", 3));
    try { Console.WriteLine(ScoreFor(null, 3)); } catch (Exception ex) { Console.WriteLine(ex.GetType().Name); }
  }
}

Validation avec TryParse

Pour les entrées invalides courantes, préférez les méthodes de type TryParse qui retournent false au lieu de lever des exceptions.

using System;

// Use TryParse for user-provided text; avoid throwing for normal invalid input.
public class Program
{
  public static bool TryGetPort(string text, out int port)
  {
    port = 0;
    int value;
    if (!int.TryParse(text, out value)) return false;
    if (value < 1 || value > 65535) return false;
    port = value;
    return true;
  }

  public static void Main(string[] args)
  {
    int p;
    Console.WriteLine("8080 -> " + (TryGetPort("8080", out p) ? ("ok " + p) : "invalid"));
    Console.WriteLine("abc -> " + (TryGetPort("abc", out p) ? ("ok " + p) : "invalid"));
  }
}

Lever une exception ou retourner une valeur

  • Levez une exception pour les erreurs de programmation (mauvaise utilisation de l’API, valeur null interdite, valeur hors limites)
  • Retournez false ou un résultat pour les erreurs utilisateur courantes (texte invalide)
  • Utilisez des types d’exception précis ; incluez le nom du paramètre
  • Validez de l’extérieur vers l’intérieur : commencez par les vérifications peu coûteuses

Bonnes pratiques

Conseils :

  • Validez aux limites (contrôleurs, API publiques)
  • Préférez de petites méthodes de protection aux imbrications profondes
  • Gardez des messages d’erreur courts et clairs
  • Journalisez une seule fois à la limite, pas dans chaque protection

Signification d’une clause de protection

Vérification rapide : quelle définition décrit le mieux une clause de protection ?

Récapitulatif

Récapitulatif : validez rapidement avec des clauses de protection, levez des exceptions précises pour les erreurs de programmation et utilisez TryParse pour les entrées utilisateur courantes.

Questions Fréquemment Posées

La leçon « Modèles de contrôle et de validation » est-elle gratuite ?

Oui — le texte complet de « Modèles de contrôle et de validation » 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 « Modèles de contrôle et de validation » ?

Validez rapidement les entrées avec des clauses de contrôle, déclenchez les exceptions appropriées et utilisez des vérifications de type TryParse pour les données utilisateur. 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 « Modèles de contrôle et de validation » ?

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. Abstractions de journalisation, Debug/Trace
  2. Profilage et traces de base (concepts)
  3. Modèles de contrôle et de validation
← Retour à C# Academy