Interpolación de cadenas y mejoras en C-Sharp

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:007:26

Interpolación de cadenas y mejoras en C-Sharp

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

Clase 11 de 14

Clase 11 / 14

Recursos

¿Cómo aplicar la interpolación de cadenas en C#?

En la programación con C#, la interpolación de cadenas es una técnica poderosa que facilita la creación de cadenas de texto más legibles y fáciles de mantener. En lugar de utilizar numerosas concatenaciones con el símbolo '+', se puede aplicar esta técnica donde se combinen texto con variables o funciones. A continuación, te explico cómo implementarla en un ejemplo práctico:

Supongamos que tienes un código que se ve algo así:

foreach (var item in items)
{
    Console.WriteLine(index + ". " + item);
}

Para convertirlo utilizando interpolación de cadenas, sigue estos pasos:

Utiliza comillas dobles con un símbolo de dólar: Al inicio de la cadena, agrega el símbolo $ antes de las comillas dobles.
Reemplaza variables y expresiones: Dentro de la cadena, sustituye las partes variables o expresiones usando {}.

Así, el código quedaría de la siguiente manera:

foreach (var item in items)
{
    Console.WriteLine($"{index}. {item}");
}

Con esto, no solo haces el código más compacto, sino que también mejora la legibilidad al eliminar la necesidad de múltiples concatenaciones.

¿Cómo inicializar correctamente una lista para evitar valores nulos?

Inicializar listas u otras colecciones en C# es crucial para evitar errores de referencia a valores nulos. Especialmente cuando manejas propiedades que deberían almacenar varias entradas, como una lista de tareas (taskList), es fundamental inicializarlas correctamente en el método Main o en el constructor de tu clase.

Si bien podrías hacerlo de esta manera:

taskList = new List<Task>();

Existe una mejora en C# que permite realizar esta inicialización de forma más concisa. Puedes hacerlo directamente al declarar la propiedad, lo que puede ahorrar líneas de código y evitar futuras complicaciones:

public List<Task> taskList { get; set; } = new List<Task>();

Al tomar esta ruta, te aseguras de que taskList siempre esté lista para almacenar elementos sin temor a errores de ejecución relacionados con valores nulos.

¿Qué es el operador null en C# y cuándo utilizarlo?

El operador null, también conocido como operador de coalescencia nula (??), es otra mejora significativa en C#. Este operador es útil cuando quieres manejar situaciones donde una variable puede ser nula y deseas proporcionar un valor predeterminado.

Por ejemplo, considera un escenario donde tienes una variable que podría ser nula y necesitas manejar ese caso:

string message = userProvidedMessage ?? "Valor predeterminado";

En este caso, si userProvidedMessage es nulo, la variable message tomará el valor "Valor predeterminado". Esta técnica no solo es elegante sino también efectiva para garantizar que tu aplicación maneje correctamente los valores nulos sin necesidad de múltiples verificaciones o estructuras condicionales.

Estas prácticas no solo te ayudarán a escribir código más limpio y eficiente, sino que además te permitirán ser más productivo y reducir errores comunes en la programación con C#. Continúa explorando estas y otras características de C# para seguir mejorando tus habilidades como desarrollador. ¡La práctica constante te llevará lejos!

Miguel Angel Reyes Moreno

Hace 3 años

Código actualizado:

using System;
using System.Collections.Generic;

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

        static void Main(string[] args)
        {
            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.");
            }
        }

        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?.Count > 0)
            {
                ListTasks();
            } 
            else
            {
                Console.WriteLine("No hay tareas por realizar");
            }
        }

        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
    }
}

Comentarios (13)13 comentarios

Hans González

Hace 4 años

Carlos Gomez

Leoneider Trigos Guerrero

Victor Apolinares

Hace 2 años

Santiago Montero

Alexis Duque

Gaston Rodrigo Farru

Miguel Teheran

Profesor

Andres Madrid

Christian Guzmán

Jaime Eduardo Falla Cardozo

Alejandra Suárez

Emilio Nicolás Mendoza Patti

Miguel Andres Rendon Reyes

Manuel Rincon

ROMMEL DUAREZ SAENZ

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

Interpolación de cadenas y mejoras en C-Sharp

Progreso del curso

Introducción

Principios del código limpio

Mejoras en C# y comentarios

Cierre

Recursos

Recursos