No tienes acceso a esta clase

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

Aplicando el Principio KISS en Programación C#

8/14
Recursos

¿Qué es el principio KISS y cómo aplicarlo?

El principio KISS, conocido por "Keep It Simple, Stupid", es una guía esencial en el desarrollo de software. Establece que el código debe mantenerse lo más simple posible, evitando la sobre arquitectura y la complejidad innecesaria. Esto significa que, al desarrollar una aplicación, deberíamos buscar soluciones sencillas para problemas simples, y únicamente recurrir a métodos más complejos cuando la naturaleza del problema lo justifique.

¿Cómo se manifiesta el principio KISS en un proyecto de C#?

Al aplicar el principio KISS en un proyecto de C#, se busca minimizar el código redundante y evitar estructuras complicadas. Un ejemplo típico es la eliminación de ifs anidados, donde un desarrollador puede combinar condiciones para simplificar el código. Esta práctica no sólo mejora la legibilidad del código, sino que también facilita su mantenimiento a largo plazo.

Código simplificado: Un ejemplo práctico

Supongamos que tienes un código que incluye un if anidado. La forma simplificada utilizando el principio KISS puede verse así:

// Código original
if (condicion1) {
    if (condicion2) {
        // Acción a realizar
    }
}

// Código simplificado
if (condicion1 && condicion2) {
    // Acción a realizar
}

Al combinar las condiciones, eliminamos un bloque if innecesario, haciendo el código más limpio y fácil de entender.

¿Cómo utilizar .NET y Link para simplificar aún más?

Al trabajar con colecciones en .NET, el uso de la biblioteca Link permite aplicar una lógica más compacta y elegante para manipular datos. Un uso adecuado de forEach en lugar de un ciclo for tradicional puede hacer maravillas en términos de simplificación del código.

// Uso del ciclo for tradicional
for (int i = 0; i < listaTareas.Count; i++) {
    Console.WriteLine(listaTareas[i]);
}

// Uso de forEach con una función lambda
listaTareas.ForEach(tarea => Console.WriteLine(tarea));

Este cambio no sólo reduce la cantidad de líneas de código, sino que también mejora la legibilidad al someter el recorrido de la colección a un único método.

Ajustando índices durante la enumeración

En ciertos casos, cuando se necesita mantener un índice a lo largo de un forEach, se puede implementar una variable adicional que ayude en el manejo de los índices:

int indexTask = 1;
listaTareas.ForEach(tarea => Console.WriteLine($"{indexTask++}. {tarea}"));

Este enfoque permite mantener el orden y apariencia del listado de tareas, mientras que el código se mantiene limpio y fácil de seguir.

¿Por qué es importante aplicar el principio KISS?

Mantener el código simple tiene numerosos beneficios, entre ellos:

  1. Mantenibilidad: Un código simple es más fácil de mantener, corregir y actualizar.
  2. Legibilidad: Facilita la comprensión, tanto para ti como para los futuros desarrolladores que trabajen con tu código.
  3. Eficiencia: Evita el uso innecesario de recursos del sistema, optimizando el rendimiento general de la aplicación.
  4. Escalabilidad: Facilita realizar cambios y mejoras sin tener que enfrentar una arquitectura complicada desde el principio.

En conclusión, aplicar este principio no solo mejora la calidad de tu código, sino que también contribuye a un desarrollo más ágil y eficiente. ¡Atrévete a simplificar y verás los increíbles resultados que puedes conseguir!

Aportes 22

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).

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.

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

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

“No 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: “vamos, dilo, dilooo”

Tasks.ForEach((task) =>
 {
	Console.WriteLine($"{Tasks.IndexOf(task) + 1} .  {task}");
});

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.
 private static void ShowMenuOptions()
        {
            TaskList.ForEach(p => Console.WriteLine(p.IndexOf(p) + 1 + ". " + p));
            Console.WriteLine("----------------------------------------");
        }
## 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.**
como comentario , cuando creas un lambda el P es el nombre de la variable, si somos consistentes con los estandares de variables para que sea legible seria mejor dejarlo asi :`TaskList.ForEach(task => Console.WriteLine($"{(++indexTask)}.{task}"));`
Este principio puedes aplicarlo , cuando te sientes muy orgulloso del codigo, query que hiciste porque es muy complejo y funciono, ahi te debes preguntar si este principio si lo tuviste en cuenta
Para poder reforzar aun mas el principio de buenas practicas de NOMBRAMIENTO, podemos mejorar la variable p que se usa en el ForEach `TaskList.ForEach(Task => Console.WriteLine(IndexTask++) + ". " } Task)`
Otra mejora que pude hacer es en la asignación de la posición de la lista: `if (indexToRemove > -1 && ListOfTask.Count > 0)` ` {` ` ListOfTask.RemoveAt(indexToRemove);` ` Console.WriteLine("Tarea " + ListOfTask[indexToRemove] + " eliminada");` ` }`
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
    }
}

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

En este ejemplo no estamos usando LinQ