Managing windows settings in any way using C# code

Question

Is there ant library, method to get/set some of windows setting (like changing monitor brightness, changing power supply mode (from high performance to eco and back))?

Answer 1

You can use the SetMonitorBrightness API to modify the screen brightness:

   public partial class MainWindow : Window  
    {  
        public MainWindow()  
        {  
            InitializeComponent();  
           
        }  
        private void button_Click(object sender, RoutedEventArgs e)  
        {  
            IntPtr windowHandle = new WindowInteropHelper(this).Handle;  
            using (BrightnessController brightnessController = new BrightnessController(windowHandle))  
            {  
                brightnessController.SetBrightness(100);  
            }   
        }  
    }  
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]  
    public struct PHYSICAL_MONITOR  
    {  
        public IntPtr hPhysicalMonitor;  
  
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]  
        public string szPhysicalMonitorDescription;  
    }  
  
    public class BrightnessController : IDisposable  
    {  
        [DllImport("user32.dll", EntryPoint = "MonitorFromWindow")]  
        public static extern IntPtr MonitorFromWindow([In] IntPtr hwnd, uint dwFlags);  
  
        [DllImport("dxva2.dll", EntryPoint = "DestroyPhysicalMonitors")]  
        [return: MarshalAs(UnmanagedType.Bool)]  
        public static extern bool DestroyPhysicalMonitors(uint dwPhysicalMonitorArraySize, ref PHYSICAL_MONITOR[] pPhysicalMonitorArray);  
  
        [DllImport("dxva2.dll", EntryPoint = "GetNumberOfPhysicalMonitorsFromHMONITOR")]  
        [return: MarshalAs(UnmanagedType.Bool)]  
        public static extern bool GetNumberOfPhysicalMonitorsFromHMONITOR(IntPtr hMonitor, ref uint pdwNumberOfPhysicalMonitors);  
  
        [DllImport("dxva2.dll", EntryPoint = "GetPhysicalMonitorsFromHMONITOR")]  
        [return: MarshalAs(UnmanagedType.Bool)]  
        public static extern bool GetPhysicalMonitorsFromHMONITOR(IntPtr hMonitor, uint dwPhysicalMonitorArraySize, [Out] PHYSICAL_MONITOR[] pPhysicalMonitorArray);  
  
        [DllImport("dxva2.dll", EntryPoint = "GetMonitorBrightness")]  
        [return: MarshalAs(UnmanagedType.Bool)]  
        public static extern bool GetMonitorBrightness(IntPtr handle, ref uint minimumBrightness, ref uint currentBrightness, ref uint maxBrightness);  
  
        [DllImport("dxva2.dll", EntryPoint = "SetMonitorBrightness")]  
        [return: MarshalAs(UnmanagedType.Bool)]  
        public static extern bool SetMonitorBrightness(IntPtr handle, uint newBrightness);  
  
        private uint _physicalMonitorsCount = 0;  
        private PHYSICAL_MONITOR[] _physicalMonitorArray;  
  
        private IntPtr _firstMonitorHandle;  
  
        private uint _minValue = 0;  
        private uint _maxValue = 0;  
        private uint _currentValue = 0;  
  
        public BrightnessController(IntPtr windowHandle)  
        {  
            uint dwFlags = 0u;  
            IntPtr ptr = MonitorFromWindow(windowHandle, dwFlags);  
            if (!GetNumberOfPhysicalMonitorsFromHMONITOR(ptr, ref _physicalMonitorsCount))  
            {  
                throw new Exception("Cannot get monitor count!");  
            }  
            _physicalMonitorArray = new PHYSICAL_MONITOR[_physicalMonitorsCount];  
  
            if (!GetPhysicalMonitorsFromHMONITOR(ptr, _physicalMonitorsCount, _physicalMonitorArray))  
            {  
                throw new Exception("Cannot get phisical monitor handle!");  
            }  
            _firstMonitorHandle = _physicalMonitorArray[0].hPhysicalMonitor;  
  
            if (!GetMonitorBrightness(_firstMonitorHandle, ref _minValue, ref _currentValue, ref _maxValue))  
            {  
                throw new Exception("Cannot get monitor brightness!");  
            }  
        }  
  
        public void SetBrightness(int newValue) // 0 ~ 100  
        {  
            newValue = Math.Min(newValue, Math.Max(0, newValue));  
            _currentValue = (_maxValue - _minValue) * (uint)newValue / 100u + _minValue;  
            SetMonitorBrightness(_firstMonitorHandle, _currentValue);  
        }  
  
        public void Dispose()  
        {  
            Dispose(true);  
            GC.SuppressFinalize(this);  
        }  
  
        protected virtual void Dispose(bool disposing)  
        {  
            if (disposing)  
            {  
                if (_physicalMonitorsCount > 0)  
                {  
                    DestroyPhysicalMonitors(_physicalMonitorsCount, ref _physicalMonitorArray);  
                }  
            }  
        }  
    }  

Most of this code is quoted from this post: Adjust screen brightness using C#

Windows provides a tool to modify the power plan, we can use Process to call this tool:

Process.Start("powercfg", "-setactive  GUID");  

GUID example:

Balanced: 381b4222-f694-41f0-9685-ff5bb260df2e
High performance: 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c
Power saver: a1841308-3541-4fab-bc81-f71556f20b4a

You can also use this method to get more power options. If you want to learn more, you can open Command Prompt and type powercfg -aliases to get more available GUID values.

---

If the response is helpful, please click "Accept Answer" and upvote it.
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.