Modelado de dominios con uniones discriminadas (records) — emulación de C# 6
Modele una unión discriminada en C# 6 mediante un enum de etiquetas y clases pequeñas, cree métodos de fábrica y gestione las variantes con switch y una excepción predeterminada.
Modelado de dominios con uniones discriminadas (records) — emulación de C# 6 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.
Idea de DU en C# 6
Objetivo: Cree una unión discriminada pequeña en C# 6.
- Enum de etiquetas para el caso activo
- Pequeñas clases de casos para los datos
- Métodos de fábrica para crear casos válidos
- Switch + default que lanza una excepción para gestionar todas las variantes
Etiqueta + fábricas
Use un enum de etiquetas y métodos de fábrica para construir únicamente casos válidos; los campos de los demás casos permanecen sin utilizar.
using System;
public enum PaymentKind { Cash, Card, Wire }
public sealed class Payment
{
public PaymentKind Kind;
// per-case data (only one is meaningful per instance)
public string CardLast4; // for Card
public string Iban; // for Wire
private Payment() { }
// factories keep invariants
public static Payment Cash()
{
Payment p = new Payment();
p.Kind = PaymentKind.Cash;
return p;
}
public static Payment Card(string last4)
{
if (string.IsNullOrEmpty(last4) || last4.Length != 4)
throw new ArgumentException("last4 must be 4 digits", "last4");
Payment p = new Payment();
p.Kind = PaymentKind.Card;
p.CardLast4 = last4;
return p;
}
public static Payment Wire(string iban)
{
if (string.IsNullOrEmpty(iban))
throw new ArgumentException("iban must not be empty", "iban");
Payment p = new Payment();
p.Kind = PaymentKind.Wire;
p.Iban = iban;
return p;
}
}
public class Program
{
public static void Main(string[] args)
{
Payment a = Payment.Cash();
Payment b = Payment.Card("1234");
Payment c = Payment.Wire("TR00BANKIBAN");
Console.WriteLine(a.Kind + ", " + b.Kind + ", " + c.Kind);
}
}
Gestión de variantes
Un switch clásico sobre la etiqueta permite gestionar las variantes con claridad. Un default que lanza una excepción deja al descubierto las variantes no gestionadas durante las pruebas.
using System;
public enum PaymentKind { Cash, Card, Wire }
public sealed class Payment
{
public PaymentKind Kind;
public string CardLast4;
public string Iban;
public static Payment Cash()
{
Payment p = new Payment(); p.Kind = PaymentKind.Cash; return p;
}
public static Payment Card(string last4)
{
if (string.IsNullOrEmpty(last4) || last4.Length != 4) throw new ArgumentException("last4");
Payment p = new Payment(); p.Kind = PaymentKind.Card; p.CardLast4 = last4; return p;
}
public static Payment Wire(string iban)
{
if (string.IsNullOrEmpty(iban)) throw new ArgumentException("iban");
Payment p = new Payment(); p.Kind = PaymentKind.Wire; p.Iban = iban; return p;
}
}
public static class Exhaustive
{
public static Exception Unhandled(object x)
{
return new InvalidOperationException("Unhandled case: " + x);
}
}
public class Program
{
static string Describe(Payment p)
{
switch (p.Kind)
{
case PaymentKind.Cash: return "Cash";
case PaymentKind.Card: return "Card ****" + p.CardLast4;
case PaymentKind.Wire: return "Wire " + p.Iban;
default: throw Exhaustive.Unhandled(p.Kind);
}
}
public static void Main(string[] args)
{
Console.WriteLine(Describe(Payment.Card("9876")));
}
}
Auxiliar Match (similar a visitor)
Un pequeño auxiliar Match centraliza el switch y devuelve un valor, lo que mantiene limpios los puntos de llamada.
using System;
public enum PaymentKind { Cash, Card, Wire }
public sealed class Payment
{
public PaymentKind Kind;
public string CardLast4;
public string Iban;
public static Payment Cash() { Payment p = new Payment(); p.Kind = PaymentKind.Cash; return p; }
public static Payment Card(string last4) { Payment p = new Payment(); p.Kind = PaymentKind.Card; p.CardLast4 = last4; return p; }
public static Payment Wire(string iban) { Payment p = new Payment(); p.Kind = PaymentKind.Wire; p.Iban = iban; return p; }
}
public static class PaymentMatch
{
public static T Match<T>(
Payment p,
Func<T> onCash,
Func<string, T> onCard,
Func<string, T> onWire)
{
switch (p.Kind)
{
case PaymentKind.Cash: return onCash();
case PaymentKind.Card: return onCard(p.CardLast4);
case PaymentKind.Wire: return onWire(p.Iban);
default: throw new InvalidOperationException("Unhandled: " + p.Kind);
}
}
}
public class Program
{
public static void Main(string[] args)
{
Payment p = Payment.Card("1234");
string summary = PaymentMatch.Match(
p,
delegate { return "Cash"; },
delegate(string last4) { return "Card ****" + last4; },
delegate(string iban) { return "Wire " + iban; }
);
Console.WriteLine(summary);
}
}
Invariantes mediante fábricas
Las fábricas garantizan las invariantes: cada caso inicializa únicamente sus campos relevantes y las entradas no válidas se rechazan pronto.
using System;
public enum ResultKind { Ok, Error }
public sealed class Result
{
public ResultKind Kind;
public string Message; // only for Error
public int Value; // only for Ok
private Result() { }
public static Result Ok(int value)
{
Result r = new Result();
r.Kind = ResultKind.Ok;
r.Value = value;
r.Message = null;
return r;
}
public static Result Error(string message)
{
if (string.IsNullOrEmpty(message)) throw new ArgumentException("message");
Result r = new Result();
r.Kind = ResultKind.Error;
r.Message = message;
r.Value = 0;
return r;
}
}
public class Program
{
static string Show(Result r)
{
switch (r.Kind)
{
case ResultKind.Ok: return "OK: " + r.Value;
case ResultKind.Error: return "ERROR: " + r.Message;
default: throw new InvalidOperationException("Unhandled: " + r.Kind);
}
}
public static void Main(string[] args)
{
Console.WriteLine(Show(Result.Ok(5)));
Console.WriteLine(Show(Result.Error("Boom")));
}
}
Consejos y compromisos
Consejos:
- Prefiera casos y fábricas pequeños y centrados.
- Gestione las variantes en un solo lugar (un auxiliar switch) para mantener el código DRY.
- Mantenga un default que lance una excepción para revelar los casos que falten en las pruebas.
Compromisos: Hay más código repetitivo que con los records modernos, pero el resultado es claro y compatible con C# 6.
Enfoque para emular una DU
Repaso
Repaso: Modele las variantes con un enum de etiquetas, cree casos válidos mediante fábricas y centralice la gestión en un switch (el default lanza una excepción) para lograr exhaustividad en tiempo de ejecución.
Aprende C# con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 93
- Lecciones
- 346
Preguntas frecuentes
¿La lección «Modelado de dominios con uniones discriminadas (records) — emulación de C# 6» es gratis?
Sí — el texto completo de «Modelado de dominios con uniones discriminadas (records) — emulación de C# 6» 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 «Modelado de dominios con uniones discriminadas (records) — emulación de C# 6»?
Modele una unión discriminada en C# 6 mediante un enum de etiquetas y clases pequeñas, cree métodos de fábrica y gestione las variantes con switch y una excepción predeterminada. 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 «Modelado de dominios con uniones discriminadas (records) — emulación de C# 6»?
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
- Patrones is y patrones relacionales y lógicos (emulación de C# 6)
- Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)
- Modelado de dominios con uniones discriminadas (records) — emulación de C# 6