No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Principio KISS

8/14
Recursos

Aportes 18

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

**KISS **

  • Keep It Simple Stupid
  • Keep It Short and Simple(forma elegante).

Utilizar en el ForEach para recorrer el TaskList; se esta usando una variable de nombre p; pero esto se podria mejorar su nombramiento como task

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

KISS

KISS: es un acr贸nimo de Keep It Simple Stupid o Keep It Short and Simple y a rasgos generales se puede traducir como Mantenlo simple!.

Este principio establece que la mayor铆a de sistemas funcionan mejor si se mantienen simples o sencillos a diferencia de aquellos que se hacen complejos de manera innecesaria. Es decir, que desde el incio del proyecto la sencillez tiene que ser una meta en el desarrollo y que la complejidad innecesaria debe ser eliminada cada vez que sea detectada. Muchas veces esta complejidad ocurre cuando se dise帽an grandes soluciones para objetivos simples.

Tratemos de utilizar la mejor soluci贸n dependiendo de la complejidad de lo que estemos trabajando. Cuando algo es muy complejo o muy grande, es recomendable buscar soluciones m谩s complejas o avanzadas que se ajusten, pero si algo es m谩s simple, peque帽o o sencillo, lo ideal es darle una soluci贸n acorde a sus caracter铆sticas.

Es bueno tener presente que:

Si ya no comprendes tu propio c贸digo despu茅s de un breve per铆odo de tiempo, las campanas de alarma deber铆an sonar. Porque cuanto m谩s complicado es o se presenta, m谩s dif铆cil es para todos los involucrados trabajar con 茅l.

Algunos ejemplos de complejidad innecesaria son:

  • Incluir bibliotecas enormes en el proyecto cuando solo se necesitan un par de funciones de ellas.
  • Abstracci贸n excesiva en el c贸digo.
  • Funciones que resultan enormes por por la l贸gica que contienen.
  • Anidaci贸n de condicionales que solo cumplen una funci贸n.

No estoy completamente de acuerdo con la refactorizaci贸n del for. A煤n as铆 me parece mucho mejor que como estaba.

La raz贸n es que no me da buena espina el c贸digo imperativo como el operador ++ o la funci贸n WriteLine dentro de una funci贸n anonima que es usada dentro de otra funci贸n. Esto porque rompe con el esquema de las funciones puras.

Sin embargo creo es una especie de code smell personal, no tiene que ser necesariamente siempre as铆, siempre hay que juzgar por la situaci贸n.

Yo con tal de evitar mezclar funcional e imperativo llegu茅 a esto:

foreach (var (task, i) in taskList.WithIndex())
{
    Console.WriteLine($"{i + 1}. {task}");
}

Y claro, primero es m谩s largo, y segundo tuve que poner m谩s abajo otro pedazo de c贸digo que encontr茅 en internet para definir WithIndex, por lo que no necesariamente mi soluci贸n es mejor pero quer铆a compartir esto por si a alguien le parece interesante y encuentra m谩s del tema.

Esa frase es po茅tica

鈥淣o debemos usar una bazuka para matar una mosca鈥 que excelente.

Elimin茅 los Console.WriteLine por un forEach

 List<string> MenuOptionsList=new List<string>{"----------------------------------------","Ingrese la opci贸n a realizar:","1. Nueva tarea","2. Remover tarea","3. Tareas pendientes","4. Salir"};
            MenuOptionsList.ForEach(menuOption=>Console.WriteLine(menuOption));

yo al empezar la clase: 鈥渧amos, dilo, dilooo鈥

todo esta perfecto en el curso, pero creo que fue una mala idea no haberlo hecho en visual studio, por que las personas que llegan a este curso normalmente estan usando IDE para programar, la mayoria que podemos pagar la plataforma tenemos una computadora que sin problema corre visual studio exagero de mas profe, pero pues ya que a darle

Recordar que no siempre es viable cambiar el for a foreach, puesto que al hacer este cambio, perdemos la informaci贸n del indice (en el video nos muestran c贸mo recuperarla, pero justamente eso es lo que hace el for). Recomiendo tener en cuenta en qu茅 momentos usar el uno o el otro, porque en el caso de desarrollar un videojuego en Unity, y necesitar listar el ranking de jugadores, es mucho menos engorroso usar el for. Linq permite tener un performance m谩s optimo a la hora de ejecutar el c贸digo cuando las listas son inmensamente grandes; por ende es otro factor clave que nos puede poner en duda si elegir el uno o el otro, pero siempre tener en cuenta que cada proyecto puede tener unas caracter铆sticas espec铆ficas de reescalabilidad y que por esta razon pueda diferir mucho cu谩l sea la mejor opci贸n.
## Principio KISS: Mantenlo simple **驴Qu茅 es?** KISS es un principio de dise帽o que busca **priorizar la simplicidad** en el desarrollo de software. Se basa en la idea de que un sistema o c贸digo es m谩s efectivo si se mantiene **simple y f谩cil de entender**. **驴Por qu茅 es importante?** La complejidad innecesaria puede generar problemas como: * **Dificultad de mantenimiento:** Dificultad para comprender y modificar el c贸digo. * **Errores:** Mayor probabilidad de errores debido a la complejidad del c贸digo. * **Dificultad de aprendizaje:** Dificultad para aprender a usar el sistema o c贸digo. **驴C贸mo aplicar el principio KISS?** * **Eliminar la complejidad innecesaria.** * **Utilizar un lenguaje claro y conciso.** * **Dividir las tareas complejas en tareas m谩s peque帽as y manejables.** **Ejemplos de aplicaci贸n en C#:** * **Utilizar nombres descriptivos para variables y m茅todos.** * **Evitar la anidaci贸n excesiva de condicionales.** * **Documentar el c贸digo de forma clara y concisa.**
Tasks.ForEach((task) =>
 {
	Console.WriteLine($"{Tasks.IndexOf(task) + 1} .  {task}");
});
Hi everyone! I share a fragment of the code where I also apply the principle: ```js //Before applying the principle string taskNumberToDelete = Console.ReadLine(); int indexToRemove = Convert.ToInt32(taskNumberToDelete) - 1; //After int indexToRemove = Convert.ToInt32(Console.ReadLine()) - 1; ```pply the principle:
Hi everyone! I share a fragment of the code where I also apply the principle: Before applying the principle ```js string taskNumberToDelete = Console.ReadLine(); int indexToRemove = Convert.ToInt32(Console.ReadLine()) - 1; ```After ```js int indexToRemove = Convert.ToInt32(Console.ReadLine()) - 1; ```I also share my repository where you will find the summary of this course: <https://github.com/mathiascabrera/good_practices_and_clean_code_in_csharp.git> Thanks! Never stop learning!馃挌

Es bueno aprender desde cero

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("----------------------------------------");
            //Mejorar en una linea de codigo para compilar un codigo
            var taskIndex = 1;
            GetTaskList().ForEach(task => Console.WriteLine(taskIndex++ + ". " + task));
            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()
        {
            List<string> MenuOptionsList = new List<string> { "----------------------------------------", "Ingrese la opci贸n a realizar:", "1. Nueva tarea", "2. Remover tarea", "3. Tareas pendientes", "4. Salir", "----------------------------------------" };
            MenuOptionsList.ForEach(menuOption => Console.WriteLine(menuOption));
            string taskIndex = Console.ReadLine();
            Console.WriteLine("----------------------------------------");
            return Convert.ToInt32(taskIndex);

        }

        public static void ShowMenuRemove()
        {
            try
            {
                Console.WriteLine("Ingrese el n煤mero de la tarea a remover: ");
                //Llamo a la funcion de la lista
                ShowTaskList();
                string taskIndex = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(taskIndex) - 1;
                if (indexToRemove > -1 && 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
    }
}

 private static void ShowMenuOptions()
        {
            TaskList.ForEach(p => Console.WriteLine(p.IndexOf(p) + 1 + ". " + p));
            Console.WriteLine("----------------------------------------");
        }

Sobre Arquitectura: es cuando dise帽amos nuestra aplicacion demasiado compleja para algo que es demasiado simple

En este ejemplo no estamos usando LinQ