C# Case Statement (Cómo funciona para los desarrolladores)

En sentencia switch en C# ofrece una alternativa más ágil y legible a las múltiples expresiones if-else. Resulta útil cuando se tiene una variable que puede tomar uno de varios valores distintos y se necesita ejecutar código diferente en función del valor. Esta sentencia case evalúa una expresión y ejecuta código estático void main basado en el valor coincidente, lo que la convierte en una parte integral de la toma de decisiones en tu código.

Mientras que las estructuras if-else son geniales para condiciones o comprobaciones simples, las sentencias switch case brillan cuando se trata de comprobaciones de condiciones más complejas, especialmente aquellas basadas en una única variable o expresión de coincidencia de patrón. Proporcionan una sintaxis más limpia y comprensible en comparación con la sentencia if, lo que es crucial tanto para escribir como para mantener el mismo código.

Conceptos básicos de la declaración Switch

¿Qué es una Declaración Switch?

Una sentencia switch en C# es una estructura de control utilizada para seleccionar una de las muchas rutas de código a ejecutar. La selección se basa en el valor o en una expresión con cualquiera de los tipos de datos. Es una alternativa eficaz al uso de múltiples condiciones if-else, especialmente cuando se trata de una variable que puede tener varios valores distintos.

Sintaxis

La sintaxis básica de una sentencia switch es sencilla:

//sentencia switch
switch (variable)
{
    case value1:
        //  Código a ejecutar si la variable es igual a valor1
        break;
    case value2:
        //  Código a ejecutar si la variable es igual a valor2
        break;
    //  Más casos según sea necesario
    default:
        //  Código a ejecutar si la variable no coincide con ningún caso o comportamiento fallido
        break;
}

//sentencia switch
switch (variable)
{
    case value1:
        //  Código a ejecutar si la variable es igual a valor1
        break;
    case value2:
        //  Código a ejecutar si la variable es igual a valor2
        break;
    //  Más casos según sea necesario
    default:
        //  Código a ejecutar si la variable no coincide con ningún caso o comportamiento fallido
        break;
}

'sentencia switch
Select Case variable
	Case value1
		'  Código a ejecutar si la variable es igual a valor1
	Case value2
		'  Código a ejecutar si la variable es igual a valor2
	'  Más casos según sea necesario
	Case Else
		'  Código a ejecutar si la variable no coincide con ningún caso o comportamiento fallido
End Select

• interruptor (variable): Aquí es donde se especifica la variable o expresión a evaluar como se muestra en el programa anterior.
• caso valor1: Estos son los diferentes valores o condiciones que compruebas contra la variable.
• break: Esta palabra clave se utiliza para salir del bloque switch una vez que se ejecuta un caso coincidente.
• Sentencia por defecto: Este bloque opcional goto se ejecuta si ninguno de los casos especificados coincide con la variable.

Comprender la declaración de ruptura

La sentencia break en el switch es crucial. Evita el comportamiento "fall through", en el que la ejecución pasa al caso siguiente aunque ya se cumpla la condición de coincidencia. Cada bloque case suele terminar con una sentencia break para garantizar que sólo se ejecuta el código del case correspondiente.

Comparación de las sentencias Switch e If-Else

Mientras que la estructura de la sentencia if-else implica la comprobación de una condición y la ejecución de un bloque de código si la condición es verdadera, las sentencias switch comparan una única variable o expresión con múltiples valores potenciales. Esto hace que la sentencia switch sea más concisa y fácil de leer cuando se tienen muchas condiciones o patrones de casos que comprobar.

Ejemplo: Uso de una sentencia Switch

int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Other Number");//  imprimir en consola
        break;
}

int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Other Number");//  imprimir en consola
        break;
}

Dim number As Integer = 3
Select Case number
	Case 1
		Console.WriteLine("One")
	Case 2
		Console.WriteLine("Two")
	Case 3
		Console.WriteLine("Three")
	Case Else
		Console.WriteLine("Other Number") '  imprimir en consola
End Select

En este ejemplo, el programa imprimirá "Tres" como salida ya que el número coincide con el caso 3.

El papel del caso por defecto

Comprender el valor predeterminado en un bloque de interruptores

En una sentencia switch, el caso por defecto juega un papel crucial. Sirve como opción comodín que se ejecuta cuando ninguna de las etiquetas de caso especificadas coincide con el valor de la expresión de conmutación. Aunque es opcional, incluir un caso por defecto es una buena práctica, especialmente para manejar valores inesperados o desconocidos.

Cómo y cuándo utilizar la declaración por defecto

El caso por defecto se utiliza cuando se desea ejecutar un bloque de código si no coincide ninguno de los casos específicos. Garantiza que la sentencia switch siempre tenga un comportamiento definido, independientemente de la entrada. El caso por defecto se declara utilizando la palabra clave default, seguida de dos puntos.

default:
    //  Código a ejecutar si no hay coincidencias
    break;

default:
    //  Código a ejecutar si no hay coincidencias
    break;

Case Else
	'  Código a ejecutar si no hay coincidencias
	break

El caso por defecto se puede colocar en cualquier lugar dentro del bloque de conmutación, pero normalmente se coloca al final para facilitar la lectura.

Ejemplo: Sentencia Switch con Caso por Defecto

Imagínese que está evaluando un día de la semana:

int day = 5;
string dayName;
switch (day)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
Console.WriteLine(dayName);

int day = 5;
string dayName;
switch (day)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
Console.WriteLine(dayName);

Dim day As Integer = 5
Dim dayName As String
Select Case day
	Case 1
		dayName = "Monday"
	Case 2
		dayName = "Tuesday"
	Case 3
		dayName = "Wednesday"
	Case 4
		dayName = "Thursday"
	Case 5
		dayName = "Friday"
	Case 6
		dayName = "Saturday"
	Case 7
		dayName = "Sunday"
	Case Else
		dayName = "Invalid day"
End Select
Console.WriteLine(dayName)

En este ejemplo, si day tiene un valor distinto de 1 a 7, se ejecuta el caso por defecto, estableciendo dayName como "Día no válido".

Buenas prácticas para el caso por defecto

Incluya siempre un caso por defecto: Aunque creas que has cubierto todos los casos posibles, incluye un caso por defecto para manejar valores imprevistos.

Acciones significativas: Utiliza el caso por defecto para realizar acciones significativas, como registrar un error, establecer un valor por defecto o notificar al usuario de un valor desconocido.

Funciones avanzadas del conmutador

Introducción a las expresiones de conmutación en C#

Con la evolución de C#, se introdujeron las expresiones switch como una forma más concisa y expresiva de manejar múltiples ramas condicionales. A diferencia de las sentencias switch tradicionales, las expresiones switch devuelven un valor y son más ágiles, lo que las convierte en una potente herramienta de la programación moderna en C#.

Sintaxis de las expresiones de conmutación

La sintaxis de una expresión switch en C# es una forma más compacta de la sentencia switch case. He aquí una estructura básica:

var result = variable switch
{
    value1 => result1,
    value2 => result2,
    _ => defaultResult
};

var result = variable switch
{
    value1 => result1,
    value2 => result2,
    _ => defaultResult
};

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'var result = variable switch
'{
'	value1 => result1,
'	value2 => result2,
'	_ => defaultResult
'};

El guión bajo (_) representa el caso por defecto en las expresiones switch, funcionando de forma similar al bloque por defecto en las sentencias switch tradicionales.

Ejemplo: Utilización de una expresión de conmutación

Imagínese que necesita clasificar una lectura de temperatura:

int temperature = 25;
string weatherDescription = temperature switch
{
    <= 0 => "Freezing",
    < 20 => "Cold",
    < 30 => "Mild",
    _ => "Hot"
};
Console.WriteLine(weatherDescription);

int temperature = 25;
string weatherDescription = temperature switch
{
    <= 0 => "Freezing",
    < 20 => "Cold",
    < 30 => "Mild",
    _ => "Hot"
};
Console.WriteLine(weatherDescription);

Dim temperature As Integer = 25
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'string weatherDescription = temperature switch
'{
'	<= 0 => "Freezing",
'	< 20 => "Cold",
'	< 30 => "Mild",
'	_ => "Hot"
'};
Console.WriteLine(weatherDescription)

En este ejemplo, la expresión switch categoriza sucintamente la temperatura, con el caso por defecto (_) cubriendo cualquier escenario no coincidente con los otros casos.

Comparación de patrones con expresiones de conmutación

Las expresiones de cambio en C# permiten la coincidencia de patrones, lo que las hace aún más versátiles. Puede hacer coincidir tipos, valores o incluso patrones:

object obj = //  algún objeto;
string description = obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    _ => "Unknown type"
};

object obj = //  algún objeto;
string description = obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    _ => "Unknown type"
};

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'object obj = string description = obj switch
'{
'	int i => $"Integer: {i}",
'	string s => $"String: {s}",
'	_ => "Unknown type"
'};

C# Sentencia Switch vs. Expresión Switch

Sentencia Switch en C#: Tradicionalmente utilizada para ejecutar diferentes bloques de código basados en el valor de una variable. Requiere una sentencia break para cada caso.

Expresión de conmutación: Introducida en C# 8.0, proporciona una sintaxis más concisa y se utiliza normalmente cuando es necesario devolver un valor en función de una condición.

Integración de Switch Statements con IronPDF en C#

IronPDF es una biblioteca PDF .NET para crear, editar y trabajar con documentos PDF. Cuando se combina con expresiones o sentencias switch de C#, se convierte en una potente herramienta para gestionar diversas operaciones relacionadas con PDF basadas en condiciones específicas. Esta integración es especialmente útil para tareas que requieren tomar decisiones basadas en el contenido o los metadatos de los PDF.

Ejemplo: Marca de agua condicional con IronPDF y sentencias Switch

Consideremos una situación en la que tiene un documento PDF y desea aplicar diferentes marcas de agua en función del número de páginas del documento. A continuación se explica cómo conseguirlo utilizando IronPDF en combinación con una sentencia switch de C#:

using IronPdf;
IronPdf.License.LicenseKey = "Your-License-Code";
PdfDocument pdf = PdfDocument.FromFile("sample.pdf");
//  Definir diferentes marcas de agua HTML para cada caso
string watermarkHtmlOnePage = "<div style='color:red;'>One Page Document</div>";
string watermarkHtmlTwoPage = "<div style='color:blue;'>Two Page Document</div>";
switch (pdf.PageCount)
{
    case 1:
        //  Aplicar marca de agua a un documento de una página
        pdf.ApplyWatermark(watermarkHtmlOnePage);
        break;
    case 2:
        //  Aplicar marca de agua a documentos de dos páginas
        pdf.ApplyWatermark(watermarkHtmlTwoPage);
        break;
    default:
        //  Aplicar una marca de agua por defecto para otros casos
        pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>");
        break;
}
//  Guardar el PDF con marca de agua
pdf.SaveAs("watermarked.pdf");

using IronPdf;
IronPdf.License.LicenseKey = "Your-License-Code";
PdfDocument pdf = PdfDocument.FromFile("sample.pdf");
//  Definir diferentes marcas de agua HTML para cada caso
string watermarkHtmlOnePage = "<div style='color:red;'>One Page Document</div>";
string watermarkHtmlTwoPage = "<div style='color:blue;'>Two Page Document</div>";
switch (pdf.PageCount)
{
    case 1:
        //  Aplicar marca de agua a un documento de una página
        pdf.ApplyWatermark(watermarkHtmlOnePage);
        break;
    case 2:
        //  Aplicar marca de agua a documentos de dos páginas
        pdf.ApplyWatermark(watermarkHtmlTwoPage);
        break;
    default:
        //  Aplicar una marca de agua por defecto para otros casos
        pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>");
        break;
}
//  Guardar el PDF con marca de agua
pdf.SaveAs("watermarked.pdf");

Imports IronPdf
IronPdf.License.LicenseKey = "Your-License-Code"
Dim pdf As PdfDocument = PdfDocument.FromFile("sample.pdf")
'  Definir diferentes marcas de agua HTML para cada caso
Dim watermarkHtmlOnePage As String = "<div style='color:red;'>One Page Document</div>"
Dim watermarkHtmlTwoPage As String = "<div style='color:blue;'>Two Page Document</div>"
Select Case pdf.PageCount
	Case 1
		'  Aplicar marca de agua a un documento de una página
		pdf.ApplyWatermark(watermarkHtmlOnePage)
	Case 2
		'  Aplicar marca de agua a documentos de dos páginas
		pdf.ApplyWatermark(watermarkHtmlTwoPage)
	Case Else
		'  Aplicar una marca de agua por defecto para otros casos
		pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>")
End Select
'  Guardar el PDF con marca de agua
pdf.SaveAs("watermarked.pdf")

Aquí está el archivo PDF de salida de una página:

Conclusión

En este tutorial, hemos explorado la sentencia switch case en C#, una forma de tomar decisiones en programación. Empezamos por entender su estructura básica y la comparamos con las sentencias if-else tradicionales, destacando sus ventajas en cuanto a legibilidad y simplicidad para manejar múltiples condiciones.

Crearemos casos de conmutación sencillos, manejaremos varios escenarios con el caso por defecto y exploraremos funciones avanzadas como las expresiones de conmutación. La aplicación real de las sentencias switch se demostró mediante un ejemplo de integración de IronPDF para el procesamiento dinámico de PDF, mostrando cómo las sentencias switch pueden ser valiosas en el conjunto de herramientas de un programador.

IronPDF ofrece un prueba gratuita para explorar sus características y funcionalidades. Para un uso continuado y acceso a todo su conjunto de herramientas, las licencias de IronPDF empiezan desde $749, proporcionando una solución completa para todas sus necesidades de procesamiento de PDF en C#.