Aprender C#

Explicación de Switch Expression en C#: Una guía práctica de Tim Corey

Tim Corey

9m 16s

En el mundo del desarrollo en C#, escribir código limpio y fácil de mantener es un objetivo clave. Una función moderna de C# que ayuda a conseguirlo es la expresión switch, una alternativa compacta y potente a la sentencia switch tradicional. Aunque a menudo se pasan por alto, las expresiones de conmutación simplifican la lógica de bifurcación compleja, especialmente cuando se trata de patrones relacionales, concordancia de patrones y patrones constantes.

Para entender mejor cómo funciona esta función y cómo se compara con los enfoques tradicionales, vamos a ver un vídeo muy útil de Tim Corey. A lo largo de su vídeo sobre "Switch Expressions In C#", Tim desglosa el uso real de las expresiones de conmutación en C#, demostrando cómo escribir mejor código con menos líneas.

Vamos a sumergirnos en la explicación práctica de Tim, que comienza con un ejemplo de gradación y avanza hacia escenarios más avanzados utilizando interfaces, patrones de tipos y evaluación de objetos.

Expresión If-Else tradicional frente a expresión Switch

Tim comienza con una aplicación de consola en la que una variable int llamada numberGrade contiene una puntuación de examen como 85. El objetivo es convertir este valor numérico de entrada en una calificación con letra correspondiente, como "B". En la mayoría de los casos, los desarrolladores utilizarían una serie de sentencias if-else o una sentencia switch, como esta:

if (numberGrade >= 90)
    letterGrade = "A";
else if (numberGrade >= 80)
    letterGrade = "B";
// ...and so on

if (numberGrade >= 90)
    letterGrade = "A";
else if (numberGrade >= 80)
    letterGrade = "B";
// ...and so on

If numberGrade >= 90 Then
    letterGrade = "A"
ElseIf numberGrade >= 80 Then
    letterGrade = "B"
' ...and so on
End If

If numberGrade >= 90 Then
    letterGrade = "A"
ElseIf numberGrade >= 80 Then
    letterGrade = "B"
' ...and so on
End If

Aunque esto funciona, es prolijo. Por otro lado, las expresiones de conmutación de C# ofrecen una sintaxis más limpia.

Escribir una expresión de conmutación para calificar

Para demostrar una expresión de conmutación, Tim reescribe la lógica anterior utilizando el siguiente código:

string letterGrade = numberGrade switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

string letterGrade = numberGrade switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

Dim letterGrade As String = 
    If(numberGrade >= 90, "A", 
    If(numberGrade >= 80, "B", 
    If(numberGrade >= 70, "C", 
    If(numberGrade >= 60, "D", "F"))))

Dim letterGrade As String = 
    If(numberGrade >= 90, "A", 
    If(numberGrade >= 80, "B", 
    If(numberGrade >= 70, "C", 
    If(numberGrade >= 60, "D", "F"))))

Aquí, la palabra clave switch se utiliza en un nuevo contexto: como una expresión, no como una afirmación. Esto significa que se evalúa directamente a un valor y se puede asignar a una variable (como letterGrade).

Este formulario admite patrones relacionales (por ejemplo, >= 90) y utiliza el patrón de descarte (_) para manejar el caso por defecto, que equivale al else final.

Tim señala que el compilador determina la coincidencia en tiempo de ejecución, comprobando cada condición de arriba abajo y eligiendo el primer patrón que se ajuste a la entrada.

Simplificación del código con expresiones

En palabras de Tim, esta nueva sintaxis "sustituye un montón de código" En lugar de repetir condiciones con else if, la expresión switch lo maneja todo en una estructura clara y concisa. Esto simplifica el flujo de control, mejora la legibilidad y reduce la redundancia en su lógica.

Destaca que esta estructura es especialmente útil cuando se asignan valores de entrada a salidas específicas, como la clasificación, los mensajes de estado o la transformación de datos.

Uso de la concordancia de patrones con tipos de objetos

Para explorar los patrones de tipos y la concordancia de patrones, Tim presenta un escenario que implica una interfaz IAnimal. Define tres clases (Dog, Cat y Cow), cada una de las cuales implementa la interfaz. Esto le permite crear una lista de animales, cada uno con propiedades diferentes.

interface IAnimal { }

record Dog(string Name) : IAnimal;
record Cat(string Title, string Name) : IAnimal;
record Cow(string Breed) : IAnimal;

interface IAnimal { }

record Dog(string Name) : IAnimal;
record Cat(string Title, string Name) : IAnimal;
record Cow(string Breed) : IAnimal;

Interface IAnimal
End Interface

Record Dog(Name As String)
    Implements IAnimal
End Record

Record Cat(Title As String, Name As String)
    Implements IAnimal
End Record

Record Cow(Breed As String)
    Implements IAnimal
End Record

Interface IAnimal
End Interface

Record Dog(Name As String)
    Implements IAnimal
End Record

Record Cat(Title As String, Name As String)
    Implements IAnimal
End Record

Record Cow(Breed As String)
    Implements IAnimal
End Record

Se rellena una lista con varias instancias de animales y se demuestra cómo utilizar la concordancia de patrones de tipo para identificar el tipo de objeto y extraer los datos.

Expresión de conmutación con concordancia de patrones

Tim muestra cómo funciona el siguiente código utilizando sentencias if:

if (a is Dog d)
    message = $"Dog: {d.Name}";
else if (a is Cat c)
    message = $"Cat: {c.Title} {c.Name}";
else if (a is Cow co)
    message = $"Cow: {co.Breed}";
else
    message = "Unknown animal";

if (a is Dog d)
    message = $"Dog: {d.Name}";
else if (a is Cat c)
    message = $"Cat: {c.Title} {c.Name}";
else if (a is Cow co)
    message = $"Cow: {co.Breed}";
else
    message = "Unknown animal";

If TypeOf a Is Dog Then
    Dim d As Dog = DirectCast(a, Dog)
    message = $"Dog: {d.Name}"
ElseIf TypeOf a Is Cat Then
    Dim c As Cat = DirectCast(a, Cat)
    message = $"Cat: {c.Title} {c.Name}"
ElseIf TypeOf a Is Cow Then
    Dim co As Cow = DirectCast(a, Cow)
    message = $"Cow: {co.Breed}"
Else
    message = "Unknown animal"
End If

If TypeOf a Is Dog Then
    Dim d As Dog = DirectCast(a, Dog)
    message = $"Dog: {d.Name}"
ElseIf TypeOf a Is Cat Then
    Dim c As Cat = DirectCast(a, Cat)
    message = $"Cat: {c.Title} {c.Name}"
ElseIf TypeOf a Is Cow Then
    Dim co As Cow = DirectCast(a, Cow)
    message = $"Cow: {co.Breed}"
Else
    message = "Unknown animal"
End If

Puede sustituirse por una expresión de conmutación mucho más compacta y legible:

string message = a switch
{
    Dog d => $"Dog: {d.Name}",
    Cat c => $"Cat: {c.Title} {c.Name}",
    Cow co => $"Cow: {co.Breed}",
    _ => "Unknown animal"
};

string message = a switch
{
    Dog d => $"Dog: {d.Name}",
    Cat c => $"Cat: {c.Title} {c.Name}",
    Cow co => $"Cow: {co.Breed}",
    _ => "Unknown animal"
};

Dim message As String = 
    If(TypeOf a Is Dog, $"Dog: {DirectCast(a, Dog).Name}", 
    If(TypeOf a Is Cat, $"Cat: {DirectCast(a, Cat).Title} {DirectCast(a, Cat).Name}",
    If(TypeOf a Is Cow, $"Cow: {DirectCast(a, Cow).Breed}", 
    "Unknown animal")))

Dim message As String = 
    If(TypeOf a Is Dog, $"Dog: {DirectCast(a, Dog).Name}", 
    If(TypeOf a Is Cat, $"Cat: {DirectCast(a, Cat).Title} {DirectCast(a, Cat).Name}",
    If(TypeOf a Is Cow, $"Cow: {DirectCast(a, Cow).Breed}", 
    "Unknown animal")))

Esta expresión comprueba el tipo de objeto y aplica la salida correcta en función del patrón encontrado. Si no se encuentra ninguna coincidencia, se vuelve a un resultado por defecto utilizando la función de descartar _.

Esta característica mejora la funcionalidad sin sacrificar la claridad. El comportamiento en tiempo de ejecución sigue siendo predecible y legible.

Guardias opcionales con la palabra clave when

Aunque no se muestra en el ejemplo de Tim, es importante tener en cuenta que las expresiones switch pueden ampliarse con la palabra clave when para aplicar una condición booleana opcional:

int score = 90;

string result = score switch
{
    int s when s >= 90 && s <= 100 => "Excellent",
    int s when s >= 75 => "Good",
    _ => "Needs Improvement"
};

int score = 90;

string result = score switch
{
    int s when s >= 90 && s <= 100 => "Excellent",
    int s when s >= 75 => "Good",
    _ => "Needs Improvement"
};

Dim score As Integer = 90

Dim result As String = score Select Case
    Case s When s >= 90 AndAlso s <= 100
        Return "Excellent"
    Case s When s >= 75
        Return "Good"
    Case Else
        Return "Needs Improvement"
End Select

Dim score As Integer = 90

Dim result As String = score Select Case
    Case s When s >= 90 AndAlso s <= 100
        Return "Excellent"
    Case s When s >= 75
        Return "Good"
    Case Else
        Return "Needs Improvement"
End Select

Aquí, la cláusula when permite una evaluación personalizada del argumento, utilizando expresiones booleanas más complejas.

Bestes prácticas y reflexiones finales

Tim hace hincapié en un concepto fundamental: aunque las expresiones de conmutación hacen que el código sea más compacto, compacto no siempre significa mejor. A veces, especialmente con lógica complicada o entradas poco claras, una sentencia switch tradicional o un bloque if pueden ser más apropiados.

No es necesario utilizar una expresión de conmutación en todos los casos, sino la herramienta adecuada para cada tarea. No se trata de unirse al "culto del cambio", como bromea Tim. Se trata de escribir código mantenible y comprensible en su sistema.

Resumen: Cómo añadir expresiones de conmutación a su caja de herramientas de desarrollador

Las expresiones switch de C# ofrecen una forma moderna y limpia de evaluar y devolver valores basados en patrones de entrada, utilizando una combinación de patrones constantes, relacionales y de tipo. Son ideales cuando se desea simplificar la lógica, reducir el lenguaje repetitivo y mejorar la legibilidad.

Desde la gradación de números enteros hasta la identificación de objetos animales, los siguientes ejemplos del vídeo de Tim Corey ponen de relieve sus usos prácticos. Tanto si está creando una función para calcular resultados como si está gestionando entradas de usuario o trabajando con casos nulos e indefinidos, las expresiones switch pueden ayudarle a ahorrar tiempo, reducir errores y facilitar la gestión de su código.

Como dice Tim, "Son una herramienta realmente útil para tener en tu caja de herramientas para hacer tu código más simple y limpio-y aún así ser tan comprensible, si no más."

Si quieres mejorar la calidad de tu código C# y estar al día de las innovaciones de .NET Core, no te saltes las expresiones de conmutación. Pruébalas, experimenta en tus proyectos de Visual Studio y comprueba cuánto más limpia puede llegar a ser tu lógica.