Mejoras de Sintaxis y Minimalismo en C# utilizando .NET 6

Clase 12 de 14 • Curso de Buenas Prácticas y Código Limpio en C#

Resumen

En el mundo del desarrollo de software, adoptar las últimas características y mejoras de un lenguaje de programación puede hacer una gran diferencia en la eficiencia y legibilidad del código. Este es particularmente el caso con C#, un lenguaje en constante evolución con funcionalidades que permiten un estilo de codificación más limpio y minimalista. A continuación, exploraremos cómo las actualizaciones recientes de C# y .NET pueden ayudarnos a minimizar nuestra base de código al tiempo que mantenemos o incluso mejoramos la funcionalidad del mismo.

¿Cómo actualizar a .NET 6 para aprovechar las mejoras de C#?

Antes de sumergirnos en las optimizaciones que nos trae el lenguaje, es crucial actualizar nuestro entorno de desarrollo a .NET 6. Esta actualización es imprescindible para acceder a las últimas características de C#. Veamos cómo hacerlo:

Ve al archivo de proyecto.
Elimina la referencia a 'exe' en la configuración previa, ya que ya no es necesaria.
Indica que el proyecto usará .NET 6 modificando la configuración correspondiente.

Con estos sencillos pasos, tendrás la plataforma lista para trabajar con las mejoras más recientes de C#.

¿Qué son los 'global using' o 'implicit using' y cómo pueden minimizar el código?

Una vez actualizado a .NET 6, puedes aprovechar las funcionalidades de 'implicit using' para reducir la cantidad de líneas de código necesarias en tus archivos. Esta característica permite que no tengas que definir explícitamente cada espacio de nombres (namespace) que usas al inicio de cada archivo. Para habilitar esta función:

Asegúrate de añadir 'implicit using enable' en la configuración del proyecto. Esto hará que C# detecte automáticamente los usos necesarios.

Implementar 'implicit using' es un cambio pequeño pero poderoso que puede limpiar significativamente la parte superior de cada archivo de código, evitando líneas redundantes y mejorando la legibilidad.

¿Cómo simplificar los espacios de nombres con 'top level statements' y 'static namespace'?

Las mejoras en los espacios de nombres pueden simplificar aún más tu código. Dos alternativas disponibles son:

Utilizar 'top level statements' que eliminan la necesidad del espacio de nombres y la estructura de clase estándar.
Aplicar la mejora 'static namespace' permite declarar el espacio de nombres sin necesidad de utilizar llaves, utilizando simplemente un punto y coma al final de la declaración.

Ambas opciones son viables y dependerán de la estructura y necesidades específicas de tu proyecto.

¿Qué debemos hacer para simplificar aún más la estructura de nuestro código?

En algunos casos, especialmente en proyectos pequeños o ejemplos de código, la estructura completa de clases y métodos puede ser innecesaria. C# permite ahora ejecutar código directamente sin esa estructura jerárquica a través de 'top level statements'. Para esto, puedes:

Eliminar la declaración de clase 'Program'.
Transformar variables complejas a simples declaraciones.
Eliminar el método 'Main' y proceder a trabajar directamente con el código a ejecutar.

Esto ayuda a que el código sea más directo y fácil de leer, centrando la atención en la lógica del negocio en lugar de la estructura del código.

¿Cómo garantizar que todos los cambios funcionen correctamente?

Después de realizar cualquier modificación en el código, es esencial verificar que todo siga funcionando como se espera. Para ello, utiliza el comando .NET Build desde la consola.

En caso de encontrar errores relacionados con la utilización de características como 'top level statements', asegúrate de que la aplicación sea del tipo ejecutable agregando 'OutputType Exe' en la configuración si se había eliminado previamente.

¿Qué considerar para la próxima sesión de código?

Tu tarea como desarrollador es ahora mejorar la estructura del código que hemos refinado. Presta atención a los siguientes puntos:

Asegúrate de que todos los bloques de código estén correctamente alineados e indentados.
Elimina espacios innecesarios que no contribuyan a la claridad del código.
Considera las mejoras de este código y cómo puedes aplicarlas consistentemente en futuros proyectos.

Finalmente, recuerda que aprender a codificar de manera efectiva es un proceso continuo. En la próxima sesión, discutiremos sobre la importancia del uso de comentarios en el código, cuándo son útiles y cuándo podrían ser innecesarios. Con cada paso que das para optimizar tu código, estás construyendo una base sólida para ser un desarrollador más eficiente y efectivo. ¡Sigue adelante, cada mejora cuenta!

Luis Sandoval

student•

Si utilizan Visual Studio al darle control + k + d, el IDE formatea el archivo.

Hector David Cabrera Vásquez

student•

En el caso de Visual studio code, se utiliza shift + alt + f

Miguel Teheran

teacher•

Buen aporte

Daniel Arturo Dominguez Lopez

student•

Me encanto ese truco de <ImplicitUsings>enable</ImplicitUsings>

Cristhian Alex Dipas Castañeda

student•

Es increíble usando todo lo aprendido pude crear una mini calculadora en pocas líneas de código.

using System;

namespace cosola

{

public class Program

{

static void Main(string[] args)

{

string calculadora(int num1, int num2, int operacion)

{

int sum() => (num1 + num2);

int res() => (num1 - num2);

int mul() => (num1 * num2);

int div() => (num1 / num2);

var total = (operacion) switch

{

((int)operadores.sum) => (sum()),

((int)operadores.res) => (res()),

((int)operadores.mul) => (mul()),

((int)operadores.div) => (div()),

_ => 0

};

return $"El total es: {total}";

}

string total = calculadora(1, 3, (int)operadores.res);

Console.WriteLine(total);

}

enum operadores

{

sum = 1,

res = 2,

mul = 3,

div = 4,

}

Luis Jacobo Hernandez Campuzano

student•

Hola Comunidad ! A mi me sirvio el shortcut: Presiona las teclas Ctrl + K seguido de Ctrl + F

En Windosws VCS

Perry Lee Daniels

student•

Las ultimas versiones de C# y dotnet soportan el codigo desarrollado en verciones anteriores?

Miguel Teheran

teacher•

Claro que si, tiene retrocompatbilidad.

Juan Sebastian Ramirez Leyva

student•

Si al eliminar la estructura de namespace y using "referencias en el proyecto" y estan dentro de visual studio code se debe tener instalado la extensión de C# en este.

Edgar Eduardo Delgado Scott

student•

Me parece muy bueno este docente, hay más cursos con él?

Kenneth David Gaitan Evanks

student•

El implicit using en C# simplifica la gestión de espacios de nombres, permitiendo que ciertos using se apliquen de manera global en un archivo sin necesidad de declararlos explícitamente en cada uno. Esto reduce la cantidad de líneas de código y mejora la legibilidad. Es especialmente útil en proyectos con múltiples archivos, ya que evita la repetición innecesaria de using y ayuda a mantener un código más limpio y minimalista. Esta característica se introdujo en .NET 6 como parte de las mejoras de sintaxis y minimalismo.

Kenneth David Gaitan Evanks

student•

El implicit using en C# funciona bien para los namespaces que son comunes y que se utilizan con frecuencia en todo el proyecto, como System, System.Collections.Generic, entre otros. Sin embargo, no se aplica a todos los namespaces, especialmente aquellos que son específicos de tu aplicación o que no se utilizan en todos los archivos. Por lo tanto, debes seguir declarando explícitamente aquellos usando namespaces que no sean globales o que no se deseen incluir de manera implícita.

Silvia Corrales

student•

Veo que en su Visual Studio Code arriba de las clases o metodos se indican las referencias que se han hecho de las mismas ¿se debe a alguna extension?

Miguel Teheran

teacher•

debes instalar la extesion de C# para visual code y abrir el proyecto en la carpeta donde se encuentra el archivo csproj

Yllen Santamaría Chacón

student•

¿En qué casos sería mejor o inluso obligatorio seguir manejando la estructura del namespace y las clases?

Miguel Teheran

teacher•

Cuando tienes proyecto viejos es casi mandatorio por que este feature es nuevo, cuando creas librerías compartidas y quieres administrar lo mejor posible el acceso usando los namespaces y puede ser tambien en proyectos enormes monoliticos que depronto puede ser confuso la separacion de elementos y componentes en los archivos puede ser mejor la estructura tradicional

Pablo Andres Muñoz Martinez

student•

Lo del XML es esencial para optimizar el codigo y poder trabajar bien las versiones de .NET,

Antonio Aguilar

student•

Así queda mi código.


    List<string> TaskList =  new List<string>();

    int menuSelected = 0;
    do
    {
        menuSelected = ShowMainMenu();
        if ((Menu)menuSelected == Menu.Add)
        {
            ShowMenuAdd();
        }
        else if ((Menu)menuSelected == Menu.Remove)
        {
            ShowMenuRemove();
        }
        else if ((Menu)menuSelected == Menu.List)
        {
            ShowMenuTaskList();
        }
    } while ((Menu)menuSelected != Menu.Exit);

    /// <summary>
    /// Show the main menu 
    /// </summary>
    /// <returns>Returns option indicated by user</returns>
    static int ShowMainMenu()
    {
        Console.WriteLine("----------------------------------------");
        Console.WriteLine("Ingrese la opción a realizar: ");
        Console.WriteLine("1. Nueva tarea");
        Console.WriteLine("2. Remover tarea");
        Console.WriteLine("3. Tareas pendientes");
        Console.WriteLine("4. Salir");

        // Read line
        string line = Console.ReadLine();
        return Convert.ToInt32(line);
    }

    void ShowMenuRemove()
    {
        try
        {
            Console.WriteLine("Ingrese el número de la tarea a remover: ");
            // Show current taks
            ShowTaskList();

            string line = Console.ReadLine();
            // Remove one position
            int indexToRemove = Convert.ToInt32(line) - 1;

            if ((indexToRemove > TaskList.Count -1) || (indexToRemove > 0))
            {
                Console.WriteLine("Numero de tarea seleccionado no es valido");
            }
            else{
                if ((indexToRemove > -1) && (TaskList.Count > 0))
                {
                    string task = TaskList[indexToRemove];
                    TaskList.RemoveAt(indexToRemove);
                    Console.WriteLine("Tarea " + task + " eliminada");
                }
            }
        }

        catch (Exception ex)
        {
            Console.WriteLine("Ha ocurrido un error al eliminar la tarea");
        }
    }

    void ShowMenuAdd()
    {
        try
        {
            Console.WriteLine("Ingrese el nombre de la tarea: ");
            string task = Console.ReadLine();

            if(string.IsNullOrEmpty(task) == true)
            {
                Console.WriteLine("Las tareas no pueden tener campos vacíos");
            }
            else{
                TaskList.Add(task);
                Console.WriteLine("Tarea registrada");

            }


        }
        catch (Exception ex)
        {
            Console.WriteLine("Ha ocurrido un error al registrar la tarea");
        }
    }

    void ShowMenuTaskList()
    {
        if (TaskList?.Count > 0)
        {
            ShowTaskList();
        } 
        else
        {
            Console.WriteLine("No hay tareas por realizar");
        }
    }

    void ShowTaskList()
    {
        Console.WriteLine("----------------------------------------");
        var indexTask = 1;
        TaskList.ForEach(task => Console.WriteLine($"{indexTask++} . {task}"));
        Console.WriteLine("----------------------------------------");
    }

    public enum Menu
    {
        Add = 1,
        Remove = 2,
        List = 3,
        Exit = 4
    }

Miguel Angel Reyes Moreno

student•

Código actualizado:

List<string> TaskList = new List<string>();

int menuOption = 0;

do
{
    menuOption = ShowMainMenu();
    if ((Menu)menuOption == Menu.Add)
    {
        AddTask();
    }
    else if ((Menu)menuOption == Menu.Remove)
    {
        RemoveTask();
    }
    else if ((Menu)menuOption == Menu.List)
    {
        ShowTaskList();
    }
} while ((Menu)menuOption != Menu.Exit);

/// <summary>
/// Show the main menu 
/// </summary>
/// <returns>Returns menuOption indicated by user</returns>
int ShowMainMenu()
{
    Console.WriteLine("----------------------------------------");
    Console.WriteLine("Ingrese la opción a realizar: ");
    Console.WriteLine("1. Nueva tarea");
    Console.WriteLine("2. Remover tarea");
    Console.WriteLine("3. Tareas pendientes");
    Console.WriteLine("4. Salir");

    // Read taskIndex
    string taskIndex = Console.ReadLine();
    return Convert.ToInt32(taskIndex);
}

void RemoveTask()
{
    try
    {
        Console.WriteLine("Ingrese el número de la tarea a remover: ");
        // Show current taks
        ListTasks();

        string taskIndex = Console.ReadLine();
        // Remove one position
        int indexToRemove = Convert.ToInt32(taskIndex) - 1;

        if (indexToRemove <= TaskList.Count - 1 && indexToRemove >= 0)
        {
            if ((indexToRemove > -1) || (TaskList.Count > 0))
            {
                string taskToRemove = TaskList[indexToRemove];
                TaskList.RemoveAt(indexToRemove);
                Console.WriteLine($"Tarea {taskToRemove} eliminada");
            }
        }
        else
        {
            Console.WriteLine("El número de tarea seleccionado no es válido.");
        }
    }
    catch (Exception)
    {
        Console.WriteLine("Ha ocurrido un error al eliminar la tarea.");
    }
}

void AddTask()
{
    try
    {
        Console.WriteLine("Ingrese el nombre de la tarea: ");
        string taskToAdd = Console.ReadLine();

        if (!string.IsNullOrEmpty(taskToAdd))
        {
            TaskList.Add(taskToAdd);
            Console.WriteLine("Tarea registrada");
        }
        else
        {
            Console.WriteLine("La tarea no puede estar vacía.");
        }

    }
    catch (Exception)
    {
        Console.WriteLine("Ha ocurrido un error al intentar ingresar la tarea.");
    }
}

void ShowTaskList()
{
    if (TaskList?.Count > 0)
    {
        ListTasks();
    }
    else
    {
        Console.WriteLine("No hay tareas por realizar");
    }
}

void ListTasks()
{
    Console.WriteLine("----------------------------------------");

    var indexTask = 1;
    TaskList.ForEach(task => Console.WriteLine($"{indexTask++}. {task}"));

    Console.WriteLine("----------------------------------------");
}


public enum Menu
{
    Add = 1,
    Remove = 2,
    List = 3,
    Exit = 4
}

Daniel Franco

student•

Saludos a todos! Usando visual Studio Code:

Pueden abrir la lista completa de comandos y atajos presionando Ctrl + K + Ctrl + R (Ctrl + K y sin dejar de presionar Ctrl , presionar R)

Para dar formato se puede usarla combinación: Shift + Alt + f

Joel Angel David Barrantes Palacios

student•

varia segun el sistema operativo

Francisco Javier Pineda Giraldo

student•

que pasa con el uso de estas caracteristicas nuevas en C#, cuando los equipos informaticos no se actualizan al mismo paso que los lenguajes?

Miguel Teheran

teacher•

Lo primero es tener cuenta que se debe actualizar .NET para poder utilizar lo último de C# y eso se debe sincronizar con el equipo. Lo ideal es hacer sesiones técnicas para compartir conocimiento y seguir las buenas prácticas en el uso de esos nuevas funcionalidades.

LEONARDO DANIEL ROSPIGLIOSI ZAVALETA

student•

Consulta, en este escenario de minimalismo, Cómo se aplica la herencia, si no se tiene la declaración de la clase en la estructura.

Ejemplo:

ClaseHijo: ClasePadre

Miguel Teheran

teacher•

La clase program no pudiera heredar por que no existe como tal, sin embargo tus clases puewden heredar normalmente sin problema es exactamente igual

José Rodrigo Álvarez Herrera

student•

¿Por qué el enum debe de ir hasta abajo?

Miguel Teheran

teacher•

No es necesario, la idea es priorizar en la parte de arriba lo que más estaría cambiando el developer, también se puede agregar en un archivo aparte de hecho así debe hacerse en proyectos más grandes que un demo.

Jason Galvis Camargo

student•

En visual studio no pude hacer este mismo procedimiento, no me aparece el archivo ToDo.csproj 1, sin embargo este se esta ejecutando en modo consola

Jorge Ivan Meza

student•

Varias de esas "simplificaciones" se sienten como volver al paradigma imperativo. Esa pérdida de estructura solo le vería utilidad cuando se hacen programas muy simples y de finalidad específica, del estilo de un script.

    List<string> TaskList =  new List<string>();

    int menuSelected = 0;
    do
    {
        menuSelected = ShowMainMenu();
        if ((Menu)menuSelected == Menu.Add)
        {
            ShowMenuAdd();
        }
        else if ((Menu)menuSelected == Menu.Remove)
        {
            ShowMenuRemove();
        }
        else if ((Menu)menuSelected == Menu.List)
        {
            ShowMenuTaskList();
        }
    } while ((Menu)menuSelected != Menu.Exit);

    /// <summary>
    /// Show the main menu 
    /// </summary>
    /// <returns>Returns option indicated by user</returns>
    static int ShowMainMenu()
    {
        Console.WriteLine("----------------------------------------");
        Console.WriteLine("Ingrese la opción a realizar: ");
        Console.WriteLine("1. Nueva tarea");
        Console.WriteLine("2. Remover tarea");
        Console.WriteLine("3. Tareas pendientes");
        Console.WriteLine("4. Salir");

        // Read line
        string line = Console.ReadLine();
        return Convert.ToInt32(line);
    }

    void ShowMenuRemove()
    {
        try
        {
            Console.WriteLine("Ingrese el número de la tarea a remover: ");
            // Show current taks
            ShowTaskList();

            string line = Console.ReadLine();
            // Remove one position
            int indexToRemove = Convert.ToInt32(line) - 1;

            if ((indexToRemove > TaskList.Count -1) || (indexToRemove > 0))
            {
                Console.WriteLine("Numero de tarea seleccionado no es valido");
            }
            else{
                if ((indexToRemove > -1) && (TaskList.Count > 0))
                {
                    string task = TaskList[indexToRemove];
                    TaskList.RemoveAt(indexToRemove);
                    Console.WriteLine("Tarea " + task + " eliminada");
                }
            }
        }

        catch (Exception ex)
        {
            Console.WriteLine("Ha ocurrido un error al eliminar la tarea");
        }
    }

    void ShowMenuAdd()
    {
        try
        {
            Console.WriteLine("Ingrese el nombre de la tarea: ");
            string task = Console.ReadLine();

            if(string.IsNullOrEmpty(task) == true)
            {
                Console.WriteLine("Las tareas no pueden tener campos vacíos");
            }
            else{
                TaskList.Add(task);
                Console.WriteLine("Tarea registrada");

            }


        }
        catch (Exception ex)
        {
            Console.WriteLine("Ha ocurrido un error al registrar la tarea");
        }
    }

    void ShowMenuTaskList()
    {
        if (TaskList?.Count > 0)
        {
            ShowTaskList();
        } 
        else
        {
            Console.WriteLine("No hay tareas por realizar");
        }
    }

    void ShowTaskList()
    {
        Console.WriteLine("----------------------------------------");
        var indexTask = 1;
        TaskList.ForEach(task => Console.WriteLine($"{indexTask++} . {task}"));
        Console.WriteLine("----------------------------------------");
    }

    public enum Menu
    {
        Add = 1,
        Remove = 2,
        List = 3,
        Exit = 4
    }

List<string> TaskList = new List<string>();

int menuOption = 0;

do
{
    menuOption = ShowMainMenu();
    if ((Menu)menuOption == Menu.Add)
    {
        AddTask();
    }
    else if ((Menu)menuOption == Menu.Remove)
    {
        RemoveTask();
    }
    else if ((Menu)menuOption == Menu.List)
    {
        ShowTaskList();
    }
} while ((Menu)menuOption != Menu.Exit);

/// <summary>
/// Show the main menu 
/// </summary>
/// <returns>Returns menuOption indicated by user</returns>
int ShowMainMenu()
{
    Console.WriteLine("----------------------------------------");
    Console.WriteLine("Ingrese la opción a realizar: ");
    Console.WriteLine("1. Nueva tarea");
    Console.WriteLine("2. Remover tarea");
    Console.WriteLine("3. Tareas pendientes");
    Console.WriteLine("4. Salir");

    // Read taskIndex
    string taskIndex = Console.ReadLine();
    return Convert.ToInt32(taskIndex);
}

void RemoveTask()
{
    try
    {
        Console.WriteLine("Ingrese el número de la tarea a remover: ");
        // Show current taks
        ListTasks();

        string taskIndex = Console.ReadLine();
        // Remove one position
        int indexToRemove = Convert.ToInt32(taskIndex) - 1;

        if (indexToRemove <= TaskList.Count - 1 && indexToRemove >= 0)
        {
            if ((indexToRemove > -1) || (TaskList.Count > 0))
            {
                string taskToRemove = TaskList[indexToRemove];
                TaskList.RemoveAt(indexToRemove);
                Console.WriteLine($"Tarea {taskToRemove} eliminada");
            }
        }
        else
        {
            Console.WriteLine("El número de tarea seleccionado no es válido.");
        }
    }
    catch (Exception)
    {
        Console.WriteLine("Ha ocurrido un error al eliminar la tarea.");
    }
}

void AddTask()
{
    try
    {
        Console.WriteLine("Ingrese el nombre de la tarea: ");
        string taskToAdd = Console.ReadLine();

        if (!string.IsNullOrEmpty(taskToAdd))
        {
            TaskList.Add(taskToAdd);
            Console.WriteLine("Tarea registrada");
        }
        else
        {
            Console.WriteLine("La tarea no puede estar vacía.");
        }

    }
    catch (Exception)
    {
        Console.WriteLine("Ha ocurrido un error al intentar ingresar la tarea.");
    }
}

void ShowTaskList()
{
    if (TaskList?.Count > 0)
    {
        ListTasks();
    }
    else
    {
        Console.WriteLine("No hay tareas por realizar");
    }
}

void ListTasks()
{
    Console.WriteLine("----------------------------------------");

    var indexTask = 1;
    TaskList.ForEach(task => Console.WriteLine($"{indexTask++}. {task}"));

    Console.WriteLine("----------------------------------------");
}


public enum Menu
{
    Add = 1,
    Remove = 2,
    List = 3,
    Exit = 4
}

Mejoras de Sintaxis y Minimalismo en C# utilizando .NET 6

Introducción

Buenas prácticas y código limpio en C-Sharp

Buenas Prácticas y Código Limpio en C-Sharp

Buenas Prácticas y Código Limpio en Desarrollo de Software

Mejora de Código C-Sharp: Buenas Prácticas de Nombramiento

Principios del código limpio

Buenas Prácticas de Nombramiento en C#

Identificación de Co-Smells en C-Sharp y Soluciones Prácticas

Aplicación del principio DRY en C# para optimizar código

Aplicando el Principio KISS en Programación C#

Buenas prácticas de uso de try-catch en C#

Mejoras en C# y comentarios

Evolución y Mejoras de C# para Optimizar tu Código

Interpolación de cadenas y mejoras en C-Sharp

Mejoras de Sintaxis y Minimalismo en C# utilizando .NET 6

Buenas Prácticas para Comentarios en Código Fuente

Cierre

Buenas Prácticas y Código Limpio en C-Sharp