No tienes acceso a esta clase

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

Nombramiento

5/14
Recursos

Aportes 29

Preguntas 7

Ordenar por:

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

TIP
Si usan Visual Studio pueden usar el comando Ctrl+R+R para renombrar variables, métodos o lo que necesiten en todos los lugares donde se use a la vez

Quiero un curso de patrones de diseño de este señor!!
por favor.

Para buscar y reemplazar al mismo tiempo una palabra en VS Code:
Windows:
Ctrl+D+D
Mac:
CMD+D+D

Nombramientos

Variables*
//Mal:
int d;

//Bien:
int daySinceModification;

Método
//Mal:
public List<Users> getUsers( )

//Bien:
public List<Users> GetActiveUsers( )

Clases
//Mal:
public class ClassUser2

//Bien:
public class User

Algo por notar en los nombramientos de esta clase, es lo importante que una buena ortografía puede aportar a nuestro código.

En Inglés el adjetivo va antes que el sujeto, como en el caso de “MainMenu”, primero va “Main” que quiere decir principal y luego va menú, que es el sujeto. Por lo tanto, si trasladamos lo mismo para los demás métodos como “ShowMenuRemove”, que en este orden de ideas, iria -> “ShowRemoveMenu” y “ShowMenuTaskList” siendo -> “ShowTaskListMenu” se puede notar una gran diferencia.

Para los que usen VS Code si seleccionan la palabra --> click derecho --> RenameSymbol, cambian una sola ves el nombre y listo

El estilo de codificación en C# que seguimos se resume en estos puntos: 1. **Regla general:** Seguir los valores predeterminados de Visual Studio. 2. **Estilo de llaves:** Usar el estilo Allman, donde cada llave comienza en una nueva línea. 3. **Indentación:** Utilizar cuatro espacios para la indentación, evitando el uso de tabulaciones. 4. **Convención de nomenclatura:** Utilizar *camelCase para campos internos y privados, y PascalCasing para campos públicos. Prefijar campos internos y privados con , campos estáticos con s y campos estáticos de subprocesos con t*. 5. **Uso de var:** Solo utilizar var cuando el tipo está explícitamente nombrado en el lado derecho. 6. **Uso de palabras clave del lenguaje:** Preferir palabras clave del lenguaje sobre tipos de la BCL. 7. **Uso de nameof():** Utilizar nameof(...) en lugar de "..." siempre que sea posible y relevante. 8. **Orden de importación de namespaces:** Especificar los importaciones de namespace al principio del archivo, ordenándolos alfabéticamente. 9. **Evitar espacios en blanco innecesarios y líneas vacías.** 10. **Convención de etiquetas y single-statement if.** 11. **Tipos internos y privados:** Hacerlos estáticos o sellados a menos que la derivación de ellos sea necesaria. 12. **EditorConfig y herramientas de formato:** Utilizar un archivo .editorconfig para el formato automático y la herramienta .NET Codeformatter para mantener un estilo consistente. Este resumen captura las principales directrices para mantener un estilo coherente en el código C# y proporciona un ejemplo de archivo siguiendo estas pautas. Este código ejemplifica algunas prácticas: * Uso de \_camelCase para campos internos y privados (\_exampleField). * Uso de PascalCasing para campos públicos (ExampleProperty). * Prefijo de campos internos y privados con \_ y campos estáticos con s\_ (s\_exampleStaticField). * Uso de var cuando el tipo está explícitamente nombrado en el lado derecho (var localVar = 10;). * Uso de palabras clave del lenguaje (public, private, static, readonly). * Uso de nameof() en lugar de "..." (nameof(items)). * Orden de importación de namespaces (using System;). * Evitar espacios en blanco innecesarios y líneas vacías. * Convención de etiquetas y single-statement if. * Tipos internos y privados (ExampleClass, ExampleMethod). * Utilización de EditorConfig y herramientas de formato. * ```js using System; namespace ExampleNamespace { public class ExampleClass { private int _exampleField; private static string s_exampleStaticField; private static readonly int s_exampleStaticReadonlyField = 42; private readonly int _exampleReadonlyField; public int ExampleProperty { get; set; } public ExampleClass(int value) { _exampleField = value; _exampleReadonlyField = value * 2; } public void ExampleMethod() { var localVar = 10; Console.WriteLine(localVar); } public static void StaticMethod() { Console.WriteLine("Static method"); } } } ```
**Nombramiento**  El nombre de las **variables** debe ser lo más descriptivo posible, indica que se está guardando o cuál es su propósito. Se debe usar camelCase.   int daySinceModification;    Para los **métodos** y **clases** el nombre debe ser lo más descriptivo posible, se debe usar PascalCase.  public List\<users> GetActiviteUsers()  public class User

En cursos pasados y recomendacion de un docente de la facultad, las variables deberian ser nombradas usando camelCase y las funciones deben ir con PascalCase

Con Ctrl + H te sale esta pequeña barra en la que puedes escribir lo que quieres camiar por el que

1. **Usa nombres descriptivos:** En lugar de usar `x` o `temp`, utiliza nombres como `contador` o `nombreUsuario`. 2. **Sigue la convención CamelCase para variables y parámetros:** `nombreUsuario`, `saldoCuenta`, `fechaNacimiento`. 3. **Sigue la convención PascalCase para métodos, clases y propiedades:** `CalcularTotal`, `ObtenerNombreCompleto`, `ValidarEntradaUsuario`**;** `Cliente`, `Factura`, `ControladorDeAutenticación`. 4. **Sigue la convención SreamingSnakeCase para constantes:** `PI`, `TASA_DE_INTERÉS`, `LIMITE_MAXIMO`. 5. **Evita palabras reservadas:** No utilices palabras reservadas de C# como nombres de variables, ya que esto causaría conflictos y errores en tu código. 6. **Usa nombres concisos pero descriptivos:** Un nombre de variable debe ser lo suficientemente corto como para no ser engorroso, pero lo suficientemente largo como para transmitir su propósito. Por ejemplo, en lugar de `cnt`, es preferible `contador`. 7. **No uses abreviaturas excesivas:** Aunque las abreviaturas pueden acortar nombres de variables, pueden hacer que el código sea menos legible. Utiliza abreviaturas solo si son ampliamente reconocidas y comprensibles, como `str` para "cadena" o `ID` para "identificador". 8. **Sé consistente:** Mantén la consistencia en la nomenclatura de tus variables a lo largo de tu código. Si decides usar CamelCase, úsalo de manera coherente en todo el proyecto. 9. **Utiliza nombres de variables significativos en bucles:** Cuando declares variables de iteración en bucles, utiliza nombres significativos como `i` o `j` para bucles simples, y `indice` o `contador` para bucles más complejos.

Así va por ahora

using System;
using System.Collections.Generic;

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

        static void Main(string[] args)
        {
            TaskList = new List<string>();
            int menuOption = 0;
            do
            {
                menuOption = ShowMainMenu();
                if (menuOption == 1)
                {
                    AddTask();
                }
                else if (menuOption == 2)
                {
                    RemoveTask();
                }
                else if (menuOption == 3)
                {
                    ShowTaskList();
                }
            } while (menuOption != 4);
        }
        /// <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
                for (int i = 0; i < TaskList.Count; i++)
                {
                    Console.WriteLine((i + 1) + ". " + TaskList[i]);
                }
                Console.WriteLine("----------------------------------------");

                string taskIndex = Console.ReadLine();
                // Remove one position
                int indexToRemove = Convert.ToInt32(taskIndex) - 1;
                if (indexToRemove > -1)
                {
                    if (TaskList.Count > 0)
                    {
                        string taskToRemove = TaskList[indexToRemove];
                        TaskList.RemoveAt(indexToRemove);
                        Console.WriteLine("Tarea " + taskToRemove + " eliminada");
                    }
                }
            }
            catch (Exception)
            {
            }
        }

        public static void AddTask()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string taskToAdd = Console.ReadLine();
                TaskList.Add(taskToAdd);
                Console.WriteLine("Tarea registrada");
            }
            catch (Exception)
            {
            }
        }

        public static void ShowTaskList()
        {
            if (TaskList == null || TaskList.Count == 0)
            {
                Console.WriteLine("No hay tareas por realizar");
            } 
            else
            {
                Console.WriteLine("----------------------------------------");
                for (int i = 0; i < TaskList.Count; i++)
                {
                    Console.WriteLine((i + 1) + ". " + TaskList[i]);
                }
                Console.WriteLine("----------------------------------------");
            }
        }
    }
}

Hay IDEs que te muestran que problemas tienes en tu codigo variables o metodos que no se usan, valores que innecesarios o palabras mal escritas

eso del nombramiento de los metodos usando Pascal Case solo se usa con C# o tbm se usa con otro lenguajes ??
Con F2 en vs code desde Windows pueden hacer el cambio de nombre en todos los lugares
![](https://static.platzi.com/media/user_upload/image-dfec1afb-520f-499a-87d0-6b952347f68c.jpg)
### Resumen de convenciones: ElementoEstiloEjemploClases/TiposPascalCase`CustomerAccount`MétodosPascalCase`CalculateInvoice`PropiedadesPascalCase`OrderId`Variables localescamelCase`currentIndex`Campos privados\_camelCase`_counter`ConstantesPascalCase`Pi`EnumeracionesPascalCase`OrderStatus`ParámetroscamelCase`customerId`Espacios de nombresPascalCase`MyCompany.ProjectName`InterfacesPascalCase, I-prefix`ICustomerRepository` Seguir estas pautas no solo mejora la consistencia en el código, sino que facilita la colaboración y el mantenimiento a largo plazo.
Utilizando la combinación de teclas de control + h se puede reemplazar el texto en todo el documento
![](https://static.platzi.com/media/user_upload/image-112f45c9-d140-4459-9adc-142f32152ef6.jpg) pueden realizar un Replace dentro de su código con VS Code he ira remplazado cada ocurrencia de TL a TaskList
`using System;` `using System.Collections.Generic;` `namespace ToDo` `{` ` internal class Program` ` {` ` public static List<string> TaskList { get; set; }` ` static void Main(string[] args)` ` {` ` TaskList = new List<string>();` ` int selectedOption = 0;` ` do` ` {` ` selectedOption = MainMenu();` ` if (selectedOption == 1)` ` {` ` NewTask();` ` }` ` else if (selectedOption == 2)` ` {` ` RemoveTask();` ` }` ` else if (selectedOption == 3)` ` {` ` PendingTask();` ` }` ` } while (selectedOption != 4);` ` }` ` /// <summary>` ` /// Show the main menu ` ` /// </summary>` ` /// <returns>Returns option indicated by user</returns>` ` public static int MainMenu()` ` {` ` 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 line` ` string option = Console.ReadLine();` ` return Convert.ToInt32(option);` ` }` ` public static void NewTask()` ` {` ` try` ` {` ` Console.WriteLine("Ingrese el nombre de la tarea: ");` ` string task = Console.ReadLine();` ` TaskList.Add(task);` ` Console.WriteLine("Tarea registrada");` ` }` ` catch (Exception)` ` {` ` }` ` }` ` public static void RemoveTask()` ` {` ` try` ` {` ` Console.WriteLine("Ingrese el número de la tarea a remover: ");` ` // Show current taks` ` for (int i = 0; i < TaskList.Count; i++)` ` {` ` Console.WriteLine((i + 1) + ". " + TaskList[i]);` ` }` ` Console.WriteLine("----------------------------------------");` ` string taskNumber = Console.ReadLine();` ` // Remove one position` ` int taskToRemove = Convert.ToInt32(taskNumber) - 1;` ` if (taskToRemove > -1)` ` {` ` if (TaskList.Count > 0)` ` {` ` string task = TaskList[taskToRemove];` ` TaskList.RemoveAt(taskToRemove);` ` Console.WriteLine("Tarea " + task + " eliminada");` ` }` ` }` ` }` ` catch (Exception)` ` {` ` }` ` }` ` public static void PendingTask()` ` {` ` if (TaskList == null || TaskList.Count == 0)` ` {` ` Console.WriteLine("No hay tareas por realizar");` ` } ` ` else` ` {` ` Console.WriteLine("----------------------------------------");` ` for (int i = 0; i < TaskList.Count; i++)` ` {` ` Console.WriteLine((i + 1) + ". " + TaskList[i]);` ` }` ` Console.WriteLine("----------------------------------------");` ` }` ` }` ` }` `}` Codigo con mis correcciones en los nombres
* **Ctrl + Shift + U:** Comentar/Descomentar selección. * **Ctrl + K + C:** Comentar bloque de código. * **Ctrl + K + D:** Formatear código. * **Ctrl + D:** Duplicar línea. * **Ctrl + Shift + E:** Eliminar línea. * **Ctrl + Shift + F:** Buscar en archivos. * **Ctrl + Shift + H:** Reemplazar en archivos. * **Ctrl + /:** Comentar/Descomentar línea.
Hi Everyone!😃 I share my task done: ```js internal class Program { public static List<string> TaskList { get; set; } static void Main(string[] args) { TaskList = new List<string>(); int menuSelected = 0; do { menuSelected = ShowMainMenu(); if (menuSelected == 1) { ShowMenuAdd(); } else if (menuSelected == 2) { ShowMenuRemove(); } else if (menuSelected == 3) { ShowMenuTaskList(); } } while (menuSelected != 4); } /// <summary> /// Show the main menu /// </summary> /// <returns>Returns option 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 line string chosenOption = Console.ReadLine(); return Convert.ToInt32(chosenOption); } public static void ShowMenuRemove() { try { Console.WriteLine("Ingrese el número de la tarea a remover: "); // Show current taks for (int i = 0; i < TaskList.Count; i++) { Console.WriteLine((i + 1) + ". " + TaskList[i]); } Console.WriteLine("----------------------------------------"); string chosenOption = Console.ReadLine(); // Remove one position int indexToRemove = Convert.ToInt32(chosenOption) - 1; if (indexToRemove > -1) { if (TaskList.Count > 0) { string task = TaskList[indexToRemove]; TaskList.RemoveAt(indexToRemove); Console.WriteLine("Tarea " + task + " eliminada"); } } } catch (Exception) { } } public static void ShowMenuAdd() { try { Console.WriteLine("Ingrese el nombre de la tarea: "); string newTask = Console.ReadLine(); TaskList.Add(newTask); Console.WriteLine("Tarea registrada"); } catch (Exception) { } } public static void ShowMenuTaskList() { if (TaskList == null || TaskList.Count == 0) { Console.WriteLine("No hay tareas por realizar"); } else { Console.WriteLine("----------------------------------------"); for (int i = 0; i < TaskList.Count; i++) { Console.WriteLine((i + 1) + ". " + TaskList[i]); } Console.WriteLine("----------------------------------------"); } } } ```And remember... Never stop learning!💚
se puede usar el comando ctrl + r X2 para remplazar el nombre anivel globa de la apliación o click derecho cambiar nombre

Reto de Nombramiento:

using System;
using System.Collections.Generic;

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

        static void Main(string[] args)
        {
            TaskList = new List<string>();
            int menuSelected = 0;
            do
            {
                menuSelected = ShowMainMenu();
                if (menuSelected == 1)
                {
                    ShowMenuAdd();
                }
                else if (menuSelected == 2)
                {
                    ShowMenuRemove();
                }
                else if (menuSelected == 3)
                {
                    ShowMenuTaskList();
                }
            } while (menuSelected != 4);
        }
        /// <summary>
        /// Show the main menu 
        /// </summary>
        /// <returns>Returns option 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 line
            string inputOptionUser = Console.ReadLine();
            return Convert.ToInt32(inputOptionUser);
        }

        public static void ShowMenuRemove()
        {
            try
            {
                Console.WriteLine("Ingrese el número de la tarea a remover: ");
                // Show current taks
                for (int i = 0; i < TaskList.Count; i++)
                {
                    Console.WriteLine((i + 1) + ". " + TaskList[i]);
                }
                Console.WriteLine("----------------------------------------");

                string inputTaskToRemove = Console.ReadLine();
                // Remove one position
                int indexTaskToRemove = Convert.ToInt32(inputTaskToRemove) - 1;
                if (indexTaskToRemove > -1)
                {
                    if (TaskList.Count > 0)
                    {
                        string taskSelectedToRemove = TaskList[indexTaskToRemove];
                        TaskList.RemoveAt(indexTaskToRemove);
                        Console.WriteLine("Tarea " + taskSelectedToRemove + " eliminada");
                    }
                }
            }
            catch (Exception)
            {
            }
        }

        public static void ShowMenuAdd()
        {
            try
            {
                Console.WriteLine("Ingrese el nombre de la tarea: ");
                string inputNewTask = Console.ReadLine();
                TaskList.Add(inputNewTask);
                Console.WriteLine("Tarea registrada");
            }
            catch (Exception)
            {
            }
        }

        public static void ShowMenuTaskList()
        {
            if (TaskList == null || TaskList.Count == 0)
            {
                Console.WriteLine("No hay tareas por realizar");
            } 
            else
            {
                Console.WriteLine("----------------------------------------");
                for (int i = 0; i < TaskList.Count; i++)
                {
                    Console.WriteLine((i + 1) + ". " + TaskList[i]);
                }
                Console.WriteLine("----------------------------------------");
            }
        }
    }
}

Martin Fowler recomienda en su libro refactoring para refactorizar se debe contar con un bateria de pruebas para asegurar la integridad del software

Excelente clase y excelente reto.

No utilizar numeros en metodos y clases

Notacion Hungara