elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (C#, VB.NET, ASP) (Moderador: kub0x)
| | | |-+  Menús y submenús en consola C#
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Menús y submenús en consola C#  (Leído 1,163 veces)
Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Menús y submenús en consola C#
« en: 28 Febrero 2020, 18:02 »

Hola:

Haciendo menús y submenús con la consola de C# 2019.

La verdad que he cometido fallos y no se si es posible resolverlo, al menos no se hacerlo. Todo de momento está hecho en un único archivo en Visual Studioi 2019.

He hecho un esquema boceto para que se entienda.


Ver zoom.

Se ha hecho un esquema de todas las opciones para tener una vista rápida y una posible facilidad de compresión.

Si nada más ejecutar el programa o aplicación, pulso Enter, muestra las opciones aue son A, B y C, señalo Salir, pulso Enter vuelve al reloj, como debe ser, así susecibamente. Hasta ahí todo bien.

El problema es cuando estoy en la opción indicada aquí.

Lo único que me falla, si voy a la opción C-1, le doy salir, al llegar a la opción principal que pone:

Citar
  Opción A.  
   Opción B.
 > Opción C.


Se me pone la flecha marcadore de opciónes siempre en Opción A, no se me guarda en la última opción seleccionada. Debo corregir esto, ya sería con una variable para memorizarlo.

Dejo el código hehco hasta el momento.

Código C#:
Código
  1. using System;
  2.  
  3. namespace Menu_consola_18_cs
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            Console.Title = "Menú de opciones";
  10.  
  11.            // Tamaño ventana consola.
  12.            // X anchura.
  13.            Console.WindowWidth = 20;
  14.  
  15.            // Y altura.
  16.            Console.WindowHeight = 5;
  17.  
  18.            // Oculto el cursor.
  19.            Console.CursorVisible = false;
  20.  
  21.            // Fondo verde.
  22.            Console.BackgroundColor = ConsoleColor.Green;
  23.  
  24.            // Letras negras.
  25.            Console.ForegroundColor = ConsoleColor.Black;
  26.  
  27.            MenuPrincipal();
  28.        }
  29.  
  30.        #region Menú principal.
  31.        public static void MenuPrincipal()
  32.        {
  33.            // Almacena la tecla pulsada en la variable.
  34.            ConsoleKey teclaInicial;
  35.  
  36.            // Limpiar pantalla.
  37.            Console.Clear();
  38.  
  39.            // Posición del cursor del título del MENÚ PRINCIPAL.
  40.            Console.SetCursorPosition(0, 0);
  41.  
  42.            // Título.
  43.            Console.Write("   MENÚ PRINCIPAL   ");
  44.  
  45.            // Pocisión de la hora.
  46.            Console.SetCursorPosition(4, 2);
  47.  
  48.            // Formato numérico dd/MM/yyyy.
  49.            Console.Write(DateTime.Now.ToString("ddd dd MMM"));
  50.  
  51.            // Almacena en la variable una tecla pulsada.
  52.            teclaInicial = Console.ReadKey(true).Key;
  53.  
  54.            // ¿Haz pulsado la tecla Enter?
  55.            if (teclaInicial == ConsoleKey.Enter)
  56.            {
  57.                // Sí. Se ejecuta esta función.
  58.                MenuOpciones();
  59.            }
  60.        }
  61.        #endregion
  62.  
  63.        #region Menú de opciones principales.
  64.        public static void MenuOpciones()
  65.        {
  66.            // Contador de teclas y navegador.
  67.            int opcion = 0;
  68.  
  69.            // Capturar tecla para luego validar.
  70.            ConsoleKey tecla;
  71.  
  72.            while (true)
  73.            {
  74.                //******************************************************************
  75.                // Dibujo el menú principal.
  76.  
  77.                // Limpiar pantalla.
  78.                Console.Clear();
  79.  
  80.                switch (opcion)
  81.                {
  82.                    case 0:
  83.                        Console.SetCursorPosition(0, 0);
  84.                        Console.Write("> Opción A.         ");
  85.                        Console.SetCursorPosition(0, 1);
  86.                        Console.Write("  Opción B.         ");
  87.                        Console.SetCursorPosition(0, 2);
  88.                        Console.Write("  Opción C.         ");
  89.                        Console.SetCursorPosition(0, 3);
  90.                        Console.Write("  Salir.            ");
  91.                        break;
  92.                    case 1:
  93.                        Console.SetCursorPosition(0, 0);
  94.                        Console.Write("  Opción A.         ");
  95.                        Console.SetCursorPosition(0, 1);
  96.                        Console.Write("> Opción B.         ");
  97.                        Console.SetCursorPosition(0, 2);
  98.                        Console.Write("  Opción C.         ");
  99.                        Console.SetCursorPosition(0, 3);
  100.                        Console.Write("  Salir.            ");
  101.                        break;
  102.                    case 2:
  103.                        Console.SetCursorPosition(0, 0);
  104.                        Console.Write("  Opción A.         ");
  105.                        Console.SetCursorPosition(0, 1);
  106.                        Console.Write("  Opción B.         ");
  107.                        Console.SetCursorPosition(0, 2);
  108.                        Console.Write("> Opción C.         ");
  109.                        Console.SetCursorPosition(0, 3);
  110.                        Console.Write("  Salir.            ");
  111.                        break;
  112.                    case 3:
  113.                        Console.SetCursorPosition(0, 0);
  114.                        Console.Write("  Opción A.         ");
  115.                        Console.SetCursorPosition(0, 1);
  116.                        Console.Write("  Opción B.         ");
  117.                        Console.SetCursorPosition(0, 2);
  118.                        Console.Write("  Opción C.         ");
  119.                        Console.SetCursorPosition(0, 3);
  120.                        Console.Write("> Salir.            ");
  121.                        break;
  122.                    default:
  123.                        Console.Write("Fuera de rango.     ");
  124.                        break;
  125.                }
  126.  
  127.                // Fin de pintar el menú principal.
  128.                //******************************************************************
  129.  
  130.                // Leer tecla ingresada por el usuario.
  131.                tecla = Console.ReadKey(true).Key;
  132.  
  133.                // Validar el tipo de tecla.
  134.                if (tecla == ConsoleKey.Enter)
  135.                {
  136.                    switch (opcion)
  137.                    {
  138.                        case 0:
  139.                            OpcionA();
  140.                            break;
  141.                        case 1:
  142.                            OpcionB();
  143.                            break;
  144.                        case 2:
  145.                            OpcionC();
  146.                            break;
  147.                        case 3:
  148.                            MenuPrincipal();
  149.                            break;
  150.                        default:
  151.                            break;
  152.                    }
  153.                }
  154.  
  155.                // Flecha abajo del teclado.
  156.                if (tecla == ConsoleKey.DownArrow)
  157.                {
  158.                    opcion++;
  159.                }
  160.  
  161.                // Flecha arriba del teclado.
  162.                if (tecla == ConsoleKey.UpArrow)
  163.                {
  164.                    opcion--;
  165.                }
  166.  
  167.                // Si está en la última opción del menú, salta a la primera.
  168.                if (opcion > 3)
  169.                {
  170.                    opcion = 0;
  171.                }
  172.  
  173.                // Si está en la primera posición del menú, salta a la última.
  174.                if (opcion < 0)
  175.                {
  176.                    opcion = 3;
  177.                }
  178.            }
  179.        }
  180.        #endregion
  181.  
  182.        #region Opción A (0).
  183.        public static void OpcionA()
  184.        {
  185.            ConsoleKey teclaOpcionA;
  186.            Console.Clear();
  187.            do
  188.            {
  189.                Console.SetCursorPosition(0, 0);
  190.                Console.WriteLine("Estás en Opción A.");
  191.                Console.SetCursorPosition(0, 2);
  192.                Console.WriteLine("Pulse Enter para");
  193.                Console.SetCursorPosition(0, 3);
  194.                Console.WriteLine("Salir.");
  195.  
  196.                // Almacena el teclado pulsado en la variable teclaSubMenuA.
  197.                teclaOpcionA = Console.ReadKey(true).Key;
  198.  
  199.            } while (teclaOpcionA != ConsoleKey.Enter);
  200.        }
  201.        #endregion
  202.  
  203.        #region Opción B (1).
  204.        public static void OpcionB()
  205.        {
  206.            // Contador de teclas y navegador.
  207.            int opcionB = 0;
  208.  
  209.            // Capturar tecla para luego validar.
  210.            ConsoleKey teclaOpcionB;
  211.  
  212.            while (true)
  213.            {
  214.                switch (opcionB)
  215.                {
  216.                    case 0:
  217.                        Console.SetCursorPosition(0, 0);
  218.                        Console.WriteLine("Estás en Opción B.  ");
  219.                        Console.SetCursorPosition(0, 1);
  220.                        Console.WriteLine("> SubOpción B-1.    ");
  221.                        Console.SetCursorPosition(0, 2);
  222.                        Console.WriteLine("  SubOpción B-2     ");
  223.                        Console.SetCursorPosition(0, 3);
  224.                        Console.WriteLine("  Salir.            ");
  225.                        break;
  226.                    case 1:
  227.                        Console.SetCursorPosition(0, 0);
  228.                        Console.WriteLine("Estás en Opción B.  ");
  229.                        Console.SetCursorPosition(0, 1);
  230.                        Console.WriteLine("  SubOpción B-1.    ");
  231.                        Console.SetCursorPosition(0, 2);
  232.                        Console.WriteLine("> SubOpción B-2     ");
  233.                        Console.SetCursorPosition(0, 3);
  234.                        Console.WriteLine("  Salir.            ");
  235.                        break;
  236.                    case 2:
  237.                        Console.SetCursorPosition(0, 0);
  238.                        Console.WriteLine("Estás en Opción B.  ");
  239.                        Console.SetCursorPosition(0, 1);
  240.                        Console.WriteLine("  SubOpción B-1.    ");
  241.                        Console.SetCursorPosition(0, 2);
  242.                        Console.WriteLine("  SubOpción B-2     ");
  243.                        Console.SetCursorPosition(0, 3);
  244.                        Console.WriteLine("> Salir.            ");
  245.                        break;
  246.                    default:
  247.                        Console.Write("Fuera de rango.     ");
  248.                        break;
  249.                }
  250.  
  251.                // Leer tecla ingresada por el usuario.
  252.                teclaOpcionB = Console.ReadKey(true).Key;
  253.  
  254.                // Validar el tipo de tecla.
  255.                if (teclaOpcionB == ConsoleKey.Enter)
  256.                {
  257.                    switch (opcionB)
  258.                    {
  259.                        case 0:
  260.                            OpcionB1();
  261.                            break;
  262.                        case 1:
  263.                            OpcionB2();
  264.                            break;
  265.                        case 2:
  266.                            MenuOpciones();
  267.                            break;
  268.                        default:
  269.                            Console.Write("Fuera de rango.     ");
  270.                            break;
  271.                    }
  272.                }
  273.  
  274.                if (teclaOpcionB == ConsoleKey.DownArrow)
  275.                {
  276.                    opcionB++;
  277.                }
  278.  
  279.                if (teclaOpcionB == ConsoleKey.UpArrow)
  280.                {
  281.                    opcionB--;
  282.                }
  283.  
  284.                // Si está en la última opción, salta a la primera.
  285.                if (opcionB > 2)
  286.                {
  287.                    opcionB = 0;
  288.                }
  289.  
  290.                // Si está en la primera posición, salta a la última.
  291.                if (opcionB < 0)
  292.                {
  293.                    opcionB = 2;
  294.                }
  295.            }
  296.        }
  297.  
  298.        #endregion
  299.  
  300.        #region Opcion B-1.
  301.        public static void OpcionB1()
  302.        {
  303.            ConsoleKey teclaOpcionB1;
  304.            Console.Clear();
  305.            do
  306.            {
  307.                Console.SetCursorPosition(0, 0);
  308.                Console.WriteLine("Estás en Opción B-1.");
  309.                Console.SetCursorPosition(0, 2);
  310.                Console.WriteLine("Pulse Enter para    ");
  311.                Console.SetCursorPosition(0, 3);
  312.                Console.WriteLine("volver atrás.       ");
  313.  
  314.                // Almacena el teclado pulsado en la variable teclaSubMenuA.
  315.                teclaOpcionB1 = Console.ReadKey(true).Key;
  316.  
  317.            } while (teclaOpcionB1 != ConsoleKey.Enter);
  318.        }
  319.        #endregion
  320.  
  321.        #region Opcion B-2.
  322.        public static void OpcionB2()
  323.        {
  324.            ConsoleKey teclaOpcionB2;
  325.            Console.Clear();
  326.            do
  327.            {
  328.                Console.SetCursorPosition(0, 0);
  329.                Console.WriteLine("Estás en Opción B-2.");
  330.                Console.SetCursorPosition(0, 2);
  331.                Console.WriteLine("Pulse Enter para    ");
  332.                Console.SetCursorPosition(0, 3);
  333.                Console.WriteLine("volver atrás.       ");
  334.  
  335.                // Almacena el teclado pulsado en la variable teclaSubMenuA.
  336.                teclaOpcionB2 = Console.ReadKey(true).Key;
  337.  
  338.            } while (teclaOpcionB2 != ConsoleKey.Enter);
  339.        }
  340.        #endregion
  341.  
  342.        #region Opción C (2).
  343.        public static void OpcionC()
  344.        {
  345.            // Contador de teclas y navegador.
  346.            int opcionC = 0;
  347.  
  348.            // Capturar tecla para luego validar.
  349.            ConsoleKey teclaOpcionC;
  350.            Console.Clear();
  351.  
  352.            while(true)
  353.            {
  354.                switch (opcionC)
  355.                {
  356.                    case 0:
  357.                        Console.SetCursorPosition(0, 0);
  358.                        Console.WriteLine("Estás en Opción C.  ");
  359.                        Console.SetCursorPosition(0, 1);
  360.                        Console.WriteLine("> Color 1.          ");
  361.                        Console.SetCursorPosition(0, 2);
  362.                        Console.WriteLine("  Color 2.          ");
  363.                        Console.SetCursorPosition(0, 3);
  364.                        Console.WriteLine("  Opción C-1.       ");
  365.                        break;
  366.                    case 1:
  367.                        Console.SetCursorPosition(0, 0);
  368.                        Console.WriteLine("Estás en Opción C.  ");
  369.                        Console.SetCursorPosition(0, 1);
  370.                        Console.WriteLine("  Color 1.          ");
  371.                        Console.SetCursorPosition(0, 2);
  372.                        Console.WriteLine("> Color 2.          ");
  373.                        Console.SetCursorPosition(0, 3);
  374.                        Console.WriteLine("  Opción C-1.       ");
  375.                        break;
  376.                    case 2:
  377.                        Console.SetCursorPosition(0, 0);
  378.                        Console.WriteLine("Estás en Opción C.  ");
  379.                        Console.SetCursorPosition(0, 1);
  380.                        Console.WriteLine("  Color 1.          ");
  381.                        Console.SetCursorPosition(0, 2);
  382.                        Console.WriteLine("  Color 2.          ");
  383.                        Console.SetCursorPosition(0, 3);
  384.                        Console.WriteLine("> Opción C-1.       ");
  385.                        break;
  386.                    case 3:
  387.                        Console.SetCursorPosition(0, 0);
  388.                        Console.WriteLine("> Color 3.          ");
  389.                        Console.SetCursorPosition(0, 1);
  390.                        Console.WriteLine("  Color 4.          ");
  391.                        Console.SetCursorPosition(0, 2);
  392.                        Console.WriteLine("  Color 5.          ");
  393.                        Console.SetCursorPosition(0, 3);
  394.                        Console.WriteLine("  Salir.            ");
  395.                        break;
  396.                    case 4:
  397.                        Console.SetCursorPosition(0, 0);
  398.                        Console.WriteLine("  Color 3.          ");
  399.                        Console.SetCursorPosition(0, 1);
  400.                        Console.WriteLine("> Color 4.          ");
  401.                        Console.SetCursorPosition(0, 2);
  402.                        Console.WriteLine("  Color 5.          ");
  403.                        Console.SetCursorPosition(0, 3);
  404.                        Console.WriteLine("  Salir.            ");
  405.                        break;
  406.                    case 5:
  407.                        Console.SetCursorPosition(0, 0);
  408.                        Console.WriteLine("  Color 3.          ");
  409.                        Console.SetCursorPosition(0, 1);
  410.                        Console.WriteLine("  Color 4.          ");
  411.                        Console.SetCursorPosition(0, 2);
  412.                        Console.WriteLine("> Color 5.          ");
  413.                        Console.SetCursorPosition(0, 3);
  414.                        Console.WriteLine("  Salir.            ");
  415.                        break;
  416.                    case 6:
  417.                        Console.SetCursorPosition(0, 0);
  418.                        Console.WriteLine("  Color 3.          ");
  419.                        Console.SetCursorPosition(0, 1);
  420.                        Console.WriteLine("  Color 4.          ");
  421.                        Console.SetCursorPosition(0, 2);
  422.                        Console.WriteLine("  Color 5.          ");
  423.                        Console.SetCursorPosition(0, 3);
  424.                        Console.WriteLine("> Salir.            ");
  425.                        break;
  426.  
  427.                    default:
  428.                        Console.Write("Fuera de rango.     ");
  429.                        break;
  430.                }
  431.  
  432.                // Leer tecla ingresada por el usuario.
  433.                teclaOpcionC = Console.ReadKey(true).Key;
  434.  
  435.                // Validar el tipo de tecla.
  436.                if (teclaOpcionC == ConsoleKey.Enter)
  437.                {
  438.                    switch (opcionC)
  439.                    {
  440.                        case 0:
  441.                            // Fondo azul.
  442.                            Console.BackgroundColor = ConsoleColor.Blue;
  443.  
  444.                            // Letras blancas.
  445.                            Console.ForegroundColor = ConsoleColor.White;
  446.                            break;
  447.                        case 1:
  448.                            // Fondo verde.
  449.                            Console.BackgroundColor = ConsoleColor.Green;
  450.  
  451.                            // Letras negras.
  452.                            Console.ForegroundColor = ConsoleColor.Black;
  453.                            break;
  454.                        case 2:
  455.                            OpcionC1();
  456.                            break;
  457.                        case 3:
  458.                            // Fondo negro.
  459.                            Console.BackgroundColor = ConsoleColor.Black;
  460.  
  461.                            // Letras rojo.
  462.                            Console.ForegroundColor = ConsoleColor.Red;
  463.                            break;
  464.                        case 4:
  465.                            // Fondo negro.
  466.                            Console.BackgroundColor = ConsoleColor.Black;
  467.  
  468.                            // Letras rojo.
  469.                            Console.ForegroundColor = ConsoleColor.Yellow;
  470.                            break;
  471.                        case 5:
  472.                            // Fondo negro.
  473.                            Console.BackgroundColor = ConsoleColor.Red;
  474.  
  475.                            // Letras rojo.
  476.                            Console.ForegroundColor = ConsoleColor.DarkRed;
  477.                            break;
  478.                        case 6:
  479.                            MenuOpciones();
  480.                            break;
  481.                        default:
  482.                            Console.Write("Fuera de rango.     ");
  483.                            break;
  484.                    }
  485.                }
  486.  
  487.                if (teclaOpcionC == ConsoleKey.DownArrow)
  488.                {
  489.                    opcionC++;
  490.                }
  491.  
  492.                if (teclaOpcionC == ConsoleKey.UpArrow)
  493.                {
  494.                    opcionC--;
  495.                }
  496.  
  497.                // Si está en la última opción, salta a la primera.
  498.                if (opcionC > 6)
  499.                {
  500.                    opcionC = 0;
  501.                }
  502.  
  503.                // Si está en la primera posición, salta a la última.
  504.                if (opcionC < 0)
  505.                {
  506.                    opcionC = 6;
  507.                }
  508.            }
  509.        }
  510.        #endregion
  511.  
  512.        #region OpcionC-1.
  513.        public static void OpcionC1()
  514.        {
  515.            // Contador de teclas y navegador.
  516.            int opcionC1 = 0;
  517.  
  518.            // Capturar tecla para luego validar.
  519.            ConsoleKey teclaOpcionC1;
  520.            Console.Clear();
  521.  
  522.            while(true)
  523.            {
  524.                Console.Clear();
  525.  
  526.                switch (opcionC1)
  527.                {
  528.                    case 0:
  529.                        Console.SetCursorPosition(0, 0);
  530.                        Console.WriteLine("Estás en Opción C-1.");
  531.                        Console.SetCursorPosition(0, 2);
  532.                        Console.WriteLine("  SI");
  533.                        Console.SetCursorPosition(16, 2);
  534.                        Console.WriteLine("> NO");
  535.                        break;
  536.                    case 1:
  537.                        Console.SetCursorPosition(0, 0);
  538.                        Console.WriteLine("Estás en Opción C-1.");
  539.                        Console.SetCursorPosition(0, 2);
  540.                        Console.WriteLine("> SI");
  541.                        Console.SetCursorPosition(16, 2);
  542.                        Console.WriteLine("  NO");
  543.                        break;
  544.                    default:
  545.                        Console.Write("Fuera de rango.     ");
  546.                        break;
  547.                }
  548.  
  549.                // Leer tecla ingresada por el usuario.
  550.                teclaOpcionC1 = Console.ReadKey(true).Key;
  551.  
  552.                // Validar el tipo de tecla.
  553.                if (teclaOpcionC1 == ConsoleKey.Enter)
  554.                {
  555.                    switch (opcionC1)
  556.                    {
  557.                        case 0:
  558.                            MenuPrincipal();
  559.                            Console.Clear();
  560.                            break;
  561.                        case 1:
  562.                            OpcionSI();
  563.                            break;
  564.                        default:
  565.                            Console.Write("Fuera de rango.     ");
  566.                            break;
  567.                    }
  568.                }
  569.  
  570.                // Flecha derecha.
  571.                if (teclaOpcionC1 == ConsoleKey.RightArrow)
  572.                {
  573.                    opcionC1++;
  574.                }
  575.  
  576.                // Flecha izquierda.
  577.                if (teclaOpcionC1 == ConsoleKey.LeftArrow)
  578.                {
  579.                    opcionC1--;
  580.                }
  581.  
  582.                // Si está en la última opción, salta a la primera.
  583.                if (opcionC1 > 1)
  584.                {
  585.                    opcionC1 = 0;
  586.                }
  587.  
  588.                // Si está en la primera posición, salta a la última.
  589.                if (opcionC1 < 0)
  590.                {
  591.                    opcionC1 = 1;
  592.                }
  593.            }
  594.        }
  595.        #endregion
  596.  
  597.        #region opcionSI del sub menú C-1.
  598.        public static void OpcionSI()
  599.        {
  600.            ConsoleKey teclaOpcionB1;
  601.            Console.Clear();
  602.            do
  603.            {
  604.                Console.SetCursorPosition(0, 0);
  605.                Console.WriteLine("Estás en Opción SÍ.");
  606.                Console.SetCursorPosition(0, 2);
  607.                Console.WriteLine("Pulse Enter para    ");
  608.                Console.SetCursorPosition(0, 3);
  609.                Console.WriteLine("volver atrás.       ");
  610.  
  611.                // Almacena el teclado pulsado en la variable teclaOpciónB1.
  612.                teclaOpcionB1 = Console.ReadKey(true).Key;
  613.  
  614.            } while (teclaOpcionB1 != ConsoleKey.Enter);
  615.        }
  616.        #endregion
  617.    }
  618. }

Se que se podrá hacer mucho mejor y sin fallos como estos. No se quedará así, sino que mi idea principal, es coger el truco que se pueda crear menús y submenús que se pueda hacer de forma muy sencilla.

Dejo clarqo eu solo hacerlo que funcione con botones flecha arriba, abajo, derecha, izquierda y Enter (Escape solo para salir si estás en la ventana principal).

Saludos.


« Última modificación: 28 Febrero 2020, 22:52 por Meta » En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
ThunderCls


Desconectado Desconectado

Mensajes: 432


Coder | Reverser | Gamer


Ver Perfil WWW
Re: Menús y submenús en consola C#
« Respuesta #1 en: 1 Marzo 2020, 00:19 »

Porque no lo implementas usando algo similar a un arbol?. Creo que seria mucho mas eficiente, dinamico y sobretodo sencillo
Saludos


En línea

-[ "…I can only show you the door. You're the one that has to walk through it." – Morpheus (The Matrix) ]-
http://reversec0de.wordpress.com
https://github.com/ThunderCls/
Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Re: Menús y submenús en consola C#
« Respuesta #2 en: 1 Marzo 2020, 08:04 »

Hola:

¿Tu crees que es más fácil?
http://www.udb.edu.sv/udb/archivo/guia/informatica-ingenieria/programacion-iv/2013/ii/guia-6.pdf
https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/concepts/expression-trees/

Al final lo hice con archivos externos.



Ver zoom.

Saludos.
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
ThunderCls


Desconectado Desconectado

Mensajes: 432


Coder | Reverser | Gamer


Ver Perfil WWW
Re: Menús y submenús en consola C#
« Respuesta #3 en: 2 Marzo 2020, 08:16 »


No creo que era necesario referenciarme una conferencia de Arboles  :laugh:  se muy bien lo que son. En fin, en mi opinion una implementacion en este caso usando una ED tipo Arbol es la solucion ideal y vuelvo a repetirme, es una implementacion mas eficiente, dinamica y si, muchisimo mas sencilla aunque no lo parezca.
Como me parecio divertida la idea aqui dejo un sencillo framework (poc) que hice para crear menus en consola de forma dinamica usando un Arbol como abstraccion de datos. Aclaro que con esto no quiero decir que esta es la unica forma de hacerlo, simplemente que a mi parecer es la mas natural


Código
  1. /// <summary>
  2. /// Menu.cs
  3. /// Abstract menu class
  4. /// </summary>
  5. public abstract class Menu
  6. {
  7.    /// <summary>
  8.    /// Menu header UI details
  9.    /// </summary>
  10.    public class Position
  11.    {
  12.        public int TopSpacing { get; set; }
  13.        public int TopPadding { get; set; }
  14.        public int LeftPadding { get; set; }
  15.        public int LeftSpacing { get; set; }
  16.        public bool LeftCentered { get; set; }
  17.        public bool TopCentered { get; set; }
  18.    }
  19.  
  20.    public const string MarkerSymbol = "=>";
  21.    public List<string> HeaderText { get; set; }
  22.    public string EntryTitle { get; set; }
  23.    public bool Selected { get; set; }
  24.    public Position HeaderPos { get; set; }
  25.    public Position EntriesPos { get; set; }
  26.  
  27.    protected internal Menu Parent;
  28.    protected internal List<Menu> Children;
  29.    protected internal int ChildIndex;
  30.  
  31.    protected internal Menu()
  32.    {
  33.        Children = new List<Menu>();
  34.        HeaderPos = new Position();
  35.        EntriesPos = new Position();
  36.    }
  37.  
  38.    protected internal void Select()
  39.    {
  40.        Selected = true;
  41.    }
  42.  
  43.    protected internal void Deselect()
  44.    {
  45.        Selected = false;
  46.    }
  47.  
  48.    protected internal string GetMarker()
  49.    {
  50.        return Selected ? MarkerSymbol : new string(' ', MarkerSymbol.Length);
  51.    }
  52.  
  53.    public void AddChild(Menu child)
  54.    {
  55.        child.Parent = this;
  56.        Children.Add(child);
  57.    }
  58.  
  59.    protected internal string GetEntryString()
  60.    {
  61.        return $"{this.GetMarker()} {this.EntryTitle}";
  62.    }
  63.  
  64.    public void ControlLoop()
  65.    {
  66.        Console.CursorVisible = false;
  67.        do
  68.        {
  69.            ShowMenu();
  70.            ProcessKeyPress();
  71.        } while (true);
  72.    }
  73.  
  74.    protected internal abstract void Execute();
  75.    protected internal abstract void ShowMenu();
  76.    protected internal abstract void ProcessKeyPress();
  77. }
  78.  
  79.  
  80. /// <summary>
  81. /// VerticalMenu.cs
  82. /// Vertical menu class
  83. /// </summary>
  84. public class VerticalMenu : Menu
  85. {
  86.    protected internal override void Execute()
  87.    {
  88.        ControlLoop();
  89.    }
  90.  
  91.    protected internal override void ShowMenu()
  92.    {
  93.        Console.Clear();
  94.  
  95.        // calculating left positioning for menu header
  96.        int leftPosition = (HeaderPos.LeftCentered)
  97.                ? (Console.WindowWidth / 2) - (HeaderText.Max(x => x.Length) / 2)
  98.                : HeaderPos.LeftSpacing;
  99.  
  100.        int topPosition = (HeaderPos.TopCentered)
  101.            ? (Console.WindowHeight / 2) -
  102.              (((HeaderPos.TopPadding > 0) ? HeaderText.Count * 2 * HeaderPos.TopPadding : HeaderText.Count +
  103.              ((EntriesPos.TopPadding > 0) ? Children.Count * 2 * EntriesPos.TopPadding : Children.Count)) / 2)
  104.            : Console.CursorTop + HeaderPos.TopSpacing;
  105.  
  106.        Console.SetCursorPosition(leftPosition, topPosition);
  107.        foreach (string line in HeaderText)
  108.        {
  109.            Console.WriteLine(line);
  110.            Console.SetCursorPosition(leftPosition, Console.CursorTop + HeaderPos.TopPadding);
  111.        }
  112.  
  113.        // calculating left positioning for menu entries
  114.        int totalLeft = Children.Select(x => x.GetEntryString().Length).ToList().Max(x => x);
  115.        leftPosition = (EntriesPos.LeftCentered)
  116.            ? (Console.WindowWidth / 2) -
  117.              (totalLeft / 2)
  118.            : EntriesPos.LeftSpacing;
  119.  
  120.        Console.SetCursorPosition(leftPosition, Console.CursorTop + EntriesPos.TopSpacing);
  121.        foreach (var child in Children)
  122.        {
  123.            Console.WriteLine(child.GetEntryString());
  124.            Console.SetCursorPosition(leftPosition, Console.CursorTop + EntriesPos.TopPadding);
  125.        }
  126.    }
  127.  
  128.    protected internal override void ProcessKeyPress()
  129.    {
  130.        var key = Console.ReadKey();
  131.        switch (key.Key)
  132.        {
  133.            case ConsoleKey.UpArrow:
  134.                MoveMarkerUp();
  135.                break;
  136.  
  137.            case ConsoleKey.DownArrow:
  138.                MoveMarkerDown();
  139.                break;
  140.  
  141.            case ConsoleKey.Enter:
  142.                ExecuteEntry();
  143.                break;
  144.  
  145.            case ConsoleKey.Escape:
  146.                TryExitConsole();
  147.                break;
  148.        }
  149.    }
  150.  
  151.    private void MoveMarkerUp()
  152.    {
  153.        ChildIndex = (ChildIndex - 1 >= 0) ? ChildIndex -= 1 : Children.Count - 1;
  154.        Children.ForEach(x => x.Deselect());
  155.        Children[ChildIndex].Select();
  156.    }
  157.  
  158.    private void MoveMarkerDown()
  159.    {
  160.        ChildIndex = (ChildIndex + 1 < Children.Count) ? ChildIndex += 1 : 0;
  161.        Children.ForEach(x => x.Deselect());
  162.        Children[ChildIndex].Select();
  163.    }
  164.  
  165.    private void ExecuteEntry()
  166.    {
  167.        if (ChildIndex >= 0 && ChildIndex < Children.Count)
  168.        {
  169.            Menu menu = Children[ChildIndex];
  170.            if (menu?.GetType() != typeof(Entry) && menu?.Children.Count == 0)
  171.            {
  172.                menu = this.Parent;
  173.            }
  174.  
  175.            menu?.Execute();
  176.        }
  177.    }
  178.  
  179.    private void TryExitConsole()
  180.    {
  181.        if (this.Parent == null)
  182.            Environment.Exit(0);
  183.    }
  184. }
  185.  
  186.  
  187. /// <summary>
  188. /// HorizontalMenu.cs
  189. /// Horizontal menu class
  190. /// </summary>
  191. public class HorizontalMenu : Menu
  192. {
  193.    protected internal override void Execute()
  194.    {
  195.        ControlLoop();
  196.    }
  197.  
  198.    protected internal override void ShowMenu()
  199.    {
  200.        Console.Clear();
  201.  
  202.        // calculating left positioning for menu header
  203.        int leftPosition = (HeaderPos.LeftCentered)
  204.                ? (Console.WindowWidth / 2) - (HeaderText.Max(x => x.Length) / 2)
  205.                : HeaderPos.LeftSpacing;
  206.  
  207.        int topPosition = (HeaderPos.TopCentered)
  208.            ? (Console.WindowHeight / 2) -
  209.              (((HeaderPos.TopPadding > 0) ? HeaderText.Count * 2 * HeaderPos.TopPadding : HeaderText.Count +
  210.              ((EntriesPos.TopSpacing > 0) ? EntriesPos.TopSpacing + 1 : 1)) / 2)
  211.            : Console.CursorTop + HeaderPos.TopSpacing;
  212.  
  213.        Console.SetCursorPosition(leftPosition, topPosition);
  214.        foreach (string line in HeaderText)
  215.        {
  216.            Console.WriteLine(line);
  217.            Console.SetCursorPosition(leftPosition, Console.CursorTop + HeaderPos.TopPadding);
  218.        }
  219.  
  220.        // calculating left positioning for menu entries
  221.        int totalEntriesLeftSpace = Children.Select(x => x.GetEntryString().Length + EntriesPos.LeftPadding)
  222.                                            .ToList().Sum(x => x) - EntriesPos.LeftPadding;
  223.        topPosition = Console.CursorTop + EntriesPos.TopSpacing;
  224.        leftPosition = (EntriesPos.LeftCentered)
  225.            ? (Console.WindowWidth / 2) - (totalEntriesLeftSpace / 2)
  226.            : EntriesPos.LeftSpacing;
  227.        foreach (var entry in Children)
  228.        {
  229.            Console.SetCursorPosition(leftPosition, topPosition);
  230.            Console.WriteLine(entry.GetEntryString());
  231.            leftPosition += MarkerSymbol.Length + entry.EntryTitle.Length + EntriesPos.LeftPadding;
  232.        }
  233.    }
  234.  
  235.    protected internal override void ProcessKeyPress()
  236.    {
  237.        var key = Console.ReadKey();
  238.        switch (key.Key)
  239.        {
  240.            case ConsoleKey.LeftArrow:
  241.                MoveMarkerLeft();
  242.                break;
  243.  
  244.            case ConsoleKey.RightArrow:
  245.                MoveMarkerRight();
  246.                break;
  247.  
  248.            case ConsoleKey.Enter:
  249.                ExecuteEntry();
  250.                break;
  251.  
  252.            case ConsoleKey.Escape:
  253.                TryExitConsole();
  254.                break;
  255.        }
  256.    }
  257.  
  258.    private void MoveMarkerLeft()
  259.    {
  260.        ChildIndex = (ChildIndex - 1 >= 0) ? ChildIndex -= 1 : Children.Count - 1;
  261.        Children.ForEach(x => x.Deselect());
  262.        Children[ChildIndex].Select();
  263.    }
  264.  
  265.    private void MoveMarkerRight()
  266.    {
  267.        ChildIndex = (ChildIndex + 1 < Children.Count) ? ChildIndex += 1 : 0;
  268.        Children.ForEach(x => x.Deselect());
  269.        Children[ChildIndex].Select();
  270.    }
  271.  
  272.    private void ExecuteEntry()
  273.    {
  274.        if (ChildIndex >= 0 && ChildIndex < Children.Count)
  275.        {
  276.            Menu menu = Children[ChildIndex];
  277.            if (menu?.GetType() != typeof(Entry) && menu?.Children.Count == 0)
  278.            {
  279.                menu = this.Parent;
  280.            }
  281.  
  282.            menu?.Execute();
  283.        }
  284.    }
  285.  
  286.    private void TryExitConsole()
  287.    {
  288.        if (this.Parent == null)
  289.            Environment.Exit(0);
  290.    }
  291. }
  292.  
  293.  
  294. /// <summary>
  295. /// Entry.cs
  296. /// Menu entry class
  297. /// </summary>
  298. public class Entry : Menu
  299. {
  300.    public Action Event { get; set; }
  301.  
  302.    protected internal override void Execute()
  303.    {
  304.        Event?.Invoke();
  305.    }
  306.  
  307.    protected internal override void ShowMenu() { }
  308.  
  309.    protected internal override void ProcessKeyPress() { }
  310. }


Su uso para crear menus seria muy basico


Código
  1. static void Main(string[] args)
  2. {
  3.    Menu mainMenu = new VerticalMenu
  4.    {
  5.        HeaderText = new List<string>()
  6.        {
  7.            "============",
  8.            " Main Menu  ",
  9.            "============",
  10.            "Options:"
  11.        }
  12.    };
  13.    Entry blueEntry = new Entry
  14.    {
  15.        Selected = true,
  16.        EntryTitle = "Blue",
  17.        Event = () => { Console.BackgroundColor = ConsoleColor.DarkBlue; }
  18.    };
  19.    Entry redEntry = new Entry
  20.    {
  21.        Selected = false,
  22.        EntryTitle = "Red",
  23.        Event = () => { Console.BackgroundColor = ConsoleColor.DarkRed; }
  24.    };
  25.  
  26.    mainMenu.AddChild(blueEntry);
  27.    mainMenu.AddChild(redEntry);
  28.    mainMenu.ControlLoop();
  29. }


Igual he añadido un par de opciones para jugar con el posicionamiento de los elementos en la ventana de la consola, como el centrado horizontal y vertical, padding, etc



Resumiendo todo lo anterior, como decia antes el codigo base es mucho mas sencillo usando un Arbol para almacenar cada menu y si le quitamos todo el codigo extra para lo ultimo que comente y demas mierdas que puse son mucho menos lineas de codigo y logica de funcionamiento en general, ademas tienes la posibilidad de crear todos los menus, submenus y entradas que quieras de forma dinamica simplemente usando dichas clases en cualquier proyecto.
Pues nada, estuvo divertido  ;-)
Saludos
« Última modificación: 2 Marzo 2020, 08:28 por ThunderCls » En línea

-[ "…I can only show you the door. You're the one that has to walk through it." – Morpheus (The Matrix) ]-
http://reversec0de.wordpress.com
https://github.com/ThunderCls/
Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Re: Menús y submenús en consola C#
« Respuesta #4 en: 3 Marzo 2020, 00:20 »

Pedazo de código. Eso si, tengo que entenderlo todo paso por paso. Si lo hiciste tu, buen trabajo.

LAs campturas te quedaron de lujo. Voy a investigar.
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
ThunderCls


Desconectado Desconectado

Mensajes: 432


Coder | Reverser | Gamer


Ver Perfil WWW
Re: Menús y submenús en consola C#
« Respuesta #5 en: 3 Marzo 2020, 01:02 »

Pedazo de código. Eso si, tengo que entenderlo todo paso por paso. Si lo hiciste tu, buen trabajo.

LAs campturas te quedaron de lujo. Voy a investigar.

Si si lo hice yo  :xD de igual manera si no entiendes algo por parte del codigo o el algoritmo en si puedes preguntar, en realidad no es tan complicado. Como dije en un mensaje anterior, una vez que te abstraes lo suficiente puedes ver perfectamente como la relacion de un menu con un Arbol es casi perfecta, haciendo este tipo de estructura de datos las mas apropiada para implementarlo. El codigo se puede simplificar muchisimo si solo se deja el funcionamiento basico. La clase abstracta Menu es nuestra abstraccion del arbol y los atributos principales son:

Código
  1. protected internal Menu Parent;
  2. protected internal List<Menu> Children;
  3. protected internal int ChildIndex;

Parent sera el nodo padre o el menu padre si se quiere ver, Children los nodos hijos de dicho nodo padre, el cual es una lista de nodos pues evidentemente no estamos tratando con arbol binario en este caso pues un menu puede tener mas de dos entradas y finalmente ChildIndex sera nuestro selector.
Luego una de las funciones mas importantes es public void ControlLoop(), la encargada de mostrar el Nodo (menu) y procesar el input del usuario. Finalmente las clases HorizontalMenu/VerticalMenu y Entry son clases especializadas que implementan la clase abstracta Menu de acuerdo a su especificacion para lograr el objetivo de cada una y sus nombres son bien descriptivos del tipo de Nodo que serian.
Saludos

En línea

-[ "…I can only show you the door. You're the one that has to walk through it." – Morpheus (The Matrix) ]-
http://reversec0de.wordpress.com
https://github.com/ThunderCls/
Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Re: Menús y submenús en consola C#
« Respuesta #6 en: 3 Marzo 2020, 02:15 »

Me gustó lo que hiciste.
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Submenus
Desarrollo Web
aldg 0 526 Último mensaje 20 Marzo 2011, 23:30
por aldg
[MOD] Turcbo C submenus
Programación C/C++
Angel Zero 6 1,998 Último mensaje 1 Junio 2011, 23:57
por Angel Zero
SubMenus en Open gl
Programación C/C++
V_Dan 1 778 Último mensaje 31 Agosto 2012, 06:25
por BlackZeroX (Astaroth)
Menús en modo consola
.NET (C#, VB.NET, ASP)
Meta 9 1,206 Último mensaje 8 Febrero 2019, 20:47
por Meta
Creación de subpáginas y submenús automatizados
Desarrollo Web
2AA2 1 396 Último mensaje 29 Agosto 2020, 07:31
por Beginner Web
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines