Buenas:

Me imaginaba que había que montar un servidor Web.

En cuanto a GMail si se puede porque la mayoría de la gente no lo tiene desactivado. Si tiene activado no leer fotos o píxeles, irá todo bien para no ser detectado. En Apache recuerdo que desde que entre, muestra IP, fecha, hora y no se que más. Desde que aparezca algo, se sabe que lo leyó, lo bueno sería saber qué emal leyó, así que cada mensaje leído se muestra chivato diferente.

Con una buena Raspberry Pi está muy bien la idea hasta para ahorrar luz.

Gracias por las respuestas.

Buenas:

Cuando envío un e-mail o correo electrónico con gmail, hotmail, el que sea, no se si realmente una persona lo ha abierto o leído.

¿Existe un truco en hacerlo?

Aunque sea usando programación.

Un cordial saludos.

Muchísimas gracias mi muy distinguido amigo.

Buenas:

¿Es posible cambiar las propiedades de un archivo?

Tal como indica abajo en rojo.

Ver imagen.

Si existe la posibilidad de hacerlo de alguna manera.


Desde un programa en consola con C#, creo un archivo de texto con la fecha por ejemplo 20/02/2022 8:46 que es el que tiene el Windwos ahora mismo, en realidad el UEFI o BIOS, se modifique a otra en el año 2019, por poner un ejemplo.

¿Existe la posibilidad de hacerlo?

Gracias.

Buenas:

En modo consola puedo enviar correo electrónico, cuyo código fuente lo dejo abajo para que lo vean. Solo puede enviar mensajes o e-mail, funciona muy bien.

Ahora quiero hacer otro programa, que solo lee email también en modo consola y  los e-mail que tanga filtrado, si tengo tres e-mail filtrados, pues solo acepta esos e-mail en pantalla. Todo esto, lee un mensaje por cada 5 minutos. Mensaje, Asunto y la dirección del e-mail.

¿Cómo se hace?

Aquí abajo dejo el codigo de enviar e-mail por consola que funciona al 100 %, con tildes, ñ y otros símbolos correctamente a parte de enviar más de 255 caracteres.

Para que funcione y se usa gmail.

// Activar / desactivar Acceso de aplicaciones poco seguras en Google.
https://myaccount.google.com/lesssecureapps

Código C#:

using System;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Text;
 
namespace Enviar_email_Consola_07
{
    internal class Program
    {
        static void Main(string[] args)
        {
 
 
            // Variables.
            string usuario, contraseña, destinatario, asunto, mensaje;
            const int MAXIMA_LONGITUD = 40000;
 
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Gestor correo electrónico";
 
            // Tamaño de la ventana, x, y, o ancho y alto.
            const byte ancho = 80;
            const byte alto = 25;
            Console.SetWindowSize(ancho, alto);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.Black;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Gray;
 
            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            // Título del programa.
            Console.WriteLine("\t\t----------------------------------------");
            Console.WriteLine("\t\t\tEnviar Correo Electrónico");
            Console.WriteLine("\t\t----------------------------------------");
 
            try
            {
 
                Console.WriteLine("\n");
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tTu correo electrónico: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                usuario = Console.ReadLine();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tIntroducir contraseña: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                contraseña = LeerPassword();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tDestinatario: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                destinatario = Console.ReadLine();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tAsunto: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                asunto = Console.ReadLine();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tMensaje: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                //mensaje = Console.ReadLine();
 
                #region Enviar más de 255 caracteres.
                // #########################################################################
                Stream inputStream = Console.OpenStandardInput();
                byte[] buffer = new byte[MAXIMA_LONGITUD];
                int numerosBytesLeidos = inputStream.Read(buffer, 0, MAXIMA_LONGITUD);
                char[] chars = Console.InputEncoding.GetChars(buffer, 0, numerosBytesLeidos);
                mensaje = new string(chars);
                // #########################################################################
                #endregion
 
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.DarkCyan;
                Console.Write("\t\tCantidad de texto introducido: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                Console.WriteLine(mensaje.Length);
 
                MailMessage correo = new MailMessage(usuario, destinatario, asunto, mensaje)
                {
                    // Enviar textos con tildes.
                    BodyEncoding = Encoding.UTF8
                };
 
                SmtpClient servidor = new SmtpClient("smtp.gmail.com")
                {
                    Port = 587
                };
                NetworkCredential credenciales = new NetworkCredential(usuario, contraseña);
                servidor.Credentials = credenciales;
                servidor.EnableSsl = true;
 
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\t\tEnviando correo...");
                servidor.Send(correo);
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("\t\tCorreo enviado satisfactoriamente.");
                correo.Dispose();
                Console.CursorVisible = false;
                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("ERROR: \n");
                Console.WriteLine("\t\t" + ex.Message);
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\t\tNo se ha enviado el correo.");
                Console.ReadKey();
            }
 
        }
 
        // A la hora de introducir la contraseña, se sustituye por asterístos (*) en pantalla.
        public static string LeerPassword()
        {
            ConsoleKeyInfo cki;
            StringBuilder sb = new StringBuilder();
            int contador = 0;
 
            do
            {
                cki = Console.ReadKey(true);
                if (cki.Key != ConsoleKey.Enter)
                {
 
                    sb.Append(cki.KeyChar);
                    if (contador < 1)
                    {
                        Console.Write("*");
                    }
                    contador++;
                }
 
                else
                {
                    break;
                }
 
            } while (true);
            Console.WriteLine();
            return sb.ToString();
        }
    }
}

Feliz año 2.022.

Buenas:

Tengo un SAI/UPS que se controla por el puerto serie con su cable (también USB si lo deseas) y puede leer los datos con su programa que te da el fabricante. Lo curioso que dicho programa al ejecutarlo, te abre el navegador Web, pones tu nick y contraseña y aparece los datos en pantalla que viene desde el dispositivo.

Por lo que veo, en la Webmuestra los datos recibidos y también envías comandos, por su puesto, al puerto serie.

¿Cómo controla datos de entrada y dalidas del puerto serie dede ls Web mediante servicios?

Antiguamente usaba capas para hacerlo funcionar, mi manera era, SQL Server, Visual C# para controlar puerto serie y leer la base de datos si ha sido modificado algún estado y controlar la base de datos por vía Web.

Observando el acceso directo hay un archivo que se llama agent.cmd, lo abro y aparece esto.

start http://localhost:3052/local/

Me abre el navegadorr Web.  A patir de ahí, ya funciona el programa del SAI.

Felices fiestas 2022.

Quiero saber si es posible hacerlo con muchos menos códigos.

using System;
 
namespace Return_a_patir_del_caracter_20_Consola_01
{
    internal class Program
    {
        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Return a partir del caracter 20";
 
            // Tamaño de la ventana, x, y.
            Console.SetWindowSize(70, 25);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.Gray;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Black;
 
            // Limpiar pantalla y dejarlo todo gris.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            Console.WriteLine("Hello World!");
            string line = ReadLine20CharByLine();
        }
 
        static string ReadLine20CharByLine()
        {
            string result = "";
            ConsoleKeyInfo key;
            int count = 0;
            while ((key = Console.ReadKey()).Key != ConsoleKey.Enter)
            {
                if (key.Modifiers == (ConsoleModifiers.Control | ConsoleModifiers.Shift | ConsoleModifiers.Alt))
                {
                    continue; // ignora caracteres si viene con algún modificador
                }
                if (key.Key == ConsoleKey.Backspace) // si se pulsa BackSpace
                {
                    if (result.Length > 0)
                    {
                        if (count == 0)  // si estás al principio de un renglón que no es el 1ro
                        {                // borra el último caracter del renglón anterior 
                            Console.SetCursorPosition(20, Console.CursorTop - 1);
                            Console.Write("\b \b");
                            count = 19;
                        }
                        else       // si no, borra el caracter y retrocede en la misma linea
                        {
                            Console.Write(" \b");
                            count--;
                        }
                        result = result.Substring(0, result.Length - 1);
                    }
                }
                else  // si no se pulsó BackSpace ni ninguna tecla con Modifier
                {     // se suma el caracter a result
                    result += key.KeyChar.ToString();
                    count++;
                    if (count == 20)
                    {
                        count = 0;
                        Console.SetCursorPosition(0, Console.CursorTop + 1);
                    }
                }
            }
            return result;
        }
    }
}
 

Feliz fin e año 2021.

Buenas.

En modo consola C#.

Al escribir en el teclado al llegar al carácter 20, sigo escribiendo y me sale el renglón abajo. Así sucesivamente.

¿Es posible hacerlo sin pulsar Enter?

Que lo haga solo.

Felices fiestas 2021.

Sin usar archivos bat externos.

ProcessStartInfo info = new ProcessStartInfo("cmd", "c/ shutdown -s -t 60");

Buenas:

Al recibir datos por puerto serie, muchas veces se me come las palabras.

¿Hay alguna forma que no fallen las entradas de mensajes por puerto serie?

Dejo el código fuente aquí.

using System;
using System.IO.Ports;
using System.Text;
using System.Threading;
using System.Windows.Forms;
 
namespace Velocímetro_Arduino_Puerto_serie_01
{
    public partial class Form1 : Form
    {
        // Utilizaremos un string como buffer de recepción.
        string recibidos;
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            // Añado los puertos disponible en el PC con SerialPort.GetPortNames() al comboBox_Puerto.
            try
            {
                comboBox_Puerto.DataSource = SerialPort.GetPortNames();
            }
 
            catch
            {
                MessageBox.Show("No encuentra ningún puerto físico ni virtual.", "Aviso:",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
 
            // // Añade puertos disponibles físicos  y virtuales.
            serialPort1.PortName = comboBox_Puerto.Text.ToString();
        }
 
        #region Funciones.
 
        void UsbConectado()
        {
            byte[] miBuffer = Encoding.ASCII.GetBytes("USB_CONECTADO");
            serialPort1.Write(miBuffer, 0, miBuffer.Length);
        }
 
        void UsbDesconectado()
        {
            byte[] miBuffer = Encoding.ASCII.GetBytes("USB_DESCONECTADO");
            serialPort1.Write(miBuffer, 0, miBuffer.Length);
        }
 
        // Detecta USB o puerto serie virtual cuando lo conecta y desconecta del cable.
        protected override void WndProc(ref Message USB)
        {
            if (USB.Msg == 0x219)
            {
                comboBox_Puerto.DataSource = SerialPort.GetPortNames();
            }
 
            // Detecta si hay cambios en el usb y si los hay los refleja.
            base.WndProc(ref USB);
        }
 
        // Procesar los datos recibidos en el buffer y extraer las tramas completas.
        void Actualizar(object sender, EventArgs e)
        {
            // Asignar el valor de la trama al label_Recibir_Km.
            label_Recibir_Km.Text = recibidos;
 
            switch (recibidos)
            {
                case "OK":
                    byte[] miBuffer = Encoding.ASCII.GetBytes("Conectado.      ");
                    serialPort1.Write(miBuffer, 0, miBuffer.Length);
                    label_Recibir_Km.Text = "Arduino conectado.";
                    break;
                default:
                    break;
            }
 
            // Limpiar.
            recibidos = "";
        }
        #endregion
 
        #region Botones.
        private void button_Conectar_Click(object sender, EventArgs e)
        {
            try
            {
                serialPort1.PortName = comboBox_Puerto.Text.ToString(); // Puerto seleccionado previamente.
                serialPort1.Open(); // Abrir puerto.
                UsbConectado();
                comboBox_Puerto.Enabled = false;
                comboBox_Baudios.Enabled = false;
                button_Conectar.Enabled = false;
                button_Desconectar.Enabled = true;
                button_Enviar.Enabled = true;
            }
 
            catch
            {
                MessageBox.Show("El puerto no existe.", "Aviso:",
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
 
        private void button_Desconectar_Click(object sender, EventArgs e)
        {
            UsbDesconectado();
            serialPort1.Close(); // Cerrar puerto.
            comboBox_Puerto.Enabled = true;
            comboBox_Baudios.Enabled = true;
            button_Conectar.Enabled = true;
            button_Desconectar.Enabled = false;
            button_Enviar.Enabled = false;
        }
 
        private void button_Enviar_Click(object sender, EventArgs e)
        {
            byte[] miBuffer = Encoding.ASCII.GetBytes("KM" + textBox_Km.Text);
            serialPort1.Write(miBuffer, 0, miBuffer.Length);
        }
        #endregion
 
        // Al cerrar el formulario, cierra el puerto si está abierto.
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            try
            {
                // Al cerrar este programa, indica a Arduino cerrado.
                // Arduino sigue con su rutina al detectar CERRADO.
                byte[] miBuffer = Encoding.ASCII.GetBytes("C#_CERRADO");
                serialPort1.Write(miBuffer, 0, miBuffer.Length);
 
                // Cerrar puerto.
                serialPort1.Close();
            }
 
            catch (Exception error)
            {
                MessageBox.Show(error.Message, "Aviso:",
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
 
        private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Acumula los caracteres recibidos a nuestro "buffer" string.
            recibidos += serialPort1.ReadExisting();
 
            // Invocar o llamar al proceso de tramas.
            Invoke(new EventHandler(Actualizar));
        }
    }
}