Hola:

Teniendo este programa hecho que es un char mini por puerto serie. Puedo enviar mensajes pero no se si en el otro PC lo ha recibido.

De alguna forma, quiero saber antes que nada una buena idea para poder implementarlo en este programa.

Por ejemplo, si envío un hola mundo, en el chat mio tiene que mostrarme o indicarme con algo aunque sea una V, que ese mensaje ha sido realmente enviado al otro chat. Si no lo tiene activo o no lo ha recibido, que lo indique también.

Dejo el programa normal completo aquí. Solo a partir de aquí hay que incorporar esta nueva idea, que en realidad es sacado de los Whatsapp, pero bueno.

Código C#:

using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Threading;
 
namespace Chat_Consola_.net_7_01
{
    class Program
    {
        static bool _continua;
        static SerialPort? Puerto_serie;
 
        static void Main(string[] args)
        {
            const int MAXIMA_LONGITUD = 40000;
            string COM = "";
            string nombre;
            string mensaje;
            string titulo = "Mini chat C# .net 7.0";
 
            StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
            Thread readThread = new(Leer);
 
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = titulo;
 
            // Tamaño de la ventana, x, y, o ancho y alto.
            const byte ANCHO_X = 70, ALTO_Y = 25;
            Console.SetWindowSize(ANCHO_X, ALTO_Y);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.Green;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Black;
 
            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            #region Configuración puerto serie.
            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            Puerto_serie = new SerialPort();
 
            // Codificar a UTF-8 para que se vean bien las tildes, ñ y otros caracteres.
            Puerto_serie.Encoding = Encoding.UTF8;
 
            // Obtenga una lista de nombres de puertos serie.
            string[] puertos = SerialPort.GetPortNames();
 
            Console.WriteLine("Se encontraron los siguientes puertos series:");
 
            // Muestre el nombre de cada puerto en la consola.
            foreach (string puerto in puertos)
            {
                Console.WriteLine(puerto);
            }
 
            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.
 
Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear(); // Limpiar pantalla.
 
            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
 
            // Configuración del puerto serie.
            Puerto_serie.BaudRate = 115200;
            Puerto_serie.Parity = Parity.None;
            Puerto_serie.StopBits = StopBits.One;
            Puerto_serie.DataBits = 8;
            Puerto_serie.Handshake = Handshake.None;
            Puerto_serie.RtsEnable = true;
 
            // Establecer los tiempos de espera de lectura / escritura.
            Puerto_serie.ReadTimeout = 500; // 500 Milisegundos.
            Puerto_serie.WriteTimeout = 500; // 500
 
            // Comprueba si puede abrir el puerto serie.
            try
            {
                Puerto_serie.Open(); // Abrir el puerto serie.
            }
 
            // En caso que diera algún error como que no encuentra el puerto seleccionado
            // muestra una excepción.
            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
                o no lo encuentra.");
                Console.ReadKey();   // Pulse cualquier tecla.
                Environment.Exit(1); // Salir de la aplicación.
            }
 
            // Se ha denegado el acceso al puerto.
            catch (UnauthorizedAccessException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"Se ha denegado el acceso al puerto " + Puerto_serie.PortName +
                                "" +
                                "\nPuede estar el puerto escogido en uso.\n" +
                                "Elija un puerto diferente o desactiva el que está en uso.");
                Console.ReadKey();   // Pulse cualquier tecla.
                Environment.Exit(1); // Salir de la aplicación.
            }
            #endregion
 
            _continua = true;
            readThread.Start();
 
            // Mostrar texto Nombre y se
            Console.Write("Nombre: ");
 
            // guarda en la variable nombre.
            nombre = Console.ReadLine();
 
            // Se muestra el nombre o nick y el puerto seleccionado al final del título de la ventana.
            Console.Title = titulo + "- Nick: " + nombre + " - COM: " + COM;
 
            Console.WriteLine("Escriba /salir para salir.");
 
            while (_continua)
            {
                // Cualquier caracter recibido se guarda en la variable mensaje.
                //mensaje = Console.ReadLine();
 
                #region Enviar más de 255 caracteres.
                // #########################################################################
                Stream entradaDeDatos = Console.OpenStandardInput();
                byte[] buffer = new byte[MAXIMA_LONGITUD];
                int numerosBytesLeidos = entradaDeDatos.Read(buffer, 0, MAXIMA_LONGITUD);
                char[] chars = Console.InputEncoding.GetChars(buffer, 0, numerosBytesLeidos);
                mensaje = new string(chars);
                // #########################################################################
                #endregion
 
                // Compara /salir con el mensaje /salir si lo haz escrito igual.
                // ¿Escribiste la palabra /salir?
                if (comparaString.Equals("/salir\r\n", mensaje))
                {
                    // Sí. Entonces, pone esta variable _continue en false.
                    _continua = false;
                }
                // No. Entonces, envía por el puerto serie tu nick
                // y mensaje que haz escrito.
                else
                {
                    Puerto_serie.WriteLine(String.Format("<{0}>: {1}", nombre, mensaje));
                }
            }
 
            // Bloquea el subproceso.
            readThread.Join();
 
            // Cierra el puerto serie.
            Puerto_serie.Close();
        }
 
        // Lee mensaje recibido.
        public static void Leer()
        {
            // Si _continua es true se ejecuta todas las instrucciones dentro de while.
            while (_continua)
            {
                try
                {
                    // Almacena en la variable mensaje cualquier caracter o mensaje recibido.
                    string mensaje = Puerto_serie.ReadLine();
 
                    // Muestra en pantalla mensaje recibido.
                    Console.WriteLine(mensaje);
                }
                catch (TimeoutException) { }
                catch (IOException)
                {// 'Se devolvió esta operación porque se agotó el tiempo de espera. : ' }
                }
            }
        }
    }
}

Está hecho con el .Net 7.

Saludos camaradas.

Hola:

Con este código compara frase con alguna letra final que coincida pero en este caso nada de nada.

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void _StartsWith_Click(object sender, EventArgs e)
        {
            string cadena1 = textBox1.Text.Trim();
            string cadena2 = textBox2.Text.Trim();
 
            label_Resultado_StartsWith.Text = cadena1.StartsWith(cadena2).ToString();
        }
 
        private void _EndsWith_Click(object sender, EventArgs e)
        {
            string cadena3 = textBox3.Text.Trim();
            string cadena4 = textBox4.Text.Trim();
 
            label_Resultado_EndsWith.Text = cadena3.EndsWith(cadena4).ToString();
        }
    }

Si comparo con Hola y la me tiene que dar True y me da false en la parte de EndsWith.

¿Por qué?

Hola:

Teniendo este código para guardar archivo.json.

using System.Text.Json;
 
namespace SerializeBasic
{
    public class PronosticoDelTiempo
    {
        public DateTimeOffset Fecha { get; set; }
        public int TemperaturaCelsius { get; set; }
        public string? Resumen { get; set; }
    }
 
    public class Program
    {
        public static void Main()
        {
 
 
            var pronosticoDelTiempo = new PronosticoDelTiempo
            {
                Fecha = DateTime.Parse("2019-08-01"),
                TemperaturaCelsius = 25,
                Resumen = "Caliente."
            };
 
            string nombreDelArchivo = "PronósticoDelTiempo.json";
            string jsonString = JsonSerializer.Serialize(pronosticoDelTiempo);
            File.WriteAllText(nombreDelArchivo, jsonString);
 
            // Crear archivo.
            Console.WriteLine(File.ReadAllText(nombreDelArchivo));
 
            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

Crea un archivo y dentro de ella pone.

{"Fecha":"2019-08-01T00:00:00+01:00","TemperaturaCelsius":25,"Resumen":"Caliente."}

La idea es hacerlo así:

{     
     "Fecha":"2019-08-01T00:00:00+01:00",
     "TemperaturaCelsius":25,
     "Resumen":"Caliente."
}

Según el enlace de abajo hay que activarlo a true.

https://learn.microsoft.com/es-es/dotnet/api/system.text.json.jsonserializeroptions.writeindented?view=net-7.0#system-text-json-jsonserializeroptions-writeindented

¿Cómo lo activo?

Saludos.

Hola:

Como curiosidad y novedades del .NET 7.0 o por ahí.

Una cosa es mostrar el contenido de una variable que tiene un texto, otra cosa es mostrar el nombre de la variable. Hace años intentado por mi ignorancia, mostrar el nombre de la variable y ya está.

Hoy en día.

¿Para qué mostrar el nombre de una variable?

Lo que he hecho en el programa de abajo es:
Mostrar el nombre de la variable.
Mostrar el contenido de esa variable.
Mostrar nombre y contenido de la variable.

Código C#:

// Variable.
string soyUnaVariable = "Esto es el contenido de la Variable soyUnaVariable.";
 
// Imprime nombre de la variable.
Console.WriteLine(nameof(soyUnaVariable));
 
// Imprime el contenido de la variable.
Console.WriteLine(soyUnaVariable);
Console.WriteLine();
 
// Imprime nombre de la variable y su contenido.
Console.WriteLine(nameof(soyUnaVariable) + " = " + soyUnaVariable);
Console.WriteLine();
 
// Lo mismo pero otra forma de mostarlo en pantalla.
Console.WriteLine("{0} = {1}", nameof(soyUnaVariable), soyUnaVariable);
 
// Pulse cualquier tecla para salir.
Console.ReadKey();

Solo quiero saber que utilidad puede tener.

Lo único que se me ocurre es no usar el depurador paso a paso del IDE para ver que contiene, aquí lo hace en tiempo real.

Saludos.

Hola:

Uso el .NET 7.0 y tiene su propia librería. Mi idea es no usar librerías externas como Newtonjson, si no el que incluye el propio .NET.

La librería oficial de Visual Studio viene aquí.

Dejo el código aquí abajo hecho con Newtonjson.


Ahora toca hacer lo que se tenga que hacer con la librería que incluye el .net.

¿Alguna idea?

Lo pregunto porque veo que no es para nada compatible entre Newtonjson con el json .net de Microsoft.

Saludos.

Hola:

Antes usaba muchos el XML para guardar y leer datos que tenía en el formulario. Por ejemplo en este caso.




El archivo se genera en el disco duro o SSD hoy en día y pone esto.


Me funciona de maravilla para lo que es el XML y me lo recomendaron en este foro hace años, desde el 2.008.

Ahora, veo mucho con el santo JSON.

¿Es recomendable usar el JSON?

Si es cierto o no. Quiero hacer el mismo ejemplo de recuperar y guardar datos como se hizo el XML.

Saludos.

Hola:

Tengo desde hace tiempo un código que no uso desde el 2017, ahora en pleno 2023 vuelvo a retomar.

Se trata de recibir email los comandos necesarios para luego almacenarlo en una variable y esta lo envía al puerto serie.

Por ejemplo, en el asunto pongo Luz_ON, no hace falta el cuerpo escribir nada, lo lee el programa hecho en C# modo consola y luego envía esa información a puerto serie, tal cual.

El problema es cuando recibe comandos como Luz_ON y Luz_OFF, al enviarlo al puerto serie, me da que no envia nada aunque diga que si.

Aquí está la librería que suso del POP para recibir datos.

https://github.com/foens/hpop

Aquí abajo el código mal optimizado y mal hecho el diseño, al menos por ahora hasta que me funcione como Dios manda.

¿Se puede saber en que falla?

using System;
using System.Collections.Generic;
using OpenPop.Pop3;
using OpenPop.Mime;
using System.Text.RegularExpressions;
using System.IO.Ports;
using System.Text;
using System.Timers;
using System.Threading;
 
namespace Recibir_email_enviar_arduino_Consola_03
{
    class Program
    {
        // Disparador de eventos del timer. Dispara cada cierto tiempo por el timer.
        public static void DisparadorEventosTimer(object source, ElapsedEventArgs e)
        {
            //ConsoleKey tecla;
            string comando = "";
 
            ConnectPop3 oC = new ConnectPop3();
 
            List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();
 
 
            if (lstMessages != null)
            {
 
                foreach (var oMessage in lstMessages)
                {
                    Console.Clear(); // Limpiar pantalla.
                    Console.SetCursorPosition(0, 0);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.WriteLine("EMAIL DE: ");
                    Console.ForegroundColor = ConsoleColor.Gray;
 
                    string emailDesde = oMessage.Headers.From.ToString();
 
                    // Expresión regular detectar dirección email.
                    Regex rx = new Regex(@"<(.*?)>");
                    //Regex rx = new Regex(@"^([da-z_.-]+)@([da-z.-]+).([a-z.]{2,6})$");
                    // Guarda la dirección email en la variable "emailCompleto".
                    string emailCompleto = rx.Match(emailDesde).Groups[1].Value;
                    // Muestra solo la dirección del email.
                    Console.WriteLine(emailCompleto);
 
                    // ¿Son email filtrados? Sí, ejecuta las intrucciones necesarios para leer asunto y mensajes.
                    if ((emailCompleto == "metaconta@gmail.com") || 
                        (emailCompleto == "celltium@gmail.com") ||
                        (emailCompleto == "metaconta@hotmail.com"))
                    {
                        Console.WriteLine("{0} a pasado el filtro: ", emailCompleto);
 
                        Console.ForegroundColor = ConsoleColor.White;
                        Console.WriteLine();
                        Console.WriteLine("ASUNTO: ");
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.WriteLine(oMessage.Headers.Subject + "\n"); // Asunto.
                        comando = oMessage.Headers.Subject; // Guarda el asunto en la variable "comando".
                        Console.ForegroundColor = ConsoleColor.White;
                        Console.WriteLine();
                        Console.WriteLine("MENSAJE: ");
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.WriteLine();
 
                        // ¿Es texto sin formato? Sí.
                        // if (oMessage.MessagePart.IsText == true)
                        if (oMessage.MessagePart.IsText)
                        {
                            Console.WriteLine("Texto sin formato.");
                            Console.WriteLine(oMessage.MessagePart.GetBodyAsText());
                            Console.WriteLine("-------------------------------------------");
                        }
                        // No. Texto con formato.
                        else
                        {
                            Console.WriteLine("Texto con formato.");
 
                            // Encuentra el primer texto sin formato.
                            MessagePart plainTextPart = oMessage.FindFirstPlainTextVersion();
                            if (plainTextPart != null)
                            {
                                // El mensaje tenía una versión de texto sin formato.
                                Console.WriteLine(plainTextPart.GetBodyAsText());
                            }
                            else
                            {
                                // Trate de encontrar un cuerpo para mostrar en algunas de las otras versiones de texto.
                                List<MessagePart> textVersions = oMessage.FindAllTextVersions();
                                if (textVersions.Count >= 1)
                                {
                                    Console.WriteLine(textVersions[0].GetBodyAsText());
                                }
                                else
                                {
                                    Console.WriteLine("<<OpenPop>> Cannot find a text version body in this message to show <<OpenPop>>");
                                }
                            }
                        }
                    }
 
                    // No. Entonces,ignorará los email no filtrados.
                    else
                    {
                        Console.WriteLine("No ha pasado el filtro y no se leerá ningún email.");
                    }
                }
            }
            Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
            Console.WriteLine();
            //Console.WriteLine("FIN DEL PROGRAMA.");
            //Console.ReadKey(); // Pulse cualquier tecla para salir.
            Console.ForegroundColor = ConsoleColor.Gray;
 
            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort("COM6")
            {
                BaudRate = 115200,
                Parity = Parity.None,
                StopBits = StopBits.One,
                DataBits = 8,
                Handshake = Handshake.None,
                RtsEnable = true,
 
                // Establecer los tiempos de espera de lectura / escritura.
                ReadTimeout = 500, // Milisegundos.
                WriteTimeout = 500
            };
 
            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
 
            Puerto_serie.Open(); // Abrir puerto.
 
            // ConsoleKey tecla;
            // Console.WriteLine("Pulse tecla 1 para encender y 2 para apagar:");
 
            do
            {
 
                switch (comando)
                {
                    case "Luz_ON":
                        EncenderLuz();
                        Thread.Sleep(100);
                        break;
 
                    case "Luz_OFF":
                        ApagarLuz();
                        Thread.Sleep(100);
                        break;
 
                    case "Salir":
                        Environment.Exit(1); // Salir de la consola.
                        break;
 
                    default:
                        Console.WriteLine("Esperando comandos válidos");
                        break;
                }
 
                //tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.
 
 
 
                //switch (tecla)
                //{
                //    case ConsoleKey.D1: // Tecla 1 del teclado estandar.
                //    case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
                //        EncenderLuz();
                //        break;
 
                //    case ConsoleKey.D2:
                //    case ConsoleKey.NumPad2:
                //        ApagarLuz();
                //        break;
 
                //    default:
                //        Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
                //        break;
                //}
 
                Puerto_serie.Close(); // Cerrar puerto.
 
            } while (comando == "salir"); // while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.
 
            void EncenderLuz()
            {
                byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
                Console.WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
            }
 
            void ApagarLuz()
            {
                byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
                Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
                Console.WriteLine("Comando \"Luz_OFF\" enviado.");
 
            }
 
            //Console.WriteLine("Presione cualquier tecla para terminar...");
            Console.WriteLine();
            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
            Puerto_serie.Close(); // Cierra el puerto serie.
        }
 
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Recibir e-mail con Consola C# y enviar al LCD de Arduino";
 
            // Tamaño ventana consola.
            Console.WindowWidth = 80; // X. Ancho.
            Console.WindowHeight = 40; // Y. Alto.
 
            // Cursor invisible.
            Console.CursorVisible = false;
 
            // Título del programa.
            Console.WriteLine("\t-----------------------------------------------------");
            Console.WriteLine("\tRecibir Correo Electrónico y enviar al LCD de Arduino");
            Console.WriteLine("\t-----------------------------------------------------");
            Console.WriteLine();
 
            try
            {
                System.Timers.Timer miTimer = new System.Timers.Timer
                {
                    Enabled = true
                };
                miTimer.Elapsed += new ElapsedEventHandler(DisparadorEventosTimer);
                miTimer.Interval = 5000; // Escaneo cada 5 segundos.
                miTimer.Start(); // Activa el temporizador.
 
 
                Console.ReadKey(); // Pulse cualquier tecla para salir.
            }
 
            // Cualquier error mostrado en mensaje y de color rojo.
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine();
                Console.WriteLine(ex);
                Console.ReadKey();
            }
 
 
        }
 
        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
        }
    }
 
    public class ConnectPop3
    {
        public string email = "metaconta@gmail.com";
        public string contraseña = "g0923490xgh0945g450Xj4025g"; // Ficticio.
        public int puerto = 995;
        public bool usarSLL = true;
        public string Hostame = "pop.gmail.com";
 
        public List<OpenPop.Mime.Message> GetMessages()
        {
            using (Pop3Client oClient = new Pop3Client())
            {
                oClient.Connect(Hostame, puerto, usarSLL);
                oClient.Authenticate(email, contraseña);
 
                int messageCount = oClient.GetMessageCount();
                List<OpenPop.Mime.Message> lstMessages = new List<OpenPop.Mime.Message>(messageCount);
 
                for (int i = messageCount; i > 0; i--)
                {
                    lstMessages.Add(oClient.GetMessage(i));
                }
 
                return lstMessages;
            }
        }
    }
}

Saludos.

Edito:
Edito:

En resumen para que se entienda mejor.

El programa lo que hace leer e-mail recibidos y filtran los que he elegido para ser leídos, detecta que su contenido tiene formato o es solo texto en plano.

En el asunto de e-mail, pongo los comandos, por ejemplo, uso tres, Luz_ON, Luz_OFF y Salir. Si le llega, salir, cierra el puerto serie y el propio programa de la consola C#.

Si le llega el comando Luz_ON, lo envía al puerto serie. Acto seguido, espera una respuesta desde el puerto serie y lo muestra en pantalla de C#.

Eso es todo y es más complicado de hacer el programa de lo que parece.

Gracias por leer hasta aquí.

Hola:

Teniendo un string como este. Todo en la consola en C#.

string normal = "!Hola¡ Esto son textos o frases para esta prueba de codificación y descodificación.";
 
string resultadoCodificado = "";
string resultadoDescodificado = "";

Quiero de alguna forma aprender como se codifica que no se entienda a la hora de mostrarlo. Por ejemplo, hace una codificación y muestre caracteres raros, típico del ASCII, aunque en este caso, prefiero usar UTF-8. Ahora mismo esto da igual.

Una vez codificado a lo raro, se guarda en la variable resultadoCodificado y se lee en pantalla con el Consola.Write();

Se pulsa Enter y lee la variable resultadoCodificado para que vuelva a codificarlo como estaba en un principio, luego mostrarlo en pantalla otra vez.

Cualquier frase que ponga en la variable "normal", lo pueda codificar y descodificar sin problemas.

Si es posible hacerlo.

¿Cuál es un buen ejemplo sencillo para hacerlo?

Saludos.

Hola:

Quiero saber si el serialPort de C# tienes estas funciones que tiene Arduino.
https://docs.arduino.cc/built-in-examples/strings/StringStartsWithEndsWith

Por ejemplo detecta los primeros bytes que indiques de una trama de Bytes que llegue desde el puerto, lo mismo para los últimos bytes.

¿Alguien sabe de esto?

Si no tiene, como siempre, usar delimitadores en C#.

Saludos.

Hola:

Teniendo Visual Studio Community (Gratuito), se puede programar con tu PC de sobremesa conectado en red una Raspberry Pi.

Se que se puede programar con C++ y Python desde la interfaz o IDE de Visual Studio, en consola.

1. ¿Quiero saber, si se puede hacer un formulario como en Windows, programación con gráficos?

2. Aunque se programe en solo consola. ¿Es posible programar usando C# para la Raspberry Pi?

Saludos.