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


 


Tema destacado: Únete al Grupo Steam elhacker.NET


  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 ... 229
111  Programación / .NET (C#, VB.NET, ASP) / 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.
112  Informática / Electrónica / Re: Que vale la pena aprender de la electrónica? en: 16 Junio 2019, 19:33
Hola c3turotime:

Estudié electrónica general, en el cual das básico electricidad también. Hoy en día dentro de esa rama te pide que sepas de informática general básica como instalar Windows, saber un poco de redes y te ganarás la vida.

Estudé reparación de equipos de consumo como los TV, vídeos VHS de la época , DVD y demás, todo lo que sean aparatos, luego en industriales con máquinas muy caras que te encontrarás en las centrales eléctricas, cosas así. Si tienes electrónica general, te puedes meter hasta reparaciones de equípos médicos.

La electrónica tiene muchas salidas, el menos en España.

En mi caso, estoy actualmente ganándome la vida desde hace meses en reparación de vehículos a motor, tiene mucha electrónica, preparándome para coches solo eléctricos por eso me contrataron. No piden mucho para estas cosa, así que puedes ir a poner currículum en casas oficiales, también impartirán cursos obligados por la casa, sea online o presencial.

Saludos.

PD: Ánimos y adelante. ;)
113  Informática / Electrónica / Controlar Led 13 de Arduino desde email en: 16 Junio 2019, 19:14
Hola:

Ver imagen.

Hice un código con C# de la consola en el cual puedes apagar y encender el famoso y popular Led 13. Uso el LCD Keypad Shield para ver en pantalla los mensajes a parte desde el PC.

El código es una versión alfa pero funcional. Puede recibir códigos desde un correo electrónico pero no puede ejecutar comandos desde el teclado ni directamente desde Arduino, voy por parte.

Les dejo el código para que hagan pruebas y comente sus impresiones sobre lo que he hecho para mejorarlo. Si, está en modo consola, má adelante se hará con Windows Form y WPF, a parte de C#, también con Visual Basic .net y Visual C++.

Puedes enviar con tu movil (o celular) en cualquier parte y enviar comandos.

Dejo claroue tiene sistema de filtros de los email, solo acepta comandos de los email que hayas filtrado, de lo contrario cualquiera te puede cerrar o bajar las persianas de tu casa, ajjajajajjaja.

Recuerdo que la aplicación es alfa, falta codear que de respuesta desde el P hacia el movil el estado de las persianas, ventiladores o luces de la casa como están y si realmente se ha ejecutado dicha orden.

A descargar si no lo tienen, Visual Studio Community gratuito.

Código Arduino:
Código:
#include <LiquidCrystal.h>

// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;

const byte Led = 13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
  pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
  Serial.begin(115200);     // Puerto serie 115200 baudios.
  lcd.begin(16, 2);         // Formato de pantalla.
  lcd.clear();      // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
}

void loop()
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0)
  {
    caracter = Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */

  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Luz_ON") == true)
  {
    digitalWrite(Led, HIGH); // Enciende el Led 13.
    Serial.write("ON - Led encendido.");    // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz ON.         "); // Mostrar en el LCD.
  }


  if (comando.equals("Luz_OFF") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("OFF - Led apagado. ");  // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz OFF.        "); // Mostrar en el LCD.
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}

Luz_OFF // Apaga el Led de Arduino.

Luz_ON // Enciende el Led de Arduino.

Salir. // Sale del programa C# o se cierra.

Son solo tres comandos. Esos comandos indicado arriba solo lo pones en el email en Asuntos y lo detecta. En mensaje no tienes que poner nada, los lee y muestra en pantalla pero nada más.

Código C#:
Código
  1. // Activar / desactivar Acceso de aplicaciones poco seguras en Google.
  2. // https://myaccount.google.com/lesssecureapps
  3.  
  4. using System;
  5. using System.Collections.Generic;
  6. using OpenPop.Pop3;
  7. using OpenPop.Mime;
  8. using System.Text.RegularExpressions;
  9. using System.IO.Ports;
  10. using System.Text;
  11. using System.Timers;
  12.  
  13. namespace Recibir_email_enviar_arduino_01
  14. {
  15.    class Program
  16.    {
  17.        // Disparador de eventos del timer. Dispara cada cierto tiempo por el timer.
  18.        public static void DisparadorEventosTimer(object source, ElapsedEventArgs e)
  19.        {
  20.            //ConsoleKey tecla;
  21.            string comando = "";
  22.  
  23.            ConnectPop3 oC = new ConnectPop3();
  24.  
  25.            List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();
  26.  
  27.  
  28.            if (lstMessages != null)
  29.            {
  30.  
  31.                foreach (var oMessage in lstMessages)
  32.                {
  33.                    Console.ForegroundColor = ConsoleColor.White;
  34.                    Console.WriteLine("EMAIL DE: ");
  35.                    Console.ForegroundColor = ConsoleColor.Gray;
  36.  
  37.                    string emailDesde = oMessage.Headers.From.ToString();
  38.  
  39.                    // Expresión regular detectar dirección email.
  40.                    Regex rx = new Regex(@"<(.*?)>");
  41.                    //Regex rx = new Regex(@"^([da-z_.-]+)@([da-z.-]+).([a-z.]{2,6})$");
  42.                    // Guarda la dirección email en la variable "emailCompleto".
  43.                    string emailCompleto = rx.Match(emailDesde).Groups[1].Value;
  44.                    // Muestra solo la dirección del email.
  45.                    Console.WriteLine(emailCompleto);
  46.  
  47.                    // ¿Son email filtrados? Sí, ejecuta las intrucciones necesarios para leer asunto y mensajes.
  48.                    if ((emailCompleto == "metaconta@gmail.com") || (emailCompleto == "celltium@gmail.com"))
  49.                    {
  50.                        Console.WriteLine("{0} a pasado el filtro: ", emailCompleto);
  51.  
  52.                        Console.ForegroundColor = ConsoleColor.White;
  53.                        Console.WriteLine();
  54.                        Console.WriteLine("ASUNTO: ");
  55.                        Console.ForegroundColor = ConsoleColor.Gray;
  56.                        Console.WriteLine(oMessage.Headers.Subject + "\n"); // Asunto.
  57.                        comando = oMessage.Headers.Subject; // Guarda el asunto en la variable "comando".
  58.                        Console.ForegroundColor = ConsoleColor.White;
  59.                        Console.WriteLine();
  60.                        Console.WriteLine("MENSAJE: ");
  61.                        Console.ForegroundColor = ConsoleColor.Gray;
  62.                        Console.WriteLine();
  63.  
  64.                        // ¿Es texto sin formato? Sí.
  65.                        // if (oMessage.MessagePart.IsText == true)
  66.                        if (oMessage.MessagePart.IsText)
  67.                        {
  68.                            Console.WriteLine("Texto sin formato.");
  69.                            Console.WriteLine(oMessage.MessagePart.GetBodyAsText());
  70.                            Console.WriteLine("-------------------------------------------");
  71.                        }
  72.                        // No. Texto con formato.
  73.                        else
  74.                        {
  75.                            Console.WriteLine("Texto con formato.");
  76.  
  77.                            // Encuentra el primer texto sin formato.
  78.                            MessagePart plainTextPart = oMessage.FindFirstPlainTextVersion();
  79.                            if (plainTextPart != null)
  80.                            {
  81.                                // El mensaje tenía una versión de texto sin formato.
  82.                                Console.WriteLine(plainTextPart.GetBodyAsText());
  83.                            }
  84.                            else
  85.                            {
  86.                                // Trate de encontrar un cuerpo para mostrar en algunas de las otras versiones de texto.
  87.                                List<MessagePart> textVersions = oMessage.FindAllTextVersions();
  88.                                if (textVersions.Count >= 1)
  89.                                {
  90.                                    Console.WriteLine(textVersions[0].GetBodyAsText());
  91.                                }
  92.                                else
  93.                                {
  94.                                    Console.WriteLine("<<OpenPop>> Cannot find a text version body in this message to show <<OpenPop>>");
  95.                                }
  96.                            }
  97.                        }
  98.                    }
  99.  
  100.                    // No. Entonces,ignorará los email no filtrados.
  101.                    else
  102.                    {
  103.                        Console.WriteLine("No ha pasado el filtro y no se leerá ningún email.");
  104.                    }
  105.                }
  106.            }
  107.            Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
  108.            Console.WriteLine();
  109.            Console.WriteLine("FIN DEL PROGRAMA.");
  110.            //Console.ReadKey(); // Pulse cualquier tecla para salir.
  111.            Console.ForegroundColor = ConsoleColor.Gray;
  112.  
  113.            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
  114.            SerialPort Puerto_serie = new SerialPort("COM4")
  115.            {
  116.                BaudRate = 115200,
  117.                Parity = Parity.None,
  118.                StopBits = StopBits.One,
  119.                DataBits = 8,
  120.                Handshake = Handshake.None,
  121.                RtsEnable = true,
  122.  
  123.                // Establecer los tiempos de espera de lectura / escritura.
  124.                ReadTimeout = 500, // Milisegundos.
  125.                WriteTimeout = 500
  126.            };
  127.  
  128.            // Detecta cualquier dato recibido.
  129.            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
  130.  
  131.            Puerto_serie.Open(); // Abrir puerto.
  132.  
  133.            // ConsoleKey tecla;
  134.            Console.WriteLine("Pulse tecla 1 para encender y 2 para apagar:");
  135.  
  136.            do
  137.            {
  138.  
  139.                switch (comando)
  140.                {
  141.                    case "Luz_ON":
  142.                        EncenderLuz();
  143.                        break;
  144.  
  145.                    case "Luz_OFF":
  146.                        ApagarLuz();
  147.                        break;
  148.  
  149.                    case "Salir":
  150.                        Environment.Exit(1); // Salir de la consola.
  151.                        break;
  152.  
  153.                    default:
  154.                        Console.WriteLine("Esperando comandos válidos");
  155.                        break;
  156.                }
  157.  
  158.                //tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.
  159.  
  160.  
  161.  
  162.                //switch (tecla)
  163.                //{
  164.                //    case ConsoleKey.D1: // Tecla 1 del teclado estandar.
  165.                //    case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
  166.                //        EncenderLuz();
  167.                //        break;
  168.  
  169.                //    case ConsoleKey.D2:
  170.                //    case ConsoleKey.NumPad2:
  171.                //        ApagarLuz();
  172.                //        break;
  173.  
  174.                //    default:
  175.                //        Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
  176.                //        break;
  177.                //}
  178.  
  179.                Puerto_serie.Close(); // Cerrar puerto.
  180.  
  181.            } while (comando == "salir"); // while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.
  182.  
  183.            void EncenderLuz()
  184.            {
  185.                byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
  186.                Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
  187.                Console.WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
  188.            }
  189.  
  190.            void ApagarLuz()
  191.            {
  192.                byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
  193.                Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
  194.                Console.WriteLine("Comando \"Luz_OFF\" enviado.");
  195.            }
  196.  
  197.            Console.WriteLine("Presione cualquier tecla para terminar...");
  198.            Console.WriteLine();
  199.            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
  200.            Puerto_serie.Close(); // Cierra el puerto serie.
  201.        }
  202.  
  203.        static void Main(string[] args)
  204.        {
  205.            // Título de la ventana.
  206.            Console.Title = "Recibir e-mail con Consola C# y enviar al LCD de Arduino";
  207.  
  208.            // Tamaño ventana consola.
  209.            Console.WindowWidth = 80; // X. Ancho.
  210.            Console.WindowHeight = 40; // Y. Alto.
  211.  
  212.            // Cursor invisible.
  213.            Console.CursorVisible = false;
  214.  
  215.            // Título del programa.
  216.            Console.WriteLine("\t-----------------------------------------------------");
  217.            Console.WriteLine("\tRecibir Correo Electrónico y enviar al LCD de Arduino");
  218.            Console.WriteLine("\t-----------------------------------------------------");
  219.            Console.WriteLine();
  220.  
  221.            try
  222.            {
  223.                Timer miTimer = new Timer
  224.                {
  225.                    Enabled = true
  226.                };
  227.                miTimer.Elapsed += new ElapsedEventHandler(DisparadorEventosTimer);
  228.                miTimer.Interval = 5000; // Escaneo cada 5 segundos.
  229.                miTimer.Start(); // Activa el temporizador.
  230.  
  231.  
  232.                Console.ReadKey(); // Pulse cualquier tecla para salir.
  233.            }
  234.  
  235.            // Cualquier error mostrado en mensaje y de color rojo.
  236.            catch (Exception ex)
  237.            {
  238.                Console.ForegroundColor = ConsoleColor.Red;
  239.                Console.WriteLine();
  240.                Console.WriteLine(ex);
  241.                Console.ReadKey();
  242.            }
  243.  
  244.  
  245.        }
  246.  
  247.        // Detecta cualquier dato entrante.
  248.        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
  249.        {
  250.            SerialPort sp = (SerialPort)sender;
  251.            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
  252.            Console.WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
  253.        }
  254.    }
  255.  
  256.    public class ConnectPop3
  257.    {
  258.        public string email = "celltium@gmail.com";
  259.        public string contraseña = "g0923490xgh0945g450Xj4025g"; // Ficticio.
  260.        public int puerto = 995;
  261.        public bool usarSLL = true;
  262.        public string Hostame = "pop.gmail.com";
  263.  
  264.        public List<OpenPop.Mime.Message> GetMessages()
  265.        {
  266.            using (Pop3Client oClient = new Pop3Client())
  267.            {
  268.                oClient.Connect(Hostame, puerto, usarSLL);
  269.                oClient.Authenticate(email, contraseña);
  270.  
  271.                int messageCount = oClient.GetMessageCount();
  272.                List<OpenPop.Mime.Message> lstMessages = new List<OpenPop.Mime.Message>(messageCount);
  273.  
  274.                for (int i = messageCount; i > 0; i--)
  275.                {
  276.                    lstMessages.Add(oClient.GetMessage(i));
  277.                }
  278.  
  279.                return lstMessages;
  280.            }
  281.        }
  282.    }
  283. }
  284.  
Como no cabe en la web, lo pongo como descarga.

Los que los prueben, espero cualquier impresión.

Saludos.
114  Programación / .NET (C#, VB.NET, ASP) / Activar un timer cada cierto tiempo. en: 15 Junio 2019, 11:26
Hola:

Quiero usar un timer en modo consola C# para que lea cada cierto tiempo la bandeja de entrada de un correo.

Por ejemplo, he estado urgando con este código pero no se donde ponerlo siempre da errores.

Código
  1.                Timer miTimer = new Timer
  2.                {
  3.                    Enabled = true
  4.                };
  5.                miTimer.Elapsed += new ElapsedEventHandler(DisparadorEventosTimer);
  6.                miTimer.Interval = 60000; // 1 minuto.
  7.                miTimer.Start(); // Activa el temporizador.

En el evento debo poner en algún luegar para que lea el mensaje de entrada si hay algún mensje nuevo.

Código
  1.        public static void DisparadorEventosTimer(object source, ElapsedEventArgs e)
  2.        {
  3.            Console.Out.WriteLine("Evento: ");
  4.        }


El código del recibir corre electrónic lo ves justo debajo. Solo se actualiza al volver ejecutar la aplicación, cerrarla y vovler a ejecutar. Lo quiero automático, por cada minuto se active el timer, lea si hay mensajes nuevos sin tener que cerrar y ejecutar la aplicación.

Código
  1. using System;
  2. using System.Collections.Generic;
  3. using OpenPop.Pop3;
  4. using OpenPop.Mime;
  5. using System.Text.RegularExpressions;
  6.  
  7. namespace Recibir_email_Consola_03_cs
  8. {
  9.    class Program
  10.    {
  11.        static void Main(string[] args)
  12.        {
  13.            // Título de la ventana.
  14.            Console.Title = "Recibir e-mail con Consola C#";
  15.  
  16.            // Tamaño ventana consola.
  17.            Console.WindowWidth = 80; // X. Ancho.
  18.            Console.WindowHeight = 40; // Y. Alto.
  19.  
  20.            // Cursor invisible.
  21.            Console.CursorVisible = false;
  22.  
  23.            // Título del programa.
  24.            Console.WriteLine("\t\t----------------------------------------");
  25.            Console.WriteLine("\t\t\tRecibir Correo Electrónico");
  26.            Console.WriteLine("\t\t----------------------------------------");
  27.            Console.WriteLine();
  28.  
  29.            try
  30.            {
  31.                ConnectPop3 oC = new ConnectPop3();
  32.  
  33.                List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();
  34.  
  35.  
  36.                if (lstMessages != null)
  37.                {
  38.  
  39.                    foreach (var oMessage in lstMessages)
  40.                    {
  41.                        Console.ForegroundColor = ConsoleColor.White;
  42.                        Console.WriteLine("EMAIL DE: ");
  43.                        Console.ForegroundColor = ConsoleColor.Gray;
  44.  
  45.                        //string email = oMessage.Headers.ReturnPath.ToString();
  46.                        string email = oMessage.Headers.From.ToString();
  47.  
  48.                        // Expresión regular detectar dirección email.
  49.                        Regex rx = new Regex(@"<(.*?)>");
  50.                        //Regex rx = new Regex(@"");
  51.                        // Guarda la dirección email en la variable "emailCompleto".
  52.                        string emailCompleto = rx.Match(email).Groups[1].Value;
  53.                        // Muestra solo la dirección del email.
  54.                        Console.WriteLine(emailCompleto);
  55.  
  56.                        // ¿Son email filtrados? Sí, ejecuta las intrucciones necesarios para leer asunto y mensajes.
  57.                        if ((emailCompleto == "metaconta@gmail.com") ||  (emailCompleto == "celltium@gmail.com"))
  58.                        {
  59.                            Console.WriteLine("{0} a pasado el filtro: ", emailCompleto);
  60.  
  61.                            Console.ForegroundColor = ConsoleColor.White;
  62.                            Console.WriteLine();
  63.                            Console.WriteLine("ASUNTO: ");
  64.                            Console.ForegroundColor = ConsoleColor.Gray;
  65.                            Console.WriteLine(oMessage.Headers.Subject + "\n"); // Asunto.
  66.                            Console.ForegroundColor = ConsoleColor.White;
  67.                            Console.WriteLine();
  68.                            Console.WriteLine("MENSAJE: ");
  69.                            Console.ForegroundColor = ConsoleColor.Gray;
  70.  
  71.                            // ¿Es texto sin formato? Sí.
  72.                            // if (oMessage.MessagePart.IsText == true)
  73.                            if (oMessage.MessagePart.IsText)
  74.                            {
  75.                                Console.WriteLine("Texto sin formato.");
  76.                                Console.WriteLine(oMessage.MessagePart.GetBodyAsText());
  77.                            }
  78.                            // No. Texto con formato.
  79.                            else
  80.                            {
  81.                                Console.WriteLine("Texto con formato.");
  82.  
  83.                                // Encuentra el primer texto sin formato.
  84.                                MessagePart plainTextPart = oMessage.FindFirstPlainTextVersion();
  85.                                if (plainTextPart != null)
  86.                                {
  87.                                    // El mensaje tenía una versión de texto sin formato.
  88.                                    Console.WriteLine(plainTextPart.GetBodyAsText());
  89.                                }
  90.                                else
  91.                                {
  92.                                    // Trate de encontrar un cuerpo para mostrar en algunas de las otras versiones de texto.
  93.                                    List<MessagePart> textVersions = oMessage.FindAllTextVersions();
  94.                                    if (textVersions.Count >= 1)
  95.                                    {
  96.                                        Console.WriteLine(textVersions[0].GetBodyAsText());
  97.                                    }
  98.                                    else
  99.                                    {
  100.                                        Console.WriteLine("<<OpenPop>> Cannot find a text version body in this message to show <<OpenPop>>");
  101.                                    }
  102.                                }
  103.                            }
  104.                        }
  105.  
  106.                        // No. Entonces,ignorará los email no filtrados.
  107.                        else
  108.                        {
  109.                            Console.WriteLine("No ha pasado el filtro y no se leerá ningún email.");
  110.                        }          
  111.                    }
  112.                }
  113.                Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
  114.                Console.WriteLine();
  115.                Console.WriteLine("FIN DEL PROGRAMA.");
  116.                Console.ReadKey(); // Pulse cualquier tecla para salir.
  117.            }
  118.  
  119.            // Cualquier error mostrado en mensaje y de color rojo.
  120.            catch (Exception ex)
  121.            {
  122.                Console.ForegroundColor = ConsoleColor.Red;
  123.                Console.WriteLine();
  124.                Console.WriteLine(ex);
  125.                Console.ReadKey();
  126.            }
  127.        }
  128.    }
  129.  
  130.    public class ConnectPop3
  131.    {
  132.        public string email = "celltium@gmail.com";
  133.        public string contraseña = "g0923490xgh0945g450Xj4025g"; // Ficcicio.
  134.        public int puerto = 995;
  135.        public bool usarSLL = true;
  136.        public string Hostame = "pop.gmail.com";
  137.  
  138.        public List<OpenPop.Mime.Message> GetMessages()
  139.        {
  140.            using (Pop3Client oClient = new Pop3Client())
  141.            {
  142.                oClient.Connect(Hostame, puerto, usarSLL);
  143.                oClient.Authenticate(email, contraseña);
  144.  
  145.                int messageCount = oClient.GetMessageCount();
  146.                List<OpenPop.Mime.Message> lstMessages = new List<OpenPop.Mime.Message>(messageCount);
  147.  
  148.                for (int i = messageCount; i > 0; i--)
  149.                {
  150.                    lstMessages.Add(oClient.GetMessage(i));
  151.                }
  152.  
  153.                return lstMessages;
  154.            }
  155.        }
  156.    }
  157. }
  158.  

¿Alguna idea?

;)
115  Programación / .NET (C#, VB.NET, ASP) / Re: ¿Por qué solo puedo escribir 255 caracteres como máximo? en: 12 Junio 2019, 23:51
Console.ReadLine() solo pilla 256 caracteres.
   
Código
  1. byte[] bytes = new byte[2000]; //Nuevo tamanho maximo.
  2. Stream inputStream = Console.OpenStandardInput(bytes.Length);
  3. Console.SetIn(new StreamReader(inputStream));
  4. Console.WriteLine("\t\tMensaje: ");
  5. mensaje = Console.ReadLine();

Funciona de maravilla, muchas gracias mi muy distinguido amigo. ;)
116  Programación / .NET (C#, VB.NET, ASP) / ¿Por qué solo puedo escribir 255 caracteres como máximo? en: 12 Junio 2019, 07:00
Buenas:

Con este programa que es enviar email, en el mensaje solo puedo escribir hasta 255 letras o caracteres, lo mismo para el asunto.

¿Cuál es el motivo de la causa?

Su código es este.

Código
  1. using System;
  2. using System.Net.Mail;
  3. using System.Text;
  4. using System.Net;
  5.  
  6. namespace Enviar_e_mail_Consola_04_cs
  7. {
  8.    class Program
  9.    {
  10.        static void Main(string[] args)
  11.        {
  12.            string usuario, contraseña, destinatario, asunto, mensaje;
  13.  
  14.            // Título de la ventana.
  15.            Console.Title = "Enviar e-mail con Consola C#";
  16.  
  17.            // Tamaño ventana consola.
  18.            Console.WindowWidth = 80; // X. Ancho.
  19.            Console.WindowHeight = 40; // Y. Alto.
  20.  
  21.            // Tamaño del cursor. Del 1 al 100.
  22.            Console.CursorSize = 50;
  23.  
  24.            // Título del programa.
  25.            Console.WriteLine("\t\t----------------------------------------");
  26.            Console.WriteLine("\t\t\tEnviar Correo Electrónico");
  27.            Console.WriteLine("\t\t----------------------------------------");
  28.  
  29.            try
  30.            {
  31.                Console.WriteLine("\n");
  32.                Console.Write("\t\tIngresar tu correo electrónico: ");
  33.                usuario = Console.ReadLine();
  34.                Console.Write("\t\tIntroducir contraseña: ");
  35.                contraseña = LeerPassword();
  36.                Console.Write("\t\tDestinatario: ");
  37.                destinatario = Console.ReadLine();
  38.                Console.Write("\t\tAsunto: ");
  39.                asunto = Console.ReadLine();
  40.                Console.Write("\t\tMensaje: ");
  41.                mensaje = Console.ReadLine();
  42.  
  43.                MailMessage correo = new MailMessage(usuario, destinatario, asunto, mensaje);
  44.  
  45.                SmtpClient servidor = new SmtpClient("smtp.gmail.com")
  46.                {
  47.                    Port = 587
  48.                };
  49.                NetworkCredential credenciales = new NetworkCredential(usuario, contraseña);
  50.                servidor.Credentials = credenciales;
  51.                servidor.EnableSsl = true;
  52.  
  53.                Console.WriteLine("\t\tEnviando correo...");
  54.                servidor.Send(correo);
  55.                Console.WriteLine("\t\tCorreo enviado satisfactoriamente.");
  56.                correo.Dispose();
  57.                Console.ReadKey();
  58.            }
  59.            catch (Exception ex)
  60.            {
  61.                Console.WriteLine("\t\t" + ex.Message);
  62.                Console.WriteLine("\t\tNo se ha enviado el correo.");
  63.                Console.ReadKey();
  64.            }
  65.  
  66.        }
  67.  
  68.        // A la hora de introducir la contraseña, se sustituye por asterístos (*) en pantalla.
  69.        public static string LeerPassword()
  70.        {
  71.            ConsoleKeyInfo cki;
  72.            StringBuilder sb = new StringBuilder();
  73.            int contador = 0;
  74.  
  75.            do
  76.            {
  77.                cki = Console.ReadKey(true);
  78.                if (cki.Key != ConsoleKey.Enter)
  79.                {
  80.  
  81.                    sb.Append(cki.KeyChar);
  82.                    if (contador < 4)
  83.                    {
  84.                        Console.Write("*");
  85.                    }
  86.                    contador++;
  87.                }
  88.  
  89.                else
  90.                {
  91.                    break;
  92.                }
  93.  
  94.            } while (true);
  95.            Console.WriteLine();
  96.            return sb.ToString();
  97.        }
  98.    }
  99. }

Salu2. camaradas.
117  Programación / .NET (C#, VB.NET, ASP) / Re: ¿Cómo puedo leer el mensaje de un email y mostrarlo en la consola? en: 12 Junio 2019, 06:58
Hola:

Ya e funciona leer el POP3 del correo electrónico como puedes ver abajo, lee asunto y el mensaje de texto sin formato, de otra manera no lo lee.



El programa de abajo que funciona al completo, quiero modificar algunas cosa que no se como se hace, por ejemplo, si me llega mensajes nuevos, me lee todos los mensajes nuevos, solo quiero que me lea el último mensaje nuevo, solo un mensaje.

A parte de esto, C# no lee el último mensaje nuevo porque tiene que ser que vuelva a ejecutar el ejecutable.

¿Hay alguna manera de que el ejecutable lea en cada cierto tiempo la entrada del email?

Por ejemplo, en cada 5 minutos se pone a leer la bandeja de entrada si hay algún mensaje y lo muestra en pantalla, mientas el mensaje viejo que nunca se borra del servidor, solo en pantalla de la consola C# haga esto, Console.Clear(); // Limpiar pantalla y vuelva a mostrar mensaje nuevo.

Código fuente C#:
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using OpenPop.Pop3;
  4.  
  5. using System.Net.Mime;
  6.  
  7. namespace Recibir_email_Consola_01
  8. {
  9.    class Program
  10.    {
  11.        static void Main(string[] args)
  12.        {
  13.            // Título de la ventana.
  14.            Console.Title = "Recibir e-mail con Consola C#";
  15.  
  16.            // Tamaño ventana consola.
  17.            Console.WindowWidth = 80; // X. Ancho.
  18.            Console.WindowHeight = 40; // Y. Alto.
  19.  
  20.            // Cursor invisible.
  21.            Console.CursorVisible = false;
  22.  
  23.            // Título del programa.
  24.            Console.WriteLine("\t\t----------------------------------------");
  25.            Console.WriteLine("\t\t\tRecibir Correo Electrónico");
  26.            Console.WriteLine("\t\t----------------------------------------");
  27.            Console.WriteLine();
  28.  
  29.            try
  30.            {
  31.                ConnectPop3 oC = new ConnectPop3();
  32.  
  33.                List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();
  34.  
  35.  
  36.                if (lstMessages != null)
  37.                {
  38.  
  39.                    foreach (var oMessage in lstMessages)
  40.                    {
  41.                        Console.ForegroundColor = ConsoleColor.White;
  42.                        Console.WriteLine("ASUNTO: ");
  43.                        Console.ForegroundColor = ConsoleColor.Gray;
  44.                        Console.WriteLine(oMessage.Headers.Subject + "\n"); // Asunto.
  45.  
  46.                        //Console.WriteLine(oMessage.Headers.From); // Email del que te envió el mensaje.
  47.                        //Console.WriteLine(oMessage.Headers.ContentTransferEncoding); //out: SevenBit.
  48.                        //Console.WriteLine(oMessage.Headers.ContentType);
  49.                        //Console.WriteLine(oMessage.Headers.Date); // Fecha larga.
  50.                        //Console.WriteLine(oMessage.Headers.DateSent); // Fecha corta.
  51.                        //Console.WriteLine(oMessage.Headers.Importance); // Out: Normal.
  52.                        //Console.WriteLine(oMessage.Headers.MimeVersion); // Versión.
  53.                        //Console.WriteLine();
  54.  
  55.                        Console.ForegroundColor = ConsoleColor.White;
  56.                        Console.WriteLine("MENSAJE: "); // Aquí se pone código del mensaje que no se cual es.
  57.                        Console.ForegroundColor = ConsoleColor.Gray;
  58.                        Console.WriteLine(oMessage.MessagePart.GetBodyAsText()); // Mensaje.
  59.                    }
  60.                }
  61.                Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
  62.                Console.WriteLine();
  63.                Console.WriteLine("FIN DEL PROGRAMA.");
  64.                Console.ReadKey(); // Pulse cualquier tecla para salir.
  65.            }
  66.  
  67.            catch (Exception ex)
  68.            {
  69.                Console.ForegroundColor = ConsoleColor.Red;
  70.                Console.WriteLine();
  71.                Console.WriteLine(ex);
  72.                Console.ReadKey();
  73.            }
  74.        }
  75.    }
  76.  
  77.    public class ConnectPop3
  78.    {
  79.        public string email = "celltium@gmail.com";
  80.        public string contraseña = "g0923490xgh0945g450Xj4025g"; // Ficcicio.
  81.        public int puerto = 995;
  82.        public bool usarSLL = true;
  83.        public string Hostame = "pop.gmail.com";
  84.  
  85.        public List<OpenPop.Mime.Message> GetMessages()
  86.        {
  87.            using (Pop3Client oClient = new Pop3Client())
  88.            {
  89.                oClient.Connect(Hostame, puerto, usarSLL);
  90.                oClient.Authenticate(email, contraseña);
  91.  
  92.                int messageCount = oClient.GetMessageCount();
  93.                List<OpenPop.Mime.Message> lstMessages = new List<OpenPop.Mime.Message>(messageCount);
  94.  
  95.                for (int i = messageCount; i > 0; i--)
  96.                {
  97.                    lstMessages.Add(oClient.GetMessage(i));
  98.                }
  99.  
  100.                return lstMessages;
  101.            }
  102.        }
  103.    }
  104. }

Les recuerdo que solo admite mensaje texto sin formato para que lo lea.

Datos de interés.

https://github.com/foens/hpop

http://hdeleon.net/realizar-una-conexion-el-correo-para-ver-los-mails-con-c-net-gmail-pop3-openpop-net/

Un cordial saludos.
118  Programación / .NET (C#, VB.NET, ASP) / ¿Cómo puedo leer el mensaje de un email y mostrarlo en la consola? en: 11 Junio 2019, 01:23
Hola:

Me funciona el código, veo datos menos el que me interesa, precisamente no me sale el contenido del mensaje, es el que quiero que me muestre en pantalla.
El programa solo lee los últimos email nuevos.


(A veces tienes que actualizar varias veces tu navegador para que se muestre la captura).

Código C#:
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using OpenPop.Pop3;
  4.  
  5. namespace Recibir_email_Consola_01
  6. {
  7.    class Program
  8.    {
  9.        static void Main(string[] args)
  10.        {
  11.            // T&#237;tulo de la ventana.
  12.            Console.Title = "Recibir e-mail con Consola C#";
  13.  
  14.            // Tama&#241;o ventana consola.
  15.            Console.WindowWidth = 100; // X. Ancho.
  16.            Console.WindowHeight = 40; // Y. Alto.
  17.  
  18.            Console.WriteLine("\t\t----------------------------------------");
  19.            Console.WriteLine("\t\t\tRecibir Correo Electr&#243;nico");
  20.            Console.WriteLine("\t\t----------------------------------------");
  21.  
  22.            try
  23.            {
  24.                ConnectPop3 oC = new ConnectPop3();
  25.  
  26.                List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();
  27.  
  28.  
  29.                if (lstMessages != null)
  30.                {
  31.  
  32.                    foreach (var oMessage in lstMessages)
  33.                    {
  34.                        Console.WriteLine(oMessage.Headers.Subject); // Asunto.
  35.                        Console.WriteLine(oMessage.Headers.From); // Email del que te envi&#243; el mensaje.
  36.                        Console.WriteLine(oMessage.Headers.ContentTransferEncoding); //out: SevenBit.
  37.                        Console.WriteLine(oMessage.Headers.ContentType);
  38.                        Console.WriteLine(oMessage.Headers.Date); // Fecha larga.
  39.                        Console.WriteLine(oMessage.Headers.DateSent); // Fecha corta.
  40.                        Console.WriteLine(oMessage.Headers.Importance); // Out: Normal.
  41.                        Console.WriteLine(oMessage.Headers.MimeVersion); // Versi&#243;n.
  42.                        Console.WriteLine(oMessage.Headers.MessageId);
  43.                    }
  44.                }
  45.                Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
  46.                Console.WriteLine("FIN DEL PROGRAMA.");
  47.                Console.ReadKey(); // Pulse cualquier tecla para salir.
  48.            }
  49.  
  50.            catch (Exception e)
  51.            {
  52.                Console.WriteLine(e.ToString());
  53.            }
  54.        }
  55.    }
  56.  
  57.    public class ConnectPop3
  58.    {
  59.        public string email = "celltium@gmail.com";
  60.        public string contrase&#241;a = "g0923490xgh0945g450Xj4025g";
  61.        public int puerto = 995;
  62.        public bool usarSLL = true;
  63.        public string Hostame = "pop.gmail.com";
  64.  
  65.        public List<OpenPop.Mime.Message> GetMessages()
  66.        {
  67.            using (Pop3Client oClient = new Pop3Client())
  68.            {
  69.                oClient.Connect(Hostame, puerto, usarSLL);
  70.                oClient.Authenticate(email, contrase&#241;a);
  71.  
  72.                int messageCount = oClient.GetMessageCount();
  73.                List<OpenPop.Mime.Message> lstMesages = new List<OpenPop.Mime.Message>(messageCount);
  74.  
  75.                for (int i = messageCount; i > 0; i--)
  76.                {
  77.                    lstMesages.Add(oClient.GetMessage(i));
  78.                }
  79.  
  80.                return lstMesages;
  81.            }
  82.        }
  83.    }
  84. }
  85.  

Pensé que leer el mensaje es ete código pero veo que no.
Código
  1. Console.WriteLine(oMessage.Headers.MessageId);

http://rfinochi.github.io/pop3dotnet/

¿Cómo puedo ver el mensaje del email?

Saludos.
119  Programación / Programación C/C++ / Re: ¿Cómo transportar un ejecutable escrito en c++? en: 10 Junio 2019, 21:10
Prueba el mismo programa pero con C/C++ CLI o Visual C .net, lo mismo pero en .net y solo necesitas el .exe.
120  Programación / Programación C/C++ / Quiero saber si es posible transformas estas clases en dll y importarla en: 10 Junio 2019, 21:04
Hola:

Quiero saber si estas clases se puede transformar por llamarlo de alguna manera en una librería dll y que se pueda llamar y usarla en cualquier interfaz como C#, C++ .net y V b .net.

Por ejemplo, estas clases controla el puerto serie que puedes descargar aquí.

https://github.com/Gmatarrubia/LibreriasTutoriales

He aprovechado en su tiempo hacer un tutorial sobre esas clases creando una interfaz en C++ bajo Win32 solo consola y funciona, junto con Arduino. Aquí abajo dejo el enlace de como instalarlas y usarlas.

https://www.slideshare.net/Metaconta2/arduino-c-y-puerto-serie

Probando, hice otro tutorial solo crear una dll que muestra texto y una suma en el cual lo importas a C#, lo lee y funciona tal como indica en el enlace de abajo.

https://www.slideshare.net/Metaconta/crear-una-dll-en-c-y-llamarla-con-la-interfaz-c

Dada ya esta información y antes de empezar, quiero saber si lo que quiero hacer es posible.

Para dejarlo más claro, al crear la dll en C++ win32 como indica en el tutorial de arriba, al llamarlo o importarlo con C#, tiene que ser capaz de hacerlo cambiando valores como port, baudios, paridad, bits de stop y demás, algo similar indicado aquí.



Luego enviar comandos al puerto serie y recibirlos ya explicado arriba.

En resumen
:


1. De las clases del puerto serie convertirlas en una dll.

2. Una vez creada la dll, hacer una interfaz que se pueda configurar los parámetros del puerto serie.

3. Usar el puerto serie, enviado y recibiendo tramas de bytes como indica en este tutorial ya dicho.

¿Alguna idea?

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 ... 229
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines