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

Curso de Buenas Prácticas y Código Limpio en C#

Contenido del curso

Introducción

Principios del código limpio

Mejoras en C# y comentarios

Cierre

14
Buenas Prácticas y Código Limpio en C-Sharp
05:08 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:51

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

Curso de Buenas Prácticas y Código Limpio en C#

Clase 9 de 14

Clase 9 / 14

Recursos

¿Qué es el try-catch y cómo usarlo correctamente en C#?

El try-catch es una estructura fundamental en C# que nos permite manejar errores excepcionales en el código de forma controlada. Es crucial entender cuándo y cómo implementarlo adecuadamente para evitar afectaciones en el rendimiento de nuestra aplicación. En esta sección, exploraremos prácticas recomendadas y errores comunes al usar try-catch.

¿Cuándo debo usar try-catch?

El uso del try-catch es recomendable cuando existe la posibilidad de eventos excepcionales que no se pueden prever fácilmente con validaciones ordinarias. Sin embargo, no debe ser una solución para errores que podrían solucionarse con controles de flujo o validaciones previas en el código. Algunos ejemplos donde es válido utilizarlo incluyen:

Capturar errores de red al intentar conectarse a un servicio externo.
Manejar fallos al acceder a recursos de sistema como archivos o bases de datos.
Controlar excepciones no comunes que el programa no pueda predecir.

¿Por qué afecta el rendimiento?

El manejo de excepciones dentro de un bloque try-catch es notablemente más ineficiente en términos de rendimiento comparado con el uso de validaciones previas. Por ejemplo, al manejar divisiones por cero:

public static double GetDivision(int a, int b)
{
    if (b == 0)
        return Double.NaN; // o un valor por defecto
    return a / b;
}

En comparación con:

public static double GetDivisionException(int a, int b)
{
    try
    {
        return a / b;
    }
    catch (DivideByZeroException)
    {
        return Double.NaN; // o un valor por defecto
    }
}

El primer método comprueba y maneja el escenario antes de que se produzca la excepción, mejorando la eficiencia.

¿Cómo implementar buenas prácticas con try-catch?

Para aprovechar al máximo el try-catch y mantener el código eficiente, sigue estas recomendaciones:

¿Cómo manejar las excepciones adecuadamente?

Notificación del error: Siempre que captures una excepción, notifica al usuario o al desarrollador. Puedes hacerlo a través de mensajes claros al usuario o registrando los errores en logs para los desarrolladores.
```
catch (Exception ex)
{
    Console.WriteLine("Ha ocurrido un error al eliminar la tarea.");
    LogError(ex); // Funcion hipotética para almacenar logs
}
```

Condiciones previas: Antes de realizar operaciones que puedan producir excepciones, como accesos a listas o índices, verifica condiciones que puedan prevenir estas excepciones.

if (indexToRemove >= 0 && indexToRemove < tareaList.Count)
{
    // Operación segura
}
else
{
    Console.WriteLine("Número de tarea seleccionado no es válido.");
}

¿Cómo estructurar las condiciones de validación?

Adoptar condiciones claras y separadas para prevenir excepciones:

Utiliza operadores lógicos como && (y) y || (o) para cubrir todos los escenarios posibles.
Asegúrate de que las condiciones cubren desde el inicio (0) hasta el final del índice permitido (tareaList.Count - 1).

¿Cuál es el impacto del try-catch en el flujo del programa?

Un uso adecuado del try-catch no solo captura excepciones sino también mejora la habilidad de diagnósticos post-producción mediante logs. Sin embargo, es crucial no sobrecargar el código con bloques try-catch innecesarios, ya que podría degradar la comprensión y el rendimiento.

Manteniendo estos enfoques, puedes minimizar el impacto negativo del try-catch mientras maximizas su utilidad en el manejo de excepciones inesperadas en tu aplicación C#. ¡Sigue mejorando tus habilidades en C# y recuerda que cada reto es una oportunidad para aprender más!

Leandro Cosme Tomassini

Hace 3 años

Usando try-catch en C#

¿Qué es?

try-catch es una estructura en C# que te permite manejar excepciones en tu código.

¿Cómo funciona?

El bloque try contiene el código que podría generar una excepción.
El bloque catch se ejecuta si se produce una excepción en el bloque tryTipos de excepciones:
Exception: La clase base para todas las excepciones en C#.

Beneficios de usar try-catch:

Mejora la robustez del código.
Permite manejar errores de forma específica.
Facilita la depuración del código.

Consejos para usar try-catch:

Usa el bloque try solo para el código que podría generar una excepción.
Usa el bloque catch para manejar la excepción de forma específica.
Usa la propiedad Message de la excepción para obtener información sobre el error.
Registra la información sobre la excepción en un archivo de log.

SystemException: Excepciones que se generan por el sistema operativo o el entorno de .NET.
ApplicationException: Excepciones que se generan por la aplicación.

try
{
  // Código que podría generar una excepción
}
catch (Exception ex)
{
  // Manejar la excepción
}

Comentarios (48)48 comentarios

Gabriel Mayorga

Hace 4 años

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

Bryan Vivas

Muy buen aporte amigo

Jhonatan Alejandro Muñoz Serna

Ha este se le puede aplicar el principio KISS :)

Andres Felipe Zuleta Granados

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.

Jaison Mora

Dos errores posible excepciones encontradas adicionales al video son:

Si el usuario ingresa una letra en vez de un número.
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.

Emilio Nicolás Mendoza Patti

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

Carlos Alberto Irias Torres

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

Miguel Angel Reyes Moreno

El método ìsNullOrEmpty ya regresa un booleano y no es necesario poner == true al final.

Queda mejor así:

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

¡Muchas gracias por comentar! Lo de que queda mejor es gusto personal, creo, a mí por ejemplo me gusta leer siempre para lo que se está comparando, se me hace más fácil.

David Elias Gatica Morales

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.

Iván Orlando Ocampo Rivera

Vengo siguiendo la ruta de Backend con C# y .Net propuesta por Platzi, pero veo que acá hay conceptos como el try catch o el sistema de clases, o la programación orientada a objetos en C#, que no se vieron en el curso anterior. Mi pregunta es la siguiente ¿Qué cursos debo tener ya realizados para continuar con esta ruta?

Miguel Teheran

Profesor

Tendremos cursos complementarios en la Ruta, de momento se estan editando para poder enteder muchas de estas cosas. Este curso definitivamente es para alguien que sepa C# y ya tenga experiencia con el lenguaje.

Juan Camilo Cadavid Velásquez

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

            }

        }

Joaquin Grunwald

Hace 2 años

Mi solución al segundo try catch:

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

         if (task.Length < 1) Console.WriteLine("Debe ingresar al menos un caracter");
         else
         {
         TaskList.Add(task);
         Console.WriteLine("Tarea registrada");
         }
     }
     catch (Exception)
     {
         Console.WriteLine("No se pudo agregar la tarea");
     }
 }

Juan Pablo Ruiz

excelente tu solución me dio una guía, gracias.

Victor Hugo Vázquez Gómez

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

Luis Sandoval

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

Brandon Díaz

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);
            }
        }```

Santiago Montero

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

Manuel Cabos

Hace 5 meses

Identifico que el siguiente try catch es innecesario, lo reemplacé por una condicional

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

    if (string.IsNullOrWhiteSpace(task))
    {
        Console.WriteLine("La tarea no puede estar vacía.");
        return;
    }

    TaskList.Add(task);
    Console.WriteLine("Tarea registrada");
}

Yezid Garcia Medina

Hace un año

Es mejor validar con string.IsNullOrWhiteSpace(taskNew) que con string.IsNullOrEmpty(taskNew) , dado que estamos considerando espacios o caracteres vacios.

Gilberto Alejandro Monroy Morales

Aquí mi reto, revisando si ya existe o si no tiene contenido el string.

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

                if (string.IsNullOrWhiteSpace(newTask))
                {
                    Console.WriteLine("No se puede agregar una tarea vacía.");
                    return;
                }

                bool exist = TaskList.Any(t => t.Trim().ToLower() == newTask.ToLower());

                if (exist)
                {
                    Console.WriteLine($"La tarea {newTask} ya existe.");
                }
                else
                {
                    TaskList.Add(newTask); 
                    Console.WriteLine("Tarea registrada");
                }
                
            }
            catch (Exception ex)
            {
                Console.WriteLine("Ha Ocurrido uin error al añadir la tarea.");
            }
        }

Karen Lisbeth Gelvez Lesmes

teniendo en cuanta la clase anterior donde corregimos un error de condicionales, ¿no seria mejor aplicar una solución como esta ? ya que evitamos realizar condicionales que pueden ser innecesarios, por favor me corrigen si estoy equivocado y si hay alguna razón por la que se realiza de la manera como se hizo en el vídeo: int indexToRemove = Convert.ToInt32(ReadTaskDeleted) - 1; if (indexToRemove > -1 && TaskList.Count > 0 && indexToRemove<=(TaskList.Count-1)) { string task = TaskList[indexToRemove]; TaskList.RemoveAt(indexToRemove); Console.WriteLine("Tarea " + task + " eliminada");

            }
            else
            {
                    Console.WriteLine("Debe ingresar un numero correcto para eliminar la tarea");
            }

Hola Karen esta solución es valida pero debes tener en cuenta no mas el escenario en que el usuario puede ingresar algo que no es un numero sino una letra o caracter especial.

Claro es una solución valida, no mas debes tener en cuenta que esto no serviría si el usuario ingresa un carácter especial o una letra. Existen muchas maneras de llegar a lo mismo, lo ideal es simplificar y seguir las mejores practicas no importa cómo se implemente el código.

Brian Molina

Se podría usar un **else if ** para no anidar el **if **dentro del else?

Es una opción muy valida también, al final todo depende del escenario. ingresar un if dentro de un else seria en el escenario donde puedes tener varias condiciones y adicional un código que siempre se ejecuta, haciendolo con else if te tocaría agregar cada escenario repitiendo el código que iría solo una vez en el else. Nuevamente todo dependería del escenario por eso las buenas prácticas no hay un debe ser, todo va depender del escenario.

Carlos Andres Segura Pereira

Se puede decir que es recomendable controlar y manejar todas las posibles excepciones y solo dejar al controlador de excepciones (try-catch) el manejo de errores completamente inesperados?

Correcto, esa seria al conclusion mas acertada

Introducción

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

Prerrequisitos para código limpio en C#

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

Descarga y explora el proyecto base en C#

Principios del código limpio

Buenas prácticas de nombres en C#

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

Principio DRY aplicado en C#

Principio KISS aplicado en C#

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

Mejoras en C# y comentarios

Evolución de C# de la versión 6 al 10

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

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

Progreso del curso

Introducción

Principios del código limpio

Mejoras en C# y comentarios

Cierre

Recursos

Recursos