none
Funcionamiento de botones RRS feed

  • Pregunta

  • 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#:

    using System;
    
    namespace LCD_nombre_archivo_consola_02
    {
        class Programa
        {
    
            static string guardarNombre = "";
    
            static void Main(string[] args)
            {
                // Título de la pantalla.
                Console.Title = "Cambiar nombre";
    
                // Tamaño de la ventana.
                Console.SetWindowSize(20, 5);
    
                Inicio();
            }
    
            private static void Inicio()
            {
                int coordenadaX = 0;
                ConsoleKey key;
    
                char[] alfanumerico = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
                'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
                'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
                'z', '.', ',', '-', '_', ':', ';', '¿', '?', '(', ')', '[', ']', '{', '}','=', '$',
                '&', '"', ' '};
    
                int[] indiceArray = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                string[] texto = new string[] { "ATRÁS", "GUARDAR" };
    
                // Fondo verde.
                Console.BackgroundColor = ConsoleColor.Blue;
    
                // Letras negras.
                Console.ForegroundColor = ConsoleColor.White;
    
                Console.Clear();
    
                Console.SetCursorPosition(0, 0);
                Console.Write("Nombre del relé 1:");
                Console.SetCursorPosition(0, 1);
                Console.Write("AAAAAAAAAAAAAAAA");
                Console.SetCursorPosition(2, 3);
                Console.Write(texto[0]);
                Console.SetCursorPosition(12, 3);
                Console.Write(texto[1]);
    
                while (true)
                {
                    Console.SetCursorPosition(coordenadaX, 1);
    
                    key = Console.ReadKey(true).Key;
    
                    if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
                    {
                        coordenadaX++;
                    }
                    else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
                    {
                        coordenadaX--;
                    }
                    else if (key == ConsoleKey.UpArrow)
                    {
                        indiceArray[coordenadaX]++;
    
                        if (indiceArray[coordenadaX] >= alfanumerico.Length)
                        {
                            indiceArray[coordenadaX] = 0;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.DownArrow)
                    {
                        indiceArray[coordenadaX]--;
    
                        if (indiceArray[coordenadaX] < 0)
                        {
                            indiceArray[coordenadaX] = alfanumerico.Length - 1;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                }
            }
        }
    }

    Gracias por todo.



    http://electronica-pic.blogspot.com



    • Editado Metaconta martes, 31 de marzo de 2020 12:02
    martes, 31 de marzo de 2020 11:42

Respuestas

  • ¿Alguna otra duda?

    Creo que no. Decime vos si falta algo ahora. Les puse 10 a los índices iniciales para que comiencen en la A, que es el índice 10, así queda más normal, o sea, si pulso arriba me aparece la B, si no, si comienzan en 0, primero aparecen todas A y si pulsas arriba aparece el 1, porque el índice 0 es el 0, etc.

    using System;
    
    namespace LCD_nombre_archivo_consola_02
    {
        class Program
        {
            static void Main(string[] args)
            {
                // Título de la pantalla.
                Console.Title = "Cambiar nombre";
    
                // Tamaño de la ventana.
                Console.SetWindowSize(20, 5);
    
                string guardarNombre = "";
                int coordenadaX = 0;
                ConsoleKey key;
    
                char[] alfanumerico = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 
                'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
                'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
                'z', '.', ',', '-', '_', ':', ';', '¿', '?', '(', ')', '[', ']', '{', '}','=', '$', 
                '&', '"', ' '};
    
                int[] indiceArray = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
                string[] texto = new string[] { "ATRÁS", "GUARDAR" };
    
                // Fondo verde.
                Console.BackgroundColor = ConsoleColor.Blue;
    
                // Letras negras.
                Console.ForegroundColor = ConsoleColor.White;
    
                Console.Clear();
    
                Console.SetCursorPosition(0, 0);
                Console.Write("Nombre del relé 1:");
                Console.SetCursorPosition(0, 1);
                Console.Write("AAAAAAAAAAAAAAAA");
                Console.SetCursorPosition(2, 3);
                Console.Write(texto[0]);
                Console.SetCursorPosition(12, 3);
                Console.Write(texto[1]);
    
                while (true)
                {
                    Console.SetCursorPosition(coordenadaX, 1);
    
                    key = Console.ReadKey(true).Key;
    
                    if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
                    {
                        coordenadaX++;
                    }
                    else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
                    {
                        coordenadaX--;
                    }
                    else if (key == ConsoleKey.UpArrow)
                    {
                        indiceArray[coordenadaX]++;
    
                        if (indiceArray[coordenadaX] >= alfanumerico.Length)
                        {
                            indiceArray[coordenadaX] = 0;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.DownArrow)
                    {
                        indiceArray[coordenadaX]--;
    
                        if (indiceArray[coordenadaX] < 0)
                        {
                            indiceArray[coordenadaX] = alfanumerico.Length - 1;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.Enter) 
                    {
                        Console.SetCursorPosition(1, 3);
                        Console.Write(">");
    
                        int index = 0;
                        while (true) 
                        {
                            key = Console.ReadKey(true).Key;
                            if (key == ConsoleKey.RightArrow || key == ConsoleKey.LeftArrow)
                            { 
                                index = 1 - index; 
                            }
                            else if (key == ConsoleKey.UpArrow || key == ConsoleKey.DownArrow) 
                            {
                                Console.SetCursorPosition(coordenadaX, 1);
                                break;
                            }
                            else if (key == ConsoleKey.Enter)
                            {
                                if (index == 0)  // se pulsó Atrás
                                {
                                    Console.SetCursorPosition(0, 1);
                                    Console.Write("HAS PULSADO ATRÁS");
                                    Console.ReadLine();  // espera que se pulse Enter
                                    Console.SetCursorPosition(0, 1);
                                    for (int a = 0; a < indiceArray.Length; a++) 
                                        Console.Write(alfanumerico[indiceArray[a]]);
                                    break;  // vuelve a la edición de letras
                                }
                                else if (index == 1)  // se pulsó Guardar
                                {
                                    Console.SetCursorPosition(0, 1);
                                    Console.Write("HAS GUARDADO    ");
                                    guardarNombre = "";
                                    for (int a = 0; a < indiceArray.Length; a++)
                                        guardarNombre += alfanumerico[indiceArray[a]].ToString();
                                }
                            }
    
                            for (int a = 0; a < 2; a++)
                            {
                                Console.SetCursorPosition(1 + 10 * a, 3);
                                if (a == index)
                                    Console.Write(">");
                                else
                                    Console.Write(" ");
                            }
                        }
                        Console.SetCursorPosition(1, 3);
                        Console.Write(" ");
                    }
                }
            }
        }
    }

    • Marcado como respuesta Metaconta martes, 31 de marzo de 2020 20:53
    martes, 31 de marzo de 2020 15:00

Todas las respuestas

  • Hola

    No entendí bien que había que hacer en cada caso. Por ahora si pulsas Enter, va al menú, que lo moves con Derecha e Izquierda, si das Enter en Atrás, muestra el mensaje y espera que pulses Enter y regresa a la edición, si das Enter en Guardar no hace nada. 

    Una cosa para mencionar, que los índices de indiceArray deberían comenzar en 10, que es la A, no en 0, porque aparecen todas A al principio, si no pareciera que saltan hasta el número 0 al editar las letras. 

    using System;
    
    namespace LCD_nombre_archivo_consola_02
    {
        class Program
        {
            static void Main(string[] args)
            {
                // Título de la pantalla.
                Console.Title = "Cambiar nombre";
    
                // Tamaño de la ventana.
                Console.SetWindowSize(20, 5);
    
                string guardarNombre = "";
                int coordenadaX = 0;
                ConsoleKey key;
    
                char[] alfanumerico = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 
                'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
                'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
                'z', '.', ',', '-', '_', ':', ';', '¿', '?', '(', ')', '[', ']', '{', '}','=', '$', 
                '&', '"', ' '};
    
                int[] indiceArray = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                string[] texto = new string[] { "ATRÁS", "GUARDAR" };
    
                // Fondo verde.
                Console.BackgroundColor = ConsoleColor.Blue;
    
                // Letras negras.
                Console.ForegroundColor = ConsoleColor.White;
    
                Console.Clear();
    
                Console.SetCursorPosition(0, 0);
                Console.Write("Nombre del relé 1:");
                Console.SetCursorPosition(0, 1);
                Console.Write("AAAAAAAAAAAAAAAA");
                Console.SetCursorPosition(2, 3);
                Console.Write(texto[0]);
                Console.SetCursorPosition(12, 3);
                Console.Write(texto[1]);
    
                while (true)
                {
                    Console.SetCursorPosition(coordenadaX, 1);
    
                    key = Console.ReadKey(true).Key;
    
                    if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
                    {
                        coordenadaX++;
                    }
                    else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
                    {
                        coordenadaX--;
                    }
                    else if (key == ConsoleKey.UpArrow)
                    {
                        indiceArray[coordenadaX]++;
    
                        if (indiceArray[coordenadaX] >= alfanumerico.Length)
                        {
                            indiceArray[coordenadaX] = 0;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.DownArrow)
                    {
                        indiceArray[coordenadaX]--;
    
                        if (indiceArray[coordenadaX] < 0)
                        {
                            indiceArray[coordenadaX] = alfanumerico.Length - 1;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.Enter) 
                    {
                        Console.SetCursorPosition(1, 3);
                        Console.Write(">");
    
                        int index = 0;
                        while (true) 
                        {
                            key = Console.ReadKey(true).Key;
                            if (key == ConsoleKey.RightArrow)
                                index = 1;
                            else if (key == ConsoleKey.LeftArrow)
                                index = 0;
                            else if (key == ConsoleKey.Enter)
                            {
                                if (index == 0)  // se pulsó Atrás
                                {
                                    Console.SetCursorPosition(2, 2);
                                    Console.Write("HAS PULSADO ATRÁS.");
                                    Console.ReadLine();  // espera que se pulse Enter
                                    break;  // vuelve a la edición de letras
                                }
                                else if (index == 1)  // se pulsó Guardar
                                    ;  // aquí que hay que hacer? No hace nada por ahora
                            }
    
                            for (int a = 0; a < 2; a++)
                            {
                                Console.SetCursorPosition(1 + 10 * a, 3);
                                if (a == index)
                                    Console.Write(">");
                                else
                                    Console.Write(" ");
                            }
                        }
                    }
                }
            }
        }
    }

    martes, 31 de marzo de 2020 12:53
  • hola

    Solo a modo de sugerencia, espero no lo tomen a mal

    Pero no se plantearon pasarse los contactos y arman una meeting, es que el ultimo tiempo observo que ponen muuucho codigo en el cual solo Pablo responde y al resto de la comunidad no veo que aporte ya que es codigo muy especifico y puntual

    No seria mas facil armen un repo en GitHub y trabajen colabotativo en lugar de copiar y pegar continuamente codigo por este medio que no es el mejor para ese fin

    Digo, no es el foro un medio adecuado para compartirse codigo

    Despues si hay alguna duda algo mas general en ese caso si plantearlo en el grupo

    Es mas si el resultado ven que pueda interesar podrian armar un articulo o varios en un blog con el resultado final y compartirlo, eso creo que aportaria muchos mas

    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    martes, 31 de marzo de 2020 13:17
  • Hola:

    Tal vez sea mejor. Da igual solo quien responde. Hay muchos visitante que con el tiempo tienen ideas.

    Gracias por la sugerencia.


    http://electronica-pic.blogspot.com

    martes, 31 de marzo de 2020 13:26
  • Avatar de Tigre Pablito

    Tigre Pablito

    Vas por buen camino.

    Para dejarlo claro.

    Paso 1:
    El cursor está parpadeando en la parte AAAAAAAAAAAA.
    Cuando tenga ya el nombre hecho, pulsa Enter y se va a ATRÁS.

    > ATRÁS     GUADAR

    Paso 2.
    Cuando esté el > ATRÁS y GUARDAR. El símbolo > tiene que ser capaz de moverte en esos ámbitos. Si pulsa todo el rato por ejemplo a la izquierda, el > se va rotando, no que se quede pegado siempre a la izquierda.

    Paso 3.
    Estando todavía el > en ATRÁS o GUARDAR, desde que pulse una flecha arriba o bajo, se va directamente el cursor a donde pone AAAAAAAAAAA, para cambiar nombre otra vez. Para salir del AAAAAAAAAAA, pulsa Enter y vas directamente el cursor a > ATRÁS.

    Paso 4.
    Si ya estamos en la parte > ATRÁS y pulsas Enter. Se va el cursor hacia el AAAAAAAAAAA y aparece el mensaje "HAS PULSADO ATRÁS", tal como hicieste. Una vez cuando pulse Enter otra vez cuando ya estoy en la zona de AAAAAAAAAAAA, pasa a > ATRÁS y se quitta el mensaje "HAS PULSADO ATRÁS".

    Paso 5.
    Estando en > GUARDAR, pulsas Enter. Aparecerá el mensaje "HAS GUARDADO." Hay una variable llamdo:

    string guardarNombre = "";

    No se si esta está mejor.

    string guardarNombre = string.Empty;

    Que  ahí se guarda el nombre seleccionado que cambiamos en AAAAAAAAAAAAAA.

    ¿Alguna otra duda?


    http://electronica-pic.blogspot.com

    martes, 31 de marzo de 2020 13:48
  • ¿Alguna otra duda?

    Creo que no. Decime vos si falta algo ahora. Les puse 10 a los índices iniciales para que comiencen en la A, que es el índice 10, así queda más normal, o sea, si pulso arriba me aparece la B, si no, si comienzan en 0, primero aparecen todas A y si pulsas arriba aparece el 1, porque el índice 0 es el 0, etc.

    using System;
    
    namespace LCD_nombre_archivo_consola_02
    {
        class Program
        {
            static void Main(string[] args)
            {
                // Título de la pantalla.
                Console.Title = "Cambiar nombre";
    
                // Tamaño de la ventana.
                Console.SetWindowSize(20, 5);
    
                string guardarNombre = "";
                int coordenadaX = 0;
                ConsoleKey key;
    
                char[] alfanumerico = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 
                'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
                'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
                'z', '.', ',', '-', '_', ':', ';', '¿', '?', '(', ')', '[', ']', '{', '}','=', '$', 
                '&', '"', ' '};
    
                int[] indiceArray = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
                string[] texto = new string[] { "ATRÁS", "GUARDAR" };
    
                // Fondo verde.
                Console.BackgroundColor = ConsoleColor.Blue;
    
                // Letras negras.
                Console.ForegroundColor = ConsoleColor.White;
    
                Console.Clear();
    
                Console.SetCursorPosition(0, 0);
                Console.Write("Nombre del relé 1:");
                Console.SetCursorPosition(0, 1);
                Console.Write("AAAAAAAAAAAAAAAA");
                Console.SetCursorPosition(2, 3);
                Console.Write(texto[0]);
                Console.SetCursorPosition(12, 3);
                Console.Write(texto[1]);
    
                while (true)
                {
                    Console.SetCursorPosition(coordenadaX, 1);
    
                    key = Console.ReadKey(true).Key;
    
                    if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
                    {
                        coordenadaX++;
                    }
                    else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
                    {
                        coordenadaX--;
                    }
                    else if (key == ConsoleKey.UpArrow)
                    {
                        indiceArray[coordenadaX]++;
    
                        if (indiceArray[coordenadaX] >= alfanumerico.Length)
                        {
                            indiceArray[coordenadaX] = 0;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.DownArrow)
                    {
                        indiceArray[coordenadaX]--;
    
                        if (indiceArray[coordenadaX] < 0)
                        {
                            indiceArray[coordenadaX] = alfanumerico.Length - 1;
                        }
    
                        Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                    }
                    else if (key == ConsoleKey.Enter) 
                    {
                        Console.SetCursorPosition(1, 3);
                        Console.Write(">");
    
                        int index = 0;
                        while (true) 
                        {
                            key = Console.ReadKey(true).Key;
                            if (key == ConsoleKey.RightArrow || key == ConsoleKey.LeftArrow)
                            { 
                                index = 1 - index; 
                            }
                            else if (key == ConsoleKey.UpArrow || key == ConsoleKey.DownArrow) 
                            {
                                Console.SetCursorPosition(coordenadaX, 1);
                                break;
                            }
                            else if (key == ConsoleKey.Enter)
                            {
                                if (index == 0)  // se pulsó Atrás
                                {
                                    Console.SetCursorPosition(0, 1);
                                    Console.Write("HAS PULSADO ATRÁS");
                                    Console.ReadLine();  // espera que se pulse Enter
                                    Console.SetCursorPosition(0, 1);
                                    for (int a = 0; a < indiceArray.Length; a++) 
                                        Console.Write(alfanumerico[indiceArray[a]]);
                                    break;  // vuelve a la edición de letras
                                }
                                else if (index == 1)  // se pulsó Guardar
                                {
                                    Console.SetCursorPosition(0, 1);
                                    Console.Write("HAS GUARDADO    ");
                                    guardarNombre = "";
                                    for (int a = 0; a < indiceArray.Length; a++)
                                        guardarNombre += alfanumerico[indiceArray[a]].ToString();
                                }
                            }
    
                            for (int a = 0; a < 2; a++)
                            {
                                Console.SetCursorPosition(1 + 10 * a, 3);
                                if (a == index)
                                    Console.Write(">");
                                else
                                    Console.Write(" ");
                            }
                        }
                        Console.SetCursorPosition(1, 3);
                        Console.Write(" ");
                    }
                }
            }
        }
    }

    • Marcado como respuesta Metaconta martes, 31 de marzo de 2020 20:53
    martes, 31 de marzo de 2020 15:00
  • Lo de las AAAAAAAAAAAAA.

    Parece que mejor hacer algo parecido a esto.

                for (int i = 0; i < alfanumerico.Length; i++)
                {
                    Console.Write(alfanumerico[i]);
                }

    No está bien hecho. En vez de presentarlo así como indica abajo.

    Console.Write("AAAAAAAAAAAAAAAA");

    Mejor lo presentamos de otra manera que lea lo que hay en el array, y muestre las A. Son 16 A que tiene que mostrar.


    http://electronica-pic.blogspot.com

    martes, 31 de marzo de 2020 16:41
  • En este caso y al principio es lo mismo, pero podes poner

    for (int a = 0; a < indiceArray.Length; a++)
        Console.Write(alfanumerico[indiceArray[a]]);

    Y escribirá 

    AAAAAAAAAAAAAAAA

    Lo que si no cambies que los índices comiencen en 10, porque si no imprimirá todos 0

    martes, 31 de marzo de 2020 17:53
  • En este caso y al principio es lo mismo, pero podes poner

    for (int a = 0; a < indiceArray.Length; a++)
        Console.Write(alfanumerico[indiceArray[a]]);

    Y escribirá 

    AAAAAAAAAAAAAAAA

    Lo que si no cambies que los índices comiencen en 10, porque si no imprimirá todos 0

    Me dice este error.

    System.IndexOutOfRangeException
      HResult=0x80131508
      Mensaje = Índice fuera de los límites de la matriz.
      Origen = LCD_nombre_archivo_consola_03
      Seguimiento de la pila:
       en LCD_nombre_archivo_consola_03.Program.Main(String[] args) en C:\Users\Usuario\Documents\Visual Studio 2019\Projects\LCD_nombre_archivo_consola_03\LCD_nombre_archivo_consola_03\Program.cs: línea 44


    http://electronica-pic.blogspot.com

    martes, 31 de marzo de 2020 20:37
  • Puede ser porque pusiste ese código antes de asignar los índices (todos 10) de indiceArray ? O antes de asignar los valores de alfanumerico ? Si no es ninguna de las 2, hay algo muy misterioso que me tendrías que pasar el código para que pueda averiguar qué es ...
    martes, 31 de marzo de 2020 20:46
  • Lo tenía mal hecho, en vez de tener indiceArrray, tenia albanumérico en el for.

    Puse 16 o despés lo que pusiste indiceArray y funciona.

    Ahora si.

                for (int i = 0; i < indiceArray.Length; i++)            {                Console.Write(alfanumerico[indiceArray[i]]);            }
    
    
    
    //------------------------------
    
    
                for (int i = 0; i < 16; i++)
                {
                    Console.Write(alfanumerico[indiceArray[i]]);
                }


    http://electronica-pic.blogspot.com

    martes, 31 de marzo de 2020 20:53
  • Por curiosidad.

    En vez de usar muchos if-else.

    ¿Por qué no lo sustituyes por switch?

    Así el programa será más compato y legible, para eso se hizo el switch. Voy a intentarlo.


    http://electronica-pic.blogspot.com

    martes, 31 de marzo de 2020 23:19
  • Por 2 razones muy simples, 1) porque es mucho más sencillo y fácil de escribir el if-else if, y 2) porque te permite cualquier tipo de expresión booleana (o lógica), y el switch tenés que ponerle una sola variable (por ej.: switch (c) { ... }) y en los case tenes que ponerle un valor directo, nada de >, <, !=, o &&, ||, etc., etc..

    No creo que puedas reemplazarlos, excepto una rara y pequeña excepción, en este programa. 

    miércoles, 1 de abril de 2020 0:29
  • Parece ser que si se puede.

    He hecho cambios. La parte del botón guardar no funciona como quiero, luego lo intento arreglar.

    using System;
    
    namespace LCD_nombre_archivo_consola_03
    {
        class Program
        {
            static string guardarNombre = "";
            static int coordenadaX = 0;
            static ConsoleKey key;
    
            static readonly char[] roALFANUMERICO = new char[] {
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
                'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
                'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
                'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
                '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '};
            static readonly int[] roINDICE_ARRAY = new int[] { 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };
            static readonly string[] TEXTO = new string[] { "ATRÁS", "GUARDAR" };
            static int index = 0;
            static void Main(string[] args)
            {
                // Título de la pantalla.
                Console.Title = "Cambiar nombre";
    
                Inicio();
            }
    
            #region Inico.
            private static void Inicio()
            {
                // Tamaño de la ventana.
                Console.SetWindowSize(20, 5);
    
    
    
                // Fondo verde.
                Console.BackgroundColor = ConsoleColor.Blue;
    
                // Letras negras.
                Console.ForegroundColor = ConsoleColor.White;
    
                Console.Clear();
    
                Console.SetCursorPosition(0, 0);
                Console.Write("Nombre del relé 1:  ");
                Console.SetCursorPosition(0, 1);
                //Console.Write("AAAAAAAAAAAAAAAA");
    
                for (int i = 0; i < roINDICE_ARRAY.Length; i++)
                {
                    Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
                }
    
                Console.SetCursorPosition(2, 3);
                Console.Write(TEXTO[0]);
                Console.SetCursorPosition(12, 3);
                Console.Write(TEXTO[1]);
    
                while (true)
                {
                    Console.SetCursorPosition(coordenadaX, 1);
                    key = Console.ReadKey(true).Key;
                    switch (key)
                    {
                        case ConsoleKey.RightArrow:
                            if (coordenadaX < 15)
                                coordenadaX++;
                            break;
    
                        case ConsoleKey.LeftArrow:
                            if (coordenadaX > 0)
                                coordenadaX--;
                            break;
    
                        case ConsoleKey.UpArrow:
                            roINDICE_ARRAY[coordenadaX]++;
                            if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                            {
                                roINDICE_ARRAY[coordenadaX] = 0;
                            }
                            Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                            break;
    
                        case ConsoleKey.DownArrow:
                            roINDICE_ARRAY[coordenadaX]--;
                            if (roINDICE_ARRAY[coordenadaX] < 0)
                            {
                                roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                            }
                            Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                            break;
    
                        case ConsoleKey.Enter:
                            Console.SetCursorPosition(1, 3);
                            Console.Write(">");
      
                            while (true)
                            {
                                key = Console.ReadKey(true).Key;
    
                                switch (key)
                                {
                                    case ConsoleKey.RightArrow:
                                    case ConsoleKey.LeftArrow:
                                        index = 1 - index;
                                        break;
    
                                    case ConsoleKey.UpArrow:
                                    case ConsoleKey.DownArrow:
                                        Console.SetCursorPosition(coordenadaX, 1);
                                        break;
    
                                    case ConsoleKey.Enter:
    
                                        break;
                                }
    
                                for (int a = 0; a < 2; a++)
                                {
                                    Console.SetCursorPosition(1 + (10 * a), 3);
                                    if (a == index)
                                        Console.Write(">");
                                    else
                                        Console.Write(" ");
                                }
    
                                if (index == 0)  // se pulsó Atrás
                                {
                                    Atras();
                                    //break;  // vuelve a la edición de letras
                                }
                                else if (index == 1)  // se pulsó Guardar
                                {
                                    Guardar();
                                }
                            }
                    }
                }
            }
            #endregion
    
            private static void Atras()
            {
                Console.Clear();
                Console.SetCursorPosition(0, 1);
                Console.Write("HAS PULSADO ATRÁS   ");
                Console.ReadKey(); // Pulse cualquier tecla para salir.
            }
    
            private static void Guardar()
            {
                Console.Clear();
                Console.SetCursorPosition(0, 1);
                Console.Write("HAS GUARDADO       ");
                for (int a = 0; a < roINDICE_ARRAY.Length; a++)
                    guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
                Console.SetCursorPosition(0, 2);
                Console.Write(guardarNombre);
            }
        }
    }

    ¿Se puede o no se puede?

    Hablando la parde de los if else y switch.

    Saludos.

    PD: No se que pasa, pero ya no me deja poner const, si readonly. Para buenas prácticas de programación, se aconseja poner las constantes con mayúsculas como esto, HOLA o HOLA_AMIGO.

    Para diferenciar si es una const o readonly se pone así:

    cHOLA o cHOLA_AMIGO

    reHOLA o reHOLA_AMIGO

    si es una variable, ya que su valor varía. Se aconseja así:

    hola o holaAmigo.

    Para tenerlo en cuenta, esto ya lo sabrás.

    Lo que quiero arregar es lo del ATRÁS y GUARDAR, me salió todo mal.

    1. Si pulsas Enter, el cursor > va hacia ATRÁS. Si pulsas Enter ahí, sale el mensaje HAS PULSADO ATRÁS. Si quieres salir de ahí, cerrar programa, porque ya a acabado.

    2. Si seleccionas con el > GUARDAR, se habre otra pantalla, y muestra dos mensajes, HAS GUARDADO y en una lína más abajo muestra el nombre que haz guardado en la variable.

    3. En cada pantalla que salga, se debe ignorar todas las flechas porque el programa ha acabado.


    http://electronica-pic.blogspot.com



    • Editado Metaconta miércoles, 1 de abril de 2020 1:21
    miércoles, 1 de abril de 2020 1:08
  • No entiendo como te permite aumentar y disminuir los valores de roINDICE_ARRAY si lo pusiste readonly

    Lo demás que cambiaste (o trataste de cambiar) los if-else if por switch, no se, tendría que ver el original y ver cuales se pueden cambiar, pero me parece que no tiene mucho sentido en estos casos en los que no se gana nada y se puede lograr que el programa deje de funcionar.

    miércoles, 1 de abril de 2020 1:28
  • He modificado cosas del final.

    Sobre todo lo de los bobotnes ATRÁS y GUARDAR. Ignorando esto.

    El compilador me indicó que pusiera readonly precisamente porque solalmente lee, no modifica en ningún momento el contenido del índice del array.

    Solo lee, no modifica, lo que la palabra const no me lo deja poner, solo readonly.

    static readonly int[] roINDICE_ARRAY = new int[] { 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };

    Lo que cuentas que no entiendes, en el cual yo tampoco. Miramos el primer valor.

    roINDICE_ARRAY[0].

    Es un 80, esos valores si cambian en tiempo de ejecución, en la memoria. A pesar de ello, está en readonly y no se porqué lo permite, es más, el compilador o IDE Visual Studio Community 2019 me sugirió qu elo haga en readonly.

    Entiendo que este código de abajo, si que sea solo lectura ya que solo lee las letras.

            static readonly char[] roALFANUMERICO = new char[] {
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
                'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
                'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
                'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
                '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '};

    No hay modificación alguna.

    A ver si viene alguien que nos explique el motivo.



    http://electronica-pic.blogspot.com



    • Editado Metaconta miércoles, 1 de abril de 2020 2:06
    miércoles, 1 de abril de 2020 1:50
  • Quizás lo que no se modifica es la matriz en si misma, o sea siempre tiene 16 posiciones, o sea es

    static readonly int[] roINDICE_ARRAY;

    pero NO

    roINDICE_ARRAY = new readonly int[] { ... } 

    miércoles, 1 de abril de 2020 2:04
  • Si se modifica el reINDICE_ARRAY, puse AB, y se cambia de valor, lo comprobé en el depurador. Entonces no entiendo nada.

    A lo mejor lo que no se puede cambiar es el tamaño de la matriz si pones readonly, porque el contenido si lo hace.


    http://electronica-pic.blogspot.com


    • Editado Metaconta miércoles, 1 de abril de 2020 2:07
    miércoles, 1 de abril de 2020 2:06
  • Claro, eso es lo que te estaba diciendo, los elementos de la matriz pueden cambiar, pero no su tamaño ... creo
    miércoles, 1 de abril de 2020 2:29
  • hola

    >>el switch tenés que ponerle una sola variable

    eso ya cambio, en c# 7 y 8 el switch es mucho mas avanzado

    Pattern Matching (c# 7)

    Pattern matching enhancements (c# 8)

    puedes aplicar el swith

    - en conjunto con el "is" para saber de que tipo es la instancia de la clase

    - se puede aplicar el "when"

    when clauses in case expressions

    - se puede evaluar propiedades directamenteProperty patterns

    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    miércoles, 1 de abril de 2020 3:34
  • Holassssss:

    Está bien los enlaces que pusiste.

    Enlace uno y enlace dos en español.

    En el enalce da abajo, en el lenguaje C/C++ sea del CLR .net o del Win32, no me puedo creer que todavía en los case solo admita un caracter y no pongan un string como si hace aquí abajo. C# si lo ahce desde siempre.

    static object CreateShape(string shapeDescription)
    {
        switch (shapeDescription)
        {
            case "circle":
                return new Circle(2);
    
            case "square":
                return new Square(4);
            
            case "large-circle":
                return new Circle(12);
    
            case var o when (o?.Trim().Length ?? 0) == 0:
                // white space
                return null;
            default:
                return "invalid shape description";
        }            
    }


    El nuevo estilo del switch lo veo por ahora confuso.

    Teniendo el ejemplo switch normal, o el de toda la vida abajo.

    using System;
    
    public enum Color { Red, Green, Blue }
    
    public class Example
    {
       public static void Main()
       {
          Color c = (Color) (new Random()).Next(0, 3);
          switch (c)
          {
             case Color.Red:
                Console.WriteLine("The color is red");
                break;
             case Color.Green:
                Console.WriteLine("The color is green");
                break;
             case Color.Blue:
                Console.WriteLine("The color is blue");   
                break;
             default:
                Console.WriteLine("The color is unknown.");
                break;   
          }
       }
    }

    En if else sería así:

    using System;
    
    public enum Color { Red, Green, Blue }
    
    public class Example
    {
       public static void Main()
       {
          Color c = (Color) (new Random()).Next(0, 3);
          if (c == Color.Red)
             Console.WriteLine("The color is red");
          else if (c == Color.Green)
             Console.WriteLine("The color is green");
          else if (c == Color.Blue)
             Console.WriteLine("The color is blue");   
          else
             Console.WriteLine("The color is unknown.");
       }
    }
    // The example displays the following output:
    //       The color is re

    ¿Cómo sería con el nuevo switch?

    Saludos.


    http://electronica-pic.blogspot.com


    • Editado Metaconta miércoles, 1 de abril de 2020 11:16
    miércoles, 1 de abril de 2020 11:15
  • Hola Leandro, 

    Leí los 2 primeros enlaces y está bueno lo que allí dice, aunque yo no soy muy amigo de las expresiones tipo Linq, me parece igual que está bueno. Después cada uno puede optar por la sintaxis que más le guste.

    Hola Metaconta,

    Por lo que leí (vos leíste los enlaces?) sería así:

    public static string GetColorString(Color c)
    {
        c switch 
        {
            Color.Red     => return "The color is Red",
            Color.Green   => return "The color is green",
            Color.Blue    => return "The color is blue",
            _             => return "The color is unknown" 
        }
    }
    
    Console.WriteLine(GetColorString(c));
    
    El Random tendría que ir de 0 a 2 que son los valores válidos


    miércoles, 1 de abril de 2020 20:24
  • Hola:

    Ahora entiendo porqué no me funciona. Me dice que la versión C# 7.3 no es compatible, que use el C# 8.0 o poesterior. Pensé que tenía la C# 8.0 porque siempre actualizo Visual Studio Community 2019. Instalé el FrameWotk net 4.8.

    Deja ver si configuro algo para utulizar el C# 8.0. Lo hubieran puesto de serie y se dejen de tonterías.

    Saludos.


    http://electronica-pic.blogspot.com

    miércoles, 1 de abril de 2020 22:54