Usando try catch

El if para controlar la excepción yo lo invertiría:

if (indexToRemove <= (TaskList.Count - 1) && indexToRemove >= 0)

De esta manera podemos poner las intrucciones para remover la tarea dentro del if y no dentro del else

El try catch quedaría de esta manera:

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

                // Show current taks
                ShowTaskList();

                string userInput = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(userInput) - 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 valor que ha ingresado es invalido");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Ha ocurrido un error al eliminar la tarea");
            }

Resumiendo: Se deben controlar todas las posibles excepciones como divisiones por cero, valores fuera de rango etc., y solo dejar al controlador de excepciones ( Try Catch ) un error completamente inesperado.

En mi caso para evitar poner porciones de codigo en la clausula else y asi tenes una mayor complejidad, opte por utilizar un return;, quedandome el codigo de la siguiente manera:

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

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

                if (indexToRemove > (TaskList.Count -1) || indexToRemove < 0){
                    Console.WriteLine("Numero de tarea seleccionado no es valido");
                    return;
                }

                if (indexToRemove > -1 && TaskList.Count > 0)
                {
                    string taskToRemove = TaskList[indexToRemove];
                    TaskList.RemoveAt(indexToRemove);
                    Console.WriteLine("Tarea " + taskToRemove + " eliminada");
                }
                

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

Dos errores posible excepciones encontradas adicionales al video son:

1. Si el usuario ingresa una letra en vez de un número.
2. Si el usuario trata de eliminar una tarea de la lista y la lista está vacia, igualmente le solicita ingresar un valor.

Solución #1:

Se comprueba que el valor ingresado sea un número, en caso de no serlo, se devuelve un valor nuevo al enum que se nombró “Continuar”.

Solución #2:

El método showTaskList devuelve un booleano que sirve para comprobar si existen o no tareas, solamente se le piden valores al usuario en caso de ser True.

Así quedo mi método:

        public static void ShowMenuAdd()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");

                string taskEnteredByUser = Console.ReadLine();

                if(string.IsNullOrEmpty(taskEnteredByUser) == true)
                {
                    Console.WriteLine("Se requiere el nombre de la tarea.");
                }
                else
                {
                    TaskList.Add(taskEnteredByUser);

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

Es importante que al usar un try catch debemos devolver algo para informar al usuario de lo que sucedio, y usarlo es buena practica para el manejo de errores.

Holass, yo quité el try catch del todo y manejé todos los casos posibles que se me ocurrieron

public static void ShowMenuRemove()
        {
            if (TaskList.Count == 0)
            {
                Console.WriteLine("No hay tareas, entonces no se puede remover.");
                return;
            }
            Console.WriteLine("Ingrese el número de la tarea a remover: ");
            // Show current taks
            ShowMenuTaskList();

            string line = Console.ReadLine();
            // Remove one position
            bool didConvert;
            int indexToRemove = 0;
            didConvert = int.TryParse(line, out indexToRemove);

            if (!didConvert)
            {
                Console.WriteLine("Sólo se aceptan números enteros.");
                return;
            }

            if (indexToRemove <= 0)
            {
                Console.WriteLine("Sólo se aceptan números mayores que 0.");
                return;
            }

            if (didConvert && indexToRemove > -1 && TaskList.Count > 0)
            {
                
                if (indexToRemove > TaskList.Count)
                {
                    Console.WriteLine("Número mayor que la cantidad de tareas, no se removió ninguna tarea.");
                    return;
                }

                string task = TaskList[indexToRemove - 1];
                TaskList.RemoveAt(indexToRemove - 1);
                Console.WriteLine("Tarea " + task + " eliminada");

            }

        }

Yo le agregaria el metodo Trim a todos los inputs del usuario, ademas de otros metodos para sanitizar el input.

Para el método de remover yo lo haría de la siguiente forma, como sé que el indice debe ser un valor positivo en un inicio declaré la variable como uint y le aplique un tryparse para validar que no ingrese valores negativos o letras, y luego para eliminar le realicé el cast hacia int.

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

                string numberTaskToRemove = Console.ReadLine();
                uint indexToRemove = 0;
                if (!uint.TryParse(numberTaskToRemove,out indexToRemove) || ((indexToRemove - 1) > (TaskList.Count - 1)))
                {
                    Console.WriteLine("El valor ingresado no es valido");
                    return;
                }

                int index = (int)indexToRemove - 1;
                // Remove one position
                string taskRemoved = TaskList[index];
                TaskList.RemoveAt(index);
                Console.WriteLine("Tarea " + taskRemoved + " eliminada");
            }
            catch (Exception)
            {
                Console.WriteLine("Ha ocurrido un error al eliminar la tarea");
            }
        }

Para evitar muchos ELSE, igual desde el primer IF podemos hacer que se termine la ejecución de esa función, agregando un RETURN.

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

                string indexInput = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(indexInput) - 1;
                if (indexToRemove > TaskList.Count - 1)
                {
                    Console.WriteLine("El número de la tarea está fuera de rango.");
                    return;
                }
                if (indexToRemove > -1 && TaskList.Count > 0)
                {
                    string task = TaskList[indexToRemove];
                    TaskList.RemoveAt(indexToRemove);
                    Console.WriteLine("Tarea " + task + " eliminada. 👍🏼");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("No se pudo eliminar el tarea. Tarea no encontrada.");
                Console.WriteLine(ex.Message);
            }
        }```

Mi codigo para ShowMenuAdd

public static void ShowMenuAdd()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string taskAdd = Console.ReadLine();
                
                if(string.IsNullOrWhiteSpace(taskAdd))
                {
                    System.Console.WriteLine("No se permiten campos nullos");
                    return;
                }
                else
                {
                    TaskList.Add(taskAdd);
                    Console.WriteLine("Tarea registrada");
                }
            }
            catch (Exception)
            {
                System.Console.WriteLine("Ha surgido un erro al ingresar la tarea");
            }
        }

Decidí invertir el if para controlar mejor la excepción y como aporte validé si existe un elemento en la lista antes de eliminar, el metodo quedaria así:

public static void ShowMenuRemove()
{
    try
    {
        if (TaskList.Count > 0)
        {
            Console.WriteLine("Ingrese el número de la tarea a remover: ");
            // Show current taks
            ShowMenuTaskList();

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

            if (indexToRemove >= 0 && indexToRemove <= TaskList.Count - 1) 
            {
                string task = TaskList[indexToRemove];
                TaskList.RemoveAt(indexToRemove);
                Console.WriteLine("Tarea " + task + " eliminada");
            }
            else Console.WriteLine("Indice fuera de rango");
        }
        else Console.WriteLine("No hay tareas para eliminar.");
    }
    catch (Exception)
    {
        Console.WriteLine("Ocurrio un error al eliminar la tarea.");
    }
}

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

                string indexTask = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(indexTask) - 1;
                int tasksLength = Tasks.Count - 1;
                if (indexToRemove > -1 && tasksLength > 0 && indexToRemove <= tasksLength)
                {
                    string task = Tasks[indexToRemove];
                    Tasks.RemoveAt(indexToRemove);
                    Console.WriteLine($"Tarea {task} eliminada");
                } else {
                    Console.WriteLine("----------------------------------------");
                    Console.WriteLine("Tarea no encontrada");
                }
            }
            catch (FormatException)
            {
                Console.WriteLine("----------------------------------------");
                Console.WriteLine("Fallo de conversión");
}

También agregaría un try catch en la función ShowMainMenu, si el user pone algo diferente a un número el programa se deja de funcionar, así quedaría mi código:

        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
            try 
            {
                string selectedMenu = Console.ReadLine();
                return Convert.ToInt32(selectedMenu);
            } catch (Exception) 
            {
                Console.WriteLine("Ha ocurrido un error al seleccionar la opcion del menu");
                return -1;
            }
        }

Un try catch afecta el rendimiento de la aplicación

Código actualizado:

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 <= 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. Ese número no existe, por favor, inténtelo de nuevo.");
            }
        }

        public static 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.");
            }
        }

        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("----------------------------------------");

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

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

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

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

                ShowTaskList();

                string line = Console.ReadLine();

                int indexToRemove = Convert.ToInt32(line) - 1;

                if(indexToRemove < 0 || indexToRemove > TaskList.Count){
                    Console.WriteLine("El numero ingresado no es valido.");
                    return;
                }

                string task = TaskList[indexToRemove];
                TaskList.RemoveAt(indexToRemove);
                Console.WriteLine("Tarea " + task + " eliminada");
                
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: ", ex.Message);
            }
        }

A mi no me da error el Remover Tarea. Me da error leer la opcion de Menu que tiene que ser un Entero pero puede leer un String y da error de Conversion. En ese punto puse un try-catch

Mi propuesta para el método de agregar tarea

        public static void ShowMenuAdd()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string newTask = Console.ReadLine();
                if (string.IsNullOrWhiteSpace(newTask))
                {
                    Console.WriteLine("Por favor ingresar una tarea con formato valido");
                    return;
                }
                TaskList.Add(newTask);
                Console.WriteLine("Tarea registrada");
            }
            catch (Exception)
            {
                Console.WriteLine("Ha ocurrido un error al eliminar la tarea");
            }
        }

Mi propuesta de mejora en el método de agregar tarea

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

                if (task == string.Empty || string.IsNullOrWhiteSpace(task)){
                    Console.WriteLine("La tarea no puede estar en blanco");
                    return;
                }

                TaskList.Add(task);
                Console.WriteLine("Tarea registrada");
            }
            catch (Exception)
            {
                Console.WriteLine("Ha ocurrido un error al ingresar una nueva tarea");
            }
        }