0Pricing
C# Academy · Lección

Patrones de validación y guardas

Valide las entradas desde el principio con cláusulas de guarda, lance las excepciones adecuadas y use comprobaciones al estilo de TryParse para los datos del usuario.

Patrones de validación y guardas es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Por qué usar validaciones previas

Objetivo: Mantenga los métodos seguros y legibles.

  • Use cláusulas de guarda al principio
  • Lance excepciones específicas (ArgumentNullException, ArgumentOutOfRangeException)
  • Use TryParse para la entrada del usuario
  • Falle rápido; evite el anidamiento profundo

Demostración de validaciones tempranas

Añada pequeñas comprobaciones al principio para validar los argumentos; lance excepciones específicas para que los consumidores sepan qué salió mal.

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); }
  }
}

Clase auxiliar Guard

Extraiga las comprobaciones comunes a una pequeña clase Guard para mantener los cuerpos de los métodos limpios y coherentes.

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); }
  }
}

Validación con TryParse

Para entradas no válidas habituales, prefiera métodos del estilo de TryParse que devuelvan false en lugar de lanzar excepciones.

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"));
  }
}

Lanzar frente a devolver

  • Lance excepciones ante errores del programador (uso incorrecto de la API, valores nulos no permitidos o valores fuera de rango)
  • Devuelva false/Result ante errores normales del usuario (texto no válido)
  • Use tipos de excepción específicos e incluya el nombre del parámetro
  • Valide de fuera hacia dentro: haga primero las comprobaciones económicas

Buenas prácticas

Consejos:

  • Valide en los límites (controladores y API públicas)
  • Prefiera pequeños métodos de guarda al anidamiento profundo
  • Mantenga los mensajes de error breves y claros
  • Registre una sola vez en el límite, no en cada guarda

Qué significa una cláusula de guarda

Comprobación rápida: ¿Qué describe mejor una cláusula de guarda?

Resumen

Resumen: Valide pronto con cláusulas de guarda, lance excepciones específicas ante errores del programador y use TryParse para la entrada habitual del usuario.

Preguntas frecuentes

¿La lección «Patrones de validación y guardas» es gratis?

Sí — el texto completo de «Patrones de validación y guardas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Patrones de validación y guardas»?

Valide las entradas desde el principio con cláusulas de guarda, lance las excepciones adecuadas y use comprobaciones al estilo de TryParse para los datos del usuario. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Patrones de validación y guardas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Abstracciones de logging y Debug/Trace
  2. Profiling básico y trazas (conceptos)
  3. Patrones de validación y guardas
← Volver a C# Academy