No tienes acceso a esta clase

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

Interpolación de cadenas en C# paso a paso

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:

  1. Utiliza comillas dobles con un símbolo de dólar: Al inicio de la cadena, agrega el símbolo $ antes de las comillas dobles.
  2. 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!

Aportes 12

Preguntas 1

Ordenar por:

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

Fan de C# , pero tambien puedo tener amigos como vuejs, react !

Se puede mejorar la legibilidad renombrando ‘p’ por task.

Cada vez c# es mas sencillo de utilizarlo, que estupendo!

Que buena clase, había vuelto a ver los fundamentos de C# porque había notado cosas como estas que antes no estaban

Me encanta C#, cada vez es mas y mas sencillo usarlo, sin dejar de ser robusto.

Estaría buenísimo combinar este curso con TDD para automatizar las pruebas de código.

Hay otro patrón que retorno temprano, y es si no se cumple la validación del dato, hacer el return en vez de hacer el else
En el momento en que hago este curso, C# se siente muy similar a Typescript de alguna forma.

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

Interpolacion de cadenas

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

Buen día reto realizado.

me parece que: if (TaskList?) está preguntando "si no es null" y de ser V entra al if....en vez de preguntar "si es null"