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

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


  Mostrar Temas
Páginas: 1 2 3 4 [5] 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 66
41  Programación / .NET (C#, VB.NET, ASP) / Ya no puedo enviar e-mail con C#. en: 8 Junio 2022, 07:20 am
Hola:

Antes para poder enviar e-mail desde la consola en C# podía hacerlo, antes había que activarlo por aquí en este enlace.
https://myaccount.google.com/lesssecureapps

¿Hay alguna otra forma de hacerlo o el cuento ya se acabó?

Código C#:
Código
  1. using System;
  2. using System.IO;
  3. using System.Net;
  4. using System.Net.Mail;
  5. using System.Text;
  6.  
  7. namespace Enviar_email_Consola_07
  8. {
  9.    internal class Program
  10.    {
  11.        static void Main(string[] args)
  12.        {
  13.  
  14.  
  15.            // Variables.
  16.            string usuario, contraseña, destinatario, asunto, mensaje;
  17.            const int MAXIMA_LONGITUD = 40000;
  18.  
  19.            #region Configuración ventana.
  20.            // Título de la ventana y versión del .Net usando.
  21.            Console.Title = "Gestor correo electrónico GMail. "
  22.                + typeof(string).Assembly.ImageRuntimeVersion;
  23.  
  24.            // Tamaño de la ventana, x, y, o ancho y alto.
  25.            const byte ancho = 80;
  26.            const byte alto = 25;
  27.            Console.SetWindowSize(ancho, alto);
  28.  
  29.            // Color de fondo.
  30.            Console.BackgroundColor = ConsoleColor.Black;
  31.  
  32.            // Color de las letras.
  33.            Console.ForegroundColor = ConsoleColor.Gray;
  34.  
  35.            // Limpiar pantalla y dejarlo todo en color de fondo.
  36.            Console.Clear();
  37.  
  38.            // Visible el cursor.
  39.            Console.CursorVisible = true;
  40.            #endregion
  41.  
  42.            // Título del programa.
  43.            Console.WriteLine("\t\t----------------------------------------");
  44.            Console.WriteLine("\t\t\tEnviar Correo Electrónico");
  45.            Console.WriteLine("\t\t----------------------------------------");
  46.  
  47.            try
  48.            {
  49.  
  50.                Console.WriteLine("\n");
  51.                Console.ForegroundColor = ConsoleColor.Cyan;
  52.                Console.Write("\t\tTu correo electrónico: ");
  53.                Console.ForegroundColor = ConsoleColor.Gray;
  54.                usuario = Console.ReadLine();
  55.                Console.WriteLine();
  56.                Console.ForegroundColor = ConsoleColor.Cyan;
  57.                Console.Write("\t\tIntroducir contraseña: ");
  58.                Console.ForegroundColor = ConsoleColor.Gray;
  59.                contraseña = LeerPassword();
  60.                Console.WriteLine();
  61.                Console.ForegroundColor = ConsoleColor.Cyan;
  62.                Console.Write("\t\tDestinatario: ");
  63.                Console.ForegroundColor = ConsoleColor.Gray;
  64.                destinatario = Console.ReadLine();
  65.                Console.WriteLine();
  66.                Console.ForegroundColor = ConsoleColor.Cyan;
  67.                Console.Write("\t\tAsunto: ");
  68.                Console.ForegroundColor = ConsoleColor.Gray;
  69.                asunto = Console.ReadLine();
  70.                Console.WriteLine();
  71.                Console.ForegroundColor = ConsoleColor.Cyan;
  72.                Console.Write("\t\tMensaje: ");
  73.                Console.ForegroundColor = ConsoleColor.Gray;
  74.                //mensaje = Console.ReadLine();
  75.  
  76.                #region Enviar más de 255 caracteres.
  77.                // #########################################################################
  78.                Stream entradaDeDatos = Console.OpenStandardInput();
  79.                byte[] buffer = new byte[MAXIMA_LONGITUD];
  80.                int numerosBytesLeidos = entradaDeDatos.Read(buffer, 0, MAXIMA_LONGITUD);
  81.                char[] chars = Console.InputEncoding.GetChars(buffer, 0, numerosBytesLeidos);
  82.                mensaje = new string(chars);
  83.                // #########################################################################
  84.                #endregion
  85.  
  86.                Console.WriteLine();
  87.                Console.ForegroundColor = ConsoleColor.DarkCyan;
  88.                Console.Write("\t\tCantidad de texto introducido: ");
  89.                Console.ForegroundColor = ConsoleColor.Gray;
  90.                Console.WriteLine(mensaje.Length);
  91.  
  92.                MailMessage correo = new MailMessage(usuario, destinatario, asunto, mensaje)
  93.                {
  94.                    // Enviar textos con tildes.
  95.                    BodyEncoding = Encoding.UTF8
  96.                };
  97.  
  98.                SmtpClient servidor = new SmtpClient("smtp.gmail.com")
  99.                {
  100.                    Port = 587
  101.                };
  102.                NetworkCredential credenciales = new NetworkCredential(usuario, contraseña);
  103.                servidor.Credentials = credenciales;
  104.                servidor.EnableSsl = true;
  105.  
  106.                Console.WriteLine();
  107.                Console.ForegroundColor = ConsoleColor.Yellow;
  108.                Console.WriteLine("\t\tEnviando correo...");
  109.                servidor.Send(correo);
  110.                Console.WriteLine();
  111.                Console.ForegroundColor = ConsoleColor.Green;
  112.                Console.WriteLine("\t\t¡Correo enviado satisfactoriamente!");
  113.                correo.Dispose();
  114.                Console.CursorVisible = false;
  115.                Console.ReadKey();
  116.            }
  117.            catch (Exception ex)
  118.            {
  119.                Console.ForegroundColor = ConsoleColor.Red;
  120.                Console.WriteLine("ERROR: \n");
  121.                Console.WriteLine("\t\t" + ex.Message);
  122.                Console.WriteLine();
  123.                Console.ForegroundColor = ConsoleColor.Yellow;
  124.                Console.WriteLine("\t\tNo se ha enviado el correo.");
  125.                Console.ReadKey();
  126.            }
  127.  
  128.        }
  129.  
  130.        // A la hora de introducir la contraseña, se sustituye por asterístos (*) en pantalla.
  131.        public static string LeerPassword()
  132.        {
  133.            ConsoleKeyInfo cki;
  134.            StringBuilder sb = new StringBuilder();
  135.            int contador = 0;
  136.  
  137.            do
  138.            {
  139.                cki = Console.ReadKey(true);
  140.                if (cki.Key != ConsoleKey.Enter)
  141.                {
  142.  
  143.                    sb.Append(cki.KeyChar);
  144.                    if (contador < 1)
  145.                    {
  146.                        Console.Write("*");
  147.                    }
  148.                    contador++;
  149.                }
  150.  
  151.                else
  152.                {
  153.                    break;
  154.                }
  155.  
  156.            } while (true);
  157.            Console.WriteLine();
  158.            return sb.ToString();
  159.        }
  160.    }
  161. }

Saludos.
42  Programación / .NET (C#, VB.NET, ASP) / Saber cuántos bytes consume la RAM y el archivo exe en: 29 Mayo 2022, 10:33 am
Buenas:

Quiero saber si en algún lugar de Visual Studio Community 2022 hay alguna opción o indica alguna parte cuantos bytes se tanto en la RAM y el propio archivo exe tienen. La RAM por una parte y el exe por otro. Solo saber si te indica esa información por algún lado.

Por ejemplo, en otros compiladores como en Arduino IDE, tiene este mensaje al final, para que se hagan una idea a lo que me refiero.

El Sketch usa 7386 bytes (22%) del espacio de almacenamiento de programa. El máximo es 32256 bytes.
Las variables Globales usan 671 bytes (32%) de la memoria dinámica, dejando 1377 bytes para las variables locales. El máximo es 2048 bytes.


Si no es posible, al menos crear un programa o una función que me muestre en un archivo de texto .txt este tipo de mensaje al compilar un programa hecho en C#, para tener una idea. ;) Si es que C# es capaz de poder hacerlo, que es otra cosa.

Saludos.
43  Programación / Programación General / Adaptación de códigos en: 19 Mayo 2022, 21:31 pm
Buena gente.

Tengo una función de consola C# y quiero adaptarlo a Arduino, lo tengo a medias pero me fallan cosas. Sobre todo la pulsaciones de teclas y botones.

Espero tener ualguna ayuda.

Código C#:
Código
  1. using System;
  2. using System.IO;
  3.  
  4. namespace LCD_Menu_con_submenus_Consola_01
  5. {
  6.    public class NombresReles
  7.    {
  8.        // Variables.
  9.        static int coordenadaX = 0;         // Coordenada X del textBox del nombre del Relé.
  10.        static int index = 0;               // Índice de ATRÁS y GUARDAR.
  11.        static int textBox = 0;             // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
  12.        static string[] nombresDeLosReles;  // Líneas que al final se van a guardar en Archivo.txt.
  13.        static bool cargado = false;        // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.
  14.  
  15.        // Caracteres alfanuméricos en el array.
  16.        static readonly char[] roALFANUMERICO = new char[]
  17.        {
  18.            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  19.            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  20.            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  21.            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  22.            '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
  23.            ' '
  24.        };
  25.  
  26.        // Índices de los caracteres de los 8 Relés para el array alfanumérico.
  27.        // Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
  28.        static readonly int[][] roINDICE_ARRAY = new int[][]
  29.        {
  30.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  31.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  32.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  33.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  34.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  35.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  36.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  37.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
  38.        };
  39.  
  40.        static readonly char[] roNUMERICO = new char[] { '1', '2', '3', '4', '5', '6', '7', '8' };
  41.        static int roINDICE_NUMERICO = 0;
  42.  
  43.        public static void NombreReles_Principal()
  44.        {
  45.            ConsoleKey tecla, tecla2;
  46.            int indice = 0;
  47.  
  48.            Inicio();
  49.  
  50.            while (true)
  51.            {
  52.                Console.CursorVisible = true; // Mostrar cursor.
  53.                tecla = Console.ReadKey(true).Key;
  54.  
  55.                // ¿Has pulsado tecla flecha arriba?
  56.                if (tecla == ConsoleKey.RightArrow) // Sí.
  57.                {
  58.                    if (textBox == 0)
  59.                    {
  60.                        Console.SetCursorPosition(4, 1);
  61.                        textBox = 1;
  62.                    }
  63.                    else // textBox == 1
  64.                    {
  65.                        if (coordenadaX < 15)
  66.                        {
  67.                            coordenadaX++;
  68.                            Console.SetCursorPosition(4 + coordenadaX, 1);
  69.                        }
  70.                    }
  71.                }
  72.                // Entonces. ¿Haz pulsado flecha izquierda?
  73.                else if (tecla == ConsoleKey.LeftArrow) // Sí.
  74.                {
  75.                    if (textBox == 1)
  76.                    {
  77.                        if (coordenadaX > 0)
  78.                        {
  79.                            coordenadaX--;
  80.                            Console.SetCursorPosition(4 + coordenadaX, 1);
  81.                        }
  82.                        else
  83.                        {
  84.                            Console.SetCursorPosition(2, 1);
  85.                            textBox = 0;
  86.                        }
  87.                    }
  88.                }
  89.                // Entonces. ¿Haz pulsado flecha abajo?
  90.                else if (tecla == ConsoleKey.DownArrow) // Sí.
  91.                {
  92.                    if (textBox == 0)
  93.                    {
  94.                        roINDICE_NUMERICO--;
  95.                        if (roINDICE_NUMERICO < 0)
  96.                        {
  97.                            roINDICE_NUMERICO = 7;
  98.                        }
  99.                        Console.SetCursorPosition(2, 1);
  100.                        Console.Write(roNUMERICO[roINDICE_NUMERICO]);
  101.                        MostrarLineaNombre();
  102.                        Console.SetCursorPosition(2, 1);
  103.                    }
  104.                    else // textBox == 1
  105.                    {
  106.                        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]--;
  107.                        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] < 0)
  108.                        {
  109.                            roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 85;
  110.                        }
  111.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  112.                        Console.SetCursorPosition(4 + coordenadaX, 1);
  113.                    }
  114.                }
  115.                // Entonces. ¿Haz pulsado flecha arriba?
  116.                else if (tecla == ConsoleKey.UpArrow) // Sí.
  117.                {
  118.                    if (textBox == 0)
  119.                    {
  120.                        roINDICE_NUMERICO++;
  121.                        if (roINDICE_NUMERICO >= 8)
  122.                        {
  123.                            roINDICE_NUMERICO = 0;
  124.                        }
  125.                        Console.SetCursorPosition(2, 1);
  126.                        Console.Write(roNUMERICO[roINDICE_NUMERICO]);
  127.                        MostrarLineaNombre();
  128.                        Console.SetCursorPosition(2, 1);
  129.                    }
  130.                    else // textBox == 1
  131.                    {
  132.                        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]++;
  133.                        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] > 85) // Acá es > 85 (o >= 86) porque 86 es la cantidad
  134.                        {                                                        // total y al alcanzarla ahí paso al comienzo (0)
  135.                            roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 0;
  136.                        }
  137.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  138.                        Console.SetCursorPosition(4 + coordenadaX, 1);
  139.                    }
  140.                }
  141.                // Entonces. ¿Haz pulsado la tecla Enter?
  142.                else if (tecla == ConsoleKey.Enter) // Sí.
  143.                {
  144.                    Console.CursorVisible = false;
  145.                    Console.SetCursorPosition(0, 3);
  146.                    Console.Write("> ATRÁS     GUARDAR ");
  147.                    index = 0;
  148.                    while ((tecla2 = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  149.                    {
  150.                        if ((tecla2 == ConsoleKey.RightArrow) || (tecla2 == ConsoleKey.LeftArrow))
  151.                        {
  152.                            index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
  153.                            Console.SetCursorPosition(0, 3);
  154.                            if (index == 0)
  155.                            {
  156.                                Console.Write("> ATRÁS     GUARDAR ");
  157.                            }
  158.                            else
  159.                            {
  160.                                Console.Write("  ATRÁS   > GUARDAR ");
  161.                            }
  162.                        }
  163.                    }
  164.                    if (index == 1)  // Se pulsó Enter en Guardar.
  165.                    {
  166.                        nombresDeLosReles = new string[8];
  167.                        for (int a = 0; a < 8; a++)
  168.                        {
  169.                            for (int b = 0; b < 16; b++)
  170.                            {
  171.                                nombresDeLosReles[a] += roALFANUMERICO[roINDICE_ARRAY[a][b]].ToString();
  172.                            }
  173.                        }
  174.  
  175.                        // Guardar archivo de texto con los nombres de los relés.
  176.                        File.WriteAllLines("NombresReles.txt", nombresDeLosReles);
  177.  
  178.                        // Puede que los nombres contengan espacios al final, que no se verán pero no
  179.                        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
  180.                        Console.Clear();
  181.                        Console.SetCursorPosition(2, 1);
  182.                        Console.Write("Haz guardado:");
  183.                        Console.SetCursorPosition(2, 3);
  184.                        Console.Write((indice + 1).ToString());
  185.                        Console.SetCursorPosition(4, 3);
  186.                        Console.Write(nombresDeLosReles[indice]);
  187.  
  188.                        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
  189.                        while ((tecla2 = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  190.                        {
  191.                            // ¿Haz pulsado flecha arriba?
  192.                            if (tecla2 == ConsoleKey.UpArrow) // Sí. Ejecuta código dentro de ella.
  193.                            {
  194.                                indice--; // Decrementa la variable indice.
  195.                                // ¿indice es menor que 0?
  196.                                if (indice < 0) // Sí.
  197.                                {
  198.                                    indice = 7;
  199.                                }
  200.                            }
  201.                            // Entonces. ¿Haz pulsado flecha abajo?
  202.                            else if (tecla2 == ConsoleKey.DownArrow) // Sí.
  203.                            {
  204.                                indice++; // Incrementa la variable indice.
  205.                                // ¿indice es mayor o igual que 8?
  206.                                if (indice >= 8) // Sí.
  207.                                {
  208.                                    indice = 0;
  209.                                }
  210.                            }
  211.                            Console.SetCursorPosition(2, 3);
  212.                            Console.Write((indice + 1).ToString());
  213.                            Console.SetCursorPosition(4, 3);
  214.                            Console.Write(nombresDeLosReles[indice]);
  215.                        }
  216.                        Inicio();
  217.                    }
  218.                    else if (index == 0)
  219.                    {
  220.                        break;
  221.                    }
  222.                }
  223.            }
  224.        }
  225.  
  226.        static void Inicio()
  227.        {
  228.            Console.SetWindowSize(20, 5);                   // Establece el ancho y alto de la ventana.
  229.            Console.Clear();                                // Limpiar ventana.
  230.            Console.SetCursorPosition(2, 0);                // Posición del cursor.
  231.            Console.Write("Nombre de Relés:    ");
  232.            Console.SetCursorPosition(0, 3);
  233.            Console.Write("  ATRÁS     GUARDAR ");
  234.  
  235.            if (cargado == false)
  236.            {
  237.                // ¿Existe el archivo de texto?
  238.                if (File.Exists("NombresReles.txt"))
  239.                {
  240.                    // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
  241.                    nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
  242.                    int a, b, c;
  243.                    for (a = 0; a < 8; a++)
  244.                    {
  245.                        for (b = 0; b < 16; b++)
  246.                        {
  247.                            for (c = 0; nombresDeLosReles[a][b] != roALFANUMERICO[c]; c++)
  248.                            {
  249.                                ;
  250.                            }
  251.                            roINDICE_ARRAY[a][b] = c;
  252.                        }
  253.                    }
  254.                }
  255.                cargado = true;
  256.            }
  257.            MostrarLineaNombre();
  258.            Console.SetCursorPosition(2, 1);
  259.            Console.Write(roNUMERICO[roINDICE_NUMERICO]);
  260.            if (textBox == 0)
  261.            {
  262.                Console.SetCursorPosition(2, 1);
  263.            }
  264.            else
  265.            {
  266.                Console.SetCursorPosition(4 + coordenadaX, 1);
  267.            }
  268.        }
  269.  
  270.        static void MostrarLineaNombre()
  271.        {
  272.            Console.SetCursorPosition(4, 1);
  273.            for (int a = 0; a < 16; a++)
  274.            {
  275.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][a]]);
  276.            }
  277.        }
  278.    }
  279. }

Código C de Arduino:
Código
  1. // Variables.
  2. int coordenadaX = 0;          // Coordenada X del textBox del nombre del Relé.
  3. int index = 0;                // Índice de ATRÁS y GUARDAR.
  4. int textBox = 0;              // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
  5. String nombresDeLosReles[8]; // Líneas que al final se van a guardar en Archivo.txt.
  6. bool cargado = false;         // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.
  7.  
  8. // Caracteres alfanuméricos en el array.
  9. char roALFANUMERICO[] =
  10. {
  11.  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  12.  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  13.  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  14.  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  15.  '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
  16.  ' '
  17. };
  18.  
  19. // Índices de los caracteres de los 8 Relés para el array alfanumérico.
  20. // Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
  21. int roINDICE_ARRAY[][16] =
  22. {
  23.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  24.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  25.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  26.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  27.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  28.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  29.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  30.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
  31. };
  32.  
  33. char roNUMERICO[] = { '1', '2', '3', '4', '5', '6', '7', '8' };
  34. int roINDICE_NUMERICO = 0;
  35.  
  36. void NombreReles_Principal()
  37. {
  38.  ConsoleKey tecla, tecla2;
  39.  int indice = 0;
  40.  
  41.  Inicio();
  42.  
  43.  while (true)
  44.  {
  45.    lcd.cursor(); // Mostrar cursor.
  46.    lcd.blink();  // Cursosr parpadeando.
  47.    tecla = Console.ReadKey(true).Key;
  48.  
  49.    // ¿Has pulsado tecla flecha arriba?
  50.    if (tecla == digitalRead(A1)) // Sí.
  51.    {
  52.      if (textBox == 0)
  53.      {
  54.        lcd.setCursor(4, 1);
  55.        textBox = 1;
  56.      }
  57.      else // textBox == 1
  58.      {
  59.        if (coordenadaX < 15)
  60.        {
  61.          coordenadaX++;
  62.          lcd.setCursor(4 + coordenadaX, 1);
  63.        }
  64.      }
  65.    }
  66.    // Entonces. ¿Haz pulsado flecha izquierda?
  67.    else if (tecla == digitalRead(A3)) // Sí.
  68.    {
  69.      if (textBox == 1)
  70.      {
  71.        if (coordenadaX > 0)
  72.        {
  73.          coordenadaX--;
  74.          lcd.setCursor(4 + coordenadaX, 1);
  75.        }
  76.        else
  77.        {
  78.          lcd.setCursor(2, 1);
  79.          textBox = 0;
  80.        }
  81.      }
  82.    }
  83.    // Entonces. ¿Haz pulsado flecha abajo?
  84.    else if (tecla == digitalRead(A2)) // Sí.
  85.    {
  86.      if (textBox == 0)
  87.      {
  88.        roINDICE_NUMERICO--;
  89.        if (roINDICE_NUMERICO < 0)
  90.        {
  91.          roINDICE_NUMERICO = 7;
  92.        }
  93.        lcd.setCursor(2, 1);
  94.        lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  95.        MostrarLineaNombre();
  96.        lcd.setCursor(2, 1);
  97.      }
  98.      else // textBox == 1
  99.      {
  100.        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]--;
  101.        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] < 0)
  102.        {
  103.          roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 85;
  104.        }
  105.        lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  106.        lcd.setCursor(4 + coordenadaX, 1);
  107.      }
  108.    }
  109.    // Entonces. ¿Haz pulsado flecha arriba?
  110.    else if (tecla == digitalRead(A1)) // Sí.
  111.    {
  112.      if (textBox == 0)
  113.      {
  114.        roINDICE_NUMERICO++;
  115.        if (roINDICE_NUMERICO >= 8)
  116.        {
  117.          roINDICE_NUMERICO = 0;
  118.        }
  119.        lcd.setCursor(2, 1);
  120.        lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  121.        MostrarLineaNombre();
  122.        lcd.setCursor(2, 1);
  123.      }
  124.      else // textBox == 1
  125.      {
  126.        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]++;
  127.        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] > 85) // Acá es > 85 (o >= 86) porque 86 es la cantidad
  128.        { // total y al alcanzarla ahí paso al comienzo (0)
  129.          roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 0;
  130.        }
  131.        lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  132.        lcd.setCursor(4 + coordenadaX, 1);
  133.      }
  134.    }
  135.    // Entonces. ¿Haz pulsado la tecla Enter?
  136.    else if (tecla == digitalRead(A5)) // Sí.
  137.    {
  138.      lcd.cursor();   // Ocultar cursor.
  139.      lcd.noBlink();  // Sin parpadeos el cursor.
  140.      lcd.setCursor(0, 3);
  141.      lcd.print("> ATRÁS     GUARDAR ");
  142.      index = 0;
  143.      while ((tecla2 = Console.ReadKey(true).Key) != digitalRead(A5))
  144.      {
  145.        if ((tecla2 == digitalRead(A4)) || (tecla2 == digitalRead(A3)))
  146.        {
  147.          index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
  148.          lcd.setCursor(0, 3);
  149.          if (index == 0)
  150.          {
  151.            lcd.print("> ATRÁS     GUARDAR ");
  152.          }
  153.          else
  154.          {
  155.            lcd.print("  ATRÁS   > GUARDAR ");
  156.          }
  157.        }
  158.      }
  159.      if (index == 1)  // Se pulsó Enter en Guardar.
  160.      {
  161.        nombresDeLosReles = new String[8];
  162.        for (int a = 0; a < 8; a++)
  163.        {
  164.          for (int b = 0; b < 16; b++)
  165.          {
  166.            nombresDeLosReles[a] += roALFANUMERICO[roINDICE_ARRAY[a][b]].ToString();
  167.          }
  168.        }
  169.  
  170.        // Guardar archivo de texto con los nombres de los relés.
  171.        //File.WriteAllLines("NombresReles.txt", nombresDeLosReles);
  172.  
  173.        // En esta parte, justo arriba se hace con el lenguaje de C#, aquí hay que usar la
  174.        // EEPROM interna de Arduino que haré más adelante.
  175.  
  176.        // Puede que los nombres contengan espacios al final, que no se verán pero no
  177.        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
  178.        lcd.clear();
  179.        lcd.setCursor(2, 1);
  180.        lcd.print("Haz guardado:");
  181.        lcd.setCursor(2, 3);
  182.        lcd.print((indice + 1).ToString());
  183.        lcd.setCursor(4, 3);
  184.        lcd.print(nombresDeLosReles[indice]);
  185.  
  186.        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
  187.        while ((tecla2 = Console.ReadKey(true).Key) != digitalRead(A5))
  188.        {
  189.          // ¿Haz pulsado flecha arriba?
  190.          if (tecla2 == digitalRead(A1)) // Sí. Ejecuta código dentro de ella.
  191.          {
  192.            indice--; // Decrementa la variable indice.
  193.            // ¿indice es menor que 0?
  194.            if (indice < 0) // Sí.
  195.            {
  196.              indice = 7;
  197.            }
  198.          }
  199.          // Entonces. ¿Haz pulsado flecha abajo?
  200.          else if (tecla2 == digitalRead(A2)) // Sí.
  201.          {
  202.            indice++; // Incrementa la variable indice.
  203.            // ¿indice es mayor o igual que 8?
  204.            if (indice >= 8) // Sí.
  205.            {
  206.              indice = 0;
  207.            }
  208.          }
  209.          lcd.setCursor(2, 3);
  210.          lcd.print((indice + 1).ToString());
  211.          lcd.setCursor(4, 3);
  212.          lcd.print(nombresDeLosReles[indice]);
  213.        }
  214.        Inicio();
  215.      }
  216.      else if (index == 0)
  217.      {
  218.        break;
  219.      }
  220.    }
  221.  }
  222. }
  223.  
  224. void Inicio()
  225. {
  226.  //Console.SetWindowSize(20, 5);                   // Establece el ancho y alto de la ventana.
  227.  lcd.clear();                                // Limpiar ventana.
  228.  lcd.setCursor(2, 0);                // Posición del cursor.
  229.  lcd.print("Nombre de Relés:    ");
  230.  lcd.setCursor(0, 3);
  231.  lcd.print("  ATRÁS     GUARDAR ");
  232.  
  233.  //#########################################################################################
  234.  // Este código es de C#, ya lo pasaré a Arduino con su EEPROM interna o una tarjeta SD
  235.  // que también se puede leer archivo de texto tipo *.txt.
  236.  
  237.  /*
  238.     if (cargado == false)
  239.     {
  240.       // ¿Existe el archivo de texto?
  241.       if (File.Exists("NombresReles.txt"))
  242.       {
  243.         // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
  244.         nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
  245.         int a, b, c;
  246.         for (a = 0; a < 8; a++)
  247.         {
  248.           for (b = 0; b < 16; b++)
  249.           {
  250.             for (c = 0; nombresDeLosReles[a][b] != roALFANUMERICO[c]; c++)
  251.             {
  252.               ;
  253.             }
  254.             roINDICE_ARRAY[a][b] = c;
  255.           }
  256.         }
  257.       }
  258.       cargado = true;
  259.     }
  260.   */
  261.  //#########################################################################################
  262.  
  263.  MostrarLineaNombre();
  264.  lcd.setCursor(2, 1);
  265.  lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  266.  if (textBox == 0)
  267.  {
  268.    lcd.setCursor(2, 1);
  269.  }
  270.  else
  271.  {
  272.    lcd.setCursor(4 + coordenadaX, 1);
  273.  }
  274. }
  275.  
  276. void MostrarLineaNombre()
  277. {
  278.  lcd.setCursor(4, 1);
  279.  for (int a = 0; a < 16; a++)
  280.  {
  281.    lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][a]]);
  282.  }
  283. }

Falla en el almacenamiento o detección de botones de Arduino que no se como se hace como en C#.

Gracias.
44  Programación / Programación General / Borrar dll y que no se pueda recuperar en: 15 Abril 2022, 15:21 pm
Hola:

Quiero hacer un programa, el propio programa lo que hace es que cuando llegue una fecha y hora exacta que he programado, muestre en el escritorio un archivo de texto llamado Hola.txt y en su contenido dice:

Hola compañero.

Desde un archivo .bat se puede hacer, que cree ese texto y se borre el propio archivo .bat. Si hago un programa con C# o C++, no es capaz de autoborrarse. Se me ha ocurrido crear un ejecutable que llame al dll que solo hace crear el archivo .txt en el escritorio y dicho ejecutable borrre la dll. Antes de borrar la dll, tiene que modificarla para destruirla, guardar la modificación y luego borrar la dll para que nadie la recupere con programas de recuperación de archivos, y si lo recupera, que no descifre las funciones de las dll de lo que hace realmente. El ejecutable .exe solo llama la .dll que sabe donde está.

La pregunta del millón.

¿Es posible hacerlo?

Saludos.
45  Programación / .NET (C#, VB.NET, ASP) / Introducir esta tabla UTF-8 en: 5 Abril 2022, 22:00 pm
Buenas:

En la consola C# puedo introducir cuadro de la tabla ASCII, en este caso, quiero hacerlo con UTF-8 precisamente de este PDF.

https://www.mclibre.org/consultar/htmlcss/html/unicode/U02500-box-drawing.pdf

Aquí la tabla completa si quieren curiosear.

¿Algún ejemplo para poner un caracter en UTF-8?

En ASCII se pued directamente del teclado como Alt + Número.

Saludos.
46  Programación / .NET (C#, VB.NET, ASP) / Poner coma en vez de un punto en: 3 Abril 2022, 08:44 am
Buenas gente del foro:

Desde hace tiempo en este sobre cálculo del volumenes de tubos para agua, al escribir valores, debe usar por ejemplo la coma. Cada dato introducido también se escucha la voz en Windows, a si que a subir el altavoz del PC. ;)

0,05

Y no el punto como indica abajo haciendo de coma.

0.05

Para hacer los cálculos bien, no hay que introducir un punto, solo la coma. Por comodidad y no confundir a la gente que use este programa, quiero hacer de alguna manera que si pulsas el punto, se convierta automáticamente en la coma.

¿Es posible hacerlo?

No se me ocurre como hacer estas cosas.

Dejo el código completo.

Código C#:
Código
  1. using System;
  2. using System.Speech.Recognition; // No olvidar. Micro.
  3. using System.Speech.Synthesis; // No olvidar. Altavoz.
  4.  
  5. // No olvidar añadir en "Referencias" Speech en el "Explorador de soluciones".
  6.  
  7. namespace Calculo_cilindo_voz_Consola_03
  8. {
  9.    class Program
  10.    {
  11.        static void Main(string[] args)
  12.        {
  13.            #region Configuración ventana.
  14.            // Título de la ventana.
  15.            Console.Title = "Cálculo litros de un depósito - By Meta. Electrónica PIC";
  16.  
  17.            // Tamaño de la ventana, x, y.
  18.            // Tamaño de la ventana, x, y.
  19.            const int anchoX = 60;
  20.            const int altoY = 16;
  21.            Console.SetWindowSize(anchoX, altoY);
  22.  
  23.            // Color de fondo.
  24.            Console.BackgroundColor = ConsoleColor.Black;
  25.  
  26.            // Color de las letras.
  27.            Console.ForegroundColor = ConsoleColor.Gray;
  28.  
  29.            // Limpiar pantalla y dejarlo todo en color de fondo.
  30.            Console.Clear();
  31.  
  32.            // Visible el cursor.
  33.            Console.CursorVisible = false;
  34.            #endregion
  35.  
  36.            #region Variables.
  37.            // Variables.
  38.            const double Pi = 3.14;
  39.            float PI = Convert.ToSingle(Pi);
  40.            float radio, altura, volumen, litros, nivelAgua, resultadoPorcentaje,
  41.                resultadoLitros, volumenLitros, mitadBarra, cantidadTubosLitros,
  42.                totalLitros;
  43.            float cantidadTubos;
  44.            #endregion
  45.  
  46.            do
  47.            {
  48.                try
  49.                {
  50.                    // Inicializar una nueva instancia de SpeechSynthesizer.
  51.                    using (SpeechSynthesizer altavoz = new SpeechSynthesizer())
  52.                    {
  53.                        #region Introducción de datos en la pantalla.
  54.                        // Configure la salida de audio.
  55.                        altavoz.SetOutputToDefaultAudioDevice();
  56.  
  57.                        // Velocidad de la voz.
  58.                        altavoz.Rate = -2; // Valores entre -10 a 10.
  59.  
  60.                        // Volumen de la voz.
  61.                        altavoz.Volume = 100; // Valores entre 0 y 100.
  62.  
  63.                        // Limpiar pantalla.
  64.                        Console.Clear();
  65.  
  66.                        // Cursor visible.
  67.                        Console.CursorVisible = true;
  68.                        // Introducción de datos.
  69.                        Console.Write("Introduce el radio en m.: ");
  70.                        altavoz.Speak("Introduce el radio en metros.");
  71.                        radio = float.Parse(Console.ReadLine());
  72.                        Console.Write("Introduce la altura del tubo en m.: ");
  73.                        altavoz.Speak("Introduce la altura del tubo en metros.");
  74.                        altura = float.Parse(Console.ReadLine());
  75.                        Console.Write("Introduce altura del agua. Máximo es de {0} m.: ", altura);
  76.                        altavoz.Speak("Introduce altura del agua. Máximo es de " + altura + "metros.");
  77.                        nivelAgua = float.Parse(Console.ReadLine());
  78.                        Console.Write("Introduce cantidad de tubos: ");
  79.                        altavoz.Speak("Introduce cantidad de tubos.");
  80.                        cantidadTubos = int.Parse(Console.ReadLine());
  81.                        #endregion
  82.  
  83.                        #region Cálculos.
  84.                        // Cálculo volumen.
  85.                        volumen = PI * (radio * radio) * altura;
  86.  
  87.                        // Cálculo litros.
  88.                        litros = volumen * 1000;
  89.  
  90.                        // Cálculo porcentaje en % del litro de agua.
  91.                        resultadoPorcentaje = nivelAgua * (100 / altura);
  92.  
  93.                        // Cálculo litros de agua.
  94.                        volumenLitros = PI * (radio * radio) * nivelAgua;
  95.                        resultadoLitros = volumenLitros * 1000;
  96.  
  97.                        // Cálculo litros por cantidad de tubos
  98.                        cantidadTubosLitros = cantidadTubos * resultadoLitros;
  99.  
  100.                        // Cálculo cantidad de litros con total de tubos.
  101.                        totalLitros = litros * cantidadTubos;
  102.                        #endregion
  103.  
  104.                        #region Dibujado barra de progreso.
  105.  
  106.                        // Posición.
  107.                        Console.SetCursorPosition(0, 4);
  108.  
  109.                        // Dibujo de la barra.
  110.                        Console.WriteLine();
  111.                        Console.WriteLine("0 %                     50 %                   100 %");
  112.                        Console.WriteLine("&#9484;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9516;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9488;");
  113.  
  114.                        // Mitad de la barra para que no sea muy grande en la pantalla.
  115.                        mitadBarra = resultadoPorcentaje / 2;
  116.  
  117.                        if (resultadoPorcentaje <= 15)
  118.                        {
  119.                            Console.ForegroundColor = ConsoleColor.Red;
  120.                        }
  121.                        else if (resultadoPorcentaje <= 40)
  122.                        {
  123.                            Console.ForegroundColor = ConsoleColor.Yellow;
  124.                        }
  125.                        else if (resultadoPorcentaje <= 100)
  126.                        {
  127.                            Console.ForegroundColor = ConsoleColor.Green;
  128.                        }
  129.  
  130.                        if (mitadBarra > 50)
  131.                        {
  132.                            mitadBarra = 50;
  133.                        }
  134.  
  135.                        Console.SetCursorPosition(0, 7);
  136.                        // Rellenar la barra.
  137.                        for (int i = 1; i <= mitadBarra; i++)
  138.                        {
  139.                            Console.Write("&#9608;");
  140.                        }
  141.  
  142.                        Console.ForegroundColor = ConsoleColor.Gray;
  143.  
  144.                        // Si llega mayor a 100 se pone el # en rojo.
  145.                        if (resultadoPorcentaje > 100)
  146.                        {
  147.                            Console.ForegroundColor = ConsoleColor.Red;
  148.                            Console.Write("#");
  149.                            Console.ForegroundColor = ConsoleColor.Gray;
  150.                        }
  151.                        #endregion
  152.  
  153.                        #region Mostrar textos en pantalla.
  154.                        // Cursor invisible.
  155.                        Console.CursorVisible = false;
  156.  
  157.                        // Pisición del texto a mostrar.
  158.                        Console.SetCursorPosition(0, 9);
  159.  
  160.                        // Muestra porcentaje del depósito.
  161.                        Console.ForegroundColor = ConsoleColor.Gray;
  162.                        Console.Write("\nPorcentaje: ");
  163.                        Console.ForegroundColor = ConsoleColor.Cyan;
  164.                        Console.WriteLine(resultadoPorcentaje.ToString("N2") + " %.");
  165.                        altavoz.Speak("Cantidad de agua que hay en el depósito es de " +
  166.                            //resultadoPorcentaje.ToString("N2") + "%.");
  167.                            resultadoPorcentaje + "%.");
  168.  
  169.                        // Muestra cantidad de agua que hay actualmente y el total.
  170.                        Console.ForegroundColor = ConsoleColor.Gray;
  171.                        Console.Write("\nLitros de agua: ");
  172.                        Console.ForegroundColor = ConsoleColor.Cyan;
  173.                        Console.Write(resultadoLitros.ToString("N2"));
  174.                        Console.ForegroundColor = ConsoleColor.Gray;
  175.                        Console.WriteLine(" / " + litros.ToString("N2") + " L. total de un tubo.");
  176.                        altavoz.Speak("Cantidad de litros de agua en un tubo de " +
  177.                            resultadoLitros.ToString("N2") + "de " +
  178.                            litros.ToString("N2") + " litros total de un tubo.");
  179.  
  180.                        // Cantidad de tubos sin contar la base conectada, solo tubos independiente.
  181.                        Console.ForegroundColor = ConsoleColor.Gray;
  182.                        Console.Write("\nCantidad de Litros total por " + cantidadTubos + " tubos: ");
  183.                        Console.ForegroundColor = ConsoleColor.Cyan;
  184.                        Console.Write(cantidadTubosLitros.ToString("N2"));
  185.                        Console.ForegroundColor = ConsoleColor.Gray;
  186.                        Console.WriteLine(" / " + totalLitros.ToString("N2") + " L.");
  187.                        altavoz.Speak("Cantidad de litros en total por " + cantidadTubos.ToString("N2") +
  188.                            " tubos: " + cantidadTubosLitros.ToString("N2") +
  189.                            " de " + totalLitros.ToString("N2") + " litros.");
  190.                        #endregion
  191.                    }
  192.                }
  193.  
  194.                catch (FormatException)
  195.                {
  196.                    Console.BackgroundColor = ConsoleColor.Gray;
  197.                    Console.ForegroundColor = ConsoleColor.Red;
  198.                    Console.Clear();
  199.                    Console.SetCursorPosition(8, 5);
  200.                    Console.Write(@"La cadena de entrada no tiene el
  201.        formato correcto.
  202.  
  203.        Solo debes introducir números y comas.");
  204.                    Console.CursorVisible = false;
  205.                    Console.BackgroundColor = ConsoleColor.Black;
  206.                    Console.ForegroundColor = ConsoleColor.Gray;
  207.                }
  208.  
  209.                // Pulse cualquier tecla para continuar.
  210.                Console.ReadKey();
  211.            } while (true);
  212.        }
  213.    }
  214. }

Saludos.
47  Seguridad Informática / Seguridad / ¿Pueden ver tu información dentro de imágenes? en: 30 Marzo 2022, 22:27 pm
Buenas camaradas:

Si edito una foto o creo una en el paint. Lo guardo en Windows 10. Si dicha imagen editada lo envío tal cual a un amigo por e-mail. Si ese amigo husmea dentro de las fotos observando los metadatos.

¿Hay algún metadato o información en dicha imagen que edité o dibujé co nel paint bajo Windows 10 que sepa algo de mi?

Por ejemplo, el nombre de usuario que creó ese archivo.

Saludos.
48  Programación / .NET (C#, VB.NET, ASP) / Renombrar el mismo archivo en: 29 Marzo 2022, 20:58 pm
Buenas:

Este programa redimensiona una imagen. Una vez redimensionado y guardado, se tiene que guardar con otro nombre.

¿Hay alguna forma de guardar el archivo con el mismo nombre?

Por supuesto, la versión vieja se eliminará.

Por ahora este es el código.
Código
  1. using System;
  2. using System.Drawing;
  3. using System.Drawing.Imaging;
  4.  
  5. namespace Cambiar_tamaño_imagen_Consola_01
  6. {
  7.    internal class Program
  8.    {
  9.        public static Image resizeImage(Image imgToResize, Size size)
  10.        {
  11.            return (Image)(new Bitmap(imgToResize, size));
  12.        }
  13.        static void Main(string[] args)
  14.        {
  15.            #region Configuración ventana.
  16.            // Título de la ventana.
  17.            Console.Title = "Cambiar tamaño imagen";
  18.  
  19.            // Tamaño de la ventana, x, y.
  20.            // Tamaño de la ventana, x, y.
  21.            const int anchoX = 80;
  22.            const int altoY = 30;
  23.            Console.SetWindowSize(anchoX, altoY);
  24.  
  25.            // Color de fondo.
  26.            Console.BackgroundColor = ConsoleColor.Green;
  27.  
  28.            // Color de las letras.
  29.            Console.ForegroundColor = ConsoleColor.Black;
  30.  
  31.            // Limpiar pantalla y dejarlo todo en color de fondo.
  32.            Console.Clear();
  33.  
  34.            // Visible el cursor.
  35.            Console.CursorVisible = false;
  36.            #endregion
  37.  
  38.            //string path = "E:\\Imagenes\\Imagen.jpg";
  39.            string path = @"E:\Imagenes\Imagen.jpg";
  40.            Image img = Image.FromFile(path);
  41.            Bitmap imgbitmap = new Bitmap(img);
  42.  
  43.            if (img != null)
  44.            {
  45.                using (Image resizedImage = new Bitmap(img, new Size(20, 20)))
  46.                {
  47.                    resizedImage.Save(@"E:\Imagenes\Imagen0.jpg", ImageFormat.Jpeg);
  48.                    Console.WriteLine("Imgen redimensionado correctamente.");
  49.                }
  50.            }
  51.        }
  52.    }
  53. }

Saludos.
49  Programación / .NET (C#, VB.NET, ASP) / Modificar imagen en: 27 Marzo 2022, 13:50 pm
Hola:

Quiero saber si en modo consola C#, puedo encontrar archivos *.bmp, *.jpg, etc, solo de imágenes y que las modifique, que se muestre tal como indica aquí.

Ver imagen.

Nota:
La imagen amarilla de arriba se tener el ascii en tramas de bytes almacenado en C#, por ejemplo, abres un archivo de imagen con un editor hexadecimal, copias el contenido en Byte[] y lo pones en un archivo llamado imagenAmarilla.cs por poner un ejemplo.

Su contenido es este:

byte[] rawData = {
   0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
   0x01, 0x01, 0x00, 0x60
};

En realidad es mucho más grande, este es un fragmento para de la imagen amarilla para que se entienda aquí en el foro y que quepa.

En resumen, que encuentre cada foto justo en el escritorio llamado jpg, png, bmp, etc... y que se modifique precisamente a la imagen de arriba.

Habrá cada variable tipo byte[], uno para jpeg, otro para bmp, otro para png, los que quieras. El programa detecta cada archivo y se modifica así en amarillo del ejemplo arriba. Así se podrá abrir la foto y se mostrará modificado.

Un saludo.
50  Programación / Programación General / [Info] Configuración de ventanas de nuestros programas en: 13 Marzo 2022, 21:59 pm
Buenas compañer@s del foro:

Dejo en los lenguajes en forma de consola que puedan configurar de forma básica título del programa en la ventana, tamaño, colores y posición de los textos con los lenguajes como C++ nativo, C++ CLI o .Net, C# y VB .Net.

Me han preguntado por privado estas cosas y se los dejo aquí en el cual de forma rápida hay ejemplos rápidos. Todos hechos con Visual Studio 2022. :)

C++ nativo:
Código
  1. #include <iostream>
  2. #include <windows.h> // Para mostrar texto en el título de la ventana.
  3. #include <stdio.h>   // Cambio color de fondo y letras.
  4.  
  5. using namespace std;
  6. //using std::cout;
  7. //using std::cin;
  8.  
  9. // Función posición del cursor.
  10. void gotoxy(int x, int y)
  11. {
  12. HANDLE hcon;
  13. hcon = GetStdHandle(STD_OUTPUT_HANDLE);
  14. COORD dwPos;
  15. dwPos.X = x;
  16. dwPos.Y = y;
  17. SetConsoleCursorPosition(hcon, dwPos);
  18. }
  19.  
  20. int main()
  21. {
  22. #pragma region "Configuración ventana."
  23. // Mostrar caracteres correctamente en pantalla y título de la ventana.
  24. SetConsoleOutputCP(65001);
  25. wchar_t titulo[128];
  26. MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana", -1, titulo, 128);
  27. SetConsoleTitle(titulo);
  28.  
  29. // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
  30. SMALL_RECT r = { 0, 0, 80, 20 }; // X = 49, Y = 9.
  31. SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
  32.  
  33. // Cambio color de A (verde claro), color letras 0 (negro).
  34. system("color A0");
  35.  
  36. // Ocultar cursor.
  37. CONSOLE_CURSOR_INFO cci;
  38. GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
  39. cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
  40. SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
  41. #pragma endregion
  42.  
  43. gotoxy(20, 8);
  44. cout << "Estás leyendo este texto en pantalla. C++ nativo";
  45.  
  46. cout << endl; // Nueva línea.
  47. system("pause");
  48. return 0;
  49. }

C++ CLI/.Net:
Código
  1. #include "pch.h"
  2.  
  3. using namespace System;
  4.  
  5. int main(array<System::String ^> ^args)
  6. {
  7.    #pragma region "Configuración ventana."
  8.    // Título de la ventana.
  9.    Console::Title = "Título de la ventana";
  10.  
  11.    // Tamaño de la ventana, x, y o, ancho y alto.
  12.    const Byte ancho = 80;
  13.    const Byte alto = 20;
  14.    Console::SetWindowSize(ancho, alto);
  15.  
  16.    // Color de fondo.
  17.    Console::BackgroundColor = ConsoleColor::Black;
  18.  
  19.    // Color de las letras.
  20.    Console::ForegroundColor = ConsoleColor::Yellow;
  21.  
  22.    // Limpiar pantalla y dejarlo todo en color de fondo.
  23.    Console::Clear();
  24.  
  25.    // Visible el cursor. // No! Así lo haces invisible.
  26.    Console::CursorVisible = false;
  27.    #pragma endregion
  28.  
  29.    // Posición del cursor.
  30.    int anchoX = 20;
  31.    int altoY = 8;
  32.    Console::SetCursorPosition(anchoX, altoY);
  33.  
  34.    // Mostrar textos.
  35.    Console::WriteLine("Estás leyendo este texto en pantalla. C++ CLI");
  36.  
  37.    // Pulse cualquier tecla para salir.
  38.    Console::ReadKey();
  39. }
  40.  

C#:
Código
  1. using System;
  2.  
  3. namespace Configuracion_ventanas_Consola_CS
  4. {
  5.    internal class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            #region Configuración ventana.
  10.            // Título de la ventana.
  11.            Console.Title = "Título de la ventana";
  12.  
  13.            // Tamaño de la ventana, x, y o, ancho y alto.
  14.            const byte ancho = 80;
  15.            const byte alto = 20;
  16.            Console.SetWindowSize(ancho, alto);
  17.  
  18.            // Color de fondo.
  19.            Console.BackgroundColor = ConsoleColor.Black;
  20.  
  21.            // Color de las letras.
  22.            Console.ForegroundColor = ConsoleColor.Green;
  23.  
  24.            // Limpiar pantalla y dejarlo todo en color de fondo.
  25.            Console.Clear();
  26.  
  27.            // Visible el cursor. // No! Así lo haces invisible.
  28.            Console.CursorVisible = false;
  29.            #endregion
  30.  
  31.            // Posición del cursor.
  32.            int anchoX = 20;
  33.            int altoY = 8;
  34.            Console.SetCursorPosition(anchoX, altoY);
  35.  
  36.            // Mostrar textos.
  37.            Console.WriteLine("Estás leyendo este texto en pantalla. C#");
  38.  
  39.            // Pulse cualquier tecla para salir.
  40.            Console.ReadKey();
  41.        }
  42.    }
  43. }
  44.  

Visual Basic .Net:
Código
  1. Module Module1
  2.  
  3.    Sub Main()
  4. #Region "Configuración ventana."
  5.        'Título de la ventana.
  6.        Console.Title = "Título de la ventana"
  7.  
  8.        'Tamaño de la ventana, x, y o, ancho y alto.
  9.        Const ancho As Byte = 80
  10.        Const alto As Byte = 20
  11.        Console.SetWindowSize(ancho, alto)
  12.  
  13.        'Color de fondo.
  14.        Console.BackgroundColor = ConsoleColor.Black
  15.  
  16.        'Color de las letras.
  17.        Console.ForegroundColor = ConsoleColor.Blue
  18.  
  19.        'Limpiar pantalla y dejarlo todo en color de fondo.
  20.        Console.Clear()
  21.  
  22.        'Visible el cursor. // No! Así lo haces invisible.
  23.        Console.CursorVisible = False
  24. #End Region
  25.  
  26.        'Posición del cursor.
  27.        Dim anchoX As Integer = 20
  28.        Dim altoY As Integer = 8
  29.        Console.SetCursorPosition(anchoX, altoY)
  30.  
  31.        'Mostrar textos.
  32.        Console.WriteLine("Estás leyendo este texto en pantalla. VB .Net")
  33.  
  34.        'Pulse cualquier tecla para salir.
  35.        Console.ReadKey()
  36.    End Sub
  37.  
  38. End Module

Un cordial saludos.
Páginas: 1 2 3 4 [5] 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 66
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines