No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

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

7/14
Recursos

¿Qué es el principio DRY en C#?

El principio DRY, que significa "Don't Repeat Yourself", es un pilar fundamental en el desarrollo de software que nos invita a evitar la repetición innecesaria de código. Este enfoque no solo mejora la eficiencia al ahorrar tiempo y esfuerzo, sino que también fomenta una estructura de código más limpia y comprensible. En C#, aplicar el principio DRY implica la reutilización de las rutinas de código, asegurando coherencia y mantenimiento simplificado. Sin embargo, es común que los programadores violen este principio al copiar y pegar código repetidamente, en su afán por avanzar rápidamente en el proyecto.

¿Por qué se tiende a romper el principio DRY?

El principal culpable de la ruptura del principio DRY es la tendencia a copiar y pegar segmentos de código. Aunque es una práctica común, especialmente cuando buscamos soluciones en plataformas como Stack Overflow, es fundamental entender y adaptar el código copiado para que funcione según las necesidades particulares de un proyecto. Copiar y pegar no es intrínsecamente malo, pero debe hacerse con cautela y con la intención de integrar y reutilizar el código de manera adecuada.

¿Cómo identificar y solucionar la duplicación de código?

Existen dos situaciones típicas que conllevan a la duplicación de código:

  1. Secciones exactamente duplicadas: En estos casos, es posible encapsular el código redundante en funciones o métodos reutilizables.
  2. Rutinas parecidas pero separadas: Aunque no son idénticas, estas rutinas pueden unificarse mediante la creación de funciones que acepten parámetros, permitiendo configurar distintos comportamientos.

Para abordar estos escenarios, es esencial analizar detenidamente el código, identificar patrones repetidos y definir métodos que encapsulen la lógica duplicada.

¿Cómo aplicar DRY en el código?

Pongamos en práctica el principio DRY refactorizando un ejemplo concreto. Supongamos que dentro de nuestro proyecto tenemos un método que lista tareas y otro que las elimina, pero ambos contienen la misma lógica para mostrar esa lista. El objetivo es consolidar esta lógica repetida en una sola función que pueda ser reutilizada en distintos contextos.

Ejemplo en C#:

public void ShowMenuTaskList()
{
    if (TaskCollection == null || TaskCollection.Count == 0)
    {
        Console.WriteLine("No hay tareas disponibles.");
        return;
    }

    ListTasks();
}

public void RemoveTask()
{
    ShowMenuTaskList();
    Console.WriteLine("Ingrese el número de la tarea a remover:");
    
    // Lógica para eliminar la tarea...
}

private void ListTasks()
{
    foreach (var task in TaskCollection)
    {
        Console.WriteLine($"{task.Number}: {task.Description}");
    }
    Console.WriteLine(new string('-', 20));
}

Este ejemplo muestra cómo la función ListTasks abstrae la lógica común, permitiendo su uso tanto en el menú de tareas como en la opción de eliminación.

¿Cuáles son los beneficios de aplicar DRY?

Adoptar el principio DRY ofrece múltiples ventajas significativas, tales como:

  • Mantenimiento facilitado: Un cambio en la lógica compartida se realiza en un único lugar.
  • Legibilidad mejorada: Al reducir la repetición, el código es más fácil de seguir y entender.
  • Reducción de errores: Con menos duplicaciones, se disminuyen los riesgos de inconsistencias.
  • Escalabilidad: Facilita la adición de nuevas funciones sin complicar la estructura existente.

Practicando el principio DRY

Te animo a que en tus futuros proyectos, identifiques segmentos de código repetidos y explores maneras de consolidarlos. No solo optimizarás tu código, sino que también mejorarás tus habilidades de programador. Recuerda que cada paso hacia un código más limpio es una inversión en tu desarrollo profesional.

Continúa explorando y aplicando principios de buenas prácticas, y observa cómo tu eficiencia y éxito como desarrollador crecen exponencialmente. El mundo del desarrollo de software está lleno de oportunidades de aprendizaje y mejora continua. ¡Sigue investigando y aprendiendo!

Aportes 18

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Principio DRY

DRY: Don’t Repeat Yourself (No te repitas) .

El objetivo de este principio es evitar la duplicación de partes de código en nuestro código. Andy Hunt y Dave Thomas formularon en su libro «The Pragmatic Programmer: From Journeyman to Master» el siguiente principio:

«Every piece of knowledge must have a single, unambiguous, authoritative representation within a system»

Que en español se traduciría como:

«Cada pieza de conocimiento debe tener una única representación autorizada, sin ambigüedades, dentro de un sistema».

El código duplicado no siempre es fácil de reconocer o para poder eliminarlo puede que resulte más compleja la solución. una regla de oro en el refactoring es la Regla de tres: repetir una vez el mismo código puede ser aceptable, pero la tercera vez que utilizamos el mismo código, es señal inequívoca de que hay que refactorizar y solucionar la duplicación.

Así quedaría la función:

        public static void ShowTaskList()
        {
            for (int i = 0; i < TaskList.Count; i++)
            {
                Console.WriteLine((i + 1) + ". " + TaskList[i]);
            }
            Console.WriteLine("----------------------------------------");
        }

Analizando un poco, me fije que quizas no es necesario crear otra funcion que lista, ya que su funcion principal es listar y si no hay tarear, pues basicamente diria “No hay tareas por realizar”, por lo que no habria nada por borrar, yo solo le puse ShowTaskList(), es descriptivo y no repito codigo.

Otra parte del codigo que se esta repitiendo con los Console.WriteLine que imprimen las lineas de separacion. Eso tambien puede convertirse en un metodo que podriamos reutilizar. Asi no tendriamos que copiar y pegar esa linea de codigo cada ve que queramos agregar una linea de separacion. Ademas si en el futuro queremos hacer esa linea mas larga o corta, o si queremos cambiar los guiones por algun otro simbolo, solo tendriamos que cambiarlo en un solo lugar. ```c# private static void PrintSeparator() { Console.WriteLine("----------------------------------------"); } ```
## Principio DRY (Don't Repeat Yourself) **¿Qué es?** DRY es una filosofía de desarrollo de software que busca **evitar la duplicación de código**. Se basa en la idea de que cada pieza de información o lógica debe existir **en un único lugar**. **¿Por qué es importante?** La duplicación de código puede generar varios problemas: * **Mantenimiento ineficiente:** Dificultad para realizar cambios en el código. * **Errores repetitivos:** Mayor probabilidad de errores en diferentes partes del código. * **Código difícil de entender:** Dificultad para comprender el propósito del código. **¿Cómo aplicar el principio DRY?** * **Extraer código común a métodos o clases.** * **Utilizar bucles y condicionales para evitar repeticiones.** * **Aprovechar las bibliotecas y frameworks existentes.** **Ejemplos de aplicación en C#:** * **Extraer un método para calcular el IVA.** * **Utilizar un bucle para recorrer una lista de elementos.** * **Utilizar una biblioteca para realizar operaciones matemáticas.**

StringBuilder menu = new StringBuilder();
menu.AppendLine(“Seleccione una opción:”);
menu.AppendLine(“1. Nueva tarea”);
menu.AppendLine(“2. Remover tarea”);
menu.AppendLine(“3. Tareas pendientes”);
menu.AppendLine(“4. Salir”);

    Console.WriteLine(menu);

Reto conseguido:

using System;
using System.Collections.Generic;

namespace ToDo
{
    internal class Program
    {
        public static List<string> TaskList { get; set; }

        static void Main(string[] args)
        {
            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>
        public 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 taskIndex
            string taskIndex = Console.ReadLine();
            return Convert.ToInt32(taskIndex);
        }

        public static 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 > -1)
                {
                    if (TaskList.Count > 0)
                    {
                        string taskToRemove = TaskList[indexToRemove];
                        TaskList.RemoveAt(indexToRemove);
                        Console.WriteLine("Tarea " + taskToRemove + " eliminada");
                    }
                }
            }
            catch (Exception)
            {
            }
        }

        public static void AddTask()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string taskToAdd = Console.ReadLine();
                TaskList.Add(taskToAdd);
                Console.WriteLine("Tarea registrada");
            }
            catch (Exception)
            {
            }
        }

        public static void ShowTaskList()
        {
            if (TaskList == null || TaskList.Count == 0)
            {
                Console.WriteLine("No hay tareas por realizar");
            } 
            else
            {
                ListTasks();
            }
        }

        public static void ListTasks()
        {
            Console.WriteLine("----------------------------------------");
            for (int i = 0; i < TaskList.Count; i++)
            {
                Console.WriteLine((i + 1) + ". " + TaskList[i]);
            }
            Console.WriteLine("----------------------------------------");
        }
    }

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

Mi Aporte ;$

using System;
using System.Collections.Generic;

namespace ToDo
{
    internal class Program
    {
        private static List<string> taskList { get; set; }

        public static List<string> GetTaskList()
        {
            return taskList;
        }

        public static void SetTaskList(List<string> value)
        {
            taskList = value;
        }

        // Función para mostrar la lista de tareas
        public static void ShowTaskList()
        {
            Console.WriteLine("----------------------------------------");
            for (int i = 0; i < GetTaskList().Count; i++)
            {
                Console.WriteLine((i + 1) + ". " + GetTaskList()[i]);
            }
            Console.WriteLine("----------------------------------------");
        }

        static void Main(string[] args)
        {
            SetTaskList(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)
                {
                    ShowTaskList();  // Llamada al método ShowTaskList en lugar de ShowMenuTaskList
                }
            } while ((Menu)menuSelected != Menu.Exit);
        }

        public 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 taskIndex = Console.ReadLine();
            return Convert.ToInt32(taskIndex);
        }

        public static void ShowMenuRemove()
        {
            try
            {
                Console.WriteLine("Ingrese el número de la tarea a remover: ");

                ShowTaskList();

                string taskIndex = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(taskIndex) - 1;
                if (indexToRemove > -1)
                {
                    if (GetTaskList().Count > 0)
                    {
                        string taskToRemove = GetTaskList()[indexToRemove];
                        GetTaskList().RemoveAt(indexToRemove);
                        Console.WriteLine("Tarea " + taskToRemove + " eliminada");
                    }
                }
            }
            catch (Exception)
            {
            }
        }

        public static void ShowMenuAdd()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string task = Console.ReadLine();
                GetTaskList().Add(task);
                Console.WriteLine("Tarea registrada");
            }
            catch (Exception)
            {
            }
        }

        public static void ShowMenuTaskList()
        {
            if (GetTaskList() == null || GetTaskList().Count == 0)
            {
                Console.WriteLine("No hay tareas por realizar");
            }
            else
            {
                ShowTaskList();
            }
        }
    }
        
    public enum Menu
    {
        add = 1,
        remove = 2,
        List = 3,
        Exit = 4
    }
}

muy buena clase, ahora ultimo se ven muchos códigos con muchas funciones repetidas.

```js public static void ViewList() { Console.WriteLine("----------------------------------------"); for (int i = 0; i < TaskList.Count; i++) { Console.WriteLine((i + 1) + ". " + TaskList[i]); } Console.WriteLine("----------------------------------------"); } ```Creo que si queremos algo sencillo sería así
Excelente clase
![](https://static.platzi.com/media/user_upload/image-aec55f39-b4a9-4511-861a-8b6b507e8c97.jpg)
`using System;` `using System.Collections.Generic;` `using System.Linq;` `namespace ToDo` `{` ` internal class Program` ` {` ` public static List<string> TaskList { get; set; }` ` static void Main(string[] args)` ` {` ` TaskList = new List<string>();` ` int selectedOption = 0;` ` do` ` {` ` selectedOption = MainMenu();` ` if ((Menu)selectedOption == Menu.Add)` ` {` ` NewTask();` ` }` ` else if ((Menu)selectedOption == Menu.Remove)` ` {` ` RemoveTask();` ` }` ` else if ((Menu)selectedOption == Menu.PendingTask)` ` {` ` PendingTask();` ` }` ` } while ((Menu)selectedOption != Menu.Exit);` ` }` ` /// <summary>` ` /// Show the main menu ` ` /// </summary>` ` /// <returns>Returns option indicated by user</returns>` ` public static int MainMenu()` ` {` ` Separator();` ` ShowMessage("Ingrese la opción a realizar: ");` ` ShowMessage("1. Nueva tarea");` ` ShowMessage("2. Remover tarea");` ` ShowMessage("3. Tareas pendientes");` ` ShowMessage("4. Salir");` ` // Read line` ` string option = Console.ReadLine();` ` return Convert.ToInt32(option);` ` }` ` public static void NewTask()` ` {` ` try` ` {` ` ShowMessage("Ingrese el nombre de la tarea: ");` ` string task = Console.ReadLine();` ` TaskList.Add(task);` ` Console.WriteLine("Tarea registrada");` ` }` ` catch (Exception)` ` {` ` }` ` }` ` public static void RemoveTask()` ` {` ` try` ` {` ` ShowMessage("Ingrese el número de la tarea a remover: ");` ` // Show current taks` ` PrintTasks();` ` Separator();` ` string taskNumber = Console.ReadLine();` ` // Remove one position` ` int taskToRemove = Convert.ToInt32(taskNumber) - 1;` ` if (taskToRemove > -1)` ` {` ` if (TaskList.Count > 0)` ` {` ` string task = TaskList[taskToRemove];` ` TaskList.RemoveAt(taskToRemove);` ` ShowMessage("Tarea " + task + " eliminada");` ` }` ` }` ` }` ` catch (Exception)` ` {` ` }` ` }` ` public static void PendingTask()` ` {` ` if (TaskList == null || TaskList.Count == 0)` ` {` ` ShowMessage("No hay tareas por realizar");` ` } ` ` else` ` {` ` Separator();` ` PrintTasks();` ` Separator();` ` }` ` }` ` public static void PrintTasks()` ` {` ` for (int i = 0; i < TaskList.Count; i++)` ` {` ` Console.WriteLine((i + 1) + ". " + TaskList[i]);` ` }` ` }` ` public static void Separator()` ` {` ` Console.WriteLine("----------------------------------------");` ` }` ` public static void ShowMessage(string message)` ` {` ` Console.WriteLine(message);` ` }` ` }` ` public enum Menu` ` {` ` Add = 1,` ` Remove = 2,` ` PendingTask = 3,` ` Exit = 4` ` }` `}` Mi aporte agregue 3 metodos el que se hizo en clase con el profe que es para mostrar las listas, unos para imprimir el separador y otro para motrar los distintos mensajes asi no se llama al Console.WriteLone en todos los metodo.
```js using System; using System.Collections.Generic; namespace ToDo { internal class Program { public static List<string> TaskList { get; set; } static void Main(string[] args) { TaskList = new List<string>(); int MenuSelect = 0; do { MenuSelect = ShowMainMenu(); if ((Menu)MenuSelect == Menu.Add) { ShowMenuAdd(); } else if ((Menu)MenuSelect == Menu.remove) { ShowMenuRemove(); } else if ((Menu)MenuSelect == Menu.List) { ShowMenuList(); } } while ((Menu)MenuSelect != Menu.Exit); } /// <summary> /// Show the main menu /// </summary> /// <returns>Returns option indicated by user</returns> public 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); } public static void ShowMenuRemove() { try { Console.WriteLine("Ingrese el número de la tarea a remover: "); // Show current taks Show(); string line = Console.ReadLine(); // Remove one position int indexToRemove = Convert.ToInt32(line) - 1; if (indexToRemove > -1) { if (TaskList.Count > 0) { string task = TaskList[indexToRemove]; TaskList.RemoveAt(indexToRemove); Console.WriteLine("Tarea " + task + " eliminada"); } } } catch (Exception) { } } public static void ShowMenuAdd() { try { Console.WriteLine("Ingrese el nombre de la tarea: "); string task = Console.ReadLine(); TaskList.Add(task); Console.WriteLine("Tarea registrada"); } catch (Exception) { } } public static void ShowMenuList() { if (TaskList == null || TaskList.Count == 0) { Console.WriteLine("No hay tareas por realizar"); } else { Show(); } } public static void Show() { Console.WriteLine("----------------------------------------"); for (int i = 0; i < TaskList.Count; i++) { Console.WriteLine((i + 1) + ". " + TaskList[i]); } Console.WriteLine("----------------------------------------"); } } public enum Menu { Add = 1, remove = 2, List = 3, Exit = 4 } } ```using System; using System.Collections.Generic; namespace ToDo { internal class Program { public static List\<string> TaskList { get; set; } static void Main(string\[] args) { TaskList = new List\<string>(); int MenuSelect = 0; do { MenuSelect = ShowMainMenu(); if ((Menu)MenuSelect == Menu.Add) { ShowMenuAdd(); } else if ((Menu)MenuSelect == Menu.remove) { ShowMenuRemove(); } else if ((Menu)MenuSelect == Menu.List) { ShowMenuList(); } } while ((Menu)MenuSelect != Menu.Exit); } /// \<summary> /// Show the main menu /// \</summary> /// \<returns>Returns option indicated by user\</returns> public 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); } public static void ShowMenuRemove() { try { Console.WriteLine("Ingrese el número de la tarea a remover: "); // Show current taks Show(); string line = Console.ReadLine(); // Remove one position int indexToRemove = Convert.ToInt32(line) - 1; if (indexToRemove > -1) { if (TaskList.Count > 0) { string task = TaskList\[indexToRemove]; TaskList.RemoveAt(indexToRemove); Console.WriteLine("Tarea " + task + " eliminada"); } } } catch (Exception) { } } public static void ShowMenuAdd() { try { Console.WriteLine("Ingrese el nombre de la tarea: "); string task = Console.ReadLine(); TaskList.Add(task); Console.WriteLine("Tarea registrada"); } catch (Exception) { } } public static void ShowMenuList() { if (TaskList == null || TaskList.Count == 0) { Console.WriteLine("No hay tareas por realizar"); } else { Show(); } } public static void Show() { Console.WriteLine("----------------------------------------"); for (int i = 0; i < TaskList.Count; i++) { Console.WriteLine((i + 1) + ". " + TaskList\[i]); } Console.WriteLine("----------------------------------------"); } } public enum Menu { Add = 1, remove = 2, List = 3, Exit = 4 } }
using System; using System.Collections.Generic; using System.Text; namespace ToDo { internal class ToDo { public static List\<string> TaskList { get; set; } static void Main(string\[] args) { TaskList = new List\<string>(); Menu menuSelected; do { menuSelected = ShowMainMenu(); switch (menuSelected) { case Menu.AddOnList: ShowMenuTaskAdd(); break; case Menu.RemoveTask: ShowMenuRemoveTask(); break; case Menu.ListOnScreen: ShowMenuTaskOnScreen(); break; } } while (menuSelected != Menu.ExitMenu); } public static Menu ShowMainMenu() { var menu = new StringBuilder() .AppendLine("----------------------------------------") .AppendLine("Ingrese la opción a realizar: ") .AppendLine("1. Nueva tarea") .AppendLine("2. Remover tarea") .AppendLine("3. Tareas pendientes") .AppendLine("4. Salir"); Console.WriteLine(menu); if (int.TryParse(Console.ReadLine(), out int selectedOption) && Enum.IsDefined(typeof(Menu), selectedOption)) { return (Menu)selectedOption; } else { Console.WriteLine("Opción inválida. Por favor, intente de nuevo."); return ShowMainMenu(); } } public static void ShowMenuRemoveTask() { ShowMenuTaskOnScreen(); if (int.TryParse(Console.ReadLine(), out int indexToRemove)) { indexToRemove--; if (indexToRemove > -1 && TaskList.Count > 0) { string task = TaskList\[indexToRemove]; TaskList.RemoveAt(indexToRemove); Console.WriteLine($"Tarea {task} eliminada"); } } else { Console.WriteLine("Entrada inválida. Por favor, intente de nuevo."); ShowMenuRemoveTask(); } } public static void ShowMenuTaskAdd() { Console.WriteLine("Ingrese el nombre de la tarea: "); string task = Console.ReadLine(); TaskList.Add(task); Console.WriteLine("Tarea registrada"); } public static void ShowMenuTaskOnScreen() { if (TaskList == null || TaskList.Count == 0) { Console.WriteLine("No hay tareas por realizar"); } else { var taskList = new StringBuilder() .AppendLine("----------------------------------------"); for (int i = 0; i < TaskList.Count; i++) { taskList.AppendLine($"{i + 1}. {TaskList\[i]}"); } taskList.AppendLine("----------------------------------------"); Console.WriteLine(taskList); } } } public enum Menu { AddOnList = 1, RemoveTask = 2, ListOnScreen = 3, ExitMenu = 4 } }
Encima, si lo vas usar varias veces conviertelo en Función
así me quedó la función xd `public static void ShowTaskList() ` `{` ` ShowMenuTaskList(); ` `}`
````c# using System; using System.Collections.Generic; namespace ToDo { internal class Program { public static void ListTask(){ Console.WriteLine("----------------------------------------"); for (int i = 0; i < TaskList.Count; i++) { Console.WriteLine((i + 1) + ". " + TaskList[i]); } Console.WriteLine("----------------------------------------"); } public static List<string> TaskList { get; set; } static void Main(string[] args) { 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> public 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 optionSelected = Console.ReadLine(); return Convert.ToInt32(optionSelected); } public static void ShowMenuRemove() { try { Console.WriteLine("Ingrese el número de la tarea a remover: "); // Show current taks ListTask(); string optionSelected = Console.ReadLine(); // Remove one position int indexToRemove = Convert.ToInt32(optionSelected) - 1; if (indexToRemove > -1) { if (TaskList.Count > 0) { string task = TaskList[indexToRemove]; TaskList.RemoveAt(indexToRemove); Console.WriteLine("Tarea " + task + " eliminada"); } } } catch (Exception) { } } public static void ShowMenuAdd() { try { Console.WriteLine("Ingrese el nombre de la tarea: "); string task = Console.ReadLine(); TaskList.Add(task); Console.WriteLine("Tarea registrada"); } catch (Exception) { } } public static void ShowMenuTaskList() { if (TaskList == null || TaskList.Count == 0) { Console.WriteLine("No hay tareas por realizar"); } else { ListTask(); } } } public enum menu { Add = 1, Remove = 2, List = 3, Exit = 4 } } ```using System;using System.Collections.Generic; namespace ToDo{    internal class Program    {        public static void ListTask(){            Console.WriteLine("----------------------------------------");                for (int i = 0; i < TaskList.Count; i++)                {                    Console.WriteLine((i + 1) + ". " + TaskList\[i]);                }                Console.WriteLine("----------------------------------------");        }        public static List\<string> TaskList { get; set; }         static void Main(string\[] args)        {            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>        public 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 optionSelected = Console.ReadLine();            return Convert.ToInt32(optionSelected);        }         public static void ShowMenuRemove()        {            try            {                Console.WriteLine("Ingrese el número de la tarea a remover: ");                // Show current taks                ListTask();                 string optionSelected = Console.ReadLine();                // Remove one position                int indexToRemove = Convert.ToInt32(optionSelected) - 1;                if (indexToRemove > -1)                {                    if (TaskList.Count > 0)                    {                        string task = TaskList\[indexToRemove];                        TaskList.RemoveAt(indexToRemove);                        Console.WriteLine("Tarea " + task + " eliminada");                    }                }            }            catch (Exception)            {            }        }         public static void ShowMenuAdd()        {            try            {                Console.WriteLine("Ingrese el nombre de la tarea: ");                string task = Console.ReadLine();                TaskList.Add(task);                Console.WriteLine("Tarea registrada");            }            catch (Exception)            {            }        }         public static void ShowMenuTaskList()        {            if (TaskList == null || TaskList.Count == 0)            {                Console.WriteLine("No hay tareas por realizar");            }             else            {              ListTask();              }        }    }    public enum menu    {        Add = 1,        Remove = 2,        List = 3,        Exit = 4    }} ````