Rehber C# Lowlevel hook kütüphanesi Winhooks nasıl kullanılır?

Bayram Reis · 1 Ekim 2025

Windows'taki user32.dll kütüphanesinden yararlanarak C# ile kernel level hook yapabilmemizi sağlayan Winhook artık public! Bütün eventleri, change'leri ve inputları izleyebilmenin yanında girişleri engellemenizi, kaydetmenizi, özelleştirmenizi, state durumlarını öğrenmenize yarar.

Nasıl kullanılır?

Winhooks (GitHub) Adresinden Winhooks'u indiriyoruz.
Veya direkt NuGet olarak.
Ben size göstermek amaçlı .NET 9 C# WinUI 3 oluşturuyorum.
Öncelikle bu projenin .NET 9 ve Minimum Windows 19041 sürümü gerektiğini size bildirmek isterim. İsterseniz kendiniz fork atıp eski versiyonlara da uyumlu hâle getirebilirsiniz. Ben yenilikçi olduğumdan .NET 9'u tercih ettim. Bazı özellikler 19041 ve .NET 9 altında da çalışabilir.

Winhook kütüphanesini ekliyoruz:

NOT: Mouse Down ve Up arasındaki event tetiklenmesi (Hold) için Windelay kütüphanesi gerekebilir. İlgili rehber için: Rehber: C#: Hassas bekleme kütüphanesi Windelay nasıl kullanılır?
Sonuç:

MainWindow.xaml kodları:

XML:

<Window
    x:Class="DllTester.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:DllTester"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" Title="Winhook WinUI 3 Test">
    <Window.SystemBackdrop>
        <MicaBackdrop />
    </Window.SystemBackdrop>
    <Grid>
        <ListBox x:Name="MyListBox" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>
    </Grid>
</Window>

MainWindow.xaml.cs kodları:

C#:

using static ReisProduction.Windelay.Models.DelayExecutor;
using ReisProduction.Windelay.Utilities.Enums;
using ReisProduction.Winhook.Utilities.Enums;
using ReisProduction.Windelay.Utilities;
using ReisProduction.Winhook.Utilities;
using System.Runtime.InteropServices;
using ReisProduction.Winhook.Models;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media;
using System.Threading.Tasks;
using System.Diagnostics;
using Microsoft.UI.Xaml;
using System.Threading;
using Windows.System;
using WinRT.Interop;
using System;
namespace DllTester;
public sealed partial class MainWindow : Window
{
    private readonly Winhook _winhook = new();
    public MainWindow()
    {
        InitializeComponent();
        MakeWindowAlwaysOnTop();
        InitializeInputHook();
        Task.Run(StartTest);
    }
    private static async void StartTest()
    {
        Random rnd = new();
        CancellationTokenSource cts = new();
        Debug.WriteLine("HybridDelay Test Başladı\n");
        //SpinWaitIterations = 10; // İsterseniz daha hassas yapabilirsiniz fakat gereksiz olur. Zaten 25 çok agresif bir hassaslık.
        // SpinWait için iterasyon sayısı (Varsayılan: İşlemci çekirdeğine göre değişir.)
        // public static int SpinWaitIterations { get; set; } = Math.Clamp(200 / Environment.ProcessorCount, 25, 100);
        //SpinAheadMilisecond = 500; // İsterseniz daha hassas yapabilirsiniz fakat iyi bilgisayarlar için gereksiz olur. Kötü bilgisayarlar için ise max 500ms yeterlidir.
        // HybridDelay için SpinAhead süresi (Varsayılan: 200ms)
        //public static int SpinAheadMilisecond { get; set; } = 200;
        for (int i = 0; i < 20; i++)
        {
            int ms = rnd.Next(200, 2000); // 200ms - 1000ms arası random süre
            DelayAction delay = new
            (
                ms,
                cts.Token, // İptal edebilmek için
                DelayType.HybridDelay // Delay türü (Burada HybridDelay kullanıldı) Sistemi en az yorarak en doğru sonucu verir.
                                      // Ancak DelayType vermek, sadece HandleDelay() methodunda geçerlidir.
            );

            Stopwatch sw = Stopwatch.StartNew();
            //HandleDelay(delay); // DelayType parametresi verilmezse, default olarak HybridDelay kullanılır.
            await HybridDelay(delay); // En sağlıklı ve önerilen yöntem budur.
            sw.Stop();

            double elapsed = sw.Elapsed.TotalMilliseconds,
                      diff = elapsed - ms;

            Debug.WriteLine($"Hedef: {ms,4:0000} MS | Beklenen: {elapsed,8:0000.00} MS | Sapma: {diff,8:+0000.00;-0000.00;+0000.00} MS");
        }
        Debug.WriteLine("\nTest Bitti.\nHighResSpin Test Başladı");
        for (int i = 0; i < 20; i++)
        {
            int ms = rnd.Next(10, 1000); // 10ms - 1000ms arası random süre
            DelayAction delay = new
            (
                ms,
                cts.Token, // İptal edebilmek için
                DelayType.HybridDelay // Delay türü (Burada HybridDelay kullanıldı) Sistemi en az yorarak en doğru sonucu verir.
                                      // Ancak DelayType vermek, sadece HandleDelay() methodunda geçerlidir.
            );

            Stopwatch sw = Stopwatch.StartNew();
            //HandleDelay(delay); // DelayType parametresi verilmezse, default olarak HybridDelay kullanılır.
            HighResSpin(delay); // En sağlıklı ve önerilen yöntem budur.
            sw.Stop();

            double elapsed = sw.Elapsed.TotalMilliseconds,
                      diff = elapsed - ms;

            Debug.WriteLine($"Hedef: {ms,4:0000} MS | Beklenen: {elapsed,8:0000.00} MS | Sapma: {diff,8:+0000.00;-0000.00;+0000.00} MS");
        }
        Debug.WriteLine("\nTest Bitti.");
    }
    [DllImport("user32.dll")]
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "SYSLIB1054:Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time", Justification = "<Pending>")]
    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "<Pending>")]
    private static extern bool SetWindowPos(nint hWnd, nint hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
    private static readonly nint HWND_TOPMOST = new(-1);
    private const uint
        SWP_NOSIZE = 0x0001,
        SWP_NOMOVE = 0x0002;
    private void MakeWindowAlwaysOnTop()
    {
        var hWnd = WindowNative.GetWindowHandle(this);
        SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
    }
    private void InitializeInputHook()
    {
        _winhook.FileCreated += (args) => AddMessage($"[FileCreated] Name: {args.Name}   |   Path:{args.FullPath}   |  Change Type: {args.ChangeType}");
        _winhook.FileDeleted += (args) => AddMessage($"[FileDeleted] Name: {args.Name}   |   Path:{args.FullPath}   |  Change Type: {args.ChangeType}");
        _winhook.FileRenamed += (args) => AddMessage($"[FileRenamed] Name: {args.Name}   |   Path:{args.FullPath}   |  Change Type: {args.ChangeType}");
        _winhook.FileChanged += (args) => AddMessage($"[FileChanged] Name: {args.Name}   |   Path:{args.FullPath}   |  Change Type: {args.ChangeType}");
        _winhook.FileWatcherError += (ex) => AddMessage($"[FileWatcherError] {ex.GetException().Message}");
        _winhook.MovementThreshold = 500; // Fare hareketi için eşik değeri (Move eventi tetiklenmesi için) (Varsayılan: 1)
        _winhook.AcceptNoneInput = true; // Klavye ve fareden gelen tüm girdileri kabul et (Varsayılan: false) (Yani sadece InputType enumunda olanlar) IsValid mantığı.
        _winhook.FilterKeys // Engellemek istediğiniz tuşları buraya ekleyin.
        (
            VirtualKey.V,
            VirtualKey.W,
            VirtualKey.E,
            VirtualKey.C,
            VirtualKey.Tab,
            VirtualKey.RightWindows,
            VirtualKey.Escape,
            VirtualKey.Space,
            VirtualKey.Left,
            VirtualKey.Up,
            VirtualKey.Right,
            VirtualKey.Down
        );
        _winhook.FilterMice // Engellemek istediğiniz fare tiplerini buraya ekleyin.
        (
            MouseType.MiddleButton,
            MouseType.XButton1,
            MouseType.XButton2,
            MouseType.MouseScrollLeft,
            MouseType.MouseScrollRight,
            MouseType.MouseScrollUp,
            MouseType.MouseScrollDown
        );
        _winhook.InputDown += k => AddMessage($"[InputDown] {k} (0x{(int)k:X})");
        _winhook.MouseHold += (k) => AddMessage($"[MouseHold] {k} (0x{(int)k:X})");
        _winhook.InputUp += k => AddMessage($"[InputUp] {k} (0x{(int)k:X})");
        _winhook.MouseMove += (x, y) =>
        {
            var pos = ReisProduction.Winhook.Services.Interop.GetCursorPos();
            AddMessage($"[MouseMove] X: {x}, Y: {y} - Mouse POS: ({pos.X}x{pos.Y})");
        };
        // Başlatmak için:
        _winhook.StartOrStopHooks([new KeyboardHook(true), new MouseHook(true), new FileHook(Paths: Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\Technopat")]);
        AddMessage("Winhook initialized and running...");
        // Sonlandırmak için:
        //_winhook.StartOrStopHooks([new KeyboardHook(false), new MouseHook(false), new FileHook(false, Paths: Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\Technopat")]);
    }
    private void AddMessage(string msg)
    {
        DispatcherQueue.TryEnqueue(() => // Main (UI) thread üzerinde çalıştır
        {
            MyListBox.Items.Add(msg);
            if (FindScrollViewer(MyListBox) is ScrollViewer sv)
                sv.ChangeView(null, sv.ExtentHeight, null);
        });
    }
    private static ScrollViewer? FindScrollViewer(DependencyObject obj)
    {
        if (obj is ScrollViewer sv) return sv;
        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            if (FindScrollViewer(VisualTreeHelper.GetChild(obj, i)) is ScrollViewer found) return found;
        return null;
    }
}

Enseklik olması açısından bir sürü event yaptım ama sadece InputHook ve FileHook'u gösterebildim. Siz kendiniz inceleyip kullanabilirsiniz veya sorabilirsiniz. Ekstradan fork atıp 'Alt GR' ve 'Shift' ile gelen oem karakterleri ayıran sistemi biri yapsa çok mutlu olurum. Ben daha da ayrıntıya girmeye üşendim. (Daha ne kadar girebilirdim ki )

Girdiğim ayrıntılar

Eventler:

C#:

using ReisProduction.Winhook.Utilities.Enums;
using System.Management;
using Windows.System;
namespace ReisProduction.Winhook.Models;
public partial class Winhook
{
    public event Action<EventArrivedEventArgs>
        ProcessStarted = delegate { },
        ProcessStopped = delegate { },
        ServiceStarted = delegate { },
        ServiceStopped = delegate { },
        ThreadStarted = delegate { },
        ThreadStopped = delegate { },
        ModuleLoaded = delegate { },
        ModuleUnloaded = delegate { },
        SessionChanged = delegate { },
        DeviceChanged = delegate { },
        VolumeChanged = delegate { },
        PowerChanged = delegate { },
        SystemConfigChanged = delegate { },
        TimeChanged = delegate { },
        SystemTrace = delegate { },
        IP4RouteChanged = delegate { },
        IP6RouteChanged = delegate { },
        NetworkAdapterConfigChanged = delegate { },
        ProcessTrace = delegate { },
        ProcessTraceStarted = delegate { },
        ProcessTraceStopped = delegate { },
        ThreadTrace = delegate { },
        ModuleTrace = delegate { },
        BatchJobStarted = delegate { },
        BatchJobStopped = delegate { };
    public event Action<nint>
        WindowSound = delegate { },
        WindowAlert = delegate { } ,
        WindowForegroundChanged = delegate { },
        WindowMenuStart = delegate { },
        WindowMenuEnd = delegate { },
        WindowMenuPopupStart = delegate { },
        WindowMenuPopupEnd = delegate { },
        WindowCaptureStart = delegate { },
        WindowCaptureEnd = delegate { },
        WindowMoveSizeStart = delegate { },
        WindowMoveSizeEnd = delegate { },
        WindowContextHelpStart = delegate { },
        WindowContextHelpEnd = delegate { },
        WindowDragDropStart = delegate { },
        WindowDragDropEnd = delegate { },
        WindowDialogStart = delegate { },
        WindowDialogEnd = delegate { },
        WindowScrollingStart = delegate { },
        WindowScrollingEnd = delegate { },
        WindowSwitchStart = delegate { },
        WindowSwitchEnd = delegate { },
        WindowMinimizeStart = delegate { },
        WindowMinimizeEnd = delegate { },
        WindowDesktopSwitch = delegate { },
        ConsoleCaret = delegate { },
        ConsoleUpdateRegion = delegate { },
        ConsoleUpdateSimple = delegate { },
        ConsoleUpdateScroll = delegate { },
        ConsoleLayout = delegate { },
        ConsoleStartApplication = delegate { },
        ConsoleEndApplication = delegate { },
        UiaPropertyChange = delegate { },
        UiaPatternChange = delegate { },
        UiaStructureChange = delegate { },
        UiaEventIdStart = delegate { },
        UiaEventIdEnd = delegate { },
        ObjectCreate = delegate { },
        ObjectDestroy = delegate { },
        ObjectShow = delegate { },
        ObjectHide = delegate { },
        ObjectReorder = delegate { },
        ObjectFocus = delegate { },
        ObjectSelection = delegate { },
        ObjectSelectionAdd = delegate { },
        ObjectSelectionRemove = delegate { },
        ObjectSelectionWithin = delegate { },
        ObjectStateChange = delegate { },
        ObjectLocationChange = delegate { },
        ObjectNameChange = delegate { },
        ObjectDescriptionChange = delegate { },
        ObjectValueChange = delegate { },
        ObjectParentChange = delegate { },
        ObjectHelpChange = delegate { },
        ObjectDefActionChange = delegate { },
        ObjectAcceleratorChange = delegate { },
        ObjectInvoked = delegate { },
        ObjectTextSelectionChanged = delegate { },
        ObjectContentScrolled = delegate { },
        ObjectArrangementPreview = delegate { },
        ObjectCloaked = delegate { },
        ObjectUncloaked = delegate { },
        ObjectLiveRegionChanged = delegate { },
        ObjectHostedObjectsInvalidated = delegate { },
        ObjectDragStart = delegate { },
        ObjectDragCancel = delegate { },
        ObjectDragComplete = delegate { },
        ObjectDragEnter = delegate { },
        ObjectDragLeave = delegate { },
        ObjectDragDropped = delegate { },
        ObjectImeShow = delegate { },
        ObjectImeHide = delegate { },
        ObjectImeChange = delegate { },
        ObjectTextEditConversionTargetChanged = delegate { };
    public event Action<FileSystemEventArgs>
        FileCreated = delegate { },
        FileChanged = delegate { },
        FileDeleted = delegate { },
        FileRenamed = delegate { };
    public event Action<ErrorEventArgs>
        FileWatcherError = delegate { };
    public event Action<InputType>
        InputDown = delegate { },
        InputHold = delegate { },
        InputPress = delegate { },
        InputDoublePress = delegate { },
        InputUp = delegate { };
    public event Action<VirtualKey>
        KeyDown = delegate { },
        KeyHold = delegate { },
        KeyPress = delegate { },
        KeyDoublePress = delegate { },
        KeyUp = delegate { };
    public event Action<ButtonType>
        MouseDown = delegate { },
        MouseClick = delegate { },
        MouseHold = delegate { },
        MouseDoubleClick = delegate { },
        MouseUp = delegate { };
    public event Action<ScrollType>
        MouseScroll = delegate { },
        MouseScrollLeft = delegate { },
        MouseScrollRight = delegate { },
        MouseScrollUp = delegate { },
        MouseScrollDown = delegate { };
    public event Action<int, int>
        MouseMove = delegate { },
        MouseMoveLeft = delegate { },
        MouseMoveRight = delegate { },
        MouseMoveUp = delegate { },
        MouseMoveDown = delegate { },
        MouseMoveHorizontal = delegate { },
        MouseMoveVertical = delegate { };
}

Record'lar:

C#:

using static ReisProduction.Winhook.Utilities.Constants;
namespace ReisProduction.Winhook.Utilities;
public abstract record HookBase(bool ShouldStart = true);
public record ProcessStartHook(bool ShouldStart = true, params string[] ProcessNames) : HookBase(ShouldStart);
public record ProcessStopHook(bool ShouldStart = true, params string[] ProcessNames) : HookBase(ShouldStart);
public record ServiceStartHook(bool ShouldStart = true, params string[] ServiceNames) : HookBase(ShouldStart);
public record ServiceStopHook(bool ShouldStart = true, params string[] ServiceNames) : HookBase(ShouldStart);
public record ThreadStartHook(bool ShouldStart = true, params int[] ThreadIds) : HookBase(ShouldStart);
public record ThreadStopHook(bool ShouldStart = true, params int[] ThreadIds) : HookBase(ShouldStart);
public record ModuleLoadHook(bool ShouldStart = true, params string[] ModuleNames) : HookBase(ShouldStart);
public record ModuleUnloadHook(bool ShouldStart = true, params string[] ModuleNames) : HookBase(ShouldStart);
public record RegistryChangeHook(bool ShouldStart = true, params string[] RegistryPaths) : HookBase(ShouldStart);
public record SessionChangeHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record DeviceChangeHook(bool ShouldStart = true, params string[] DeviceIds) : HookBase(ShouldStart);
public record VolumeChangeHook(bool ShouldStart = true, params string[] DriveNames) : HookBase(ShouldStart);
public record PowerManagementHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record SystemConfigChangeHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record TimeChangeHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record SystemTraceHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record IP4RouteTableHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record IP6RouteTableHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record NetworkAdapterConfigChangeHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ProcessTraceHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ProcessStartTraceHook(bool ShouldStart = true, params string[] ProcessNames) : HookBase(ShouldStart);
public record ProcessStopTraceHook(bool ShouldStart = true, params string[] ProcessNames) : HookBase(ShouldStart);
public record ThreadTraceHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ModuleTraceHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record BatchJobStartHook(bool ShouldStart = true, params string[] JobNames) : HookBase(ShouldStart);
public record BatchJobStopHook(bool ShouldStart = true, params string[] JobNames) : HookBase(ShouldStart);
public record ForegroundHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record MinimizeHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record SwitchHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record MoveSizeHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record MenuHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record MenuPopupHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record CaptureHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ContextHelpHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record DragDropHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record DialogHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ScrollingHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record DesktopSwitchHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ConsoleHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record UiaHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record ObjectHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record KeyboardHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record MouseHook(bool ShouldStart = true) : HookBase(ShouldStart);
public record FileHook (bool ShouldStart = true, string Filter = "*.*",
    NotifyFilters Filters = AllNotifyFilters, bool IncludeCreated = true, bool IncludeChanged = true, bool IncludeDeleted = true,
    bool IncludeRenamed = true, bool IncludeError = true, bool IncludeSubdirectories = true, params string[] Paths) : HookBase(ShouldStart);

Prop'lar:

C#:

public DelayType MouseHoldDelayType { get; set; } = DelayType.TaskDelay;
public DelayType KeyHoldDelayType { get; set; } = DelayType.TaskDelay;
public bool AllowClickOnDoubleClick { get; set; } = true;
public bool AllowPressOnDoublePress { get; set; } = true;
public bool AcceptInjectedKeyboard { get; set; } = true;
public bool IncloudeSubdirectories { get; set; } = false;
public bool EnableRaisingEvents { get; set; } = true;
public bool AcceptInjectedMouse { get; set; } = true;
public bool AcceptNoneInput { get; set; } = false;
public bool AcceptSYSDown { get; set; } = true;
public bool AcceptSYSUp { get; set; } = true;
public bool AllowKeyPress { get; set; } = false;
public bool AllowKeyHold { get; set; } = false;
public bool AllowClick { get; set; } = false;
public bool AllowHold { get; set; } = false;
public int DoubleClickThresholdMs { get; set; } = 250;
public int DoublePressThresholdMs { get; set; } = 250;
public int MovementThreshold { get; set; } = 1;
public int KeyHoldIntervalMs { get; set; } = 50;
public int HoldIntervalMs { get; set; } = 50;
public int MoveThresholdMs { get; set; } =
    Math.Clamp(200 / Environment.ProcessorCount, 25, 100);

InputState:

C#:

public static bool IsKeyDown(VirtualKey key) => GetKeyState((ushort)key) < 0; // Basılı mı?
public static bool IsKeyUp(VirtualKey key) => !IsKeyDown(key); // Basılı değil mi?
public static bool IsHardwareKeyDown(VirtualKey key) => GetAsyncKeyState((ushort)key) < 0; // Anlık
public static bool IsHardwareKeyUp(VirtualKey key) => !IsHardwareKeyDown(key); // Anlık
public static bool IsTogglingKeyInEffect(VirtualKey key) => (GetKeyState((ushort)key) & 0x1) is 0x1; // CapsLock ve ScrolLock gibi ikili sistem tuşlarının state'ini döner.

Helper'lar:

C#:

private static int GetInt(EventArrivedEventArgs e, string key) => int.TryParse(e.NewEvent.Properties[key]?.Value?.ToString(), out var v) ? v : 0;
private static string GetString(EventArrivedEventArgs e, string key) => e.NewEvent.Properties[key]?.Value?.ToString() ?? "";
public static string GetProcessName(int pid)
{
    try
    {
        using var process = Process.GetProcessById(pid);
        return process.ProcessName;
    }
    catch
    {
        return "Unknown";
    }
}
public static int GetProcessID(string processName)
{
    try
    {
        using var process = Process.GetProcessesByName(processName).FirstOrDefault();
        return process?.Id ?? -1;
    }
    catch
    {
        return -1;
    }
}
public static string GetClassName(EventArrivedEventArgs e) => e.NewEvent.ClassPath.ClassName;
public static string GetProcessCreationDate(EventArrivedEventArgs e) => GetString(e, "ProcessCreationDate");
public static string GetProcessName(EventArrivedEventArgs e) => GetString(e, "ProcessName");
public static string GetServiceName(EventArrivedEventArgs e) => GetString(e, "ServiceName");
public static string GetServiceState(EventArrivedEventArgs e) => GetString(e, "State");
public static string GetFilename(EventArrivedEventArgs e) => GetString(e, "Filename");
public static string GetModulePath(EventArrivedEventArgs e) => GetString(e, "ModulePath");
public static string GetModuleName(EventArrivedEventArgs e) => GetString(e, "ModuleName");
public static string GetVolumeName(EventArrivedEventArgs e) => GetString(e, "DriveName");
public static string GetDeviceID(EventArrivedEventArgs e) => GetString(e, "DeviceID");
public static string GetProperty(EventArrivedEventArgs e) => GetString(e, "PropertyName");
public static string GetOldTime(EventArrivedEventArgs e) => GetString(e, "OldTime");
public static string GetNewTime(EventArrivedEventArgs e) => GetString(e, "NewTime");
public static string GetIPRoute(EventArrivedEventArgs e) => GetString(e, "Route");
public static string GetOwner(EventArrivedEventArgs e) => GetString(e, "Owner");
public static string GetAdapterName(EventArrivedEventArgs e) => GetString(e, "Description");
public static string GetExecutablePath(EventArrivedEventArgs e) => GetString(e, "ExecutablePath");
public static string GetCommandLine(EventArrivedEventArgs e) => GetString(e, "CommandLine");
public static string GetSessionName(EventArrivedEventArgs e) => GetString(e, "SessionName");
public static int GetParentProcessID(EventArrivedEventArgs e) => GetInt(e, "ParentProcessId");
public static int GetProcessID(EventArrivedEventArgs e) => GetInt(e, "ProcessID");
public static int GetThreadID(EventArrivedEventArgs e) => GetInt(e, "ThreadID");
public static int GetSessionID(EventArrivedEventArgs e) => GetInt(e, "SessionId");
public static int GetExitStatus(EventArrivedEventArgs e) => GetInt(e, "ExitStatus");
public static int GetEventType(EventArrivedEventArgs e) => GetInt(e, "EventType");
public static int GetEventTypeCode(EventArrivedEventArgs e) => GetInt(e, "EventTypeCode");

PointerHelper (WinRT)

C#:

#if WINUI || WINDOWS_APP || WINRT
using Windows.Devices.Input;
using Windows.Foundation;
using Windows.UI.Input;
namespace ReisProduction.Winhook.Models;
public static class PointerHelper
{
    /// <inheritdoc cref="Windows.UI.Input.PointerPoint"/>
    public static PointerPoint PointerPoint { get; set; } = null!;
    /// <inheritdoc cref="PointerPoint.Properties"/>
    public static PointerPointProperties PointerProperties => PointerPoint.Properties;
    /// <inheritdoc cref="PointerPoint.Position"/>
    public static Point Position => PointerPoint.Position;
    /// <inheritdoc cref="PointerPoint.PointerDevice"/>
    public static PointerDevice PointerDevice => PointerPoint.PointerDevice;
    /// <inheritdoc cref="PointerDevice.PointerDeviceType"/>
    public static PointerDeviceType DeviceType => PointerDevice.PointerDeviceType;
    public static uint PointerId => PointerPoint.PointerId;
    /// <inheritdoc cref="PointerPoint.FrameId"/>
    public static uint FrameId => PointerPoint.FrameId;
    /// <inheritdoc cref="PointerPoint.Timestamp"/>
    public static ulong Timestamp => PointerPoint.Timestamp;
    /// <inheritdoc cref="PointerPointProperties.Twist"/>
    public static float Twist => PointerProperties.Twist;
    /// <inheritdoc cref="PointerPointProperties.XTilt"/>
    public static float XTilt => PointerProperties.XTilt;
    /// <inheritdoc cref="PointerPointProperties.YTilt"/>
    public static float YTilt => PointerProperties.YTilt;
    /// <summary>
    /// Gets the tilt of the pointer as a tuple (XTilt, YTilt).
    /// </summary>
    public static (float XTilt, float YTilt) GetTilt() => (PointerProperties.XTilt, PointerProperties.YTilt);
    /// <inheritdoc cref="PointerPointProperties.Pressure"/>
    public static float Pressure => PointerProperties.Pressure;
    /// <summary>
    /// Standard wheel delta used by Windows for one mouse wheel detent (default = 120).
    /// </summary>
    public static double WhellDelta { get; set; } = 120.0;
    /// <inheritdoc cref="PointerPointProperties.IsLeftButtonPressed"/>
    public static bool IsLeftButtonPressed => PointerProperties.IsLeftButtonPressed;
    /// <inheritdoc cref="PointerPointProperties.IsRightButtonPressed"/>
    public static bool IsRightButtonPressed => PointerProperties.IsRightButtonPressed;
    /// <inheritdoc cref="PointerPointProperties.IsMiddleButtonPressed"/>
    public static bool IsMiddleButtonPressed => PointerProperties.IsMiddleButtonPressed;
    /// <inheritdoc cref="PointerPointProperties.IsXButton1Pressed"/>
    public static bool IsXButton1Pressed => PointerProperties.IsXButton1Pressed;
    /// <inheritdoc cref="PointerPointProperties.IsXButton2Pressed"/>
    public static bool IsXButton2Pressed => PointerProperties.IsXButton2Pressed;
    /// <inheritdoc cref="PointerPointProperties.IsBarrelButtonPressed"/>
    public static bool IsBarrelButtonPressed => PointerProperties.IsBarrelButtonPressed;
    /// <inheritdoc cref="PointerPointProperties.IsEraser"/>
    public static bool IsEraser => PointerProperties.IsEraser;
    /// <inheritdoc cref="PointerPointProperties.IsInRange"/>
    public static bool IsInRange => PointerProperties.IsInRange;
    /// <inheritdoc cref="PointerPointProperties.IsInverted"/>
    public static bool IsInverted => PointerProperties.IsInverted;
    /// <inheritdoc cref="PointerPointProperties.IsCanceled"/>
    public static bool IsCanceled => PointerProperties.IsCanceled;
    /// <inheritdoc cref="PointerPointProperties.TouchConfidence"/>
    public static bool TouchConfidence => PointerProperties.TouchConfidence;
    /// <inheritdoc cref="PointerPointProperties.ZDistance"/>
    public static float? ZDistance => PointerProperties.ZDistance;
    /// <inheritdoc cref="PointerPointProperties.ContactRect"/>
    public static Rect ContactRect => PointerProperties.ContactRect;
    /// <inheritdoc cref="PointerPointProperties.ContactRectRaw"/>
    public static Rect ContactRectRaw => PointerProperties.ContactRectRaw;
    /// <summary>
    /// Gets the mouse wheel delta and orientation.
    /// </summary>
    /// <inheritdoc cref="PointerPointProperties.MouseWheelDelta" path="/summary"/>
    /// <inheritdoc cref="PointerPointProperties.IsHorizontalMouseWheel" path="/summary"/>
    /// <returns>(Delta, IsHorizontal)</returns>
    public static (int Delta, bool IsHorizontal) GetMouseWheelDelta()
    {
        var properties = PointerProperties;
        if (properties is null) return (0, false);
        return (properties.MouseWheelDelta, properties.IsHorizontalMouseWheel);
    }
    /// <inheritdoc cref="PointerPointProperties.MouseWheelDelta"/>
    public static int GetVerticalWheelDelta()
    {
        var (delta, isHorizontal) = GetMouseWheelDelta();
        return isHorizontal ? 0 : delta;
    }
    /// <inheritdoc cref="PointerPointProperties.MouseWheelDelta"/>
    public static int GetHorizontalWheelDelta()
    {
        var (delta, isHorizontal) = GetMouseWheelDelta();
        return isHorizontal ? delta : 0;
    }
    /// <summary>
    /// Get the normalized scroll delta, where 1.0 represents one standard scroll step.
    /// </summary>
    public static double GetNormalizedScrollDelta()
    {
        var (delta, _) = GetMouseWheelDelta();
        return delta / WhellDelta;
    }
    /// <summary>
    /// Calculates the Euclidean distance between two PointerPoint positions.
    /// </summary>
    public static double CalculateDistance(PointerPoint point1, PointerPoint point2)
    {
        double deltaX = point2.Position.X - point1.Position.X,
               deltaY = point2.Position.Y - point1.Position.Y;
        return Math.Sqrt(deltaX * deltaX + deltaY * deltaY);
    }
}
#endif

ClipboardHelper (WinUI-Forms)

C#:

public static class ClipboardHelper
{
    public static bool TryGetClipboardText(bool isWinUI, out string? text)
    {
        text = null;
        try
        {
            if (isWinUI)
            {
                var content = Clipboard.GetContent();
                if (!content.Contains(StandardDataFormats.Text))
                    return false;
                text = content.GetTextAsync().GetAwaiter().GetResult();
            }
            else
            {
                if (!System.Windows.Forms.Clipboard.ContainsText())
                    return false;
                text = System.Windows.Forms.Clipboard.GetText();
            }
            return !string.IsNullOrWhiteSpace(text);
        }
        catch { return false; }
    }
    public static bool TrySetClipboardText(bool isWinUI, string text)
    {
        try
        {
            if (string.IsNullOrWhiteSpace(text))
                throw new ArgumentNullException(nameof(text));
            if (isWinUI)
            {
                DataPackage pkg = new();
                pkg.SetText(text);
                Clipboard.SetContent(pkg);
            }
            else
                System.Windows.Forms.Clipboard.SetText(text);
            return true;
        }
        catch { return false; }
    }
    public static bool TryGetClipboardBitmap(bool isWinUI, out object? bitmap)
    {
        bitmap = null;
        try
        {
            if (isWinUI)
            {
                var content = Clipboard.GetContent();
                if (!content.Contains(StandardDataFormats.Bitmap))
                    return false;
                bitmap = content.GetBitmapAsync().GetAwaiter().GetResult();
                return bitmap is not null;
            }
            else
            {
                if (!System.Windows.Forms.Clipboard.ContainsImage())
                    return false;
                bitmap = System.Windows.Forms.Clipboard.GetImage();
                return bitmap is not null;
            }
        }
        catch { return false; }
    }
    public static bool TrySetClipboardBitmap(bool isWinUI, object bitmap)
    {
        try
        {
            if (bitmap is null)
                return false;
            if (isWinUI)
            {
                if (bitmap is Windows.Storage.Streams.RandomAccessStreamReference rasr)
                {
                    DataPackage pkg = new();
                    pkg.SetBitmap(rasr);
                    Clipboard.SetContent(pkg);
                    return true;
                }
                return false;
            }
            else
            {
                if (bitmap is System.Drawing.Image img)
                {
                    System.Windows.Forms.Clipboard.SetImage(img);
                    return true;
                }
                return false;
            }
        }
        catch { return false; }
    }
    public static bool TryGetClipboardContent(bool isWinUI, out object? content)
    {
        try
        {
            if (isWinUI)
            {
                content = Clipboard.GetContent();
                return content is not null;
            }
            else
            {
                content = System.Windows.Forms.Clipboard.GetDataObject();
                return content is not null;
            }
        }
        catch
        {
            content = null;
            return false;
        }
    }
    public static bool TrySetClipboardContent(bool isWinUI, object content)
    {
        try
        {
            if (content is null)
                return false;
            if (isWinUI)
            {
                if (content is DataPackage pkg)
                {
                    Clipboard.SetContent(pkg);
                    return true;
                }
                return false;
            }
            else
            {
                if (content is System.Windows.Forms.IDataObject dataObj)
                {
                    System.Windows.Forms.Clipboard.SetDataObject(dataObj, true);
                    return true;
                }
                return false;
            }
        }
        catch { return false; }
    }
}

Yakında Winjoys'u da public yapmayı düşünüyorum. Belki sonrasında yapacağım Winmacro'yu da ücretsiz olarak public sunabilirim. Ben macro kullanmayı seven birisiyim ve Jitbit Recorder'a bağlı kalmaktan memnun değilim. Daha iyisini ücretsiz bir şekilde yapabileceğimi düşünüyorum. Şu anda gayet iyi gidiyorum. Görünüm olarak da WinUI 3 kullanacağımdan, o konuda problemim olmayacak. Kütüphaneyi inceleyip eklememi istediğiniz özellik veya düzeltmem gereken bir bug bulursanız bildirmeyi unutmayın. Şimdilik bitti ve rafa kaldırdım. Arada bir değişiklik olursa güncellemeler getiririm.

Ciddi emek sarfettim. C# ile açık kaynak olup Global çalışan en sağlam Hook'lardan biri oldu.

NOT: Bu konu sonradan düzeltilip, kütüphaneye bir sürü eklenmeler yapılmıştır. Ek olarak System.Management DLL'si kullanılmaya başlanmıştır. Güncellemeler pushlanıp v25.5.1 olarak GitHub'a eklenmiştir. NuGet olarak da eklenmiştir.

Sırada ise LowLevel Injector'u tamamen bitirip public yapacağım.
İyi günler ve iyi çalışmalar dilerim!

Yakında çıkacak Windoc uygulamamı takip etmek için: Bilgisayarın sağlığını ve performansını kontrol eden uygulamam Windoc

Bayram Reis · Dün 23:04

TheAny dedi:
Async olan fonksiyonu, sync cagiracaksan, ya not dus, uyar, yada hem async, hem sync versiyonlarini sun. Bu tarz seylerin async olmasinin sebebi asiri buyuk bitmap resimlerinde tutulabiliyor olusu. Tercihen kullanici async ve sync arasindaki karari kendi verebilmeli.

Yine developer friendliness acisindan, bi fonksiyona birden fazla rol vermeyi birakman lazim. Gruplara ayir. Hem WinUI icin hem WinForms icin getirmemelisinin clipboard'i mesela.

C#:

class ClipboardHelpers { class WinUI { // buraya WinUI implementasyonlari } class WinForms { // buraya WinForms } private enum ContextType { WinUI, WinForm, Unknown } private static ContextType getContext(); // eger sisteminde WinUI yada WinForms oldugunu tespit etmene yarayacak // bi cesit abstraction varsa, o abstraction sistemini kullanip // public api'nde kullaniciya WinUI ve WinForms mu kismini // elle vermeyi zorunlu kilmadan dondurebilirsin; // ornek; public static boolean TryGetX(out object? outref) { return getContext() switch { ContextType.WinUI => WinUI.TryGetX(outref), ContextType.WinForm => WinForm.TryGetX(outref), ContextType.Unknown => false; } } }

Bunun daha guzeli Provider sistemine gecmen. Boylece daha farkli platformlar icin extend etmek istediginde, kodda ve public API'de ciddi degisiklikler yapmana gerek kalmaz.

Kalanina bakmadim. Baktikca ekleme yaparim konuya. Onerilerle alakali takildigin bi sey olursa da sormaktan cekinme.

Bu çoj hızlı çıkarmak istediğimden kaynaklı. Şu Wincore'a bakarsan her şeyi mükemmel seviyede (şu ana kadar) yaptım. Hâlâ daha ekliyorum. Bahsettiğin gibi böldüm ikisini de ve #if ile compile sırasında da görmezden gelmesini sağladım. Bahsettiğin otomatik algılama olayı güzel fakat WinForm WinUI desteklemiyorken WinUI'ın ikisini de destekliyor. Hatta zorlansa WinForm'a da WinUI eklenebilir. Bir de şu an baya yoğunum ama unutmazsam Sync ve Async olarak böleceğim. Zaten şu anda Winform ve WinRT olarak böldüm method ve classları. Önerilerin için teşekkürler. NuGet'a en yeni versiyonlarını atıyorum. Şu anda kafamda bir yapı var o tam olarak bitince yayımlayıp buradaki konuları da düzelteceğim. Kafamdaki yapının tek dezavantı (benim için avantaj) genelde birbirleriyle bağımlı. Fakat zaten hepsi 1er mb olduğundan çok büyük sıkıntı gibi görmüyorum şahsen.

Rehber C# Lowlevel hook kütüphanesi Winhooks nasıl kullanılır?

Ayrıntılı düzenleme

Nasıl kullanılır?

Girdiğim ayrıntılar

Eventler:

Record'lar:

Prop'lar:

InputState:

Helper'lar:

PointerHelper (WinRT)

ClipboardHelper (WinUI-Forms)

Bayram Reis

Kilopat

Benzer konular

Rehber C# Lowlevel hook kütüphanesi Winhooks nasıl kullanılır?

Nasıl kullanılır?​

Girdiğim ayrıntılar ​

Eventler:​

Record'lar:​

Prop'lar:​

InputState:​

Helper'lar:​

PointerHelper (WinRT)​

ClipboardHelper (WinUI-Forms)​

Bayram Reis

Kilopat

Benzer konular

Nasıl kullanılır?

Girdiğim ayrıntılar

Eventler:

Record'lar:

Prop'lar:

InputState:

Helper'lar:

PointerHelper (WinRT)

ClipboardHelper (WinUI-Forms)