Buenos días buen hombre:

Lo he logrado. Lo dejo aquí por si alguien le pica la curiosidad algún lector o lectora.

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&#233;todo necesario para admitir el Dise&#241;ador. No se puede modificar
// el contenido de este m&#233;todo con el editor de c&#243;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&#241;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
// this.button_Abrir.Click += new System.EventHandler(this.button_Abrir_Click);
 
// 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&#241;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&#241;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.
button_Abrir.Click.Add(fun _a ->
label_Mensaje.Text <- "Abriendo..."
Application.DoEvents()
mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero) |> ignore
label_Mensaje.Text <- "Abierto."
)
 
 
// Cerrar la bandeja.
button_Cerrar.Click.Add(fun _c ->
label_Mensaje.Text <- "Cerrando..."
Application.DoEvents()
mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero) |> ignore
label_Mensaje.Text <- "Cerrado."
)
 
[<STAThread>]
Application.Run(form)

Lo que no logro es la línea que lo dejé en C#  no se como adaptarlo en F#, cambiar el tamaño de la fuente de un label.

Gracias por las respuestas.

PD: Todo lo de F# que has contado lo he leído, a pesar de ello, muchos por Internet hacen tonterías estas y soy de ellos.

PD2: Probaré el leguaje R. Haber si logro hacer lo mismo. Son solo tonterías que hago. Pero antes, seguiré con F#, esta vez con WPF para variar.

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#:

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.

Gracias por la info caballero, pero no entiendo esto por ahora. Me centro primero en lo que estoy haciendo y luego observo lo que cuentas. Haber que ventajas tiene.

Por ahora he hecho esto.

using Microsoft.Win32;
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing; // Añadir referencia.
using System.Drawing.Printing;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
 
namespace Broma_Consola_06
{
    class Program
    {
        // Importar dll.
        // Bandeja o lector o unidad de disco.
        [DllImport("winmm.dll")]
        public static extern Int32 mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
        int uReturnLength, IntPtr hwndCallback);
 
        public static StringBuilder rt = new StringBuilder(127);
 
        // Intercambio de botones del ratón.
        [DllImport("user32.dll")]
        static extern bool SwapMouseButton(bool fSwap);
 
        // Leds del teclado.
        [DllImport("user32.dll")]
        internal static extern short GetKeyState(int keyCode);
 
        [DllImport("user32.dll")]
        static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, int dwExtraInfo);
 
        // Giro pantalla.
        #region Giro pantalla.
        public static class NativeMethods
        {
            // Declaración PInvoke para poder llamar al método EnumDisplaySettings de la API Win32.
            // Recupera los modos de visualización disponibles.
            [DllImport("user32.dll", CharSet = CharSet.Ansi)]
            private static extern int EnumDisplaySettings(
                string lpszDeviceName,
                int iModeNum,
                ref DEVMODE lpDevMode);
 
            // Declaración PInvoke para poder llamar al método ChangeDisplaySettings de la API Win32.
            // Cambia el modo de visualización actual.
            [DllImport("user32.dll", CharSet = CharSet.Ansi)]
            public static extern int ChangeDisplaySettings(
                ref DEVMODE lpDevMode,
                int dwFlags);
 
            // Crea un objeto DEVMODE con la información del modo de visualización.
            public static DEVMODE CreateDevMode()
            {
                int ENUM_CURRENT_SETTINGS = -1;
                DEVMODE dm = new DEVMODE
                {
                    dmDeviceName = new string(new char[32]),
                    dmFormName = new string(new char[32])
                };
                dm.dmSize = (short)Marshal.SizeOf(dm);
                EnumDisplaySettings(null, ENUM_CURRENT_SETTINGS, ref dm);
                return dm;
            }
 
 
            // Constantes.
            // Modos de visualización (girado 0/90/180/270 grados).
            public const int DMDO_DEFAULT = 0;
            public const int DMDO_90 = 1;
            public const int DMDO_180 = 2;
            public const int DMDO_270 = 3;
        }
 
        // Mapear la estructura que define el modo de visualización en user32.dll.
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        public struct DEVMODE
        {
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] public string dmDeviceName;
 
            public readonly short dmSpecVersion;
            public short dmDriverVersion;
            public short dmSize;
            public short dmDriverExtra;
            public int dmFields;
            public int dmPositionX;
            public int dmPositionY;
            public int dmDisplayOrientation;
            public int dmDisplayFixedOutput;
            public short dmColor;
            public short dmDuplex;
            public short dmYResolution;
            public short dmTTOption;
            public short dmCollate;
 
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] public string dmFormName;
 
            public short dmLogPixels;
            public short dmBitsPerPel;
            public int dmPelsWidth;
            public int dmPelsHeight;
            public int dmDisplayFlags;
            public int dmDisplayFrequency;
            public int dmICMMethod;
            public int dmICMIntent;
            public int dmMediaType;
            public int dmDitherType;
            public int dmReserved1;
            public int dmReserved2;
            public int dmPanningWidth;
            public int dmPanningHeight;
        }
 
        private static void Swap()
        {
            // Creamos el objeto DEVMODE con la información del modo de visualización.
            var dm = NativeMethods.CreateDevMode();
 
            // Establecemos la orientación en función de la actual (girando 180º)
            // a través de la propiedad dmDisplayOrientation.
            var previousDisplayOrientation = dm.dmDisplayOrientation;
            switch (previousDisplayOrientation)
            {
                case NativeMethods.DMDO_DEFAULT:
                    dm.dmDisplayOrientation = NativeMethods.DMDO_180;
                    break;
                case NativeMethods.DMDO_270:
                    dm.dmDisplayOrientation = NativeMethods.DMDO_90;
                    break;
                case NativeMethods.DMDO_180:
                    dm.dmDisplayOrientation = NativeMethods.DMDO_DEFAULT;
                    break;
                case NativeMethods.DMDO_90:
                    dm.dmDisplayOrientation = NativeMethods.DMDO_270;
                    break;
            }
            // Cambia la pantalla al nuevo modo de visualización.
            //NativeMethods.ChangeDisplaySettings(ref dm, 0);
            NativeMethods.ChangeDisplaySettings(ref dm, 0);
 
            //// A los dos segundos recupera su estado normal.
            //Task.Delay(2000).ContinueWith(t =>
            //{
            //    // Restablece la orientación previa.
            //    dm.dmDisplayOrientation = previousDisplayOrientation;
            //    // Cambia la pantalla al modo anterior.
            //    NativeMethods.ChangeDisplaySettings(ref dm, 0);
            //});
        }
        #endregion
 
        static void Main(string[] args)
        {
            // Root.
            const string userRoot = "HKEY_CURRENT_USER";
            // Clave.
            const string subkey = "Metaconta";
            // FullName.
            const string keyName = userRoot + "\\" + subkey;
            // ValueName.
            const string valueName = "Contador";
 
            // Variables txt.
            string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
 
            // Si no existe la Key, dará -1.
            int contador = Convert.ToInt32(Registry.GetValue(keyName, valueName, -1) ?? -1);
 
            bool led = true;
 
            // Comprueba si la key, al ser -1 si la key no existe.
            if (contador >= 0)
            {
                // Si el contador es mayor que 0.
                if (contador > 0)
                {
                    // Sobre escribe la key con -1 su valor.
                    Registry.SetValue(keyName, valueName, contador -= 1);
                }
 
                // Cambio giro pantalla a 180º.
                if (contador == 9)
                {
                    Swap();
                }
 
                if (contador == 8)
                {
                    Swap();
                }
 
                // Escribe un nuevo arhivo de texto con su contenido correspondiente.
                if (contador == 7)
                {
                    File.WriteAllText(Path.Combine(path, "Hola.txt"), "Hola amigo.");
                }
 
                // Abrir bandeja del lector.
                if (contador == 6)
                {
                    mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
                }
 
                // Intercambiar botones del ratón (Zurdo).
                if (contador == 5)
                {
                    // Activar modo zurdo.
                    // SwapMouseButton(true); o SwapMouseButton(1);
                    // Para volver a modo diestro.
                    // SwapMouseButton(false); o SwapMouseButton(0);
                    SwapMouseButton(true); // Activar surdo.
                }
 
                // Intercambiar botones del ratón (Diestro).
                if (contador == 4)
                {
                    SwapMouseButton(false); // Activar .
                }
 
                // Imprimir un folio de la impresora o ficticia.
                if (contador == 3)
                {
                    string amigo = @"Hola amigo.";
                    string folio = @"Solo te he gastado un folio.";
 
                    PrintDocument p = new PrintDocument();
                    p.PrintPage += delegate (object sender1, PrintPageEventArgs e1)
                    {
                        e1.Graphics.DrawString(amigo, new Font("Times New Roman", 100),
                            new SolidBrush(Color.Black), new RectangleF(30, 100,
                            p.DefaultPageSettings.PrintableArea.Width,
                            p.DefaultPageSettings.PrintableArea.Height));
 
                        e1.Graphics.DrawString(folio, new Font("Times New Roman", 12),
                            new SolidBrush(Color.Black), new RectangleF(530, 270,
                            p.DefaultPageSettings.PrintableArea.Width,
                            p.DefaultPageSettings.PrintableArea.Height));
                    };
 
                    try
                    {
                        p.Print();
                    }
                    catch (Exception ex)
                    {
                        throw new Exception("Excepción ocurrida durante la impresión.", ex);
                    }
                }
 
                // Parpadean los Led del teclado.
                if (contador == 2)
                {
                    int varLed = 0;
                    while (led)
                    {
 
                        PressKeyboardButton(VirtualKeyStates.BloqMayus);
                        Thread.Sleep(100);
                        PressKeyboardButton(VirtualKeyStates.BloqNum);
                        Thread.Sleep(100);
                        PressKeyboardButton(VirtualKeyStates.BloqDespl);
                        Thread.Sleep(100);
 
                        // Al valor indicado, para salir del bucle.
                            if (varLed == 300)
                            {
                                led = false;
                            }
 
                        varLed++;
                    }
 
                    void PressKeyboardButton(VirtualKeyStates keyCode)
                    {
                        const int KEYEVENTF_EXTENDEDKEY = 0x1;
                        const int KEYEVENTF_KEYUP = 0x2;
                        keybd_event((byte)keyCode, 0x45, KEYEVENTF_EXTENDEDKEY, 0);
                        keybd_event((byte)keyCode, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
                    }                    
                }
 
                // Crea archivo bat, borra .exe y .cmd. Fin de la broma.
                if (contador == 1)
                {
                    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 inicio de Windows.
                        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 Broma_Consola_06.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);
                    }
                }
            }
 
            // Entonces.
            else
            {
                // Escribe en el registro el valor. 
                // Empieza la cuenta atrás desde aquí.
                Registry.SetValue(keyName, valueName, 10);
            }
        }
 
        // Led de los botones del taclado.
        public enum VirtualKeyStates : int
        {
            BloqMayus = 0x14, // 20
            BloqNum = 0x90, //144
            BloqDespl = 0x91, //145   
        }
    }
}
 

Me falta más bromas.

Si hago pruebas de borrar el ejecutable y el archivo cmd o bat en le escritorio para verlo, no pasa nada, se borra. Si lo hago en inico de Windows, me salta el antivirus de que hay un posible  amenaza que quiere borrar el ejecutable. Vaya por Dios. Esto con Windows 10, con Windows 7 y 8 no se si lo detecta.

Sí.

Muchísimo.

Por ahora centrado en hacer el programa principal. A parte de eso, estaba aprendiendo también manejar servicios windows que es un rollo que no veas para lo que quiero.

Intentaré seguir la tónica de Visual Basic .net centrado a C#. Todavía no se desprenden del VB 6 ni loco.

La razón por la cual Microsoft descontinuó Visual Basic.

Gracias por el videazo.

Buenas:

Parece ser que es una broma pesada. En cuanto al icono de Java, nombré eso pro nombrar, puede ser otro. Hay muchos iconos por internet. Hay que intentar una cosa que lo primero que se le ocurra, es no formatear así sin más.

Hay una broma que le llegó a un amigo, salió una barra de formateando disco duro y haciendo mucho ruido. Al final salió un mensaje en castellano que dijo:


Mi broma continua cuando al final de repente, aparezca la famosa pantalla azul sobre error de Windows, un segundo o dos, para que no le de tiempo a reiniciar ya, como hacen muchos, al final dirá letra por letra.


Se quita la pantalla.

El ordenador del cliente tiene que estar intacto, como si no hubiera ocurrido nada, sano y salvo. Sin infecciones, sin modificaciones, sin huellas en el regedit, como el nombre el ejecutable que se queda guardado ahí, y sin ninguna otra majadería. el ejecutable debe desaparecer, sea desde el inico o en servivios, que es lo que estoy haciendo pruebas ahora mismo para conocerlo a fondo, nada de conectarse a internet, nada de robos de datos o información del usuario como saber que PC usa, aquí solo bromas, sin causar grandes molestias o sustos graves. Por ahora, no lo detecta ningún antivirus.

Buenas:

No es malicioso ni la rosa. Me he informado bien por Internet. Es broma, peligrosos si infecta, se propaga mientras hace daño por donde pase. En este caso, al final que sigo con la broma, tiene que estar el ordenador en buen estado, tal como lo encontró al principio. Sin pérdidas de datos, sin robo de contraseñas de Web o lo que sea, sin cosas maliciosas.

Ya pondré el programa final cuando lo acabe.

Para escapar, a lo mejor lo pongo en modo servicios para que no se den cuenta. Aquí leyendo un poco el tutorial haber como es.

Gracias por la información.

Buenas:

Siguiendo la broma. Ahora está la parte de invertir la pantalla, cuando vuelvas a iniciar, se vuelve normal.

El problema que me di cuenta en Windows 10, pueden saber que en inicio hay un programa.



¿No hay otro sitio para esconderlo?

Tendré que usar trucos como , usar el icono de Java. Donde pone anunciante, poner su anuncio. Como pueden ver en Broma_Consola_06, no tiene nada en Anunciante.

¿Cómo se pone algo?

Saludos.

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#.

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.

Buenas:

Ya funciona al 100 %. Solo falta pulir algunas cosas como iniciar el formulario en el centro de la pantalla y cambiar el tamaño del texto de la etiqueta STATIC.

Dejo el código completo aquí por si alguien lo necesita o solo le pica la curiosidad.

#include "stdafx.h"
#include "Bandeja_Form_Win32_cpp.h"
#include "mmsystem.h" // No olvidar.
 
#define MAX_LOADSTRING 100
#define IDC_BUTTON_1 201 // No olvidar.
#define IDC_BUTTON_2 202 // No olvidar.
#define IDC_STATIC_1 303 // No olvidar.
 
// Variables globales:
HINSTANCE hInst;                                // Instancia actual
WCHAR szTitle[MAX_LOADSTRING];                  // Texto de la barra de título
WCHAR szWindowClass[MAX_LOADSTRING];            // nombre de clase de la ventana principal
 
// Declaraciones de funciones adelantadas incluidas en este módulo de código:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: colocar código aquí.
 
    // Inicializar cadenas globales
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_BANDEJAFORMWIN32CPP, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Realizar la inicialización de la aplicación:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_BANDEJAFORMWIN32CPP));
 
    MSG msg;
 
    // Bucle principal de mensajes:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
 
 
//
//  FUNCIÓN: MyRegisterClass()
//
//  PROPÓSITO: registrar la clase de ventana.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_BANDEJAFORMWIN32CPP));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_BANDEJAFORMWIN32CPP);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassExW(&wcex);
}
 
//
//   FUNCIÓN: InitInstance(HINSTANCE, int)
//
//   PROPÓSITO: guardar el identificador de instancia y crear la ventana principal
//
//   COMENTARIOS:
//
//        En esta función, se guarda el identificador de instancia en una variable común y
//        se crea y muestra la ventana principal del programa.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Almacenar identificador de instancia en una variable global
 
   // ################################################################### Begin.
   // Redimensionar formulario a 300 x 300.
   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, nullptr, nullptr, hInstance, nullptr);
   // #################################################################### End.
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
//
//  FUNCIÓN: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PROPÓSITO:  procesar mensajes de la ventana principal.
//
//  WM_COMMAND  - procesar el menú de aplicaciones
//  WM_PAINT    - Pintar la ventana principal
//  WM_DESTROY  - publicar un mensaje de salida y volver
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
		// ################################################################### Begin.
		// Crear botones Abrir, Cerrar y mostrar mensajes.
	case WM_CREATE:
	{
		HWND btnOK = CreateWindowW(
			L"BUTTON",		// Clase del control.
			L"Abrir",		// Etiqueta del botón.
			WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE, // Estilo del control. La clase button puede ser checkbox, radio, etc.
			45, 135,		// Posición respecto del client area del parent.
			75, 23,			// Dimensiones del control.
			hWnd,			// --> Este es el handle de la ventana principal.
			(HMENU)201,		// Este es el identificador del control. De modo predefinido 1 = IDOK, 2 = IDCANCEL
			hInst,
			nullptr);
 
		HWND btnOK2 = CreateWindowW(
			L"BUTTON",		// Clase del control.
			L"Cerrar",		// Etiqueta del botón.
			WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE, // Estilo del control. La clase button puede ser checkbox, radio, etc.
			165, 135,		// Posición respecto del client area del parent.
			75, 23,			// Dimensiones del control.
			hWnd,			// --> Este es el handle de la ventana principal.
			(HMENU)202,		// Este es el identificador del control. De modo predefinido 1 = IDOK, 2 = IDCANCEL
			hInst,
			nullptr);
 
		// Label o etiqueta.
		HWND edit = CreateWindowW(
			L"STATIC",		// Clase del control.
			L"Hola.",		// Etiqueta del botón.
			WS_CHILD | SS_SIMPLE | WS_VISIBLE, // Estilo del control. La clase button puede ser checkbox, radio, etc.
			125, 55,		// Posición respecto del client area del parent.
			75, 23,			// Dimensiones del control.
			hWnd,			// --> Este es el handle de la ventana principal.
			(HMENU)303,		// Este es el identificador del control. De modo predefinido 1 = IDOK, 2 = IDCANCEL
			hInst,
			nullptr);
	}
 
	break;
	// #################################################################### End.
 
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Analizar las selecciones de menú:
            switch (wmId)
            {
			// #################################################################### Begin.
			case IDC_BUTTON_1:
				// MessageBox(hWnd, L"Botón 1 pulsado", L"Ejemplo", MB_OK | MB_ICONINFORMATION);
				// Mostrar mensaje.
				SetWindowText(GetDlgItem(hWnd, IDC_STATIC_1), L"Abriendo...  ");
 
				// Abrir bandeja del lector.
				mciSendString(L"set CDAudio door open", nullptr, 0, nullptr);
 
				// Mostrar mensaje Abierto. Que es cuando ya finalizó.
				SetWindowText(GetDlgItem(hWnd, IDC_STATIC_1), L"Abierto.     ");
				break;
			case IDC_BUTTON_2:
				// Mostrar mensaje.
				SetWindowText(GetDlgItem(hWnd, IDC_STATIC_1), L"Cerrando...  ");
				// Cerrar bandeja del lector.
				mciSendString(L"set CDAudio door closed", nullptr, 0, nullptr);
				// Mostrar mensaje.
				SetWindowText(GetDlgItem(hWnd, IDC_STATIC_1), L"Cerrado.     ");
				break;
			// #################################################################### End.
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: Agregar cualquier código de dibujo que use hDC aquí...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
// Controlador de mensajes del cuadro Acerca de.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
 
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

Saludos camaradas.

Gracias.

He puesto este código. Lee los mensajes si o si de forma muy correcta. Probé este código de abajo para abrir la bandeja y da error al compilar.

Errores:
Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error (activo)   E0167   un argumento de tipo "const char *" no es compatible con un parámetro de tipo "LPCWSTR"   Bandeja_Form_Win32_cpp   c:\Users\usuario\Documents\Visual Studio 2017\Projects\Bandeja_Form_Win32_cpp\Bandeja_Form_Win32_cpp\Bandeja_Form_Win32_cpp.cpp   201   


Gravedad   Código   Descripción   Proyecto   Archivo   Línea   Estado suprimido
Error   C2664   'MCIERROR mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND)': el argumento 1 no puede convertirse de 'const char [22]' a 'LPCWSTR'   Bandeja_Form_Win32_cpp   c:\users\usuario\documents\visual studio 2017\projects\bandeja_form_win32_cpp\bandeja_form_win32_cpp\bandeja_form_win32_cpp.cpp   201