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

 

 


Tema destacado: Security Series.XSS. [Cross Site Scripting]


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 [16] 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ... 237
151  Programación / .NET (C#, VB.NET, ASP) / Re: Seleccionar > en las opciones en: 1 Abril 2020, 16:14 pm
Muy bueno.

Lo que no sabía la forma que esto se puede hacer como lo hiciste.
Código
  1. static char[] abc123 = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789".ToCharArray();

Ni en los documentos oficiales aparece ese ejemplo que hiciste.
https://docs.microsoft.com/es-es/dotnet/api/system.array?view=netframework-4.8

El compilador me indicó que pusiera readonly (solo lectura).
Código
  1.        static bool escribiendo = true, fin = false;
  2.        static ConsoleKey key;
  3.        static String nombre;
  4.        static readonly char[] abc123 = " ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789".ToCharArray();
  5.        static readonly int[] idx = new int[16];

Funciona todo el programa perfecto. Faltó un detalle. Si estás en las flechas en la zona.

> ATRÁS     GUARDAR.

Cuando pulses todo el rato la flecha izquierda o derecha, tiene que rotar el cursos >, no que si pulso izquierda, se quede ahí.

En cuanto a lo demás, buena calidad del código y buen trabajo.

Saludos.  ;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-)
152  Programación / Scripting / Re: Crear solo un modelo de Menú y Submenú en: 31 Marzo 2020, 06:24 am
Gracias por los consejos.

En caunto al switch, si tiene break  al final. El ejemplo lo saqué de este enlace.

En el código general, tendré que empezar desde cero. A ver si me sale como Dios manda.
153  Programación / .NET (C#, VB.NET, ASP) / Seleccionar > en las opciones en: 31 Marzo 2020, 05:24 am
Buenas:



Este programa se trata de usar solo las teclas de las flechas y Enter. Ninguna más. Me funciona lo de cambiar un nombre con las teclas de las flechas. Una vez que tenga el nombre, si pulsas la Tecla Enter, tiene que aparecer este símbolo > al lado donde pone ATRÁS.

Tiene que aparecer así:

Citar
> ATRÁS      GUARDAR

Desde que esté el signo > en ATRÁS, ya se puede mover hacia GUARDAR, puedes elegir con las flechas del teclado, izquierda y derecha.

Independientemente donde esté el > sea en ATRÁS o en GUARDAR, si pulsas las flechas arriba o abajo, se pone en la parte del nombre para cambiarlo otra vez, una vez que tenga el nombre que quieras, pulsas Enter otra vez y se va este > a ATRÁS como dije antes.

Si el > está en GUARDAR como indica abajo.

Citar
ATRÁS     > GUARDAR

Si pulsas Enter, guarda el nombre que hayas puesto en la variable guardaNombre. Se queda simplemente almacenado ahí del programa.

Si vuelves con el > en ATRÁS y pulsas Enter. Muentra un mensaje en pantalla. Haz pulsado ATRÁS y el programa se queda ahí.

Espero que se entienda los paso que he escrito, si no se entiende algo, lo comentan.

Sólo he hecho esto.

Código C#:
Código
  1. using System;
  2.  
  3. namespace LCD_nombre_archivo_consola_02
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            // Título de la pantalla.
  10.            Console.Title = "Cambiar nombre";
  11.  
  12.            // Tamaño de la ventana.
  13.            Console.SetWindowSize(20, 5);
  14.  
  15.            string guardarNombre = "";
  16.            int coordenadaX = 0;
  17.            ConsoleKey key;
  18.  
  19.            char[] alfanumerico = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'Ñ', 'O', 'P',
  20.                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
  21.            int[] indiceArray = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  22.            string[] texto = new string[] {"ATRÁS", "GUARDAR"};
  23.  
  24.            // Fondo verde.
  25.            Console.BackgroundColor = ConsoleColor.Blue;
  26.  
  27.            // Letras negras.
  28.            Console.ForegroundColor = ConsoleColor.White;
  29.  
  30.            Console.Clear();
  31.  
  32.            Console.SetCursorPosition(0, 0);
  33.            Console.Write("Nombre del relé 1:");
  34.            Console.SetCursorPosition(0, 1);
  35.            Console.Write("AAAAAAAAAAAAAAAA");
  36.            Console.SetCursorPosition(2, 3);
  37.            Console.Write(texto[0]);
  38.            Console.SetCursorPosition(12, 3);
  39.            Console.Write(texto[1]);
  40.  
  41.            while (true)
  42.            {
  43.                Console.SetCursorPosition(coordenadaX, 1);
  44.  
  45.                key = Console.ReadKey(true).Key;
  46.  
  47.                if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
  48.                {
  49.                    coordenadaX++;
  50.                }
  51.                else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
  52.                {
  53.                    coordenadaX--;
  54.                }
  55.                else if (key == ConsoleKey.UpArrow)
  56.                {
  57.                    indiceArray[coordenadaX]++;
  58.  
  59.                    if (indiceArray[coordenadaX] >= alfanumerico.Length)
  60.                    {
  61.                        indiceArray[coordenadaX] = 0;
  62.                    }
  63.  
  64.                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
  65.                }
  66.                else if (key == ConsoleKey.DownArrow)
  67.                {
  68.                    indiceArray[coordenadaX]--;
  69.  
  70.                    if (indiceArray[coordenadaX] < 0)
  71.                    {
  72.                        indiceArray[coordenadaX] = alfanumerico.Length - 1;
  73.                    }
  74.  
  75.                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
  76.                }
  77.            }
  78.        }
  79.    }
  80. }
  81.  
  82.  

Gracias por todo.
154  Programación / Scripting / Re: Crear solo un modelo de Menú y Submenú en: 30 Marzo 2020, 14:42 pm
Hola compañero:

¿Qué tal estás?

Se los paso. Dejo calro que fue guiado por unapersona mayor en el cual su forma de programar no es a objetos que digamos, sino a procedimental o programación clásica, ya que es lo que le enceñaros desde la época de estudiante cuando se programaba en MS-DOS. Ya es la prehistoria. jajaj

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

Ya dije que el código es larrrrrrrrrrgo y horrible.

Pero.....

Funciona, ajajjajajajjaja.

Lo que no quiero programar así, tengo que mejorar sea como sea para hacer las cosas bien desde el principio.
155  Programación / Scripting / Re: Crear solo un modelo de Menú y Submenú en: 30 Marzo 2020, 05:35 am
@XSStringManolo Lo tengo hecho con el lenguaje C#. Está tan chapuza lo que he hecho con tantos códigos repetidos, que me da vergüenza publicarlo. Si quieres lo publico aquí el código de C#. Aguanto la vergüenza sea como sea.  :silbar:

@EdePC Me encanta tu trabajo. Me he dado cuenta que no funciona como tiene que funcionar. Hace cosas no deseadas.

Si estoy en la pantalla de inicio, pulso un número, sale el menú, no debería, solo si pulso Enter.
Si pulso el 1 cuando ya estoy en el menú, entras bien, luego tiene que pulsar solo Enter y va al inicio de todo, donde se ve la hora y fecha. No tiene tampoco que cerrarse la ventana nunca.
Son muchos detalles que no está tal como puse en el esquema. Es para que te hagas una idea. Aún así lo que hiciste, buen trabajo.

Ya que dicen que PowerShell es el sustituto del cmd, pues no es compatibl el programa de bat al ps1. DEl CMD al PowerShell.

Gracias a los dos.
156  Programación / Programación C/C++ / Re: Movimiento en un juego c++ en: 29 Marzo 2020, 21:55 pm
Como vez la fecla abajo en C#.
Código
  1. tecla == ConsoleKey.DownArrow

Si quieres la de, solo tienes que poner la D, quedaría así.

Código
  1. tecla == ConsoleKey.D

Saludos.
157  Programación / Scripting / Crear solo un modelo de Menú y Submenú en: 29 Marzo 2020, 21:03 pm
Hola:

Quiero saber si a estas alturas se puede crear un menú y submenú con la línea de comando de Windows 10, el cmd de siempre. Se que está PowerShell, el sustituto del cmd, pero este es más complicado, nuevo y no entiendo, en realidad, no entiendo ninguno.

Solo se permite usar las flechas del teclado y la tecla Enter para navegar por esos menú y submenús.

Esquema boceto para hacer una idea.


Vídeo:


Saludos.
158  Programación / Programación C/C++ / Re: Redimensionar y quitar tildes o otro carecter que no viene a cuento en: 29 Marzo 2020, 18:27 pm
Gracias.

Ya lo he hecho. Dejo el ejemplo aquí por si alguien lo necesita, aunque hayan pasado 20 años, jajajaja. O poco le faltan.

Código
  1. #include <iostream>
  2. #include <windows.h> // Para mostrar texto en el título de la ventana.
  3.  
  4. using namespace std;
  5. using std::cout;
  6. using std::cin;
  7.  
  8. int main(void)
  9. {
  10. // Mostrar caracteres correctamente en pantalla.
  11. SetConsoleOutputCP(65001);
  12. wchar_t titulo[128];
  13. MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
  14. SetConsoleTitle(titulo);
  15.  
  16. // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
  17. SMALL_RECT r = { 0, 0, 49, 9 };
  18. SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
  19.  
  20. // Mostrar textos en pantalla.
  21. cout << "Terminarías. Conocerías. Título. Analógico. \n";
  22. cout << "Muchas gracias mi muy distinguido amigo.";
  23.  
  24. // Esperando pulsar Enter para salir.
  25. cin.get();
  26. return 0;
  27. }

Saludos.
159  Programación / Programación General / Re: De voz a texto en: 29 Marzo 2020, 14:08 pm
Prueba con esto en Consola C#:

Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. using System.Speech.Recognition; // No olvidar.
  8.  
  9. namespace Reconocimiento_voz_consola_02
  10. {
  11.    class Program
  12.    {
  13.        public SpeechRecognitionEngine escucha = new SpeechRecognitionEngine();
  14.  
  15.        static void Main(string[] args)
  16.        {
  17.            Console.WindowWidth = 80; // Redimensionando ventana consola.
  18.            Console.WindowHeight = 43;
  19.            Console.Title = "Reconicimiento voz 02"; // Título de la ventana.
  20.            Console.BackgroundColor = ConsoleColor.White; // Fondo pantalla blanco.
  21.            Console.Clear(); // Limpiar pantalla.
  22.            Console.ForegroundColor = ConsoleColor.Blue; // Color texto azul.
  23.            string entradaComandos = string.Empty;
  24.            Console.WriteLine(@"Elija una opción:
  25.  
  26. 1) Activar reconocimiento de voz.
  27. 2) Salir del programa.");
  28.            Console.CursorVisible = true;
  29.            entradaComandos = Console.ReadLine().ToString();
  30.  
  31.  
  32.                switch (entradaComandos)
  33.                {
  34.                    case "1":
  35.                        Program escuchaProgram = new Program();
  36.                        escuchaProgram.MicroActivo();
  37.                        Console.WriteLine("Reconocimiento de voz activado. Escuchando...");
  38.                    Console.ReadKey();
  39.                        break;
  40.  
  41.                    case "2":
  42.                        // Salir del programa.
  43.                        // Aquí instrucciones para salir de esta aplicación.
  44.                        break;
  45.                }
  46.  
  47.        }
  48.  
  49.        public void MicroActivo()
  50.        {
  51.            escucha.SetInputToDefaultAudioDevice(); // Abrir el dispositivo de audio. Micro.
  52.            escucha.LoadGrammar(new DictationGrammar()); // Escuchar tu voz desde el micro.
  53.            escucha.SpeechRecognized += new EventHandler<SpeechRecognizedEventArgs>(lector); // Escribe las palabras.
  54.            escucha.RecognizeAsync(RecognizeMode.Multiple); // Reconociendo varias palabas.
  55.        }
  56.  
  57.        public void lector(object sender, SpeechRecognizedEventArgs e)
  58.        {
  59.            foreach (RecognizedWordUnit palabra in e.Result.Words)
  60.            {
  61.                Console.SetCursorPosition(10, 10);
  62.                Console.Write(palabra.ToString());
  63.  
  64.                if (palabra.ToString() == "izquierda")
  65.                {
  66.  
  67.                    Console.Write("Palabra: ");
  68.                }
  69.            }
  70.        }
  71.    }
  72. }
  73.  

Ya dirás si algo funciona..
160  Programación / Programación General / Re: Manual de PowerShell en: 29 Marzo 2020, 14:04 pm
Hola:

Otro manual en español más mucho más actualizado, moderno y completo, hasta puedes explica como incrusta códigos C# y VB .net en PowerShell.

Ver manual.

Saludos.
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 [16] 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ... 237
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines