Temas

Lo tengo en unidades de metros.

Quiero calcular un cilindro como este, su volumen.


h = altura.
r = radio.
v = volumen.



Aquí hice un pequeño programa en la consola C# que calcula solo introduciendo dos valores, el radio del cilindro o depósito de agua y la altura.

Código (csharp) [Seleccionar] Expandir

using System;

namespace namespace_Calculo_cilindro_consola_02_cs
{
   class Program
   {
       static void Main(string[] args)
       {
           Console.Title = "Cálculo geométrico cilindro - C# 2019";
           Console.SetWindowSize(50, 25);

           // Variables.
           double Pi = 3.14;
           double radio = 0;
           double altura = 0;
           double areaLateral = 0;
           double areaTotal = 0;
           double volumen = 0;
           double litros = 0;

           Console.WriteLine("===== Área lateral =====");
           Console.Write("Introduce el radio en m.: ");
           radio = double.Parse(Console.ReadLine());
           Console.Write("Introduce la altura en m.: ");
           altura = double.Parse(Console.ReadLine());

           // Cálculo área lateral.
           areaLateral = 2 * Pi * radio * altura;

           Console.WriteLine("Área lateral = 2 x Pi x radio x altura.");
           Console.ForegroundColor = ConsoleColor.Green;
           Console.WriteLine("Área lateral: {0} m^2. (Metros cuadrados). \n", areaLateral);

           Console.ForegroundColor = ConsoleColor.Gray;
           Console.WriteLine("===== Área total =====");

           // Cálculo área Total.
           areaTotal = areaLateral + 2 * (Pi * (radio * radio));

           Console.WriteLine("Área total = Áreal lateral + 2 x (Pi x r^2)");
           Console.ForegroundColor = ConsoleColor.Yellow;
           Console.WriteLine("Área total = {0} m^2. \n", areaTotal);

           Console.ForegroundColor = ConsoleColor.Gray;
           Console.WriteLine("===== Volumen =====");
           Console.WriteLine("Volumen = Pi x radio^2 x altura");

           // Cálculo volumen.
           volumen = Pi * (radio * radio) * altura;

           Console.ForegroundColor = ConsoleColor.Cyan;
           Console.WriteLine("Volumen = {0} m^3. (Metros cúbicos). \n", volumen);

           Console.ForegroundColor = ConsoleColor.Gray;
           Console.WriteLine("===== Litros =====");
           Console.WriteLine("Litros = Volumen * 1000");
           Console.WriteLine("Litros = {0} m^3 * 1000", volumen);

           // Cálculo litros.
           litros = volumen * 1000;

           Console.ForegroundColor = ConsoleColor.Red;
           Console.WriteLine("Litros = {0}", litros + " L.\n");

           Console.ForegroundColor = ConsoleColor.Gray;
           Console.WriteLine("FIN DE PROGRAMA. Pulse cualquier tecla para salir.");
           // Pulse cualquier tecla para salir.
           Console.ReadLine();
       }
   }
}




Me falta hacer una fórmula que no se hacer sobre saber que cantidad de litros tengo en este depósito de agua o cilindro. Por ejemplo, ya que la altura es de 0 a 2 metros, quiero saber que si cambio la altura del agua, por ejemplo que está a 0.7 metros, que me muestre el porcentaje en %. Está claro que si está el nivel del agua a 2 metros de altura que es la máxima, será el 100 %.

1. Si la altura está en 0.7 metros. ¿Qué porcentaje muestra?

2. ¿Qué cantidad de Litros de agua hay cuando está el nivel de agua a 0.7 metros?

Solo me falta saber estas dos cosas en papel. Luego lo transformo en C#.

Saludos.

Buenos días compañeros.

No tengo idea de PowerShell. He creado una dll con Visual C++ nativo y a 64 bits. Hice un ejemplo con una interfaz de consola C# y me lee la dll de C++ nativo.

Dejo un ejemplo.

Código (csharp) [Seleccionar] Expandir

Código C#:

using System;
using System.Runtime.InteropServices; // No olvidar.

namespace Consola_cs
{
    class Program
    {
        // Importar dll.
        [DllImport("MyDLL.dll")]
        extern static public int Suma(int a, int b);
        [DllImport("MyDLL.dll")]
        extern static public IntPtr Mensaje();

        static void Main()
        {
            // Título de la ventana.
            Console.Title = "Consola C# 2019";

            // Tamaño de la ventana.
            Console.SetWindowSize(40, 5);

            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Green;

            // Llamando a la dll para mostrar un mensaje y una suma.
            Console.WriteLine(Marshal.PtrToStringAuto(Mensaje()));
            Console.WriteLine(Suma(1764, -764).ToString());

            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}


DLL hecho con C++:

Código (cpp) [Seleccionar] Expandir

// dllmain.cpp : Define el punto de entrada de la aplicación DLL.
#include "pch.h"

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

extern "C"
{
    __declspec(dllexport)  int WINAPI Suma(int, int);
    __declspec(dllexport) LPTSTR WINAPI Mensaje();
};

// Suma.
int WINAPI Suma(int a, int b) { return a + b; }

// Mensaje.
LPTSTR WINAPI Mensaje() { return LPTSTR(L"Hola. Soy una dll de C++ nativo."); }


El archivo dll que he creado se llama MyDLL.dll y quiero saber si PowerShell es capaz de leer las dll y que funciona. Esta dll solo hace una suma y muestra un mensaje en pantalla.

¿Es posible que PowerShell sea capaz de leer una dll?

Si es cierto. ¿Cómo se hace?

Un cordial saludos.

[System.BadImageFormatException:]

Buenas:

Tengo un proyecto en el cual creé una dll, solo se actualiza una vez y está en esta dirección.
C:\Users\Meta\Documents\Visual Studio 2019\Projects\MyDLL\Debug\MyDLL.dll.

Lo curioso que cambié el texto de la dll para que me diga otra cosa, y la dirección de arriba no se actualiza pero es la dll que funciona. Se actualiza otra copia en otro directorio indicado abajo.
C:\Users\Meta\Documents\Visual Studio 2019\Projects\MyDLL\x64\Debug\MyDLL.dll.

Si uso esta dll llevándolo a la interfaz creada en la consola de C#, no funciona, me da este error.

System.BadImageFormatException: 'Se ha intentado cargar un programa con un formato incorrecto. (Excepción de HRESULT: 0x8007000B)'

Da igual que haga volver a compilar la dll, recopilar, limpiar  copilar de nuevo, nunca actualiza la dll que si funciona.

Dejo un tutorial en pdf de los pasos que he hecho para que entiendan lo que estoy diciendo, más bien, escribiendo.
Ver turorial en pdf.

Muchas gracias.

[Código C#:]

Buenas:

Tengo un ejemplo en C# para leer una dll hecho en C++ Win32.

Código C#:

Código (csharp) [Seleccionar] Expandir

using System;
using System.Runtime.InteropServices;

namespace Consola_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Marshal.PtrToStringAuto(SUPER_DLL.Mensaje()));
            Console.WriteLine(SUPER_DLL.Suma(1764, -764).ToString());

            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
        internal class SUPER_DLL
        {
            [DllImport("Super_dll.dll")]
            extern static public int Suma(int a, int b);
            [DllImport("Super_dll.dll")]
            extern static public IntPtr Mensaje();
        }
    }
}


Quiero adaptarlo la consola en Win32, pero me da errores.

Código C++ Win32:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <windows.h>

int main()
{
    std::cout << Marshal.PtrToStringAuto(SUPER_DLL.Mensaje());
    std::cout << SUPER_DLL.Suma(1764, -764).ToString();

    // Esperando pulsar Enter para salir.
    std::cin.get();
    return 0;
}

internal class SUPER_DLL
{
    [DllImport("Super_dll.dll")]
    extern static public int Suma(int a, int b);
    [DllImport("Super_dll.dll")]
    extern static public IntPtr Mensaje();
}

Documento de aquí.


¿Alguna idea?

Saludos.

Buenas gente del foro:

Teniendo este programa, no se comporta como quiero. Se trata de usar solo las teclas flechas y la tecla Enter. Con ello se puede crear un nombre, escribir un nombre que quiera. Cuando ya termine, pulso Enter y se posiciona en la parte indicada en la imagen de abajo.

Aquí abajo, escribí todo a AAAAAAAAAAAAA.

Al pulsar Enter, tiene que ser capaz de señalar con las teclas flechas izquiera y derecha para poder elegir ATRÁS o GUARDAR.


Una vez que haya elegido con el símbolo en > ATRÁS, si pulsa Enter muestra un mensaje:

Código (csharp) [Seleccionar] Expandir

Console.Write("HAS PULSADO ATRÁS   ");

El programa en esta parte se acaba ahí.

Si con las flechas del teclado selecciona en > GUARDAR, luego pulsa la tecla Enter. A parte que el nombre como en este caso AAAAAAAAAAA, se almacena en la variable...

Código (csharp) [Seleccionar] Expandir

static string guardarNombre = "";

Muestra el mensaje: HAS GUARDADO y el nombre AAAAAAAAAAAAAAAA en pantalla.

Código completo en C#:

Código (csharp) [Seleccionar] Expandir

using System;

namespace LCD_nombre_archivo_consola_06
{
    class Program
    {
        static string guardarNombre = "";
        static int coordenadaX = 0;
        static ConsoleKey key;

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

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

        private static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };

        static int index = 0;
        static void Main(string[] args)
        {
            // Título de la pantalla.
            Console.Title = "Cambiar nombre";

            Inicio();
        }

        #region Inico.
        private static void Inicio()
        {
            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.White;

            // Limpiar pantalla.
            Console.Clear();

            Console.SetCursorPosition(0, 0);
            Console.Write("Nombre del relé 1:  ");
            Console.SetCursorPosition(0, 1);
            //Console.Write("AAAAAAAAAAAAAAAA");

            // Recorre todo el índice del array y el de los datos alfanumérico.
            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
            {
                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
            }

            Console.SetCursorPosition(2, 3);
            Console.Write(roTEXTO[0]); // ATRÁS.
            Console.SetCursorPosition(12, 3);
            Console.Write(roTEXTO[1]); // GUARDAR.

            while (true)
            {
                Console.SetCursorPosition(coordenadaX, 1);
                key = Console.ReadKey(true).Key;
                switch (key)
                {
                    case ConsoleKey.RightArrow:
                        if (coordenadaX < 15)
                            coordenadaX++;
                        break;

                    case ConsoleKey.LeftArrow:
                        if (coordenadaX > 0)
                            coordenadaX--;
                        break;

                    case ConsoleKey.UpArrow:
                        roINDICE_ARRAY[coordenadaX]++;
                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                        {
                            roINDICE_ARRAY[coordenadaX] = 0;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;

                    case ConsoleKey.DownArrow:
                        roINDICE_ARRAY[coordenadaX]--;
                        if (roINDICE_ARRAY[coordenadaX] < 0)
                        {
                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;

                    case ConsoleKey.Enter:
                        Console.SetCursorPosition(1, 3);
                        Console.Write(">");
 
                        while (true)
                        {
                            key = Console.ReadKey(true).Key;

                            switch (key)
                            {
                                case ConsoleKey.RightArrow:
                                case ConsoleKey.LeftArrow:
                                    index = 1 - index;
                                    break;

                                case ConsoleKey.UpArrow:
                                case ConsoleKey.DownArrow:
                                    Console.SetCursorPosition(coordenadaX, 1);
                                    break;

                                case ConsoleKey.Enter:

                                    break;
                            }

                            for (int a = 0; a < 2; a++)
                            {
                                Console.SetCursorPosition(1 + (10 * a), 3);
                                if (a == index)
                                    Console.Write(">");
                                else
                                    Console.Write(" ");
                            }

                            if (index == 0)  // se pulsó Atrás
                            {
                                Atras();
                                //break;  // vuelve a la edición de letras
                            }
                           
                            if (index == 1)  // se pulsó Guardar
                            {
                                Guardar();
                            }
                        }
                }
            }
        }
        #endregion

        private static void Atras()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS PULSADO ATRÁS   ");
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }

        private static void Guardar()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS GUARDADO       ");
            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
            {
                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
            }
            Console.SetCursorPosition(0, 2);
            Console.Write(guardarNombre);
        }
    }
}

¿Alguna idea?

Un saludo.

Buenas:

Tengo este código de Python 2.x. No me funciona en Visual Studio Community 2019 (Gratuito).

Código (python) [Seleccionar] Expandir

import os, sys, tkFileDialog,Tkinter

root = Tkinter.Tk()
root.withdraw()

formats = [ ('Roms Super Nintendo SMC','.smc'),('Roms Super Nintendo SFC','.sfc'),('Fichier Bin','.bin'),('Roms Super Nintendo','.smc .sfc .bin') ]

input = tkFileDialog.askopenfile(parent=root,mode='rb',filetypes=formats,title='Select file to swap bin HI to LO like A16->A15, A17->A16...A21->A20 and A15->21')
if not input:
        print "Error: Cannot open file"
        sys.exit()

output = tkFileDialog.asksaveasfile(parent=root,mode='wb',filetypes=formats,title='Create output file name')
if not output:
        print "Error: cannot create output file"
        sys.exit()
       

# reading input file to a byte array
data = bytearray(input.read())

# calculating rom size in 2 exponants
expsize = 0
bytesize = len(data)
while bytesize > 1:
        expsize += 1
        bytesize = bytesize // 2

# init a proper size empty bytearray
buffer = bytearray()
for i in range(2**expsize): buffer.append(0)

# let's do the swap
count = 0
for i in range(len(data)):
        addr = (i & 0x7fff) + ((i & 0x008000) << (expsize - 16)) + ((i & 0x010000) >> 1) + ((i & 0x020000) >> 1) + ((i & 0x040000) >> 1) + ((i & 0x080000) >> 1) + ((i & 0x100000) >> 1) + ((i & 0x200000) >> 1)
        if addr != i: count += 1
        buffer[addr] = data[i]
print "Swapped %s (%s) addresses" % (count, hex(count))

# writing output file
output.write(buffer)

# close file handles
input.close()
output.close()

Me sale estos errores.
Traceback (most recent call last):
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 193, in _run_module_as_main
    "__main__", mod_spec)
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 85, in _run_code
    exec(code, run_globals)
  File "c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\microsoft\python\core\debugpy\__main__.py", line 45, in <module>
    cli.main()
  File "c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\microsoft\python\core\debugpy/..\debugpy\server\cli.py", line 429, in main
    run()
  File "c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\microsoft\python\core\debugpy/..\debugpy\server\cli.py", line 266, in run_file
    runpy.run_path(options.target, run_name=compat.force_str("__main__"))
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 261, in run_path
    code, fname = _get_code_from_file(run_name, path_name)
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 236, in _get_code_from_file
    code = compile(f.read(), fname, 'exec')
  File "C:\Users\Meta\Documents\Visual Studio 2019\Python_consola_01\Python_consola_01\Python_consola_01.py", line 10
    print "Error: Cannot open file"
                                  ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Error: Cannot open file")?
Press any key to continue . . .

¿Les dicen algo?

Saludos.

Buenas:

En C++ CLR para almacenar en una variable cualquier tecla pulsada de hace así indicado abajo.

Código [Seleccionar] Expandir


// Almacena la tecla pulsada en la variable.
ConsoleKey teclaInicial;

¿Cómo se hace en C++ Win32?

Saludos.

Buenas:

Trabajando con Win32 de C++ bajo Visual Studio Community 2019.

Cuando escriba Hola mundo. El cursor parpadea.

¿Hay alguna manera de quitarlo?

En C++ del CLR si se puede.

Código (cpp) [Seleccionar] Expandir

Console::CursorVisible = false;

En C++ Win32 no se como se hace.

Saludos.

Hola:

Aquí un programa hecho en consola, solo se usa las flechas del teclado y Enter.

Este programa se basa en radioButton, que en este caso funciona si selecciona una opción y pulsas Enter, se pone un asterisco. Hasta ahí bien.

Al pulsar Salir, luego Entrar, no se queda guardado el * en el último radioButton seleccionado.

¿Cómo se hace?

El código que tengo por ahora lo dejo aquí.

Código [Seleccionar] Expandir

using System;

namespace radioButton_consola_02_cs
{
    class Program
    {
        #region Variables.
        private static readonly string[] TEXTO = new string[]
        {
            "( ) Opción A        ",
            "( ) Opción B        ",
            "( ) Opción C        ",
            "    SALIR"
        };
        #endregion

        static void Main(string[] args)
        {
            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.White;

            // Oculto el cursor.
            Console.CursorVisible = false;

            // Almacena la tecla pulsada en la variable.
            ConsoleKey teclaInicial;

            do
            {
                // Limpiar pantalla.
                Console.Clear();

                // Posición del cursor del título del MENÚ PRINCIPAL.
                Console.SetCursorPosition(0, 0);

                // Título.
                Console.Write("   MENÚ PRINCIPAL   ");

                // Pocisión de la hora.
                Console.SetCursorPosition(4, 2);

                // Formato numérico dd/MM/yyyy.
                Console.Write(DateTime.Now.ToString("ddd dd MMM"));

                // Almacena en la variable una tecla pulsada.
                teclaInicial = Console.ReadKey(true).Key;

                // ¿Haz pulsado la tecla Enter?
                if (teclaInicial == ConsoleKey.Enter)
                {
                    // Sí. Se ejecuta esta función.
                    MenuPrincipal();
                }
            } while (teclaInicial != ConsoleKey.Escape);

            #region Menú Principal.
            void MenuPrincipal()
            {
                bool salir = false;

                // En itemSelecionado:
                // -1 = Sin seleccionar con * ninguna opción.
                // 0 = Seleccionar con * la Opción A.
                // 1 = Seleccionar con * la Opción B.
                // 2 = Seleccionar con * la opción C.
                int itemSeleccionado = 0;
                int itemSeñalado = 0;

                // Capturar tecla para luego validar.
                ConsoleKey tecla;

                do
                {
                    //******************************************************************
                    // Dibujo el menú principal.

                    // Rellenar fondo verde.
                    //Console.BackgroundColor = ConsoleColor.Green;

                    // Letras negras.
                    //Console.ForegroundColor = ConsoleColor.Black;

                    // Limpiar pantalla.
                    Console.Clear();

                    for (int k = 0; k < TEXTO.Length; k++)
                    {
                        Console.SetCursorPosition(0, k);
                        Console.Write(itemSeñalado == k ? "> " : "  ");
                        Console.Write(TEXTO[k]);
                        Console.SetCursorPosition(3, k);
                        Console.Write(itemSeleccionado == k ? "*" : " ");
                    }

                    // Fin de pintar el menú principal.
                    //******************************************************************

                    // Leer tecla ingresada por el usuario.
                    tecla = Console.ReadKey(true).Key;

                    switch (tecla)
                    {
                        case ConsoleKey.Enter:
                            itemSeleccionado = itemSeñalado;
                            salir = (itemSeleccionado == TEXTO.Length - 1);
                            break;

                        case ConsoleKey.DownArrow:
                            if (++itemSeñalado >= TEXTO.Length)
                            {
                                itemSeñalado = 0;
                            }
                            break;

                        case ConsoleKey.UpArrow:
                            if (--itemSeñalado < 0)
                            {
                                itemSeñalado = TEXTO.Length - 1;
                            }
                            break;
                    }
                    // Uso la tecla escape como salida.
                } while (!salir);
            }
            #endregion
        }
    }
}

Saludos.

Buenas:



Usando el teclado solo las flechas y el Enter, en este programa puedo escribir nombre y se muestra en pantalla. Al escribir un nombre, pulso Enter y correctamente me lleva a la zona de > "Atrás". Si con la flecha derecha o izquierda me tiene que llevar a la parte de > Guardar.

El problema está que tiene que indicar con el caracter > en Guardar, y se ejecuta directamente, cosa que no debe ser. En la zona Atrás y Guardar solo se ejecuta si pulso Enter.

Dejo el código aquí como ejemplo.

Código (csharp) [Seleccionar] Expandir

using System;

namespace LCD_nombre_archivo_consola_03
{
    class Program
    {
        static string guardarNombre = "";
        static int coordenadaX = 0;
        static ConsoleKey key;

        static readonly char[] roALFANUMERICO = new char[] {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
            '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '};
        static readonly int[] roINDICE_ARRAY = new int[] {
            80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };
        static readonly string[] TEXTO = new string[] { "ATRÁS", "GUARDAR" };
        static int index = 0;
        static void Main(string[] args)
        {
            // Título de la pantalla.
            Console.Title = "Cambiar nombre";

            Inicio();
        }

        #region Inico.
        private static void Inicio()
        {
            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.White;

            Console.Clear();

            Console.SetCursorPosition(0, 0);
            Console.Write("Nombre del relé 1:  ");
            Console.SetCursorPosition(0, 1);
            //Console.Write("AAAAAAAAAAAAAAAA");

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

            Console.SetCursorPosition(2, 3);
            Console.Write(TEXTO[0]); // ATRÁS.
            Console.SetCursorPosition(12, 3);
            Console.Write(TEXTO[1]); // GUARDAR.

            while (true)
            {
                Console.SetCursorPosition(coordenadaX, 1);
                key = Console.ReadKey(true).Key;
                switch (key)
                {
                    case ConsoleKey.RightArrow:
                        if (coordenadaX < 15)
                            coordenadaX++;
                        break;

                    case ConsoleKey.LeftArrow:
                        if (coordenadaX > 0)
                            coordenadaX--;
                        break;

                    case ConsoleKey.UpArrow:
                        roINDICE_ARRAY[coordenadaX]++;
                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                        {
                            roINDICE_ARRAY[coordenadaX] = 0;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;

                    case ConsoleKey.DownArrow:
                        roINDICE_ARRAY[coordenadaX]--;
                        if (roINDICE_ARRAY[coordenadaX] < 0)
                        {
                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;

                    case ConsoleKey.Enter:
                        Console.SetCursorPosition(1, 3);
                        Console.Write(">");
 
                        while (true)
                        {
                            key = Console.ReadKey(true).Key;

                            switch (key)
                            {
                                case ConsoleKey.RightArrow:
                                case ConsoleKey.LeftArrow:
                                    index = 1 - index;
                                    break;

                                case ConsoleKey.UpArrow:
                                case ConsoleKey.DownArrow:
                                    Console.SetCursorPosition(coordenadaX, 1);
                                    break;

                                case ConsoleKey.Enter:

                                    break;
                            }

                            for (int a = 0; a < 2; a++)
                            {
                                Console.SetCursorPosition(1 + (10 * a), 3);
                                if (a == index)
                                    Console.Write(">");
                                else
                                    Console.Write(" ");
                            }

                            if (index == 0)  // se pulsó Atrás
                            {
                                Atras();
                                //break;  // vuelve a la edición de letras
                            }
                            else if (index == 1)  // se pulsó Guardar
                            {
                                Guardar();
                            }
                        }
                }
            }
        }
        #endregion

        private static void Atras()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS PULSADO ATRÁS   ");
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }

        private static void Guardar()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS GUARDADO       ");
            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
            Console.SetCursorPosition(0, 2);
            Console.Write(guardarNombre);
        }
    }
}

Un cordial saludos.

Hola:

En un archivo de Arduino C, se escribe algo así.

Código (c) [Seleccionar] Expandir

void setup()
{
  // put your setup code here, to run once:

}

void loop()
{
  // put your main code here, to run repeatedly:

}

Quiero simularlo en C# los setup y loop. Que daría en C# así:

Código (csharp) [Seleccionar] Expandir

using System;

namespace Prueba
{
    class Program
    {
        static void Main(string[] args)
        {
            setup();
            while (true)
            {
                loop();
            }
        }

        private static void setup()
        {
          // put your setup code here, to run once:
        }

        private static void loop()
        {
          // put your main code here, to run repeatedly:
        }
    }
}

Mostrar texto en consola de C# es así:

Código (csharp) [Seleccionar] Expandir

Console.Write"¡Hola Mundo!";

En Arduino mostarlo en un LCD es así:

Código (c) [Seleccionar] Expandir

lcd.printf("¡Hola Mundo!");

Se crea en C# simulando el C de Arduino así:

Código (csharp) [Seleccionar] Expandir

public static class lcd{

    public static void printf(string mensaje){

        Console.Write(mensaje);

   }

}

¿Cómo hago en C# una buena plantilla para que se vea solo lo de abajo?

Código (c) [Seleccionar] Expandir

    void setup()
    {
      // put your setup code here, to run once:
     
    }
     
    void loop()
    {
      // put your main code here, to run repeatedly:
     
    }

En pleno C#.

Saludos.

[Código C#:]

Buenas:



Este programa se trata de usar solo las teclas de las flechas y Enter. Ninguna más. Me funciona lo de cambiar un nombre con las teclas de las flechas. Una vez que tenga el nombre, si pulsas la Tecla Enter, tiene que aparecer este símbolo > al lado donde pone ATRÁS.

Tiene que aparecer así:

> ATRÁS      GUARDAR

Desde que esté el signo > en ATRÁS, ya se puede mover hacia GUARDAR, puedes elegir con las flechas del teclado, izquierda y derecha.

Independientemente donde esté el > sea en ATRÁS o en GUARDAR, si pulsas las flechas arriba o abajo, se pone en la parte del nombre para cambiarlo otra vez, una vez que tenga el nombre que quieras, pulsas Enter otra vez y se va este > a ATRÁS como dije antes.

Si el > está en GUARDAR como indica abajo.

ATRÁS     > GUARDAR

Si pulsas Enter, guarda el nombre que hayas puesto en la variable guardaNombre. Se queda simplemente almacenado ahí del programa.

Si vuelves con el > en ATRÁS y pulsas Enter. Muentra un mensaje en pantalla. Haz pulsado ATRÁS y el programa se queda ahí.

Espero que se entienda los paso que he escrito, si no se entiende algo, lo comentan.

Sólo he hecho esto.

Código C#:

Código (csharp,15) [Seleccionar] Expandir

using System;

namespace LCD_nombre_archivo_consola_02
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la pantalla.
            Console.Title = "Cambiar nombre";

            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);

            string guardarNombre = "";
            int coordenadaX = 0;
            ConsoleKey key;

            char[] alfanumerico = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'Ñ', 'O', 'P',
                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
            int[] indiceArray = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
            string[] texto = new string[] {"ATRÁS", "GUARDAR"};

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.White;

            Console.Clear();

            Console.SetCursorPosition(0, 0);
            Console.Write("Nombre del relé 1:");
            Console.SetCursorPosition(0, 1);
            Console.Write("AAAAAAAAAAAAAAAA");
            Console.SetCursorPosition(2, 3);
            Console.Write(texto[0]);
            Console.SetCursorPosition(12, 3);
            Console.Write(texto[1]);

            while (true)
            {
                Console.SetCursorPosition(coordenadaX, 1);

                key = Console.ReadKey(true).Key;

                if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
                {
                    coordenadaX++;
                }
                else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
                {
                    coordenadaX--;
                }
                else if (key == ConsoleKey.UpArrow)
                {
                    indiceArray[coordenadaX]++;

                    if (indiceArray[coordenadaX] >= alfanumerico.Length)
                    {
                        indiceArray[coordenadaX] = 0;
                    }

                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                }
                else if (key == ConsoleKey.DownArrow)
                {
                    indiceArray[coordenadaX]--;

                    if (indiceArray[coordenadaX] < 0)
                    {
                        indiceArray[coordenadaX] = alfanumerico.Length - 1;
                    }

                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
                }
            }
        }
    }
}



Gracias por todo.

Hola:

Quiero saber si a estas alturas se puede crear un menú y submenú con la línea de comando de Windows 10, el cmd de siempre. Se que está PowerShell, el sustituto del cmd, pero este es más complicado, nuevo y no entiendo, en realidad, no entiendo ninguno.

Solo se permite usar las flechas del teclado y la tecla Enter para navegar por esos menú y submenús.

Esquema boceto para hacer una idea.


Vídeo:
[youtube=640,360]https://www.youtube.com/watch?v=vvT-dAeuNXg[/youtube]

Saludos.

[Paso 1.]

Hola:

Paso 1.

Quiero quitar caracter raros hasta en el título cuando uso tildes.

Antes usaba el #include "pch.h". Ya no se como añadirlo. Hace dos años que no uso el C++ de Visual Studio Community 2019.

Código (cpp) [Seleccionar] Expandir

#include <iostream>

#include <windows.h> // Para mostrar texto en el título de la ventana.



using namespace std;

using std::cout;



int main(void)

{



SetConsoleTitle(TEXT("Título de la ventana. Win32 C++ 2019."));



cout << "Terminarías. Conocerías. Título. Analógico. \n";

cout << "Muchas gracias mi muy distinguido amigo.";



cin.get();

return 0;

}

Paso 2.

¿Cómo redimensionar la ventana?

Por ejemplo, en C# se usa esto.

Código (csharp) [Seleccionar] Expandir

          // Tamaño ventana consola.

           // X anchura.

           Console.WindowWidth = 20;



           // Y altura.

           Console.WindowHeight = 5;

Más fácil aún y en una sola línea es:

Código (csharp) [Seleccionar] Expandir

Console.SetWindowSize(20, 5);

¿Cómo se hace en C++?

Gracias.

Hola gente del foro:

En la consola C# 2019 quiero hacer un menú con estas dimensiones.

Código (csharp) [Seleccionar] Expandir

            Console.Title = "Menú de opciones";

            // Tamaño ventana consola.
            // X anchura.
            Console.WindowWidth = 20;

            // Y altura.
            Console.WindowHeight = 5;

            // Oculto el cursor.
            Console.CursorVisible = false;

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Green;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.Black;

El diseño lo hago primero a mano. Hay que seleccionar o indicar la parte de la pantalla este símbolo >.
Con esto maneja las dos barras indicada abajo y las opciónes ATRÁS y MENÚ.

Las coordenadas del > está indicada en el dibujo de abajo.



Ver zoom.

El > lo mueves solo con flechas del teclado, arriba, abajo, derecha e izquierda.

Para dejarlo más claro, aquí una captura pero no es funcional.


La barra Brillo y Voum. se mueve del 0 al 7.

Antes de sacar un super código horrible, quiero saber cual es la mejor idea y facilidad para el dibujado y que funcione.

Saludos.

[Código C#:]

Hola:

Haciendo menús y submenús con la consola de C# 2019.

La verdad que he cometido fallos y no se si es posible resolverlo, al menos no se hacerlo. Todo de momento está hecho en un único archivo en Visual Studioi 2019.

He hecho un esquema boceto para que se entienda.


Ver zoom.

Se ha hecho un esquema de todas las opciones para tener una vista rápida y una posible facilidad de compresión.

Si nada más ejecutar el programa o aplicación, pulso Enter, muestra las opciones aue son A, B y C, señalo Salir, pulso Enter vuelve al reloj, como debe ser, así susecibamente. Hasta ahí todo bien.

El problema es cuando estoy en la opción indicada aquí.

Lo único que me falla, si voy a la opción C-1, le doy salir, al llegar a la opción principal que pone:

Opción A.  
  Opción B.
> Opción C.

Se me pone la flecha marcadore de opciónes siempre en Opción A, no se me guarda en la última opción seleccionada. Debo corregir esto, ya sería con una variable para memorizarlo.

Dejo el código hehco hasta el momento.

Código C#:

Código (csharp) [Seleccionar] Expandir

using System;

namespace Menu_consola_18_cs
{
   class Program
   {
       static void Main(string[] args)
       {
           Console.Title = "Menú de opciones";

           // Tamaño ventana consola.
           // X anchura.
           Console.WindowWidth = 20;

           // Y altura.
           Console.WindowHeight = 5;

           // Oculto el cursor.
           Console.CursorVisible = false;

           // Fondo verde.
           Console.BackgroundColor = ConsoleColor.Green;

           // Letras negras.
           Console.ForegroundColor = ConsoleColor.Black;

           MenuPrincipal();
       }

       #region Menú principal.
       public static void MenuPrincipal()
       {
           // Almacena la tecla pulsada en la variable.
           ConsoleKey teclaInicial;

           // Limpiar pantalla.
           Console.Clear();

           // Posición del cursor del título del MENÚ PRINCIPAL.
           Console.SetCursorPosition(0, 0);

           // Título.
           Console.Write("   MENÚ PRINCIPAL   ");

           // Pocisión de la hora.
           Console.SetCursorPosition(4, 2);

           // Formato numérico dd/MM/yyyy.
           Console.Write(DateTime.Now.ToString("ddd dd MMM"));

           // Almacena en la variable una tecla pulsada.
           teclaInicial = Console.ReadKey(true).Key;

           // ¿Haz pulsado la tecla Enter?
           if (teclaInicial == ConsoleKey.Enter)
           {
               // Sí. Se ejecuta esta función.
               MenuOpciones();
           }
       }
       #endregion

       #region Menú de opciones principales.
       public static void MenuOpciones()
       {
           // Contador de teclas y navegador.
           int opcion = 0;

           // Capturar tecla para luego validar.
           ConsoleKey tecla;

           while (true)
           {
               //******************************************************************
               // Dibujo el menú principal.

               // Limpiar pantalla.
               Console.Clear();

               switch (opcion)
               {
                   case 0:
                       Console.SetCursorPosition(0, 0);
                       Console.Write("> Opción A.         ");
                       Console.SetCursorPosition(0, 1);
                       Console.Write("  Opción B.         ");
                       Console.SetCursorPosition(0, 2);
                       Console.Write("  Opción C.         ");
                       Console.SetCursorPosition(0, 3);
                       Console.Write("  Salir.            ");
                       break;
                   case 1:
                       Console.SetCursorPosition(0, 0);
                       Console.Write("  Opción A.         ");
                       Console.SetCursorPosition(0, 1);
                       Console.Write("> Opción B.         ");
                       Console.SetCursorPosition(0, 2);
                       Console.Write("  Opción C.         ");
                       Console.SetCursorPosition(0, 3);
                       Console.Write("  Salir.            ");
                       break;
                   case 2:
                       Console.SetCursorPosition(0, 0);
                       Console.Write("  Opción A.         ");
                       Console.SetCursorPosition(0, 1);
                       Console.Write("  Opción B.         ");
                       Console.SetCursorPosition(0, 2);
                       Console.Write("> Opción C.         ");
                       Console.SetCursorPosition(0, 3);
                       Console.Write("  Salir.            ");
                       break;
                   case 3:
                       Console.SetCursorPosition(0, 0);
                       Console.Write("  Opción A.         ");
                       Console.SetCursorPosition(0, 1);
                       Console.Write("  Opción B.         ");
                       Console.SetCursorPosition(0, 2);
                       Console.Write("  Opción C.         ");
                       Console.SetCursorPosition(0, 3);
                       Console.Write("> Salir.            ");
                       break;
                   default:
                       Console.Write("Fuera de rango.     ");
                       break;
               }

               // Fin de pintar el menú principal.
               //******************************************************************

               // Leer tecla ingresada por el usuario.
               tecla = Console.ReadKey(true).Key;

               // Validar el tipo de tecla.
               if (tecla == ConsoleKey.Enter)
               {
                   switch (opcion)
                   {
                       case 0:
                           OpcionA();
                           break;
                       case 1:
                           OpcionB();
                           break;
                       case 2:
                           OpcionC();
                           break;
                       case 3:
                           MenuPrincipal();
                           break;
                       default:
                           break;
                   }
               }

               // Flecha abajo del teclado.
               if (tecla == ConsoleKey.DownArrow)
               {
                   opcion++;
               }

               // Flecha arriba del teclado.
               if (tecla == ConsoleKey.UpArrow)
               {
                   opcion--;
               }

               // Si está en la última opción del menú, salta a la primera.
               if (opcion > 3)
               {
                   opcion = 0;
               }

               // Si está en la primera posición del menú, salta a la última.
               if (opcion < 0)
               {
                   opcion = 3;
               }
           }
       }
       #endregion

       #region Opción A (0).
       public static void OpcionA()
       {
           ConsoleKey teclaOpcionA;
           Console.Clear();
           do
           {
               Console.SetCursorPosition(0, 0);
               Console.WriteLine("Estás en Opción A.");
               Console.SetCursorPosition(0, 2);
               Console.WriteLine("Pulse Enter para");
               Console.SetCursorPosition(0, 3);
               Console.WriteLine("Salir.");

               // Almacena el teclado pulsado en la variable teclaSubMenuA.
               teclaOpcionA = Console.ReadKey(true).Key;

           } while (teclaOpcionA != ConsoleKey.Enter);
       }
       #endregion

       #region Opción B (1).
       public static void OpcionB()
       {
           // Contador de teclas y navegador.
           int opcionB = 0;

           // Capturar tecla para luego validar.
           ConsoleKey teclaOpcionB;

           while (true)
           {
               switch (opcionB)
               {
                   case 0:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción B.  ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("> SubOpción B-1.    ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  SubOpción B-2     ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Salir.            ");
                       break;
                   case 1:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción B.  ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  SubOpción B-1.    ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("> SubOpción B-2     ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Salir.            ");
                       break;
                   case 2:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción B.  ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  SubOpción B-1.    ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  SubOpción B-2     ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("> Salir.            ");
                       break;
                   default:
                       Console.Write("Fuera de rango.     ");
                       break;
               }

               // Leer tecla ingresada por el usuario.
               teclaOpcionB = Console.ReadKey(true).Key;

               // Validar el tipo de tecla.
               if (teclaOpcionB == ConsoleKey.Enter)
               {
                   switch (opcionB)
                   {
                       case 0:
                           OpcionB1();
                           break;
                       case 1:
                           OpcionB2();
                           break;
                       case 2:
                           MenuOpciones();
                           break;
                       default:
                           Console.Write("Fuera de rango.     ");
                           break;
                   }
               }

               if (teclaOpcionB == ConsoleKey.DownArrow)
               {
                   opcionB++;
               }

               if (teclaOpcionB == ConsoleKey.UpArrow)
               {
                   opcionB--;
               }

               // Si está en la última opción, salta a la primera.
               if (opcionB > 2)
               {
                   opcionB = 0;
               }

               // Si está en la primera posición, salta a la última.
               if (opcionB < 0)
               {
                   opcionB = 2;
               }
           }
       }

       #endregion

       #region Opcion B-1.
       public static void OpcionB1()
       {
           ConsoleKey teclaOpcionB1;
           Console.Clear();
           do
           {
               Console.SetCursorPosition(0, 0);
               Console.WriteLine("Estás en Opción B-1.");
               Console.SetCursorPosition(0, 2);
               Console.WriteLine("Pulse Enter para    ");
               Console.SetCursorPosition(0, 3);
               Console.WriteLine("volver atrás.       ");

               // Almacena el teclado pulsado en la variable teclaSubMenuA.
               teclaOpcionB1 = Console.ReadKey(true).Key;

           } while (teclaOpcionB1 != ConsoleKey.Enter);
       }
       #endregion

       #region Opcion B-2.
       public static void OpcionB2()
       {
           ConsoleKey teclaOpcionB2;
           Console.Clear();
           do
           {
               Console.SetCursorPosition(0, 0);
               Console.WriteLine("Estás en Opción B-2.");
               Console.SetCursorPosition(0, 2);
               Console.WriteLine("Pulse Enter para    ");
               Console.SetCursorPosition(0, 3);
               Console.WriteLine("volver atrás.       ");

               // Almacena el teclado pulsado en la variable teclaSubMenuA.
               teclaOpcionB2 = Console.ReadKey(true).Key;

           } while (teclaOpcionB2 != ConsoleKey.Enter);
       }
       #endregion

       #region Opción C (2).
       public static void OpcionC()
       {
           // Contador de teclas y navegador.
           int opcionC = 0;

           // Capturar tecla para luego validar.
           ConsoleKey teclaOpcionC;
           Console.Clear();
           
           while(true)
           {
               switch (opcionC)
               {
                   case 0:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción C.  ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("> Color 1.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  Color 2.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Opción C-1.       ");
                       break;
                   case 1:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción C.  ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  Color 1.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("> Color 2.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Opción C-1.       ");
                       break;
                   case 2:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción C.  ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  Color 1.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  Color 2.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("> Opción C-1.       ");
                       break;
                   case 3:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("> Color 3.          ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  Color 4.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  Color 5.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Salir.            ");
                       break;
                   case 4:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("  Color 3.          ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("> Color 4.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  Color 5.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Salir.            ");
                       break;
                   case 5:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("  Color 3.          ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  Color 4.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("> Color 5.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("  Salir.            ");
                       break;
                   case 6:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("  Color 3.          ");
                       Console.SetCursorPosition(0, 1);
                       Console.WriteLine("  Color 4.          ");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  Color 5.          ");
                       Console.SetCursorPosition(0, 3);
                       Console.WriteLine("> Salir.            ");
                       break;

                   default:
                       Console.Write("Fuera de rango.     ");
                       break;
               }

               // Leer tecla ingresada por el usuario.
               teclaOpcionC = Console.ReadKey(true).Key;

               // Validar el tipo de tecla.
               if (teclaOpcionC == ConsoleKey.Enter)
               {
                   switch (opcionC)
                   {
                       case 0:
                           // Fondo azul.
                           Console.BackgroundColor = ConsoleColor.Blue;

                           // Letras blancas.
                           Console.ForegroundColor = ConsoleColor.White;
                           break;
                       case 1:
                           // Fondo verde.
                           Console.BackgroundColor = ConsoleColor.Green;

                           // Letras negras.
                           Console.ForegroundColor = ConsoleColor.Black;
                           break;
                       case 2:
                           OpcionC1();
                           break;
                       case 3:
                           // Fondo negro.
                           Console.BackgroundColor = ConsoleColor.Black;

                           // Letras rojo.
                           Console.ForegroundColor = ConsoleColor.Red;
                           break;
                       case 4:
                           // Fondo negro.
                           Console.BackgroundColor = ConsoleColor.Black;

                           // Letras rojo.
                           Console.ForegroundColor = ConsoleColor.Yellow;
                           break;
                       case 5:
                           // Fondo negro.
                           Console.BackgroundColor = ConsoleColor.Red;

                           // Letras rojo.
                           Console.ForegroundColor = ConsoleColor.DarkRed;
                           break;
                       case 6:
                           MenuOpciones();
                           break;
                       default:
                           Console.Write("Fuera de rango.     ");
                           break;
                   }
               }

               if (teclaOpcionC == ConsoleKey.DownArrow)
               {
                   opcionC++;
               }

               if (teclaOpcionC == ConsoleKey.UpArrow)
               {
                   opcionC--;
               }

               // Si está en la última opción, salta a la primera.
               if (opcionC > 6)
               {
                   opcionC = 0;
               }

               // Si está en la primera posición, salta a la última.
               if (opcionC < 0)
               {
                   opcionC = 6;
               }
           }
       }
       #endregion

       #region OpcionC-1.
       public static void OpcionC1()
       {
           // Contador de teclas y navegador.
           int opcionC1 = 0;

           // Capturar tecla para luego validar.
           ConsoleKey teclaOpcionC1;
           Console.Clear();
           
           while(true)
           {
               Console.Clear();

               switch (opcionC1)
               {
                   case 0:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción C-1.");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("  SI");
                       Console.SetCursorPosition(16, 2);
                       Console.WriteLine("> NO");
                       break;
                   case 1:
                       Console.SetCursorPosition(0, 0);
                       Console.WriteLine("Estás en Opción C-1.");
                       Console.SetCursorPosition(0, 2);
                       Console.WriteLine("> SI");
                       Console.SetCursorPosition(16, 2);
                       Console.WriteLine("  NO");
                       break;
                   default:
                       Console.Write("Fuera de rango.     ");
                       break;
               }

               // Leer tecla ingresada por el usuario.
               teclaOpcionC1 = Console.ReadKey(true).Key;

               // Validar el tipo de tecla.
               if (teclaOpcionC1 == ConsoleKey.Enter)
               {
                   switch (opcionC1)
                   {
                       case 0:
                           MenuPrincipal();
                           Console.Clear();
                           break;
                       case 1:
                           OpcionSI();
                           break;
                       default:
                           Console.Write("Fuera de rango.     ");
                           break;
                   }
               }

               // Flecha derecha.
               if (teclaOpcionC1 == ConsoleKey.RightArrow)
               {
                   opcionC1++;
               }

               // Flecha izquierda.
               if (teclaOpcionC1 == ConsoleKey.LeftArrow)
               {
                   opcionC1--;
               }

               // Si está en la última opción, salta a la primera.
               if (opcionC1 > 1)
               {
                   opcionC1 = 0;
               }

               // Si está en la primera posición, salta a la última.
               if (opcionC1 < 0)
               {
                   opcionC1 = 1;
               }
           }
       }
       #endregion

       #region opcionSI del sub menú C-1.
       public static void OpcionSI()
       {
           ConsoleKey teclaOpcionB1;
           Console.Clear();
           do
           {
               Console.SetCursorPosition(0, 0);
               Console.WriteLine("Estás en Opción SÍ.");
               Console.SetCursorPosition(0, 2);
               Console.WriteLine("Pulse Enter para    ");
               Console.SetCursorPosition(0, 3);
               Console.WriteLine("volver atrás.       ");

               // Almacena el teclado pulsado en la variable teclaOpciónB1.
               teclaOpcionB1 = Console.ReadKey(true).Key;

           } while (teclaOpcionB1 != ConsoleKey.Enter);
       }
       #endregion
   }
}

Se que se podrá hacer mucho mejor y sin fallos como estos. No se quedará así, sino que mi idea principal, es coger el truco que se pueda crear menús y submenús que se pueda hacer de forma muy sencilla.

Dejo clarqo eu solo hacerlo que funcione con botones flecha arriba, abajo, derecha, izquierda y Enter (Escape solo para salir si estás en la ventana principal).

Saludos.

[Código Arduino]

Hola:

Ver imagen.

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

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

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

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

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

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

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

Código Arduino:

Código [Seleccionar] Expandir

#include <LiquidCrystal.h>

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

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

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

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

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

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

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


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

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

Luz_OFF // Apaga el Led de Arduino.

Luz_ON // Enciende el Led de Arduino.

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

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

Código C#:

Código (csharp) [Seleccionar] Expandir

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

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;

namespace Recibir_email_enviar_arduino_01
{
   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.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"))
                   {
                       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("COM4")
           {
               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();
                       break;

                   case "Luz_OFF":
                       ApagarLuz();
                       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
           {
               Timer miTimer = new 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 = "celltium@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;
           }
       }
   }
}

Como no cabe en la web, lo pongo como descarga.

Los que los prueben, espero cualquier impresión.

Saludos.

Hola:

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

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

Código (csharp) [Seleccionar] Expandir

                Timer miTimer = new Timer
                {
                    Enabled = true
                };
                miTimer.Elapsed += new ElapsedEventHandler(DisparadorEventosTimer);
                miTimer.Interval = 60000; // 1 minuto.
                miTimer.Start(); // Activa el temporizador.

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

Código (csharp) [Seleccionar] Expandir

        public static void DisparadorEventosTimer(object source, ElapsedEventArgs e)
        {
            Console.Out.WriteLine("Evento: ");
        }


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

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using OpenPop.Pop3;
using OpenPop.Mime;
using System.Text.RegularExpressions;

namespace Recibir_email_Consola_03_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Recibir e-mail con Consola C#";

            // 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\t----------------------------------------");
            Console.WriteLine("\t\t\tRecibir Correo Electrónico");
            Console.WriteLine("\t\t----------------------------------------");
            Console.WriteLine();

            try
            {
                ConnectPop3 oC = new ConnectPop3();

                List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();


                if (lstMessages != null)
                {

                    foreach (var oMessage in lstMessages)
                    {
                        Console.ForegroundColor = ConsoleColor.White;
                        Console.WriteLine("EMAIL DE: ");
                        Console.ForegroundColor = ConsoleColor.Gray;

                        //string email = oMessage.Headers.ReturnPath.ToString();
                        string email = oMessage.Headers.From.ToString();

                        // Expresión regular detectar dirección email.
                        Regex rx = new Regex(@"<(.*?)>");
                        //Regex rx = new Regex(@"");
                        // Guarda la dirección email en la variable "emailCompleto".
                        string emailCompleto = rx.Match(email).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"))
                        {
                            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.
                            Console.ForegroundColor = ConsoleColor.White;
                            Console.WriteLine();
                            Console.WriteLine("MENSAJE: ");
                            Console.ForegroundColor = ConsoleColor.Gray;

                            // ¿Es texto sin formato? Sí.
                            // if (oMessage.MessagePart.IsText == true)
                            if (oMessage.MessagePart.IsText)
                            {
                                Console.WriteLine("Texto sin formato.");
                                Console.WriteLine(oMessage.MessagePart.GetBodyAsText());
                            }
                            // 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.
            }

            // Cualquier error mostrado en mensaje y de color rojo.
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine();
                Console.WriteLine(ex);
                Console.ReadKey();
            }
        }
    }

    public class ConnectPop3
    {
        public string email = "celltium@gmail.com";
        public string contraseña = "g0923490xgh0945g450Xj4025g"; // Ficcicio.
        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;
            }
        }
    }
}


¿Alguna idea?

Buenas:

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

¿Cuál es el motivo de la causa?

Su código es este.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Net.Mail;
using System.Text;
using System.Net;

namespace Enviar_e_mail_Consola_04_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            string usuario, contraseña, destinatario, asunto, mensaje;

            // Título de la ventana.
            Console.Title = "Enviar e-mail con Consola C#";

            // Tamaño ventana consola.
            Console.WindowWidth = 80; // X. Ancho.
            Console.WindowHeight = 40; // Y. Alto.

            // Tamaño del cursor. Del 1 al 100.
            Console.CursorSize = 50;

            // 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.Write("\t\tIngresar tu correo electrónico: ");
                usuario = Console.ReadLine();
                Console.Write("\t\tIntroducir contraseña: ");
                contraseña = LeerPassword();
                Console.Write("\t\tDestinatario: ");
                destinatario = Console.ReadLine();
                Console.Write("\t\tAsunto: ");
                asunto = Console.ReadLine();
                Console.Write("\t\tMensaje: ");
                mensaje = Console.ReadLine();

                MailMessage correo = new MailMessage(usuario, destinatario, asunto, mensaje);

                SmtpClient servidor = new SmtpClient("smtp.gmail.com")
                {
                    Port = 587
                };
                NetworkCredential credenciales = new NetworkCredential(usuario, contraseña);
                servidor.Credentials = credenciales;
                servidor.EnableSsl = true;

                Console.WriteLine("\t\tEnviando correo...");
                servidor.Send(correo);
                Console.WriteLine("\t\tCorreo enviado satisfactoriamente.");
                correo.Dispose();
                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.WriteLine("\t\t" + ex.Message);
                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 < 4)
                    {
                        Console.Write("*");
                    }
                    contador++;
                }

                else
                {
                    break;
                }

            } while (true);
            Console.WriteLine();
            return sb.ToString();
        }
    }
}

Salu2. camaradas.

[Código C#:]

Hola:

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


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

Código C#:

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using OpenPop.Pop3;

namespace Recibir_email_Consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Recibir e-mail con Consola C#";

            // Tamaño ventana consola.
            Console.WindowWidth = 100; // X. Ancho.
            Console.WindowHeight = 40; // Y. Alto.

            Console.WriteLine("\t\t----------------------------------------");
            Console.WriteLine("\t\t\tRecibir Correo Electrónico");
            Console.WriteLine("\t\t----------------------------------------");

            try
            {
                ConnectPop3 oC = new ConnectPop3();

                List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();


                if (lstMessages != null)
                {

                    foreach (var oMessage in lstMessages)
                    {
                        Console.WriteLine(oMessage.Headers.Subject); // Asunto.
                        Console.WriteLine(oMessage.Headers.From); // Email del que te envió el mensaje.
                        Console.WriteLine(oMessage.Headers.ContentTransferEncoding); //out: SevenBit.
                        Console.WriteLine(oMessage.Headers.ContentType);
                        Console.WriteLine(oMessage.Headers.Date); // Fecha larga.
                        Console.WriteLine(oMessage.Headers.DateSent); // Fecha corta.
                        Console.WriteLine(oMessage.Headers.Importance); // Out: Normal.
                        Console.WriteLine(oMessage.Headers.MimeVersion); // Versión.
                        Console.WriteLine(oMessage.Headers.MessageId);
                    }
                }
                Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
                Console.WriteLine("FIN DEL PROGRAMA.");
                Console.ReadKey(); // Pulse cualquier tecla para salir.
            }

            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
    }

    public class ConnectPop3
    {
        public string email = "celltium@gmail.com";
        public string contraseña = "g0923490xgh0945g450Xj4025g";
        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> lstMesages = new List<OpenPop.Mime.Message>(messageCount);

                for (int i = messageCount; i > 0; i--)
                {
                    lstMesages.Add(oClient.GetMessage(i));
                }

                return lstMesages;
            }
        }
    }
}


Pensé que leer el mensaje es ete código pero veo que no.

Código (csharp) [Seleccionar] Expandir

Console.WriteLine(oMessage.Headers.MessageId);

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

¿Cómo puedo ver el mensaje del email?

Saludos.

[En resumen:]

Hola:

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

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

https://github.com/Gmatarrubia/LibreriasTutoriales

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

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

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

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

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

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



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

En resumen:

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

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

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

¿Alguna idea?

Saludos.

Hola:

Quiero hacer los dibujos exactamente lo mismo como en este ordenador ochentero de esta película exactamente indicado en el minuto 6:56 de este vídeo.

Lo que he hecho hasta ahora son solo textos, en el cual no se el motivo, no me sale el rellenado de la parte derecha de la pantalla con el │ ASCII 179.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Threading;

namespace The_Thing_La_Cosa_Consola_01_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "The Thing - La Cosa - C#";
            Console.WindowWidth = 38;   // X ancho.
            Console.WindowHeight = 15;  // Y altura.

            int tiempo = 1;

            // Cursor invisible.
            Console.CursorVisible = false;

            // Dibujar cuadro.
            DrawMarco(1, 1, 35, 14);

            // Escribir textos.
            Console.SetCursorPosition(2, 4);
            Escribir("PROJECTION: \n", 25);
            Console.SetCursorPosition(2, 5);
            Escribir("IF INTRUDER ORGANISM REACHES \n", 25);
            Console.SetCursorPosition(2, 6);
            Escribir("CIVILIZED AREAS . . . \n", 25);
            Thread.Sleep(100);
            Console.SetCursorPosition(2, 10);
            Escribir("ENTIRE WORLD POPULATION INFECTED \n", 25);
            Console.SetCursorPosition(2, 11);
            Escribir("27,000 HOURS FROM FIRST CONTACT. \n", 25);

            // En español.
            Thread.Sleep(2000);

            // Limpiar pantalla.
            Console.Clear();

            // Dibujar cuadro.
            DrawMarco(1, 1, 35, 14);

            // Escribir textos.
            Console.SetCursorPosition(2, 3);
            Escribir("PROYECCIÓN: \n", 25);
            Console.SetCursorPosition(2, 4);
            Escribir("SI ORGANISMO INTRUSO ALCANZA \n", 25);
            Console.SetCursorPosition(2, 5);
            Escribir("ZONAS CIVILIZADAS . . . \n", 25);
            Thread.Sleep(100);
            Console.SetCursorPosition(2, 9);
            Escribir("TODA LA POBLACIÓN MUNDIAL INFECTÓ\n", 25);
            Console.SetCursorPosition(2, 10);
            Escribir("27,000 HORAS DESDE EL PRIMER\n", 25);
            Console.SetCursorPosition(2, 11);
            Escribir("CONTACTO. \n", 25);

            Console.ReadKey();
        }

        public static void Escribir(string Cadena, int tiempo)
        {
            foreach (char letra in Cadena)
            {
                Console.Write(letra);
                Thread.Sleep(tiempo);
            }
        }

        private static void DrawMarco(int v1, int v2, int v3, int v4)
        {
            Console.ForegroundColor = ConsoleColor.Cyan; // Texto azul claro.
            Console.BackgroundColor = ConsoleColor.DarkBlue; // Fondo azul oscuro.
            Console.Clear(); // Para poner fondo azul oscuro en la pantalla completa.

            Console.CursorVisible = false;
            gotoXY(v1, v2, "┌");

            for (int i = v1 + 1; i < v3; i++)
            {
                gotoXY(i, v2, "─");
            }
            gotoXY(v3, v2, "┐");
            for (int i = v2 + 1; i < v4; i++)
            {
                gotoXY(v3, i, "│");
            }
            gotoXY(v3, v4, "┘");
            for (int i = v3 - 1; i > v1; i--)
            {
                gotoXY(i, v4, "─");
            }
            gotoXY(v1, v4, "└");
            for (int i = v4 - 1; i > v2; i--)
            {
                gotoXY(v1, i, "│");
            }
            //Console.CursorVisible = true;
        }

        private static void gotoXY(int v1, int v2, string cadena)
        {
            Console.SetCursorPosition(v1, v2);
            Console.WriteLine(cadena);
            Thread.Sleep(1);
        }
    }
}


¿Alguna idea de como hacerlo?

Por lo que parece, a pesar de que es del 1982, hoy en día exige mucho tiempo y complicado.

Saludos.

Hola:

Independientemente de la cantidad de █ haya para crear una barra de progreso, no llega al 100 %.


Este es su código que he hecho hasta ahora.

Código [Seleccionar] Expandir

using System;
using System.Threading;

namespace Porcentaje_barra_consola_01_cs
{
   class Program
   {
       public static int resultado = 0;

       static void Main(string[] args)
       {
           // Título de la ventana.
           Console.Title = "Simulaor barra";

           // Tamaño ventana consola.
           Console.WindowWidth = 60; // X ancho.
           Console.WindowHeight = 20; // Y altura.

           // Cursor invisible.
           Console.CursorVisible = false;

           // Variables.
           int barra = 49;
           int porcentaje = 0;

           Console.SetCursorPosition(17, 1);
           Console.Write("    ");
           Console.SetCursorPosition(17, 1);
           Console.Write("");

           // Dibujamos la barra del portentaje.
           Console.SetCursorPosition(0, 3);
           Console.Write("0 %                         50 %                       100 %");
           Console.SetCursorPosition(0, 4);
           Console.Write("┌────────────────────────────┬───────────────────────────┐");
           Console.SetCursorPosition(0, 5);
           Console.ForegroundColor = ConsoleColor.Yellow;

           // Barra de progreso.
           for (int i = 0; i <= barra; i++)
           {
               Console.Write("█"); // Muestra ASCII 219 Dec y DB en Hex.
                                   // Console.Write((char)219);
                                   // Console.Write(Encoding.ASCII.GetBytes((char)219));
               porcentaje++; // Incrementa valor.

               printCargando(porcentaje);

               Thread.Sleep(100); // 100 ms o 0.1 segundos.
           }

           Console.ReadKey();
       }

       static void printCargando(int porcentaje)
       {
           Console.ForegroundColor = ConsoleColor.Gray;
           Console.SetCursorPosition(0, 1);
           // Por dos para que simule el 100%.
           Console.Write("Cargado: " + (porcentaje).ToString() + " %");
           //Console.Write("Cargado: {0} %", (porcentaje * 2).ToString());
           //Console.Write($"Cargado: { (porcentaje * 2).ToString() } %");

           // Reestablecemos para que vuelva a imprimir bajo la línea de carga.
           Console.ForegroundColor = ConsoleColor.Yellow;
           Console.SetCursorPosition(porcentaje, 5);
       }

   }
}

Gracias.

Hola:

Código que creo que se puede hacer es algo así.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Musica_consola_01_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            #region Música.
            /* Posición Inicial: 00000000, Posición Final: 00001891, Longitud: 00001892 */

// Pongo pocos bytes para no agrandar el tema en el foro.

            byte[] rawData = {
    0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x08
};

#endregion

            var c1 = new System.Windows.Media.MediaPlayer();
            c1.Open(new System.Uri(rawData));
            c1.Play();
        }
    }
}


Me da este error.

Gravedad    Código    Descripción    Proyecto    Archivo    Línea    Estado suprimido
Error    CS0234    El tipo o el nombre del espacio de nombres 'Media' no existe en el espacio de nombres 'System.Windows' (¿falta alguna referencia de ensamblado?)    Musica_consola_01_cs    C:\Users\Usuario\Documents\Visual Studio 2017\Projects\Musica_consola_01_cs\Musica_consola_01_cs\Program.cs    545    Activo

No encuentro en referencia el Media.

¿Alguna idea?

Saludos.

Hola:

Teniendo un menú hecho por defecto en español en este caso. (Cuando todo esté acabado tiene que estar en Inglés por defecto).

Quiero crear menús que sea capaz de elegir el idioma, en al cual hoy en día no hay problema porque está este traductor para escapar.

Mi idea para tener un orden de cada idioma a introducir, por ejemplo, español, inglés, alemán, francés, italiano y portugués.

En este ejemplo hay 6 lenguas. No se si la mejor opción es crear una carpeta de idiomas y ahí meto cada lengua en el cual es llamado.



Código de ejemplo para.

Código (csharp) [Seleccionar] Expandir

using System;

namespace Idiomas_consola_01_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Menú - C# 2017";

            // Tamaño ventana consola.
            // X anchura.
            Console.WindowWidth = 80;

            // Y altura.
            Console.WindowHeight = 40;

            // Oculto el cursor.
            Console.CursorVisible = false;

            // Almacena la tecla pulsada en la variable.
            ConsoleKey teclaInicial;

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Green;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.Black;

            do
            {
                // Limpiar pantalla.
                Console.Clear();

                // Formato numérico dd/MM/yyyy.
                Console.WriteLine(DateTime.Now.ToString("ddd dd MMM"));

                // Almacena en la variable una tecla pulsada.
                teclaInicial = Console.ReadKey(true).Key;

                // ¿Haz pulsado la tecla Enter?
                if (teclaInicial == ConsoleKey.Enter)
                {
                    // Sí. Se ejecuta esta función.
                    menuPrincipal();
                }
            } while (teclaInicial != ConsoleKey.Escape);
        }

        #region Menú Principal.
        public static void menuPrincipal()
        {

            // Contador de teclas y navegador.
            int opcion = 0;
            bool salir = false;
            // Capturar tecla para luego validar.
            ConsoleKey tecla;

            do
            {
                // Limpiar pantalla.
                Console.Clear();

                switch (opcion)
                {
                    case 0:
                        Console.SetCursorPosition(0, 0);
                        Console.Write("Language");
                        break;
                    case 1:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Opción 1.");
                        break;
                    case 2:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Opción 2.");
                        break;
                    case 3:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Opción 3.");
                        break;
                    case 4:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Opción 4.");
                        break;
                    case 5:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Opción 5.");
                        break;
                    case 6:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Opción 6.");
                        break;
                    case 7:
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine("Salir menú");
                        break;
                    default:
                        break;
                }

                // Fin de pintar el menú.
                //******************************************************************

                // Leer tecla ingresada por el usuario.
                tecla = Console.ReadKey(true).Key;

                // Validar el tipo de tecla.
                if (tecla == ConsoleKey.Enter)
                {
                    switch (opcion)
                    {
                        case 1:
                            // Instrucciones.
                            break;
                        case 2:
                            // Instrucciones.
                            break;
                        case 3:
                            // Instrucciones.
                            break;
                        case 4:
                            // Instrucciones.
                            break;
                        case 6:
                            // Instrucciones.
                            break;
                        case 7:
                            salir = true;
                            break;
                        default:
                            break;
                    }
                }

                if (tecla == ConsoleKey.DownArrow)
                {
                    opcion += 1; // Equivalente ++.
                }

                if (tecla == ConsoleKey.UpArrow)
                {
                    opcion -= 1; // --.
                }

                // Si está en la última opción, salta a la primera.
                if (opcion > 7)
                {
                    opcion = 0;
                }

                // Si está en la primera posición, salta a la última.
                if (opcion < 0)
                {
                    opcion = 7;
                }

                // Uso la tecla escape como salida.
            } while (salir == false);
        }
        #endregion
    }
}

En el menú Languaje, si pulsas Enter, tiene que verse en Inglés, todos los idiomas que vayamos incorporando. El usuario elige el idioma y se queda seleccionado.

¿Alguna idea?

Saludos.

Hola:

Quiero hacer un parpadeo de un texto en modo consola. Por ahora solo me sale con Sleep, pero no me gusta este. Aún así dejo un ejemplo de lo que quiero pero está hecho en Sleep.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Threading; // No olvidar.

namespace Parpadeo_texto_consola_01_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Blink";

            // Tamaño ventana consola.
            // X anchura.
            Console.WindowWidth = 16;

            // Y altura.
            Console.WindowHeight = 2;

            // Oculto el cursor.
            Console.CursorVisible = false;

            // Como estamos en un ejemplo, da igual en este caso
            // poner un bucle infinito. Quiero que se muestre el
            // resultado.
            while (true)
            {
                // Posición de la pantalla.
                Console.SetCursorPosition(0, 0);

                // Mostrar texto en pantalla.
                Console.Write("Hola mundo");

                // Retardo de 0.5 segundos. 1000 ml (mili segundos)
                // es igual a 1 segundo.
                Thread.Sleep(500);

                // Posición de la pantalla.
                Console.SetCursorPosition(0, 0);

                // Mostrar espaciones en blanco para borrar texto anterior.
                Console.Write("          ");

                // Retardo 0.3 seg.
                Thread.Sleep(300);
            }
        }
    }
}

Quiero hacer lo mismo, pero con el Timer en modo consola, lo que me cuesta hacerlo. Ya qu el timer pude interrumpir el programa cuando está dentro del temporizador pero con el Sleep, hasta que no acabe el tiempo, el programa se queda como en esclavo, sobre todo en tiempos muy largos.

¿Hay alguna forma de hacerlo en modo consola?

Si se puede hacer el parpadeo en una función y lo llamo cuando quiera, mejor que mejor.

Saludos.

Hola:

Estoy usando la consola de C#, me dio ahora por el retro.



Hice este menú de opciones, pero no hace nada. Por ahora solo selecciona las opciones.

Lo que no se es como entrar en otra opción dentro de ella en DOS al pulsar Enter.

Estoy en el submenú que sale un menaje que diga. Estoy dentro de la opción DOS. Con capacidad de pulsar Escape y vuelva al menú principal.

Lo que he hecho hasta ahora es solo esto.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Menu_consola_02_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Menú de opciones";

            // Tamaño ventana consola.
            Console.WindowWidth = 20; // X anchura.
            Console.WindowHeight = 8; // Y altura.

            // Cursor invisible.
            Console.CursorVisible = false;

            //Contador de teclas y navegador
            int contador = 0;
            //tomar la tecla para validar luego
            ConsoleKey tecla;
            //escondo el cursor
            Console.CursorVisible = false;
            do
            {
                //******************************************************************
                //Pinto el menú
                Console.Clear();
                Console.Write("╔══════════════════╗\n");
                if (contador == 0)
                {
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write("║   UNO            ║\n");
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                }
                else
                {
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("║   UNO            ║\n");
                }
                if (contador == 1)
                {
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write("║   DOS            ║\n");
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                }
                else
                {
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("║   DOS            ║\n");
                }
                if (contador == 2)
                {
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write("║   TRES           ║\n");
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                }
                else
                {
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("║   TRES           ║\n");
                }
                if (contador == 3)
                {
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write("║   CUATRO         ║\n");
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                }
                else
                {
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("║   CUATRO         ║\n");
                }
                if (contador == 4)
                {
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write("║   ESC = SALIR    ║\n");
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                }
                else
                {
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("║   ESC = SALIR    ║\n");
                }
                Console.Write("╚══════════════════╝\n");
                //Fin de pintar el menú
                //******************************************************************

                //leer tecla ingresada por el usuario
                tecla = Console.ReadKey(true).Key;

                //validar el tipo de tecla
                if (tecla == ConsoleKey.DownArrow)
                {
                    contador += 1;
                }
                if (tecla == ConsoleKey.UpArrow)
                {
                    contador -= 1;
                }
                //valido que el conteo de teclas no supere el rango establecido por los Ifs de más arriba
                if (contador > 4)
                {
                    contador = 4;
                }
                if (contador < 0)
                {
                    contador = 0;
                }
                //uso la tecla escape como salida
            } while (tecla != ConsoleKey.Escape);
        }
    }
}


No logro cuajarlo como si se ha hecho por aquí en este otro ejemplo de abajo.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Menu_y_opciones_consola_02_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Menú y opciones C# 2017";

            // Tamaño ventana consola.
            Console.WindowWidth = 30; // X. Ancho.
            Console.WindowHeight = 17; // Y. Alto.

            // Cursor invisible.
            Console.CursorVisible = false;

            // Cuadro doble borde ventana.
            Menu_y_opciones_consola_02_cs.Cuadro.cuadrado();

            // Posición del mansaje en la ventana.
            Console.SetCursorPosition(2, 2);
            Console.WriteLine("Elija una opción:");
            Console.WriteLine("");
            Console.SetCursorPosition(2, 4);
            Console.WriteLine("1 - Opción A.");
            Console.SetCursorPosition(2, 5);
            Console.WriteLine("2 - Opción B.");
            Console.SetCursorPosition(2, 6);
            Console.WriteLine("3 - Opción C.");
            Console.SetCursorPosition(2, 7);
            Console.WriteLine("Escape - Salir.");
            Console.SetCursorPosition(2, 8);
            Console.Write("===============");

            ConsoleKey key;

            do
            {
                // Cursor invisible
                Console.CursorVisible = false;

                // Lee cualquier tecla.
                key = Console.ReadKey(true).Key;

                // Variable de mensaje vacío.
                string mensaje = string.Empty;

                // Leer tecla selecconada por el usuario.
                switch (key)
                {
                    case ConsoleKey.D1: // Tecla principal 1.
                    case ConsoleKey.NumPad1: // Tecla extendida 1.
                        Console.SetCursorPosition(2, 10);
                        mensaje = "OPCIÓN A."; // Mostrar mensaje en pantalla.
                        break;

                    case ConsoleKey.D2:
                    case ConsoleKey.NumPad2:
                        mensaje = "OPCIÓN B.";
                        break;
                    case ConsoleKey.D3:
                    case ConsoleKey.NumPad3:
                        mensaje = "OPCIÓN C.";
                        break;
                }

                // Posición de los mensajes.
                Console.SetCursorPosition(2, 10);
                Console.Write("             "); // 13 espacios.
                Console.SetCursorPosition(2, 10);
                Console.Write(mensaje);

            }

            // Salir de la plicación al pulsar la tecla Escape o número 4.
            while (key != ConsoleKey.Escape);


        }
    }
}


Saludos.

[Sí]

Hola gente del foro:

Que pasen buen comienzo del 2.019.

Quiero hacer con Windows Form cambiar de opción de una Web de gmail. En este caso pongo el enlace.

https://myaccount.google.com/lesssecureapps

Desde la Web puedo poner Sí o No.

¿Existe esta posibilidad controlar esa opción desde C#?

Por supuesto que tendrás que poner en C# los datos la cuenta gmail, eso seguro.

Saludos.

Hola:

Estaba curioseando si hay alguna manera de enviar mensajes de texto y recibirlo con el PC y la PlayStation 4 usando C#.

Buscando que te busca en el San Google, no veo que lo hayan hecho, me da que no se puede. Si hay alguien que sabe del tema, lo puede confirmar por aquí.

Por aquí dicen que no se puede, pero vete a sabar a día de hoy.
https://www.laps4.com/foro/18_zona_psnetwork/320251-mandar_mensaje_pc.html

Ya dirán si existe esa posibilidad.

Saludos.

Hola:

Me da error al enviar mensaje por emmail desde C#.



El código por ahora es este.

Código [Seleccionar] Expandir

using System;
using System.Windows.Forms;
using System.Net;       // No olvidar.
using System.Net.Mail;  // No olvidar.

namespace Enviar_e_mail_01_cs
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button_Enviar_Click(object sender, EventArgs e)
        {
            //La cadena "servidor" es el servidor de correo que enviará tu mensaje
            string servidor = comboBox_smtp.SelectedItem.ToString(); // smtp.gmail.com

            // Crea el mensaje estableciendo quién lo manda y quién lo recibe
            MailMessage mensaje = new MailMessage(
               textBox_Emisor.Text,
               textBox_Receptor.Text,
               textBox_Asunto.Text,
               richTextBox_Mensaje.Text);

            //Envía el mensaje.
            SmtpClient cliente = new SmtpClient(servidor);
            cliente.DeliveryMethod = SmtpDeliveryMethod.Network;
            cliente.UseDefaultCredentials = false;
            cliente.Credentials = new System.Net.NetworkCredential(textBox_Emisor.Text, textBox_Contraseña.Text);
            cliente.Port = Int32.Parse(comboBox_Puerto.Text); ; // 587
            //cliente.Port = 25;
            cliente.Host = servidor; // smtp.gmail.com
            cliente.EnableSsl = true;

            //Añade credenciales si el servidor lo requiere.
            cliente.Credentials = CredentialCache.DefaultNetworkCredentials;
            cliente.Send(mensaje);
        }
    }
}

Error indicado aquí. Da igual sea con hotmail o gmail.



Me llegó un mensaje al gmail de seguridad por usar formulario C#.

Se ha bloqueado un intento de inicio de sesión
   metaconta@gmail.com

Alguien acaba de usar tu contraseña para intentar iniciar sesión en tu cuenta desde una aplicación que no es de Google. Aunque Google ha bloqueado el acceso, deberías averiguar qué ha pasado. Revisa la actividad de la cuenta y comprueba que solo tú tienes acceso a ella.

Pincho y eso sale.
Se ha bloqueado una aplicación poco segura
Hemos bloqueado la aplicación que intentabas usar porque no cumple nuestros estándares de seguridad.
Algunos dispositivos y aplicaciones utilizan una tecnología de inicio de sesión menos segura, lo que hace que tu cuenta sea más vulnerable. Te recomendamos que desactives el acceso de estas aplicaciones, aunque también puedes activarlo si quieres usarlas a pesar de los riesgos que conllevan.
Más información

Permitir el acceso a cuentas desde aplicaciones menos seguras

Si una aplicación o un dispositivo no cumple con nuestros estándares de seguridad, Google bloqueará a cualquier persona que intente iniciar sesión desde esa aplicación o dispositivo. El bloqueo contribuye a mantener la seguridad de tu cuenta, ya que es muy fácil acceder a estas aplicaciones y dispositivos sin autorización.

A continuación, se muestran algunos ejemplos de aplicaciones que no son compatibles con la última versión de los estándares de seguridad:

    La aplicación Mail para iPhone o iPad con la versión 6 o versiones anteriores
    La aplicación Mail en un teléfono con una versión de Windows Phone anterior a la 8.1
    Algunos clientes de correo electrónico para ordenadores, como Microsoft Outlook y Mozilla Thunderbird

Cambiar el acceso a la cuenta para aplicaciones menos seguras

Para mantener más protegidas tus cuentas de Google del trabajo, del centro educativo o de otro grupo, bloqueamos las aplicaciones menos seguras para que no puedan acceder a ellas. Si tienes una cuenta de este tipo, se te mostrará el error "Contraseña incorrecta" cuando intentes iniciar sesión. Si es así, tienes dos opciones:

    Opción 1: instala una aplicación más segura que utilice medidas de seguridad más sólidas. Todos los productos de Google, como Gmail, utilizan las medidas de seguridad más recientes.
    Opción 2: cambia la configuración para permitir que las aplicaciones poco seguras accedan a tu cuenta. Esta opción no es recomendable porque puede facilitar el acceso a tu cuenta a otra persona. Si, aún así, quieres utilizarla, sigue estos pasos:
        Ve a tu cuenta de Google.
        En el panel de navegación de la izquierda, haz clic en Seguridad.
        En el panel Acceso de aplicaciones poco seguras de la parte inferior de la página, haz clic en Activar acceso.
             Si no ves este ajuste, es posible que el administrador haya desactivado el acceso de las aplicaciones poco seguras a la cuenta.

Si sigues sin poder iniciar sesión en tu cuenta, obtén más información sobre el error "Contraseña incorrecta"

¿Alguna grandísima idea?

Hace años no pasaba estas cosas.

Saludos:)

Hola:

Tengo tres directorios en Windows 10 con fotos, ví las carpetas y no me dejaba entrar. En el CMD en modo Administrador puse este comando.

chkdsk /f :d

Me detecto en todo el disco duro que es una partición llamada D:, esas tres carpetas. Antes apareció este mensaje y puse SÍ, porque si pongo no, no hace nada.

C:\WINDOWS\system32>chkdsk /f d:
El tipo del sistema de archivos es NTFS.

Chkdsk no puede ejecutarse ya que el volumen está siendo usado por otro
proceso. Chkdsk puede ejecutarse si se desmonta previamente este volumen.
TODOS LOS IDENTIFICADORES ABIERTOS A ESTE VOLUMEN NO SERÁN VÁLIDOS.
¿Desea exigir el desmontaje de este volumen? (S/N)

Al pulsar S, me detecta las tres carpetas y comentó algo del índice, después de todo este proceso que tardó algunos minutos en completar, las carpetas ya no aparecen en ninguna parte, aunque vuelva ejeutar chkdsk una y otra vez.

¿Hay alguna solución o he perdido todo?

Saludos.

[Fórmula matemática:]

Hola:

Quiero hacer esto desce cero con Visual studio Community 2017. Creo una dll en Win32 C++. En él solo hay dos cosas, una fórmula matemática y un mensaje. Por ejemplo.

Fórmula matemática:

2 + 3

Mensaje:

Hola. Soy una DLL Win32.

Una vez creada una dll en C++ Win32 con lo indicado arriba, quiero ahora crear otro proyecto con Windows Form hecho bajo el lenguaje C#. En el formulario tiene incluido un label1 para mostrar el mensaje y otro label2 para mostrar el resultado de la suma.

Cualquier cosa que se entienda, lo repito de otra manera. Lo hice así tan sencillo para aprender de una vez y rápido como hacerlo.


Código C++:

Código (cpp) [Seleccionar] Expandir

// $nombredeproyecto$.cpp: define las funciones exportadas de la aplicación DLL.
//

#include "stdafx.h"

extern "C" {
__declspec(dllexport)  int WINAPI Suma(int, int);
__declspec(dllexport) LPTSTR WINAPI Mensaje();
}

BOOL APIENTRY DllMain(HMODULE hModule,
DWORD  ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}

int WINAPI Suma(int a, int b) { return a + b; }
LPTSTR WINAPI Mensaje() { return TEXT("Hola. Soy una DLL Win32."); }

En la última línea donde pone TEXT pone error indicado abajo.

Código (cpp,1) [Seleccionar] Expandir

LPTSTR WINAPI Mensaje() { return TEXT("Hola. Soy una DLL Win32."); }

Gravedad    Código    Descripción    Proyecto    Archivo    Línea    Estado suprimido
Error (activo)    E0120    el tipo de valor devuelto no coincide con el tipo de función    pepe    c:\Users\Usuario\Documents\Visual Studio 2017\Projects\pepe\pepe\pepe.cpp    28   

En el mismo proyecto de la dll creo la interfaz C#:

Código C#:

Código (csharp) [Seleccionar] Expandir

using System;
using System.Runtime.InteropServices; // No olvidar.
using System.Windows.Forms;

namespace Prueba_dll_cs_01
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            label1.Text = Marshal.PtrToStringAuto(PEPE.Mensaje());
            label2.Text = PEPE.Suma(1764, -764).ToString();
        }
    }

    internal class PEPE
    {
        [DllImport("pepe.dll", EntryPoint = "_Suma@8")]
        extern static public int Suma(int a, int b);
        [DllImport("pepe.dll", EntryPoint = "_Mensaje@0")]
        extern static public IntPtr Mensaje();
    }
}

Como dije antes, el problema está en el TEXT que dice el error:  el tipo de valor devuelto no coincide con el tipo de función.

¿Alguna idea?

Saludos.

Hola:

Quiero entrar en una cuenta de usuario de Windwos 7 usando Ubuntu desde arranque el DVD. No se si oopenSUSE nuevo lo permite también. Recuerdo que monté hasta un pendrive mio. Borré archivos en él y me creó como una papelera de reciclaje virtual, nunca borré esos archivos realmente, así que estará en el disco duro si borro algo de la cuenta de usuario. La carpeta que hizo de papelera de reciblaje en el pendrive en este caso se llama .Trash-999.

Pensé que si entro en modo arranque con Ubuntu, no se daría cuenta el usuario de Windows y si se dio, ya que hizo limpieza y borró hasta el Counter Strike 1.6 que tenía instalado él.

Se pone mucho a mirar el Visor de Eventos para saber si instalo o desinstalo algo, sobre todo el inicio de sesión con WinLogon. Entro en el directorio.

C:\Windows\System32\winevt\Logs

Encuentro todos los registros.


Cogí desde Ubunto este archivo para saber cuando entro o salgo de inicio de sesión de la cuenta de usuaruio.

Microsoft-Windows-Winlogon%4Operational.evtx

Por esta extensión.

Microsoft-Windows-Winlogon%4Operational.evtx.back.

Al iniciar Windows, se volvió normal el archivo y no he borrado nada.

¿Alguna manera de borrar ese archivo, al menos los contenido de los iniciios y cierres de la cuenta de Windows?

Saludos.

Hola:

Estoy en una clase, por la tarde etán dando un curso que no se quienes son instalándome el Counter Strike 1.6. Antes en mi cuenta tenía el administrador. Saben que borré programas porque vieron el visor de sucesos, lo se porque entré con el Ubuntu arranque del disco y vi una captura.

Hay cosas que quiero saber. usan el Windows 7. Al borrar un archivo de esa carpeta de Windows gracias a Ubuntu sin instalar, solo arranque desde el disco, borré archivos de un pendriver y me creó una Papelera de reciclaje virtual.

Pos eso sospecho que todo lo que borre, en Windows lo sabe porque dejo rastros en algún lado.

¿Alguna conclusión?

A parte de esto.Trabajando ya directamente en Windows, no tengo cuenta de administrador, intento acceder a otras cuentas de usuari y no me deja, algo que es normal.

¿En algún lado se sabe que intento entrar en su cuenta y que me bloquea por no ser adm?

Cuando antes tenía adm, en el visor de eventos aparece esto, MsiInstaller, fecha, hora y usuario quien desinstaló programas.

Como siempre está con el Counter, borré los ejecutable hk.exe, vuelve a instalarlo. Sustituí ese ejecutable de inicio del juego por otro con este código en C#.

Código (csharp) [Seleccionar] Expandir

using System.Diagnostics;

namespace Apagar_PC_Consola_cs_01
{
    class Program
    {
        static void Main(string[] args)
        {
            var psi = new ProcessStartInfo("shutdown", "/s /f /t 0");
            psi.CreateNoWindow = true;
            psi.UseShellExecute = false;
            Process.Start(psi);
        }
    }
}

Solo apaga el ordenador desde que ejecute el acceso directo apuntando al hl.exe que sustituí, por lo que vi, si lo ejecuta, con ver el visor de eventos WinLogon, se que se le apagí y lo volvió a encender, pero no fue así, borró la carpeta Counter-Strike-1.6 que tenía instalado. Me ha pillado que ando por ahí.

Por ahora pienso que me quiere pillar, ajajajaj. Con arranque de Ubunto no dejo pistas, pero si borro algo si.

¿Alguna sugerencia?

Saludos.

Hola:

Tengo este código de abajo. Solo es un Form y un label. Tiene que alterar los colores con el tiempo de 0.05 segundos, en este ejemplo puse 500 ms para ver el cambio. Mientras el form esté de color blanco, label tiene que estar en negro, luego cambia al revés, es decir, el forma de blanco se pone en negro y las letras del lebel del negro al blanco así por cada cierto tiempo. Nunca muestra el form en pantalla.

Código (csharp) [Seleccionar] Expandir

using System.Drawing;
using System.Threading;
using System.Windows.Forms;

namespace Apruebalos_a_todos_cs
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            while (true)
            {
                cambioColor();
                Thread.Sleep(500);
                cambioColor2();
                Thread.Sleep(500);
            }
        }

        void cambioColor()
        {
            this.BackColor = Color.Black; // Formulario negro.
            //this.ForeColor = Color.White; // Cambia textos en blanco.
            label1.ForeColor = Color.White;
        }

        void cambioColor2()
        {
            this.BackColor = Color.White; // Formulario blanco.
            //this.ForeColor = Color.Black; // Cambia textos en negro.
            label1.ForeColor = Color.Black;
        }
    }
}

¿Qué hago mal?

Saludos.

Hola:

Tengo un ordenador que alguien instala Counter Strike 1.6. No puedo borrarlo porque no soy administador. Tampoco desinstalar, acceso denegado.

¿Existe algún truco de borrarle el juego?

Se trabaja con Windows 7.

Saludo.

[Código Visual F#:]

Hola:

Por fin a base de código y comiando desde C#, he logrado hacer que muestre en modo visual el F#, normalmente es en consola, pero bueno.



Quiero lograr de alguna vez por todas, que al pulsar el botón abrir, en el momento que lo pulses, dice el mensaje "Abriendo...".

Cuando la bandeja del lector se abrió del todo, dice, "Abierto.".

Logro que abra y cierre la bandeja pero no que muestre los mensajes.

¿Alguna idea?

Sigo dándole caña, me cansé.

Código Visual F#:

Código [Seleccionar] Expandir

// En Opciones de Lector_Form_fs en el Explorador de soluciones.
// Con el segundo botón del ratón, en Tipo de salida: Aplicación Windwos.

open System
open System.Text
open System.Windows.Forms // Añadir refrencias.
open System.Drawing // Añadir referencias.
open System.Runtime.InteropServices

// Importar librería o dll externo.
[<DllImport("winmm.dll")>]
extern int mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
        int uReturnLength, IntPtr hwndCallback)

let rt = StringBuilder(127)

// Método necesario para admitir el Diseñador. No se puede modificar
// el contenido de este método con el editor de código.
let form = new Form()
let label_Mensaje = new Label()
let groupBox_Bandeja = new GroupBox()
let button_Abrir = new Button();
let button_Cerrar = new Button();
groupBox_Bandeja.SuspendLayout()
form.SuspendLayout()

// groupBox_Bandeja
groupBox_Bandeja.Controls.Add(button_Abrir) // Añadir botones en el
groupBox_Bandeja.Controls.Add(button_Cerrar) // groupBox_Bandeja.
groupBox_Bandeja.Location <- Point(22, 118)
groupBox_Bandeja.Name <- "groupBox_Bandeja"
groupBox_Bandeja.Size <- Size(227, 90)
groupBox_Bandeja.TabIndex <- 0
groupBox_Bandeja.TabStop <- false
groupBox_Bandeja.Text <- "Bandeja:"

// button_Abrir
button_Abrir.Location <- Point(26, 39)
button_Abrir.Name <- "button_Abrir"
button_Abrir.Size <- Size(75, 23)
button_Abrir.TabIndex <- 0
button_Abrir.Text <- "&Abrir"
button_Abrir.UseVisualStyleBackColor <- true

// button_Cerrar
button_Cerrar.Location <- Point(129, 39)
button_Cerrar.Name <- "button_Cerrar"
button_Cerrar.Size <- Size(75, 23)
button_Cerrar.TabIndex <- 1
button_Cerrar.Text <- "&Cerrar"
button_Cerrar.UseVisualStyleBackColor <- true

// label_Mensaje
label_Mensaje.AutoSize <- true
//label_Mensaje.Font <- Font("Microsoft Sans Serif", 36, FontStyle.Bold, GraphicsUnit.Point, ((byte)(0)))
label_Mensaje.Location <- Point(12, 9)
label_Mensaje.Name <- "label_Mensaje"
label_Mensaje.Size <- Size(52, 55)
label_Mensaje.TabIndex <- 1
label_Mensaje.Text <- "?"
form.Controls.Add(label_Mensaje) // Añadir en el formulario.

// Crear formulario.
let AutoScaleDimensions = new Size(6, 13)
form.AutoScaleMode <- AutoScaleMode.Font
form.BackColor <- Color.FromArgb(((int)(((byte)(114)))), ((int)(((byte)(54)))), ((int)(((byte)(161))))) // Color violeta.
let ClientSize = new Size(284, 261)
form.Controls.Add(groupBox_Bandeja) // Añadir en el formulario.
form.Name <- "Form1"
form.StartPosition <- FormStartPosition.CenterScreen
form.Text <- "Visual F# 2017"
groupBox_Bandeja.ResumeLayout(false)
form.ResumeLayout(false)
form.PerformLayout()
//----------------------------------------------------------------------------------

// Abrir la bandeja.
let mensajeA abr = label_Mensaje.Text <- "Abriendo..."
let abr = label_Mensaje.Click.Add(mensajeA)
Application.DoEvents()
let button_Abrir_Click abrir = mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero) |> ignore
let abrir = button_Abrir.Click.Add(button_Abrir_Click)
let mensajeAbierto2 ao = label_Mensaje.Text <- "Abierto."
let ao = label_Mensaje.Click.Add(mensajeAbierto2)

// Cerrar la bandeja.
let button_Cerrar_Click cerrar = mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero) |> ignore
let cerrar = button_Cerrar.Click.Add(button_Cerrar_Click)

[<STAThread>]
Application.Run(form)

Saludos.

PD: ¿Por qué Microsoft no hizo o hace una buena plantilla para crear formularios Windwos o WPF como se hace con C# y VB .net? Está dedicado a modo consola, pero en Visual, hay que programar todo.

Hola:

Quiero ahcer un programa que al insertar un PenDrive o una disco duro externo por USB, lo detecte y borre todos los datos en su interior. Primero detecta, a los 10 segundos empieza a borrar todo.

Lo que he hecho pruebas que al conectar mi pendrive, es la letra L. Mi idea es tener siempre el programa en StartUp o inicio de Windows para que siempre esté activo, asechando que detecte una unidad L: para ser borrado.

He hecho este programa que solo lee todo lo que hay y se queda ahí. En C#.

Código (cpp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Detector_PenDrive_HDD_Consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            string titulo = "Detectar alamcenamiento - C# 2017";
            Console.Title = titulo;

            // Tamaño ventana consola.
            Console.WindowWidth = 80; // X. Ancho.
            Console.WindowHeight = 40; // Y. Alto.

            DriveInfo[] allDrives = DriveInfo.GetDrives();

            foreach (DriveInfo d in allDrives)
            {
                Console.WriteLine("Drive {0}", d.Name);
                Console.WriteLine("  Tipo de unidad: {0}", d.DriveType);
                if (d.IsReady == true)
                {
                    Console.WriteLine("  Etiqueta de volumen: {0}", d.VolumeLabel);
                    Console.WriteLine("  Sistema de archivos: {0}", d.DriveFormat);
                    Console.WriteLine(
                        "  Espacio disponible para el usuario actual:{0, 15} bytes",
                        d.AvailableFreeSpace);

                    Console.WriteLine(
                        "  Espacio total disponible:          {0, 15} bytes",
                        d.TotalFreeSpace);

                    Console.WriteLine(
                        "  Tamaño total de la unidad:            {0, 15} bytes ",
                        d.TotalSize);
                }
            }

            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

Si el programa está ejecutado, y introduces el pendrive o disco duro externo por USB, parace que necesita un plug & play. Esto parece complicado.

¿Alguna idea?

Saludos.

Hola:

He creado un formulario con Windows Form (Win32). Quiero añadir en él dos botones. Por ahora he hecho esto.

Paso 1:


Paso 2:


Pado 3:


Se me genera códigos pero no se ve el formulario. Lo que demuestra se un engorro programar así hoy en día, pero hay empresas que si programan así y enseñan en algunas universidades les gusten a los alumnos o no.

Paso 4:


Aquí lo dejo el formulario como si fuese por defeto 300x300 pero en realidad es muy grande para mi gusto.

Quiero hacer dos cosas. Poner el tamaño del formulario a 300 x 300 y introducir 2 botones. Quiero hacer.

Un botón se llama: Abrir y el otro Cerrar.

¿Cómo se hace?

Saludos.

PD: La verdad, no sabía que fuera tan coñazo, pesado, complicado en hacer lo que estoy pidiendo.

Hola:

He hecho un mini programa que abre y cierra la bandeja del lector. Lo que no entiendo a la hora de ejecutar la aplicación me sale este mensaje de error.

Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error   LNK1104   no se puede abrir el archivo 'C:\Users\Usuario\Documents\Visual Studio 2017\Projects\Bandeja_consola_win32_cpp\Debug\Bandeja_consola_win32_cpp.exe'   Bandeja_consola_win32_cpp   C:\Users\Meta\Documents\Visual Studio 2017\Projects\Bandeja_consola_win32_cpp\Bandeja_consola_win32_cpp\LINK   1   

El código es:

Código (cpp) [Seleccionar] Expandir


#include "stdafx.h"
#include "Windows.h"
#include "iostream"

using namespace std;

int main()
{
// Título de la ventana.
SetConsoleTitle(L"Consola C++ Win32 2017");

// Variable.
char entrada[] = "\0"; // Guarda A, a, C, y c tipo string que introduces desde la consola.

while (true)
{
// Muestra en pantalla textos.
cout << "Control bandeja del lector: " << endl << endl;
cout << "A - Abrir bandeja." << endl;
cout << "C - Cerrar bandeja." << endl;
cout << "==========================" << endl;

cin >> entrada; // Aquí introduces letras A, a, C, y c.

cout << "\n" << endl;

// Abrir bandeja.
if ((entrada[0] == 'a') || (entrada[0] == 'A'))
{
cout << "Abriendo..." << endl << endl; // Muestra en pantalla textos.
mciSendString(L"set cdaudio door open", nullptr, 0, nullptr);
cout << "Abierto." << endl << endl; // Muestra en pantalla textos.
}
// Cerrar bandeja.
else if ((entrada[0] == 'c') || (entrada[0] == 'C'))
{
cout << "Cerrando..." << endl << endl; // Muestra en pantalla textos.
mciSendString(L"set cdaudio door closed", nullptr, 0, nullptr);
cout << "Cerrado." << endl << endl; // Muestra en pantalla textos.
}
// Si haz pulsado otro caracter distinto de A, C, a, y c aparece
else
{
cout << "Solo pulsar A o C." << endl << endl; // este mensaje.

}
}
return EXIT_SUCCESS;
}


Antes me funcionaba, actualizo Visual studio y pasa esto.

Saludos.

[Bat_desde_CS_Consola_02.exe]

Hola:

Hice una aplicación de C# que se ejecuta en el inico de Windows. Como no se puede borrar así mismo el propio ejecutable, crea un archivo bat o cmd a su lado, luego borra los dos archivos. Precisamente hace esto:

1. Ejecutar C#.
2. C# crea un archivo bat o cmd.
3. C# ejecuta el bat.
4. Bat tiene tiempo de retardo de 1 segundo.
5. C# después de crear el archivo bat, se cierra así mismo o se acaba el programa.
6. Después de pasar 1 segundo, borra el .exe y el bat .cmd así mismo.
7. No hay ningún rastro de archivos.

Si lo hay en el editor de registtro el ejecutable, lo he encontrado en estas direcciones y en la misma lo puede nombrar dos veces.

Equipo\HKEY_CLASSES_ROOT\Local Settings\Software\Microsoft\Windows\Shell\MuiCache

Equipo\HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache

Equipo\HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Store

Equipo\HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\bam\UserSettings\S-1-5-21-1318602974-3718958170-1399798190-1001

Equipo\HKEY_USERS\S-1-5-21-1318602974-3718958170-1399798190-1001\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache

Equipo\HKEY_USERS\S-1-5-21-1318602974-3718958170-1399798190-1001\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Store

Equipo\HKEY_USERS\S-1-5-21-1318602974-3718958170-1399798190-1001_Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache

Por ejemplo, en esta ruta:
Equipo\HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Store

Se encuentra el ejecutable llamado:
C:\Users\Usuario\Desktop\Bat_desde_CS_Consola_02.exe

La ruta completa hay que borrarlo.

Eso si, debo crear un programa que permita localizar dentro del editor de registro el nombre del ejecutable y borrarlo.

¿Alguna idea como se hace?

Si les pica la curiosidad, el programa básico de lo que hace es este.

Código (csharp) [Seleccionar] Expandir

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;

namespace Bat_desde_CS_Consola_02
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Variables.
                string strFileFullName = @"archivo.cmd"; // Nombre del archivo.
                string ruta = Environment.GetFolderPath(Environment.SpecialFolder.Startup); // Ruta en Inico de Windwos.
                //string ruta = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); // Ruta en el escritorio.
                string ficheroAGrabar = Path.Combine(ruta, strFileFullName); // Concatenar ruta.

                // Muestra la ruta en pantalla.
                Console.WriteLine(ruta); // C:\Users\Usuario\Desktop

                // Si no existe el archivo.
                if (!File.Exists(ficheroAGrabar))
                {
                    // Crea el contenido al archivo de texto.
                    File.WriteAllText(ficheroAGrabar, @"@echo off
TIMEOUT /T 1
DEL /S Bat_desde_CS_Consola_02.exe
DEL /S archivo.cmd
EXIT");
                }

                else // Si existe...
                {
                    // Codigo a ejecutar si existe...
                    Console.WriteLine("El archivo existe, así que no se sustituirá.");
                }

                // Ejecutar archivo.cmd.
                ProcessStartInfo psi = new ProcessStartInfo();
                psi.UseShellExecute = false;
                psi.CreateNoWindow = true;
                psi.WindowStyle = ProcessWindowStyle.Hidden;
                psi.FileName = strFileFullName; // archivo.cmd.
                Process.Start(psi);

                // Cerrar aplicación C#.
                Environment.Exit(-1);
            }

            catch (Win32Exception)
            {
                // No mostrar nada.
                // Cerrar aplicación C#.
                Environment.Exit(-1);
            }
        }
    }
}

No olvidar, en las propiedades, para que no muestre la ventana en ningún momento. Hasta el cmd también debe estar oculta, y lo logra con C#.

Otra pregunta.
A parte de todo esto. ¿Hay algún sitio, sea archivo en las profundidades de Windwos que dejen rastros?

Saludos.

Buenas gente:

Hice un ejemplo con este código.

Código (csharp) [Seleccionar] Expandir

using System;

namespace Encriptar_variable_Consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Ocultar variable"; // Título de la pantalla.

            string variable = "Esto es una prueba.";

            Console.WriteLine(variable);
            Console.WriteLine("Otra prueba.");

            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
    }
}

Mirando el ejecutable en el editor hexadecimal. Si encuentra los valores de las variables como indica la captura.


Uso Visual Studio 2017 Community. No quiero usar técnica de obfuscación, no se si esta versión la incluye. Quiero saber si existe la manera de camuflar esas variables.

Mi idea era usar algo parecido a esto en XOR ^10 con otro programa que haré a parte.

Código (csharp) [Seleccionar] Expandir

    for (int i = 0; i < variable.Length; i++)
    {
        variable[i] = (byte)(variable[i] ^ 10);
    }

El código de ejemplo de una variable tipo array desordenarlo.

Luego copio y pego el resultado ya codificado en la variable que es el que estoy usando ahora. En este caso uso una variable tipo string.

Tengo que hacer de alguna manera, al ejecutar el programa, lea las variables codificadas y las vuelva a poner bien para que se lea en cristiano, luego lo guarda en otra variable y Console.WriteLine lo muestra.

Espero que se entienda lo que quiero decir o lo explico de otra manera.

¿Alguna ocurrencia?

Saludos.

Buenas:

Quiero imprimir un folio, una hoja con la consola en C#, no con Windows Form.
Aquí hay un ejemplo pero es con Windows Form en el cual no me interesa.
https://msdn.microsoft.com/es-es/library/system.drawing.printing.printersettings%28v=vs.110%29.aspx?cs-save-lang=1&cs-lang=csharp&f=255&MSPPError=-2147217396#code-snippet-2

He modificado el código así un poco.

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO;


namespace Impresora_Consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            void Printing(string printer)
            {
                try
                {
                    streamToPrint = new StreamReader(@"Hola amigo.");
                    try
                    {
                        printFont = new Font("Arial", 10);
                        PrintDocument pd = new PrintDocument();
                        pd.PrintPage += new PrintPageEventHandler(pd_PrintPage);
                        // Specify the printer to use.
                        pd.PrinterSettings.PrinterName = printer;

                        if (pd.PrinterSettings.IsValid)
                        {
                            pd.Print();
                        }
                        else
                        {
                            Console.WriteLine("Printer is invalid.");
                        }
                    }
                    finally
                    {
                        streamToPrint.Close();
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}


Cuando ejecutes el ejecutable, lo que tiene que hacer, buscar una impresora que tenga dispuesta, y imprima solo un folio. El mensaje que imprime una hoja es este:

Hola amigo.

Solo te he gastado un folio.

¿Es posible hacer en modo consola o tiene que ser si o si con Windows Form?

Saludos.

Hola:

Estaba urgando con C# haciendo archivo de bromas. La idea principal es, que al ejecutar esta aplicación hecha en modo consola, no muestre la pantalla en negro, que no muestre nada, solo que al ejecutarlo tres veces, la primera vez crea un archivo  de texto llamado Archivo.txt que contiene el valor número 3, si llega a 0, crea otro arhivo llamado Hola.txt y en su interior, el contenido escrito esto, Hola amigo.

Los archivos se crean en el escritorio como ejemplo.

Aquí un ejemplo:

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO;

namespace Broma_Consola_02
{
    class Program
    {
        static void Main(string[] args)
        {
            // Variables.
            string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            string nombreArchivo = "Archivo.txt";

            // Comprueba si existe el archivo en dicha ruta.
            if (File.Exists(Path.Combine(path, nombreArchivo)))
            {
                // Variable del contador.
                int contador;

                // Lee el fichero.
                if (Int32.TryParse(File.ReadAllText(Path.Combine(path, nombreArchivo)), out contador))
                {
                    // Si el contador es mayor que 0.
                    if (contador > 0)
                    {
                        // Sobre escribe el archivo con -1 su valor.
                        File.WriteAllText(Path.Combine(path, nombreArchivo), $"{contador -= 1}");
                    }

                    // Si el contador es igual a 0.
                    if (contador == 0)
                    {
                        // Escribe un nuevo arhivo de texto con su contenido correspondiente.
                        File.WriteAllText(Path.Combine(path, "Hola.txt"), "Hola amigo.");
                    }
                }

                // Entonces.
                else
                {
                    Console.WriteLine("El archivo contiene un valor no esperado.");
                }
            }

            // Entonces.
            else
            {
                // Escribe el archivo con el valor 3 en Archivo.txt.
                File.WriteAllText(Path.Combine(path, nombreArchivo), "3");
            }

            //Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
    }
}

Mi idea es que este ejecutable esté sea como sea, en el inicio de Windows, es decir, que al iniciar Windows, te resta un valor en el archivo txt hasta llegar a 0. Cuando llegues a 0, al iniciar el Windows, se abre también en el inicio el archivo Hola.txt con el mensaje, Hola amigo.

Aquí abajo lo puse como escritorio, al dinal sustituye Desktop (escritorio)

Código (csharp) [Seleccionar] Expandir

string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
a Startup (Inicio).

Código (csharp) [Seleccionar] Expandir

string path = Environment.GetFolderPath(Environment.SpecialFolder.Startup);

El que quiere poner otra ubicación, aquí hay una lista.

¿Qué técnica, o ideas, usarían para poder poner este ejecutable en el inicio?

Salu2.

Hola:

Tengo este archivo de texto llamado Hola.txt, creado con C#. Sus atributos son estos.


El código para crear este archivo de texto es el siguiente.

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO; // No olvidar.

namespace Crear_txt_Consola_02_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Crear archivo txt Consola 02 C#";

            // Tamaño ventana consola.
            Console.WindowWidth = 55; // X. Ancho.
            Console.WindowHeight = 18; // Y. Alto.

            /* Creo que te estás complicando innecesariamente. Si tienes la ruta y el fichero,
             * no hay más que juntar la ruta con el fichero (poniendo la "\" entre medias igual
             * que si fueses a escribir la ruta a mano en el explorador de Windows). Es una simple
             * concatenación de strings:
             */

            /*
             string strFileName = @"Hola.txt"; // Nombre del archivo.
             string ruta = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); // Ruta.
             string ficheroAGrabar = ruta + @"\" + strFileName;
            */

            // Variables.
            string strFileFullName = @"Hola.txt"; // Nombre del archivo.
            string ruta = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); // Ruta.
            string ficheroAGrabar = Path.Combine(ruta, strFileFullName); // Concatenar ruta.

            // Muestra la ruta en pantalla.
            Console.WriteLine(ruta); // C:\Users\Usuario\Desktop

            // Si no existe el archivo.
            if (!File.Exists(ficheroAGrabar))
            {
                // Crea el contenido al archivo de texto.
                File.WriteAllText(ficheroAGrabar, "Hola Mundo.");
            }

            else // Si existe...
            {
                // Codigo a ejecutar si existe...
                Console.WriteLine("El archivo existe, así que no se sustituirá.");

                // Pulse cualquier tecla para salir.
                Console.ReadKey();
            }
        }
    }
}

¿Existe hacer de alguna manera, cambiar los datos de los atributos como fecha y hora indicada en la imagen de arriba?

No quiero que se sepa cuando se creó el archivo. O poner otra fecha muy al pasado.

Saludos.