I want to turn on the PC from sleep mode on windows 10/11 programmatically in WPF (.net framework) C# application. How to achieve it ?

Hi,@Vishal2 Bansal. Welcome to MicrosoftQ&A .

Turning on a PC from sleep mode programmatically in a WPF application can be achieved using different approaches

Option 2: Turn Off the Display

// Import necessary libraries
using System;
using System.Runtime.InteropServices;

public class DisplayManager
{
    // Import SendMessage function
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    private static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);

    // Constants for turning off the display
    private const int SC_MONITORPOWER = 0xF170;
    private const int WM_SYSCOMMAND = 0x0112;
    private const int MONITOR_OFF = 2;

    // Turn off the display
    public static void TurnOffDisplay()
    {
        SendMessage(IntPtr.Zero, WM_SYSCOMMAND, (IntPtr)SC_MONITORPOWER, (IntPtr)MONITOR_OFF);
    }
}

These options involve turning off the display or putting the computer to sleep. However, waking up the computer programmatically after a specific duration might require additional considerations. For example, waking up from sleep mode may require hardware support and might not be reliable for all systems.

Option 3: Wake on LAN WoL can be an effective solution for waking up a computer from sleep or hibernation remotely. However, it requires support from the computer's hardware and BIOS settings, as well as proper network configuration. Here's a general overview of how you could implement WoL:

Ensure hardware support: Check if your computer's network card supports Wake on LAN. Most modern network adapters do, but you may need to enable it in the BIOS settings.

Configure BIOS settings: Access your computer's BIOS settings and enable Wake on LAN support if it's not already enabled. The exact steps may vary depending on your motherboard and BIOS version.

Implement WoL in your WPF application: You can use a WoL library or directly send a Wake on LAN magic packet to the target computer's MAC address. Here's an example using the System.Net.Sockets.UdpClient class:

using System.Net;
using System.Net.Sockets;
using System.Text;

public class WakeOnLan
{
    public static void SendMagicPacket(string macAddress)
    {
        // Construct the magic packet
        byte[] magicPacket = ConstructMagicPacket(macAddress);

        // Send the magic packet to the broadcast address
        using (UdpClient client = new UdpClient())
        {
            client.EnableBroadcast = true;
            client.Send(magicPacket, magicPacket.Length, new IPEndPoint(IPAddress.Broadcast, 9));
        }
    }

    private static byte[] ConstructMagicPacket(string macAddress)
    {
        byte[] macBytes = ParseMacAddress(macAddress);
        byte[] magicPacket = new byte[102];
        for (int i = 0; i < 6; i++)
            magicPacket[i] = 0xFF;
        for (int i = 6; i < 102; i += 6)
            Array.Copy(macBytes, 0, magicPacket, i, 6);
        return magicPacket;
    }

    private static byte[] ParseMacAddress(string macAddress)
    {
        return macAddress.Split(':')
                         .Select(s => byte.Parse(s, System.Globalization.NumberStyles.HexNumber))
                         .ToArray();
    }
}

Handle security considerations: Ensure that you have proper security measures in place, as Wake on LAN can potentially be abused if not implemented securely. For example, you can limit access to WoL functionality using authentication and encryption.

Test and troubleshoot: Test your WoL implementation thoroughly to ensure it works reliably in your environment. You may need to adjust network settings or troubleshoot issues with specific computers or network configurations.

Option 2 may require further investigation to resolve the issue with the display turning on briefly, while option 3 (WoL) can be an effective solution for waking up computers remotely but requires proper hardware support and network configuration. Choose the option that best fits your requirements and constraints.