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

En el vasto panorama de los lenguajes de programación, la mejora de la legibilidad y la eficiencia del código es primordial y el lenguaje C# se erige como un incondicional, ya que proporciona diversas construcciones para ayudar en sus necesidades de codificación. Entre su arsenal de potentes herramientas, el "Sentencia Switch en C#"destaca de forma prominente. Esta completa guía explorará las sutiles complejidades de las mismas dentro del lenguaje C#. Profundizaremos en sus múltiples usos e iluminaremos su aplicación práctica a través de un escenario real que implica IronPDF. Este viaje no sólo pretende desentrañar su mecánica, sino también subrayar su importancia en el panorama más amplio del desarrollo en C#.

1. Entendiendo la Declaración Switch

La sentencia switch en C# es una sentencia de flujo de control que permite a los desarrolladores escribir código más limpio y conciso cuando se trata de múltiples condiciones. Resulta especialmente útil cuando se desea realizar distintas acciones en función del valor de una variable concreta.

Esto lo convierte en una alternativa perfecta a las sentencias if-else cuando la palabra clave/variable es el foco central, ya que aumenta la legibilidad y la capacidad de mantenimiento de los códigos. A diferencia de una sentencia if-else, que puede dar lugar a estructuras anidadas y a una posible complejidad del código, la sentencia switch ofrece una alternativa más organizada. Resulta especialmente beneficiosa por encima del código y cuando se trabaja con una variable que debe desencadenar distintas acciones en función de su valor.

Veamos ahora con más detalle el papel de la ruptura en el contexto de una sentencia switch. En C#, la sentencia break se utiliza para terminar la ejecución de un bloque de código asociado a un caso particular dentro del bloque switch. Cuando un caso match o switch coincide, y se ejecuta el bloque de código correspondiente a ese caso, la sentencia break es crucial para evitar que se evalúen los casos posteriores. Si desea incorporar el comportamiento fall-through dentro de su sentencia, debe utilizar la sentencia goto en lugar de break.

He aquí la estructura básica de una sentencia switch en C#:

switch (variable)
{
    case a:
        //  Código a ejecutar si la variable es igual a valor1
        break;
    case c:
        //  Código a ejecutar si la variable es igual a valor2
        break;
    //  Se pueden añadir más casos según sea necesario
    default:
        //  Caso por defecto que se ejecutará si ninguno de los casos coincide
        break;
}

switch (variable)
{
    case a:
        //  Código a ejecutar si la variable es igual a valor1
        break;
    case c:
        //  Código a ejecutar si la variable es igual a valor2
        break;
    //  Se pueden añadir más casos según sea necesario
    default:
        //  Caso por defecto que se ejecutará si ninguno de los casos coincide
        break;
}

Select Case variable
	Case a
		'  Código a ejecutar si la variable es igual a valor1
	Case c
		'  Código a ejecutar si la variable es igual a valor2
	'  Se pueden añadir más casos según sea necesario
	Case Else
		'  Caso por defecto que se ejecutará si ninguno de los casos coincide
End Select

Ahora, vamos a explorar los diferentes tipos de sentencias switch y sus casos de uso.

2. Tipos de sentencias Switch y sus usos

2.1. Declaración de conmutación simple

Esta es la forma más básica de una sentencia switch. Compara la variable con valores constantes y ejecuta el bloque de código asociado al primer valor o caso coincidente. Si no se encuentra ninguna coincidencia, se ejecuta el bloque de código por defecto.

int day = 3;
switch (day)
{
    case 1:
        Console.WriteLine("Monday");
        break;
    case 2:
        Console.WriteLine("Tuesday");
        break;
    //  Más casos...
    default:
        Console.WriteLine("Invalid day");
        break;
}

int day = 3;
switch (day)
{
    case 1:
        Console.WriteLine("Monday");
        break;
    case 2:
        Console.WriteLine("Tuesday");
        break;
    //  Más casos...
    default:
        Console.WriteLine("Invalid day");
        break;
}

Dim day As Integer = 3
Select Case day
	Case 1
		Console.WriteLine("Monday")
	Case 2
		Console.WriteLine("Tuesday")
	'  Más casos...
	Case Else
		Console.WriteLine("Invalid day")
End Select

2.2. Sentencia Switch con patrones (C# 7.0 y posteriores)

C# 7.0 introdujo la concordancia de patrones case, lo que permitió una sentencia switch más expresiva y flexible. Una expresión de coincidencia de patrones puede incluir patrones de tipos, patrones de propiedades y mucho más, lo que hace que el código sea aún más legible.

object obj = "Hello";
switch (obj)
{
    case string s:
        Console.WriteLine($"String of length {s.Length}");
        break;
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    //  Más casos...
    default:
        Console.WriteLine("Other type");
        break;
}

object obj = "Hello";
switch (obj)
{
    case string s:
        Console.WriteLine($"String of length {s.Length}");
        break;
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    //  Más casos...
    default:
        Console.WriteLine("Other type");
        break;
}

Dim obj As Object = "Hello"
Select Case obj
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case string s:
	Case String s
		Console.WriteLine($"String of length {s.Length}")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case int i:
	Case Integer i
		Console.WriteLine($"Integer: {i}")
	'  Más casos...
	Case Else
		Console.WriteLine("Other type")
End Select

2.3. Expresión de conmutación (C# 8.0 y posterior)

En C# 8.0, se introduce una forma nueva y más concisa de la sentencia switch: las expresiones switch. Pueden utilizarse en lugares en los que se necesita la expresión constante de un valor, lo que hace que el código sea más corto y elegante.

int day = 2;
string result = day switch
{
    1 => "Monday",
    2 => "Tuesday",
    //  Más casos...
    _ => "Invalid day"
};
Console.WriteLine(result);

int day = 2;
string result = day switch
{
    1 => "Monday",
    2 => "Tuesday",
    //  Más casos...
    _ => "Invalid day"
};
Console.WriteLine(result);

Dim day As Integer = 2
Dim tempVar As String
Select Case day
	Case 1
		tempVar = "Monday"
	Case 2
		tempVar = "Tuesday"
	'  Más casos...
	Case Else
		tempVar = "Invalid day"
End Select
Dim result As String = tempVar
Console.WriteLine(result)

Ahora que tenemos una sólida comprensión de las sentencias switch, vamos a ver cómo se pueden aplicar en un escenario del mundo real utilizando IronPDF en C#.

3. Presentación de IronPDF en C#

IronPDF es una popular biblioteca de C# que permite a los desarrolladores generar y manipular documentos PDF con facilidad. Simplifica las tareas relacionadas con la creación, edición y renderización de archivos PDF. Ahora, exploremos cómo puede emplearse la sentencia switch con IronPDF para mejorar la funcionalidad y organización de su codificación.

3.1. Uso de la sentencia Switch con IronPDF

Supongamos que está trabajando en un sistema de gestión de documentos en el que necesita generar diferentes tipos de PDF en función del caso utilizado el contenido de un documento. A continuación se explica cómo aprovechar la sentencia switch con IronPDF:

using IronPdf;
using System;
class generatePDF {
    public static void Main(String [] args)
    {
        var renderer = new ChromePdfRenderer();
        string mystring = null;
        Console.WriteLine("Enter your input : ");
        Console.WriteLine("Enter 'I' for Invoice");
        Console.WriteLine("Enter 'R' for Report");
        mystring = Console.ReadLine();
        switch (mystring)
        {
            case "R":
                var pdf = renderer.RenderHtmlFileAsPdf("invoice.html");
                pdf.SaveAs("Report.pdf");
                break;
            case "I":
                var pdfi = renderer.RenderHtmlFileAsPdf("report.html");
                pdfi.SaveAs("Invoice.pdf");
                break;
        }
    }
}

using IronPdf;
using System;
class generatePDF {
    public static void Main(String [] args)
    {
        var renderer = new ChromePdfRenderer();
        string mystring = null;
        Console.WriteLine("Enter your input : ");
        Console.WriteLine("Enter 'I' for Invoice");
        Console.WriteLine("Enter 'R' for Report");
        mystring = Console.ReadLine();
        switch (mystring)
        {
            case "R":
                var pdf = renderer.RenderHtmlFileAsPdf("invoice.html");
                pdf.SaveAs("Report.pdf");
                break;
            case "I":
                var pdfi = renderer.RenderHtmlFileAsPdf("report.html");
                pdfi.SaveAs("Invoice.pdf");
                break;
        }
    }
}

Imports IronPdf
Imports System
Friend Class generatePDF
	Public Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim mystring As String = Nothing
		Console.WriteLine("Enter your input : ")
		Console.WriteLine("Enter 'I' for Invoice")
		Console.WriteLine("Enter 'R' for Report")
		mystring = Console.ReadLine()
		Select Case mystring
			Case "R"
				Dim pdf = renderer.RenderHtmlFileAsPdf("invoice.html")
				pdf.SaveAs("Report.pdf")
			Case "I"
				Dim pdfi = renderer.RenderHtmlFileAsPdf("report.html")
				pdfi.SaveAs("Invoice.pdf")
		End Select
	End Sub
End Class

Este programa C# utiliza la biblioteca IronPDF para generar dinámicamente archivos PDF basados en la entrada del usuario. Se pide al usuario que introduzca "I" para Factura o "R" para Informe. En función de la entrada, el programa utiliza la clase ChromePdfRenderer para renderizar el archivo HTML correspondiente ("invoice.html" para Informe o "report.html" para Factura) en formato PDF. A continuación, el PDF generado se guarda con los nombres de archivo adecuados, "Informe.pdf" para el Informe y "Factura.pdf" para la Factura. Este enfoque ofrece una forma flexible e interactiva de generar tipos específicos de documentos PDF a través de una interfaz de consola.

3.2. Ejemplo de informe

En el siguiente ejemplo, crearemos un informe utilizando Input from User.

**Entrada de la consola

**PDF de salida

3.3. Ejemplo de factura

En este caso de ejemplo crearemos una factura utilizando la entrada del usuario y la sentencia switch.

**Entrada de la consola

**PDF de salida

4. Conclusión

En conclusión, la sentencia switch de C# destaca como una robusta herramienta de flujo de control que ofrece a los desarrolladores un enfoque más organizado y conciso para manejar múltiples condiciones en comparación con las tradicionales sentencias if-else. Al categorizar la ejecución del código en función de los valores de las variables, las sentencias switch pueden contribuir a mejorar la legibilidad y la capacidad de mantenimiento del código.

La versatilidad de las sentencias switch se demuestra a través de varios tipos, entre los que se incluyen conmutadores simples, bloques de conmutación basados en patrones, conmutadores y expresiones de conmutación, cada uno de los cuales atiende a escenarios de codificación específicos.

La integración de la biblioteca IronPDF ejemplifica la aplicación práctica de las sentencias switch en la generación de documentos PDF dinámicos basados en la entrada del usuario y muestra cómo puede aprovecharse esta función en situaciones reales para mejorar la flexibilidad y eficacia de la codificación en C#.

IronPDF Para saber más sobre la conversión de HTML a PDF, visite la siguiente página web enlace.