TabControl1.DisableTabs(TabPage1, TabPage2)

TabControl1.EnableTabs(TabPage1, TabPage2)

Imports System.Runtime.CompilerServices
 
''' <summary>
''' Provides extension methods for a <see cref="TabControl"/> control.
''' </summary>
<HideModuleName>
Public Module TabControlExtensions
 
    ''' <summary>
    ''' Collection used to store tab pages whose tab header need to remain disabled on a <see cref="TabControl"/>.
    ''' <para></para>
    ''' This collection depends on <see cref="TabControlExtensions.DisableOrEnableTabs_Internal"/> method.
    ''' </summary>
    Private disabledTabs As HashSet(Of TabPage)
 
    ''' <summary>
    ''' Collection used to store tab controls whose its <see cref="TabControl.Selecting"/> event
    ''' has been associated to <see cref="TabControlExtensions.disableTabPageHandler"/>.
    ''' <para></para>
    ''' This collection depends on <see cref="TabControlExtensions.DisableOrEnableTabs_Internal"/> method.
    ''' </summary>
    Private tabHandlerAddedControls As HashSet(Of TabControl)
 
    ''' <summary>
    ''' A <see cref="TabControlCancelEventHandler"/> delegate used for disabling tabs on a <see cref="TabControl"/>.
    ''' <para></para>
    ''' This handler depends on <see cref="TabControlExtensions.DisableOrEnableTabs_Internal"/> method.
    ''' </summary>
    Private tabDisablerHandler As TabControlCancelEventHandler
 
    ''' <summary>
    ''' Disables one or multiple <see cref="TabPage"/>, 
    ''' making the tabs unselectable in the source <see cref="TabControl"/>.
    ''' </summary>
    ''' 
    ''' <param name="tabControl">
    ''' The source <see cref="TabControl"/>.
    ''' </param>
    ''' 
    ''' <param name="tabPages">
    ''' An Array of <see cref="TabPage"/> to disable.
    ''' </param>
    <Extension>
    <DebuggerStepThrough>
    Public Sub DisableTabs(tabControl As TabControl, ParamArray tabPages As TabPage())
        TabControlExtensions.DisableOrEnableTabs_Internal(tabControl, enabled:=False, tabPages)
    End Sub
 
    ''' <summary>
    ''' Enables one or multiple <see cref="TabPage"/> that were previously 
    ''' disabled by a call to <see cref="TabControlExtensions.DisableTabPages"/> method, 
    ''' making the tabs selectable again in the source <see cref="TabControl"/>.
    ''' </summary>
    ''' 
    ''' <param name="tabControl">
    ''' The source <see cref="TabControl"/>.
    ''' </param>
    ''' 
    ''' <param name="tabPages">
    ''' An Array of <see cref="TabPage"/> to enable.
    ''' </param>
    <Extension>
    <DebuggerStepThrough>
    Public Sub EnableTabs(tabControl As TabControl, ParamArray tabPages As TabPage())
        TabControlExtensions.DisableOrEnableTabs_Internal(tabControl, enabled:=True, tabPages)
    End Sub
 
    ''' <summary>
    ''' *** FOR INTERNAL USE ONLY ***
    ''' <para></para>
    ''' Disables or enables one or multiple <see cref="TabPage"/>, 
    ''' denying or allowing their tab selection in the source <see cref="TabControl"/>.
    ''' </summary>
    ''' 
    ''' <param name="tabControl">
    ''' The source <see cref="TabControl"/>.
    ''' </param>
    ''' 
    ''' <param name="enabled">
    ''' If <see langword="False"/>, disables the tab pages and make them unselectable in the source <see cref="TabControl"/>; 
    ''' otherwise, enable the tab pages and allows to be selected in the source <see cref="TabControl"/>.
    ''' </param>
    ''' 
    ''' <param name="tabPages">
    ''' An Array of the tab pages to disable or enable.
    ''' </param>
    <DebuggerStepThrough>
    Private Sub DisableOrEnableTabs_Internal(tabControl As TabControl, enabled As Boolean, ParamArray tabPages As TabPage())
        If tabControl Is Nothing Then
            Throw New ArgumentNullException(paramName:=NameOf(tabControl))
        End If
        If tabPages Is Nothing Then
            Throw New ArgumentNullException(paramName:=NameOf(tabPages))
        End If
 
        ' Initialize collections.
        If TabControlExtensions.disabledTabs Is Nothing Then
            TabControlExtensions.disabledTabs = New HashSet(Of TabPage)
        End If
        If TabControlExtensions.tabHandlerAddedControls Is Nothing Then
            TabControlExtensions.tabHandlerAddedControls = New HashSet(Of TabControl)
        End If
 
        ' Initialize handler.
        If TabControlExtensions.tabDisablerHandler Is Nothing Then
            TabControlExtensions.tabDisablerHandler =
                Sub(sender As Object, e As TabControlCancelEventArgs)
                    If e.TabPageIndex < 0 Then
                        Exit Sub
                    End If
 
                    Select Case e.Action
                        Case TabControlAction.Selecting, TabControlAction.Selected
                            e.Cancel = TabControlExtensions.disabledTabs.Contains(e.TabPage)
                        Case Else
                            Exit Sub
                    End Select
                End Sub
        End If
 
        For Each tabPage As TabPage In tabPages
            If tabPage Is Nothing Then
                Throw New NullReferenceException($"{NameOf(tabPage)} object is null.")
            End If
 
            ' Disable or enable the tab page.
            tabPage.Enabled = enabled
 
            If Not enabled Then ' Disable the tab header.
                Dim success As Boolean = disabledTabs.Add(tabPage)
                If success AndAlso Not TabControlExtensions.tabHandlerAddedControls.Contains(tabControl) Then
                    AddHandler tabControl.Selecting, TabControlExtensions.tabDisablerHandler
                    TabControlExtensions.tabHandlerAddedControls.Add(tabControl)
                End If
            Else ' Enable the tab header.
                Dim success As Boolean = disabledTabs.Remove(tabPage)
                If success AndAlso TabControlExtensions.tabHandlerAddedControls.Contains(tabControl) AndAlso
                               Not TabControlExtensions.disabledTabs.Any() Then
                    RemoveHandler tabControl.Selecting, TabControlExtensions.tabDisablerHandler
                    TabControlExtensions.tabHandlerAddedControls.Remove(tabControl)
                End If
            End If
        Next tabPage
 
    End Sub
 
End Module

' Aplica recursos de localización a un form específico
Dim form As Form = Me
Dim cultureName As String = "es-ES"
ApplyCultureResources(form, cultureName)

' Aplica recursos de localización a todos los forms de la aplicación
Dim cultureName As String = "es-ES"
ApplyCultureResources(cultureName)

Culture: English (en), Component: Form1                 , Text: My Form
Culture: English (en), Component: Button1               , Text: My Button
Culture: English (en), Component: ToolStrip1            , Text: (null)
Culture: English (en), Component: ToolStripStatusLabel1 , Text: Testing
Culture: English (en), Component: MenuStrip1            , Text: (null)
Culture: English (en), Component: ToolStripMenuItem1    , Text: One
Culture: English (en), Component: ToolStripMenuItem2    , Text: Two
Culture: English (en), Component: TabControl1           , Text: (null)
Culture: English (en), Component: TabPage1              , Text: Page 1
Culture: English (en), Component: TabPage2              , Text: Page 2
Culture: English (en), Component: NotifyIcon1           , Text: Icon

Culture: Spanish (es), Component: Form1                 , Text: Mi Form
Culture: Spanish (es), Component: Button1               , Text: Mi Botón
Culture: Spanish (es), Component: ToolStrip1            , Text: (null)
Culture: Spanish (es), Component: ToolStripStatusLabel1 , Text: Probando
Culture: Spanish (es), Component: MenuStrip1            , Text: (null)
Culture: Spanish (es), Component: ToolStripMenuItem1    , Text: Uno
Culture: Spanish (es), Component: ToolStripMenuItem2    , Text: Dos
Culture: Spanish (es), Component: TabControl1           , Text: (null)
Culture: Spanish (es), Component: TabPage1              , Text: Página 1
Culture: Spanish (es), Component: TabPage2              , Text: Página 2
Culture: Spanish (es), Component: NotifyIcon1           , Text: Icono

''' <summary>
''' Provides extension methods for the <see cref="WinForms.IContainerControl"/> interface.
''' </summary>
<HideModuleName>
Public Module IContainerControlExtensions
 
 
    ''' <summary>
    ''' Gets the underlying <see cref="System.ComponentModel.ComponentCollection"/> collection
    ''' of the source <see cref="IContainerControl"/>.
    ''' </summary>
    ''' 
    ''' <param name="container">
    ''' The source <see cref="IContainerControl"/>.
    ''' </param>
    ''' 
    ''' <returns>
    ''' The underlying <see cref="System.ComponentModel.ComponentCollection"/> collection
    ''' of the source <see cref="IContainerControl"/>.
    ''' </returns>
    <DebuggerStepThrough>
    <Extension>
    <EditorBrowsable(EditorBrowsableState.Always)>
    Public Function GetComponentCollection(container As IContainerControl) As ComponentCollection
        Dim type As Type = container.GetType()
        Dim componentsField As FieldInfo = type.GetField("components", BindingFlags.NonPublic Or BindingFlags.Instance)
 
        If componentsField Is Nothing Then
            Throw New InvalidOperationException("""components"" field was not found through Reflection.")
        End If
 
        Dim containerComponents As IContainer = TryCast(componentsField.GetValue(container), IContainer)
        Return containerComponents?.Components
    End Function
 
End Module

''' <summary>
''' This method sets the current UI culture to the specified culture name,
''' then applies culture-specific resources to the specified <see cref="Form"/>, 
''' to its controls and child controls, including menus and their items, and 
''' the components in the form's <see cref="ComponentCollection"/>, recursively.
''' </summary>
''' 
''' <example> This is a code example.
''' <code language="VB">
''' Dim form As Form = Me
''' Dim cultureName As String = "es-ES"
''' ApplyCultureResources(form, cultureName)
''' </code>
''' </example>
''' 
''' <param name="form">
''' The form to apply resources to.
''' </param>
''' 
''' <param name="cultureName">
''' The culture name of the resources to apply.
''' </param>
Public Shared Sub ApplyCultureResources(form As Form, cultureName As String)
 
    Dim culture As CultureInfo = CultureInfo.GetCultureInfo(cultureName)
#If Not NETCOREAPP Then
            My.Application.ChangeUICulture(cultureName)
#Else
            Thread.CurrentThread.CurrentUICulture = culture
#End If
 
    Dim resources As New ComponentResourceManager(form.GetType())
 
    ' Action delegate that applies resources to an IComponent.
    Dim applyResources As Action(Of IComponent, String) =
        Sub(component As IComponent, name As String)
            If String.IsNullOrEmpty(name) Then
                ' Not valid to apply localization resources.
                Exit Sub
            Else
                resources.ApplyResources(component, name, culture)
            End If
 
            ' Applies resources to the items and subitems of a ToolStrip component, recursively.
            If TypeOf component Is ToolStrip Then
                Dim ts As ToolStrip = DirectCast(component, ToolStrip)
                ToolStripExtensions.ForEachItem(ts, recursive:=True, Sub(item) applyResources(item, item.Name))
            End If
 
#If DEBUG Then ' Prints debug information.
            ' Flags to retrieve the "Text" property of a component.
            Const textPropBindingFlags As BindingFlags =
                BindingFlags.Instance Or BindingFlags.Static Or
                BindingFlags.Public Or BindingFlags.NonPublic
 
            Dim textProp As PropertyInfo =
                (From prop As PropertyInfo In component.GetType().GetProperties(textPropBindingFlags)
                 Where prop.PropertyType Is GetType(String) AndAlso
                       prop.Name.Equals("Text", StringComparison.OrdinalIgnoreCase)
                ).SingleOrDefault()
 
            Dim text As String = DirectCast(textProp?.GetValue(component), String)
            If String.IsNullOrEmpty(text) Then
                text = "(null)"
            End If
            Debug.WriteLine($"Culture: {culture.EnglishName} ({culture.Name}), Component: {name,-40}, Text: {text}")
#End If
        End Sub
 
    ' Apply resources to the form.
    applyResources(form, form.Name)
 
    ' Apply resources to the controls hosted in the form, recursively.
    FormExtensions.ForEachControl(form, recursive:=True, Sub(ctrl) applyResources(ctrl, ctrl.Name))
 
    ' Apply resources to the components hosted in the ComponentCollection of the form.
    Dim components As ComponentCollection = IContainerControlExtensions.GetComponentCollection(form)
    If components IsNot Nothing Then
        ' Flags to retrieve the "Name" property of a component.
        Const namePropBindingFlags As BindingFlags =
            BindingFlags.Instance Or BindingFlags.Static Or
            BindingFlags.Public Or BindingFlags.NonPublic
 
        For Each component As IComponent In components
            Dim nameProp As PropertyInfo =
                  (From prop As PropertyInfo In component.GetType().GetProperties(namePropBindingFlags)
                   Where prop.PropertyType Is GetType(String) AndAlso
                         prop.Name.Equals("Name", StringComparison.OrdinalIgnoreCase)
                  ).SingleOrDefault()
 
            Dim name As String = DirectCast(nameProp?.GetValue(component), String)
            applyResources(component, name)
        Next component
    End If
 
    ' This code finds and applies resources to component fields declared at the form level 
    ' (including those in the auto-generated code of the form designer) that doesn't have 
    ' defined a "Name" property (such as NotifyIcon, ColorDialog, OpenFileDialog, etc).
    Const fieldsBindingFlags As BindingFlags =
        BindingFlags.Instance Or BindingFlags.DeclaredOnly Or BindingFlags.Static Or
        BindingFlags.Public Or BindingFlags.NonPublic
 
    Dim fields As IEnumerable(Of FieldInfo) =
                From field As FieldInfo In form.GetType().GetFields(fieldsBindingFlags)
                Where GetType(IComponent).IsAssignableFrom(field.FieldType) AndAlso
                  Not GetType(Control).IsAssignableFrom(field.FieldType) AndAlso
                  Not GetType(ToolStripItem).IsAssignableFrom(field.FieldType)
 
    For Each field As FieldInfo In fields
        Dim component As IComponent = DirectCast(field.GetValue(form), IComponent)
        Dim name As String = field.Name.TrimStart("_"c) ' E.g.: "_NotifyIcon1" -> "NotifyIcon1"
        applyResources(component, name)
    Next field
 
End Sub

''' <summary>
''' This method sets the current UI culture to the specified culture name,
''' then applies culture-specific resources to the open forms of the current application, 
''' to its controls and child controls, including menus and their items, and 
''' the components in the form's <see cref="ComponentCollection"/>, recursively.
''' </summary>
''' 
''' <example> This is a code example.
''' <code language="VB">
''' Dim cultureName As String = "es-ES"
''' ApplyCultureResources(cultureName)
''' </code>
''' </example>
''' 
''' <param name="cultureName">
''' The culture name of the resources to apply.
''' </param>
Public Shared Sub ApplyCultureResources(cultureName As String)
    For Each form As Form In System.Windows.Forms.Application.OpenForms
        ApplyCultureResources(form, cultureName)
    Next form
End Sub

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security;
using System.Threading;
 
using DevCase.Win32;
using DevCase.Win32.Enums;
 
namespace DevCase {
 
    namespace Core.IO.Devices.Input {
 
        /// <summary>
        /// Provides mouse interaction related utilities.
        /// </summary>
        internal sealed class UtilMouse {
 
            [DebuggerNonUserCode]
            private UtilMouse() { }
 
            /// <summary>
            /// Defines a button message to send to a window.
            /// </summary>
            internal enum MouseButtonMessage : int {
                LeftDown = WindowMessages.WM_LButtonDown,
                LeftUp = WindowMessages.WM_LButtonUp,
                RightDown = WindowMessages.WM_RButtonDown,
                RightUp = WindowMessages.WM_RButtonUp,
                MiddleDown = WindowMessages.WM_MButtonDown,
                MiddleUp = WindowMessages.WM_MButtonUp,
                WheelDown,
                WheelUp,
                WheelLeft,
                WheelRight
 
            }
 
            /// <summary>
            /// Defines a click of a mouse button.
            /// </summary>
            internal enum MouseButtonClick : int {
                LeftButton,
                RightButton,
                MiddleButton
            }
 
            /// <summary>
            /// Sends a mouse button message to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.SendMessage"/> function.
            /// </summary>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonMessage(IntPtr hWnd, MouseButtonMessage button, Point pt) {
                return UtilMouse.SendMouseButtonMessage_Internal(hWnd, button, pt, async: false);
            }
 
            /// <summary>
            /// Asynchronouslly sends a mouse button message to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.PostMessage"/> function.
            /// </summary>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonMessageAsync(IntPtr hWnd, MouseButtonMessage button, Point pt) {
                return UtilMouse.SendMouseButtonMessage_Internal(hWnd, button, pt, async: true);
            }
 
            /// <summary>
            /// Sends a mouse button click to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.SendMessage"/> function.
            /// </summary>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonClick(IntPtr hWnd, MouseButtonClick button, Point pt) {
                return UtilMouse.SendMouseButtonClick_Internal(hWnd, button, pt, async: false);
            }
 
            /// <summary>
            /// Asynchronouslly sends a mouse button click to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.PostMessage"/> function.
            /// </summary>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonClickAsync(IntPtr hWnd, MouseButtonClick button, Point pt) {
                return UtilMouse.SendMouseButtonClick_Internal(hWnd, button, pt, async: true);
            }
 
            /// <summary>
            /// *** FOR INTERNAL USE ONLY ***
            /// <para></para>
            /// Sends a mouse button message to the specified window, 
            /// on the specified coordinates relative to its client-area.
            /// </summary>
            private static bool SendMouseButtonMessage_Internal(IntPtr hWnd, MouseButtonMessage button, Point pt, bool async) {
 
                if (pt == null) {
                    pt = Point.Empty;
                }
 
                Delegate msgFunc = async ?
                    (Delegate)(new Func<IntPtr, WindowMessages, IntPtr, IntPtr, bool>(NativeMethods.PostMessage)) :
                    (Delegate)(new Func<IntPtr, WindowMessages, IntPtr, IntPtr, IntPtr>(NativeMethods.SendMessage));
 
                WindowMessages msg = (WindowMessages)button;
                IntPtr lParam = UtilWin32.MakeLParam(pt.X, pt.Y);
                IntPtr wParam = System.IntPtr.Zero;
 
                switch (button) {
                    case MouseButtonMessage.LeftUp:
                    case MouseButtonMessage.RightUp:
                    case MouseButtonMessage.MiddleUp:
                        wParam = IntPtr.Zero;
                        break;
 
                    case MouseButtonMessage.LeftDown:
                        wParam = new IntPtr((int)WParams.MK_LButton);
                        break;
 
                    case MouseButtonMessage.RightDown:
                        wParam = new IntPtr((int)WParams.MK_RButton);
                        break;
 
                    case MouseButtonMessage.MiddleDown:
                        wParam = new IntPtr((int)WParams.MK_MButton);
                        break;
 
                    case MouseButtonMessage.WheelDown:
                        msg = WindowMessages.WM_MouseWheel;
                        wParam = UtilWin32.MakeLParam(0, -120);
                        break;
 
                    case MouseButtonMessage.WheelUp:
                        msg = WindowMessages.WM_MouseWheel;
                        wParam = UtilWin32.MakeLParam(0, 120);
                        break;
 
                    case MouseButtonMessage.WheelLeft:
                        msg = WindowMessages.WM_MouseHWheel;
                        wParam = UtilWin32.MakeLParam(0, -120);
                        break;
 
                    case MouseButtonMessage.WheelRight:
                        msg = WindowMessages.WM_MouseHWheel;
                        wParam = UtilWin32.MakeLParam(0, 120);
                        break;
 
                    default:
                        throw new InvalidEnumArgumentException(nameof(button), (int)button, typeof(MouseButtonMessage));
                }
 
                // Ensures the target window has focus.
                NativeMethods.SetFocus(hWnd);
 
                object success = msgFunc.DynamicInvoke(hWnd, msg, wParam, lParam);
                return (async ? (bool)success : (IntPtr)success == IntPtr.Zero);
            }
 
            /// <summary>
            /// *** FOR INTERNAL USE ONLY ***
            /// <para></para>
            /// Sends a mouse button click to the specified window, 
            /// on the specified coordinates relative to its client-area.
            /// </summary>
            private static bool SendMouseButtonClick_Internal(IntPtr hWnd, MouseButtonClick button, Point pt, bool async) {
 
                MouseButtonMessage msgButtonDown;
                MouseButtonMessage msgButtonUp;
 
                switch (button) {
                    case MouseButtonClick.LeftButton:
                        msgButtonDown = MouseButtonMessage.LeftDown;
                        msgButtonUp = MouseButtonMessage.LeftUp;
                        break;
 
                    case MouseButtonClick.RightButton:
                        msgButtonDown = MouseButtonMessage.RightDown;
                        msgButtonUp = MouseButtonMessage.RightUp;
                        break;
 
                    case MouseButtonClick.MiddleButton:
                        msgButtonDown = MouseButtonMessage.MiddleDown;
                        msgButtonUp = MouseButtonMessage.MiddleUp;
                        break;
 
                    default:
                        throw new InvalidEnumArgumentException(nameof(button), (int)button, typeof(MouseButtonClick));
                }
 
                // Milliseconds to wait between sequentially sendig WM_#BUTTON_DOWN + WM_#BUTTON_UP message combination.
                const int msgIntervalMs = 100;
 
                bool successButtonDown = UtilMouse.SendMouseButtonMessage_Internal(hWnd, msgButtonDown, pt, async);
                Thread.Sleep(msgIntervalMs);
                bool successButtonUp = UtilMouse.SendMouseButtonMessage_Internal(hWnd, msgButtonUp, pt, async);
 
                return successButtonDown & successButtonUp;
            }
 
        }
 
    }
 
    namespace Win32 {
 
        /// <summary>
        /// Platform Invocation (P/Invoke) methods, access unmanaged code.
        /// </summary>
        [SuppressUnmanagedCodeSecurity]
        internal sealed class NativeMethods {
 
            [DebuggerNonUserCode]
            private NativeMethods() { }
 
            #region  User32.dll 
 
            /// <summary>
            /// Sets the keyboard focus to the specified window. 
            /// <para></para>
            /// The window must be attached to the calling thread's message queue.
            /// </summary>
            [DllImport("User32.dll", SetLastError = true)]
            internal static extern IntPtr SetFocus([In, Optional] IntPtr hWnd);
 
            /// <summary>
            /// Sends the specified message to a window or windows.
            /// <para></para>
            /// The SendMessage function calls the window procedure for the specified window
            /// and does not return until the window procedure has processed the message.
            /// </summary>
            [DllImport("User32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto, SetLastError = true)]
            [return: MarshalAs(UnmanagedType.SysInt)]
            internal static extern IntPtr SendMessage([In, MarshalAs(UnmanagedType.SysInt)] IntPtr hWnd,
                                                      [In, MarshalAs(UnmanagedType.I4)] WindowMessages msg,
                                                      [In, MarshalAs(UnmanagedType.SysInt)] IntPtr wParam,
                                                      [In, MarshalAs(UnmanagedType.SysInt)] IntPtr lParam);
 
            /// <summary>
            /// Places (posts) a message in the message queue associated with the thread that created 
            /// the specified window and returns without waiting for the thread to process the message.
            /// </summary>
            [DllImport("User32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto, SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            internal static extern bool PostMessage([In, Optional, MarshalAs(UnmanagedType.SysInt)] IntPtr hWnd, 
                                                    [In, MarshalAs(UnmanagedType.I4)] WindowMessages msg,
                                                    [In, MarshalAs(UnmanagedType.SysInt)] IntPtr wparam, 
                                                    [In, MarshalAs(UnmanagedType.SysInt)] IntPtr lparam);
 
            #endregion
        }
 
        /// <summary>
        /// Provides Windows API related utilites.
        /// </summary>
        internal sealed class UtilWin32 {
 
            [DebuggerNonUserCode]
            private UtilWin32() { }
 
            /// <summary>
            /// Creates a LONG Param (LParam) value for a window message, from two <see cref="Integer"/> values.
            /// <para></para>
            /// You must call this method if you need to use negative values.
            /// </summary>
            [DebuggerStepThrough]
            internal static IntPtr MakeLParam(int lo, int hi) {
                byte[] loBytes = { BitConverter.GetBytes(lo)[0], BitConverter.GetBytes(lo)[1] };
                byte[] hiBytes = { BitConverter.GetBytes(hi)[0], BitConverter.GetBytes(hi)[1] };
                byte[] combined = loBytes.Concat(hiBytes).ToArray();
 
                return new IntPtr(BitConverter.ToInt32(combined, 0));
            }
 
            /// <summary>
            /// Creates a LONG Param (LParam) value for a window message, from two <see cref="UShort"/> values.
            /// </summary>
            [DebuggerStepThrough]
            internal static IntPtr MakeLParam(ushort loWord, ushort hiWord) {
                return new IntPtr(UtilWin32.MakeDWord(loWord, hiWord));
            }
 
            /// <summary>
            /// Creates a Double WORD (DWORD, 32-Bit Unsigned Integer) value from a LOWORD and a HIWORD value.
            /// </summary>
            [DebuggerStepThrough]
            internal static uint MakeDWord(ushort loWord, ushort hiWord) {
                byte[] loBytes = BitConverter.GetBytes(loWord);
                byte[] hiBytes = BitConverter.GetBytes(hiWord);
                byte[] combined = loBytes.Concat(hiBytes).ToArray();
 
                return BitConverter.ToUInt32(combined, 0);
            }
        }
    }
 
    namespace Win32.Enums {
 
        /// <summary>
        /// Defines additional message-specific information for the WORD Param (WParam) value of window messages.
        /// </summary>
        internal enum WParams : int {
            Null = 0x0,
            MK_LButton = 0x1,
            MK_MButton = 0x10,
            MK_RButton = 0x2
        }
 
        /// <summary>
        /// Defines window messages.
        /// </summary>
        internal enum WindowMessages : int {
            WM_LButtonDown = 0x201,
            WM_LButtonUp = 0x202,
            WM_MButtonDown = 0x207,
            WM_MButtonUp = 0x208,
            WM_RButtonDown = 0x204,
            WM_RButtonUp = 0x205,
            WM_XButtonDown = 0x20B,
            WM_XButtonUp = 0x20C,
            WM_MouseWheel = 0x20A,
            WM_MouseHWheel = 0x20E
        }
 
    }
 
}

• SimulateMouseButtonAction (que internamente llamará a la función SendMessage)
• SimulateMouseButtonActionAsync (que internamente llamará a la función PostMessage)

• https://learn.microsoft.com/windows/win32/api/winuser/nf-winuser-sendinput

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security;
using System.Threading;
using System.Windows.Forms;
 
using DevCase.Win32;
using DevCase.Win32.Enums;
 
namespace DevCase {
 
    namespace Core.IO.Devices.Input {
 
        /// <summary>
        /// Provides mouse interaction related utilities.
        /// </summary>
        internal sealed class UtilMouse {
 
            /// <summary>
            /// Prevents a default instance of the <see cref="UtilMouse"/> class from being created.
            /// </summary>
            [DebuggerNonUserCode]
            private UtilMouse() { }
 
            /// <summary>
            /// Defines a button message to send to a window.
            /// </summary>
            internal enum MouseButtonMessage : int {
 
                /// <summary>
                /// Hold down the left mouse button.
                /// </summary>
                LeftDown = WindowMessages.WM_LButtonDown,
 
                /// <summary>
                /// Release up the left mouse button.
                /// </summary>
                LeftUp = WindowMessages.WM_LButtonUp,
 
                /// <summary>
                /// Hold down the right mouse button.
                /// </summary>
                RightDown = WindowMessages.WM_RButtonDown,
 
                /// <summary>
                /// Release up the right mouse button.
                /// </summary>
                RightUp = WindowMessages.WM_RButtonUp,
 
                /// <summary>
                /// Hold down the middle mouse button.
                /// </summary>
                MiddleDown = WindowMessages.WM_MButtonDown,
 
                /// <summary>
                /// Release up the middle mouse button.
                /// </summary>
                MiddleUp = WindowMessages.WM_MButtonUp,
 
                /// <summary>
                /// Move down the mouse wheel.
                /// </summary>
                WheelDown,
 
                /// <summary>
                /// Move up the mouse wheel.
                /// </summary>
                WheelUp,
 
                /// <summary>
                /// Tilt horizontal mouse wheel to left.
                /// </summary>
                WheelLeft,
 
                /// <summary>
                /// Tilt horizontal mouse wheel to right.
                /// </summary>
                WheelRight
 
            }
 
            /// <summary>
            /// Defines a click of a mouse button.
            /// </summary>
            internal enum MouseButtonClick : int {
 
                /// <summary>
                /// Left mouse button click.
                /// </summary>
                LeftButton,
 
                /// <summary>
                /// Right mouse button click.
                /// </summary>
                RightButton,
 
                /// <summary>
                /// Middle mouse button click.
                /// </summary>
                MiddleButton
            }
 
            /// <summary>
            /// Sends a mouse button message to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.SendMessage"/> function.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the target window.
            /// </param>
            /// 
            /// <param name="button">
            /// The mouse button message to send.
            /// </param>
            /// 
            /// <param name="pt">
            /// The coordinates within the client area of the window, 
            /// where to send the mouse button message.
            /// </param>
            /// 
            /// <returns>
            /// <see langword="True"/> if the function succeeds; otherwise, <see langword="False"/>.
            /// </returns>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonMessage(IntPtr hWnd, MouseButtonMessage button, Point pt) {
                return UtilMouse.SendMouseButtonMessage_Internal(hWnd, button, pt, async: false);
            }
 
            /// <summary>
            /// Asynchronouslly sends a mouse button message to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.PostMessage"/> function.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the target window.
            /// </param>
            /// 
            /// <param name="button">
            /// The mouse button message to send.
            /// </param>
            /// 
            /// <param name="pt">
            /// The coordinates within the client area of the window, 
            /// where to send the mouse button message.
            /// </param>
            /// 
            /// <returns>
            /// <see langword="True"/> if the function succeeds; otherwise, <see langword="False"/>.
            /// </returns>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonMessageAsync(IntPtr hWnd, MouseButtonMessage button, Point pt) {
                return UtilMouse.SendMouseButtonMessage_Internal(hWnd, button, pt, async: true);
            }
 
            /// <summary>
            /// Sends a mouse button click to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.SendMessage"/> function.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the target window.
            /// </param>
            /// 
            /// <param name="button">
            /// The mouse button click to send.
            /// </param>
            /// 
            /// <param name="pt">
            /// The coordinates within the client area of the window, 
            /// where to send the mouse button click.
            /// </param>
            /// 
            /// <returns>
            /// <see langword="True"/> if the function succeeds; otherwise, <see langword="False"/>.
            /// </returns>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonClick(IntPtr hWnd, MouseButtonClick button, Point pt) {
                return UtilMouse.SendMouseButtonClick_Internal(hWnd, button, pt, async: false);
            }
 
            /// <summary>
            /// Asynchronouslly sends a mouse button click to the specified window, 
            /// on the specified coordinates relative to its client-area,
            /// by calling <see cref="Win32.NativeMethods.PostMessage"/> function.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the target window.
            /// </param>
            /// 
            /// <param name="button">
            /// The mouse button click to send.
            /// </param>
            /// 
            /// <param name="pt">
            /// The coordinates within the client area of the window, 
            /// where to send the mouse button click.
            /// </param>
            /// 
            /// <returns>
            /// <see langword="True"/> if the function succeeds; otherwise, <see langword="False"/>.
            /// </returns>
            [DebuggerStepThrough]
            internal static bool SendMouseButtonClickAsync(IntPtr hWnd, MouseButtonClick button, Point pt) {
                return UtilMouse.SendMouseButtonClick_Internal(hWnd, button, pt, async: true);
            }
 
            /// <summary>
            /// *** FOR INTERNAL USE ONLY ***
            /// <para></para>
            /// Sends a mouse button message to the specified window, 
            /// on the specified coordinates relative to its client-area.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the target window.
            /// </param>
            /// 
            /// <param name="button">
            /// The mouse button message to send.
            /// </param>
            /// 
            /// <param name="pt">
            /// The coordinates within the client area of the window, 
            /// where to send the mouse button message.
            /// </param>
            /// 
            /// <param name="async">
            /// If <see langword="True"/>, calls PostMessage function rather than SendMessage.
            /// </param>
            /// 
            /// <returns>
            /// <see langword="True"/> if the function succeeds; otherwise, <see langword="False"/>.
            /// </returns>
            private static bool SendMouseButtonMessage_Internal(IntPtr hWnd, MouseButtonMessage button, Point pt, bool async) {
 
                if (pt == null) {
                    pt = Point.Empty;
                }
 
                Delegate msgFunc = async ?
                    (Delegate)(new Func<IntPtr, WindowMessages, IntPtr, IntPtr, bool>(NativeMethods.PostMessage)) :
                    (Delegate)(new Func<IntPtr, WindowMessages, IntPtr, IntPtr, IntPtr>(NativeMethods.SendMessage));
 
                WindowMessages msg = (WindowMessages)button;
                IntPtr lParam = UtilWin32.MakeLParam(pt.X, pt.Y);
                IntPtr wParam = System.IntPtr.Zero;
 
                switch (button) {
                    case MouseButtonMessage.LeftUp:
                    case MouseButtonMessage.RightUp:
                    case MouseButtonMessage.MiddleUp:
                        wParam = IntPtr.Zero;
                        break;
 
                    case MouseButtonMessage.LeftDown:
                        wParam = new IntPtr((int)WParams.MK_LButton);
                        break;
 
                    case MouseButtonMessage.RightDown:
                        wParam = new IntPtr((int)WParams.MK_RButton);
                        break;
 
                    case MouseButtonMessage.MiddleDown:
                        wParam = new IntPtr((int)WParams.MK_MButton);
                        break;
 
                    case MouseButtonMessage.WheelDown:
                        msg = WindowMessages.WM_MouseWheel;
                        wParam = UtilWin32.MakeLParam(0, -120);
                        break;
 
                    case MouseButtonMessage.WheelUp:
                        msg = WindowMessages.WM_MouseWheel;
                        wParam = UtilWin32.MakeLParam(0, 120);
                        break;
 
                    case MouseButtonMessage.WheelLeft:
                        msg = WindowMessages.WM_MouseHWheel;
                        wParam = UtilWin32.MakeLParam(0, -120);
                        break;
 
                    case MouseButtonMessage.WheelRight:
                        msg = WindowMessages.WM_MouseHWheel;
                        wParam = UtilWin32.MakeLParam(0, 120);
                        break;
 
                    default:
                        throw new InvalidEnumArgumentException(nameof(button), (int)button, typeof(MouseButtonMessage));
                }
 
                // Ensures the target window has focus.
                NativeMethods.SetFocus(hWnd);
 
                object success = msgFunc.DynamicInvoke(hWnd, msg, wParam, lParam);
                return (async ? (bool)success : (IntPtr)success == IntPtr.Zero);
            }
 
            /// <summary>
            /// *** FOR INTERNAL USE ONLY ***
            /// <para></para>
            /// Sends a mouse button click to the specified window, 
            /// on the specified coordinates relative to its client-area.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the target window.
            /// </param>
            /// 
            /// <param name="button">
            /// The mouse button click to send.
            /// </param>
            /// 
            /// <param name="pt">
            /// The coordinates within the client area of the window, 
            /// where to send the mouse button click.
            /// </param>
            /// 
            /// <param name="async">
            /// If <see langword="True"/>, calls PostMessage function rather than SendMessage.
            /// </param>
            /// 
            /// <returns>
            /// <see langword="True"/> if the function succeeds; otherwise, <see langword="False"/>.
            /// </returns>
            private static bool SendMouseButtonClick_Internal(IntPtr hWnd, MouseButtonClick button, Point pt, bool async) {
 
                MouseButtonMessage msgButtonDown;
                MouseButtonMessage msgButtonUp;
 
                switch (button) {
                    case MouseButtonClick.LeftButton:
                        msgButtonDown = MouseButtonMessage.LeftDown;
                        msgButtonUp = MouseButtonMessage.LeftUp;
                        break;
 
                    case MouseButtonClick.RightButton:
                        msgButtonDown = MouseButtonMessage.RightDown;
                        msgButtonUp = MouseButtonMessage.RightUp;
                        break;
 
                    case MouseButtonClick.MiddleButton:
                        msgButtonDown = MouseButtonMessage.MiddleDown;
                        msgButtonUp = MouseButtonMessage.MiddleUp;
                        break;
 
                    default:
                        throw new InvalidEnumArgumentException(nameof(button), (int)button, typeof(MouseButtonClick));
                }
 
                // Milliseconds to wait between sequentially sendig WM_#BUTTON_DOWN + WM_#BUTTON_UP message combination.
                const int msgIntervalMs = 100;
 
                bool successButtonDown = UtilMouse.SendMouseButtonMessage_Internal(hWnd, msgButtonDown, pt, async);
                Thread.Sleep(msgIntervalMs);
                bool successButtonUp = UtilMouse.SendMouseButtonMessage_Internal(hWnd, msgButtonUp, pt, async);
 
                return successButtonDown & successButtonUp;
            }
 
        }
 
    }
 
    namespace Win32 {
 
        /// <summary>
        /// Platform Invocation (P/Invoke) methods, access unmanaged code.
        /// </summary>
        [SuppressUnmanagedCodeSecurity]
        internal sealed class NativeMethods {
 
            /// <summary>
            /// Prevents a default instance of the <see cref="NativeMethods"/> class from being created.
            /// </summary>
            [DebuggerNonUserCode]
            private NativeMethods() { }
 
            #region  User32.dll 
 
            /// <summary>
            /// Sets the keyboard focus to the specified window. 
            /// <para></para>
            /// The window must be attached to the calling thread's message queue.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the window that will receive the keyboard input. 
            /// <para></para>
            /// If this parameter is <see cref="IntPtr.Zero"/>, keystrokes are ignored.
            /// </param>
            /// 
            /// <returns>
            /// If the function succeeds, the return value is the handle to the window that previously had the keyboard focus. 
            /// <para></para>
            /// If the <paramref name="hWnd"/> parameter is invalid or 
            /// the window is not attached to the calling thread's message queue, 
            /// the return value is <see cref="IntPtr.Zero"/>. 
            /// <para></para>
            /// To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
            /// </returns>
            [DllImport("User32.dll", SetLastError = true)]
            internal static extern IntPtr SetFocus([In, Optional] IntPtr hWnd);
 
            /// <summary>
            /// Sends the specified message to a window or windows.
            /// <para></para>
            /// The SendMessage function calls the window procedure for the specified window
            /// and does not return until the window procedure has processed the message.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// A handle to the window whose window procedure will receive the message.
            /// </param>
            /// 
            /// <param name="msg">
            /// The message to be sent.
            /// </param>
            /// 
            /// <param name="wParam">
            /// Additional message-specific information.
            /// </param>
            /// 
            /// <param name="lParam">
            /// Additional message-specific information.
            /// </param>
            /// 
            /// <returns>
            /// The return value specifies the result of the message processing; it depends on the message sent.
            /// </returns>
            [DllImport("User32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto, SetLastError = true)]
            [return: MarshalAs(UnmanagedType.SysInt)]
            internal static extern IntPtr SendMessage([In, MarshalAs(UnmanagedType.SysInt)] IntPtr hWnd,
                                                      [In, MarshalAs(UnmanagedType.I4)] WindowMessages msg,
                                                      [In, MarshalAs(UnmanagedType.SysInt)] IntPtr wParam,
                                                      [In, MarshalAs(UnmanagedType.SysInt)] IntPtr lParam);
 
            /// <summary>
            /// Places (posts) a message in the message queue associated with the thread that created 
            /// the specified window and returns without waiting for the thread to process the message.
            /// </summary>
            /// 
            /// <param name="hWnd">
            /// Handle to the window whose window procedure will receive the message.
            /// <para></para>
            /// If this parameter is WindowMessages.HWND_Broadcast, 
            /// the message is sent to all top-level windows in the system, 
            /// including disabled or invisible unowned windows, overlapped windows, and pop-up windows; 
            /// but the message is not sent to child windows.
            /// </param>
            /// 
            /// <param name="msg">
            /// The message to be sent.
            /// </param>
            /// 
            /// <param name="wparam">
            /// Additional message-specific information.
            /// </param>
            /// 
            /// <param name="lparam">
            /// Additional message-specific information.
            /// </param>
            /// 
            /// <returns>
            /// If the function succeeds, the return value is <see langword="true"/>.
            /// <para></para>
            /// If the function fails, the return value is <see langword="false"/>.
            /// <para></para>
            /// To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>. 
            /// </returns>
            [DllImport("User32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto, SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            internal static extern bool PostMessage([In, Optional, MarshalAs(UnmanagedType.SysInt)] IntPtr hWnd, 
                                                    [In, MarshalAs(UnmanagedType.I4)] WindowMessages msg,
                                                    [In, MarshalAs(UnmanagedType.SysInt)] IntPtr wparam, 
                                                    [In, MarshalAs(UnmanagedType.SysInt)] IntPtr lparam);
 
            #endregion
        }
 
        /// <summary>
        /// Provides Windows API related utilites.
        /// </summary>
        internal sealed class UtilWin32 {
 
            /// <summary>
            /// Prevents a default instance of the <see cref="UtilWin32"/> class from being created.
            /// </summary>
            [DebuggerNonUserCode]
            private UtilWin32() { }
 
            /// <summary>
            /// Creates a LONG Param (LParam) value for a window message, from two <see cref="Integer"/> values.
            /// <para></para>
            /// You must call this method if you need to use negative values.
            /// <para></para>
            /// <seealso cref="Message.LParam"/>
            /// </summary>
            /// 
            /// <remarks>
            /// <see href="https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-makelparam"/>
            /// </remarks>
            /// 
            /// <example> This is a code example.
            /// <code language="VB.NET">
            /// Dim lParam as IntPtr = MakeLParam(Integer.MaxValue, Integer.MaxValue)
            /// </code>
            /// </example>
            /// 
            /// <param name="lo">
            /// The low-order <see cref="Integer"/> value.
            /// </param>
            /// 
            /// <param name="hi">
            /// The high-order <see cref="Integer"/> value.
            /// </param>
            /// 
            /// <returns>
            /// The resulting LParam value.
            /// </returns>
            [DebuggerStepThrough]
            internal static IntPtr MakeLParam(int lo, int hi) {
                byte[] loBytes = { BitConverter.GetBytes(lo)[0], BitConverter.GetBytes(lo)[1] };
                byte[] hiBytes = { BitConverter.GetBytes(hi)[0], BitConverter.GetBytes(hi)[1] };
                byte[] combined = loBytes.Concat(hiBytes).ToArray();
 
                return new IntPtr(BitConverter.ToInt32(combined, 0));
            }
 
            /// <summary>
            /// Creates a LONG Param (LParam) value for a window message, from two <see cref="UShort"/> values.
            /// <para></para>
            /// <seealso cref="Message.LParam"/>
            /// </summary>
            /// 
            /// <remarks>
            /// <see href="https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-makelparam"/>
            /// </remarks>
            /// 
            /// <example> This is a code example.
            /// <code language="VB.NET">
            /// Dim lParam as IntPtr = MakeLParam(UShort.MaxValue, UShort.MaxValue)
            /// </code>
            /// </example>
            /// 
            /// <param name="loWord">
            /// The low-order WORD value.
            /// </param>
            /// 
            /// <param name="hiWord">
            /// The high-order WORD value.
            /// </param>
            /// 
            /// <returns>
            /// The resulting LParam value.
            /// </returns>
            [DebuggerStepThrough]
            internal static IntPtr MakeLParam(ushort loWord, ushort hiWord) {
                return new IntPtr(UtilWin32.MakeDWord(loWord, hiWord));
            }
 
            /// <summary>
            /// Creates a Double WORD (DWORD, 32-Bit Unsigned Integer) value from a LOWORD and a HIWORD value.
            /// </summary>
            /// 
            /// <example> This is a code example.
            /// <code language="VB.NET">
            /// Dim value as UInteger = MakeDWord(UShort.MaxValue, UShort.MaxValue)
            /// </code>
            /// </example>
            /// 
            /// <param name="loWord">
            /// The low-order WORD.
            /// </param>
            /// 
            /// <param name="hiWord">
            /// The high-order WORD.
            /// </param>
            /// 
            /// <returns>
            /// The resulting DWORD value.
            /// </returns>
            [DebuggerStepThrough]
            internal static uint MakeDWord(ushort loWord, ushort hiWord) {
                byte[] loBytes = BitConverter.GetBytes(loWord);
                byte[] hiBytes = BitConverter.GetBytes(hiWord);
                byte[] combined = loBytes.Concat(hiBytes).ToArray();
 
                return BitConverter.ToUInt32(combined, 0);
            }
        }
    }
 
    namespace Win32.Enums {
 
        /// <summary>
        /// Defines additional message-specific information for the WORD Param (WParam) value of window messages.
        /// </summary>
        /// 
        /// <remarks>
        /// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms644927%28v=vs.85%29.aspx#system_defined"/>
        /// </remarks>
        internal enum WParams : int {
            /// <summary>
            /// A null WParam.
            /// </summary>
            Null = 0x0,
 
            /// <summary>
            /// The left mouse button is down.
            /// <para></para>
            /// wParam to use with <see cref="WindowMessages.WM_LButtonDown"/> message.
            /// </summary>
            MK_LButton = 0x1,
 
            /// <summary>
            /// The middle mouse button is down.
            /// <para></para>
            /// wParam to use with <see cref="WindowMessages.WM_LButtonDown"/> and <see cref="WindowMessages.WM_LButtonUp"/> messages.
            /// </summary>
            MK_MButton = 0x10,
 
            /// <summary>
            /// The right mouse button is down.
            /// <para></para>
            /// wParam to use with <see cref="WindowMessages.WM_LButtonDown"/> and <see cref="WindowMessages.WM_LButtonUp"/> messages.
            /// </summary>
            MK_RButton = 0x2
        }
 
        /// <summary>
        /// Defines window messages.
        /// <para></para>
        /// The system sends or posts a system-defined message when it communicates with an application. 
        /// <para></para>
        /// It uses these messages to control the operations of applications and to provide input and other information for applications to process. 
        /// <para></para>
        /// An application can also send or post system-defined messages.
        /// <para></para>
        /// Applications generally use these messages to control the operation of control windows created by using preregistered window classes.
        /// </summary>
        /// 
        /// <remarks>
        /// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms644927%28v=vs.85%29.aspx"/>
        /// </remarks>
        internal enum WindowMessages : int {
 
            /// <summary>
            /// The message is posted when the user presses the left mouse button while the cursor is in the 
            /// client area of a window. 
            /// <para></para>
            /// If the mouse is not captured the message is posted to the window beneath the cursor. 
            /// <para></para>
            /// Otherwise the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_LButtonDown = 0x201,
 
            /// <summary>
            /// The message is posted when the user releases the left mouse button while the cursor is in the 
            /// client area of a window. 
            /// <para></para>
            /// If the mouse is not captured the message is posted to the window beneath the cursor. 
            /// <para></para>
            /// Otherwise the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_LButtonUp = 0x202,
 
            /// <summary>
            /// The message is posted when the user presses the middle mouse button while the cursor is in the 
            /// client area of a window.
            /// <para></para>
            /// If the mouse is not captured the message is posted to the window beneath the cursor.
            /// <para></para>
            /// Otherwise the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_MButtonDown = 0x207,
 
            /// <summary>
            /// The message is posted when the user releases the middle mouse button while the cursor is in the 
            /// client area of a window. 
            /// <para></para>
            /// If the mouse is not captured the message is posted to the window beneath the cursor. 
            /// <para></para>
            /// Otherwise the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_MButtonUp = 0x208,
 
            /// <summary>
            /// The message is posted when the user presses the right mouse button while the cursor is in the 
            /// client area of a window.
            /// <para></para>
            /// If the mouse is not captured the message is posted to the window beneath the cursor.
            /// <para></para>
            /// Otherwise the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_RButtonDown = 0x204,
 
            /// <summary>
            /// The message is posted when the user releases the right mouse button while the cursor is in the 
            /// client area of a window.
            /// <para></para>
            /// If the mouse is not captured the message is posted to the window beneath the cursor.
            /// <para></para>
            /// Otherwise the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_RButtonUp = 0x205,
 
            /// <summary>
            /// Posted when the user presses the first or second X button while the cursor is in the client area of a window.
            /// <para></para>
            /// If the mouse is not captured, the message is posted to the window beneath the cursor.
            /// <para></para>
            /// Otherwise, the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_XButtonDown = 0x20B,
 
            /// <summary>
            /// Posted when the user releases the first or second X button while the cursor is in the client area of a window.
            /// <para></para>
            /// If the mouse is not captured, the message is posted to the window beneath the cursor.
            /// <para></para>
            /// Otherwise, the message is posted to the window that has captured the mouse.
            /// </summary>
            WM_XButtonUp = 0x20C,
 
            /// <summary>
            /// The message is sent to the focus window when the mouse wheel is rotated.
            /// <para></para>
            /// The <c>DefWindowProc</c> function propagates the message to the window's parent. 
            /// <para></para>
            /// There should be no internal forwarding of the message since <c>DefWindowProc</c> propagates it up the 
            /// parent chain until it finds a window that processes it.
            /// </summary>
            WM_MouseWheel = 0x20A,
 
            /// <summary>
            /// The message is sent to the focus window when the mouse's horizontal scroll wheel is tilted or rotated.
            /// <para></para>
            /// The <c>DefWindowProc</c> function propagates the message to the window's parent.
            /// <para></para>
            /// There should be no internal forwarding of the message since <c>DefWindowProc</c> propagates it up 
            /// the parent chain until it finds a window that processes it.
            /// </summary>
            WM_MouseHWheel = 0x20E
 
        }
 
    }
 
}

using System;
using System.Drawing;
using System.Windows.Forms;
 
using DevCase.Core.IO.Devices.Input;
 
namespace WindowsFormsApp1 {
 
    public partial class Form1 : Form {
        public Form1() {
            this.InitializeComponent();
        }
 
        private void Button1_Click(object sender, EventArgs e) {
            IntPtr hWnd = this.button2.Handle;
            Point pt = Point.Empty;
            bool success = UtilMouse.SendMouseButtonClick(hWnd, MouseButtonClick.LeftButton, pt);
 
            // O también:
            // bool success = 
            //     UtilMouse.SendMouseButtonMessage(hWnd, MouseButtonMessage.LeftDown, point) & 
            //     UtilMouse.SendMouseButtonMessage(hWnd, MouseButtonMessage.LeftUp, point);
 
            Console.WriteLine($"{nameof(success)}: {success}");
        }
 
        private void Button2_Click(object sender, EventArgs e) {
            MessageBox.Show("Button Clicked!");
        }
    }
}

• https://learn.microsoft.com/en-us/windows/win32/inputdev/wm-lbuttondown
• https://learn.microsoft.com/en-us/windows/win32/inputdev/wm-lbuttonup