Erreur Multiple sur un autoclicker en C# Visual Studio

Bonjour,

Cela fait pas mal de temp que j'essai de regler un beug qui me ruine tout mon programme 

Gravité    Code    Description    Projet    Fichier    Ligne    État de la suppression
Erreur (active)    CS5001    Le programme ne contient pas de méthode 'Main' statique adaptée à un point d'entrée    AutoClickerCheat    C:\Users\Utilisateur\OneDrive\Bureau\AutoClickerCheat\AutoClickerCheat\CSC    1    
 

c'est infernal je regle quelque chose cela me met une autre erreur mais pour la regler je dois revenir comme avant pourriez vous m'aidez

Voici le code :

using System;
using System.Runtime.InteropServices;
using System.Threading;
using WindowsInput;
using WindowsInput.Native;
using NHotkey;
using NHotkey.WindowsForms;
using System.Windows.Forms;
using static AutoClickerApp.GlobalKeyboardHook;
using System.Diagnostics;

namespace AutoClickerApp
{
    public partial class MainForm : Form
    {
        private bool isAutoClicking = false;
        private int cpsMin = 8; // CPS minimum
        private int cpsMax = 16; // CPS maximum
        private Random random = new Random();
        private InputSimulator inputSimulator = new InputSimulator();

        public MainForm()
        {
            InitializeComponent();

            // Enregistrement de la hotkey pour la touche `
            HotkeyManager.Current.AddOrReplace("ToggleAutoClicker", Keys.Oemtilde, ToggleAutoClicker);

            // Démarrage du hook global du clavier
            KeyboardHook.Start();
            KeyboardHook.KeyPressed += KeyboardHook_KeyPressed;

            UpdateStatusLabel();
        }

        private void ToggleAutoClicker(object sender, HotkeyEventArgs e)
        {
            isAutoClicking = !isAutoClicking;
            UpdateStatusLabel();

            if (isAutoClicking)
            {
                Thread autoClickThread = new Thread(AutoClicker);
                autoClickThread.IsBackground = true;
                autoClickThread.Start();
            }
        }

        private void AutoClicker()
        {
            while (isAutoClicking)
            {
                if (IsLeftMouseButtonDown())
                {
                    int cps = random.Next(cpsMin, cpsMax + 1); // Random CPS between cpsMin and cpsMax
                    int interval = 1000 / cps;

                    inputSimulator.Mouse.LeftButtonClick();
                    Thread.Sleep(interval);
                }
                else
                {
                    Thread.Sleep(10); // Check every 10 ms if the left mouse button is pressed
                }
            }
        }

        private void KeyboardHook_KeyPressed(object sender, KeyboardHook.KeyPressedEventArgs e)
        {
            if (e.Key == Keys.Oemtilde)
            {
                isAutoClicking = !isAutoClicking;
                UpdateStatusLabel();
            }
        }

        private void UpdateStatusLabel()
        {
            string status = isAutoClicking ? "Activé" : "Désactivé";
            lblAutoClickStatus.Text = $"Auto-clicker : {status}";
        }

        private bool IsLeftMouseButtonDown()
        {
            return (Control.MouseButtons & MouseButtons.Left) != 0;
        }

        private void trackBarCPS_Scroll(object sender, EventArgs e)
        {
            // Mettre à jour les valeurs de CPS
            cpsMin = trackBarCPS.Value - 4; // 4 est la valeur minimum du trackbar
            cpsMax = trackBarCPS.Value;
            lblCPSValue.Text = $"{cpsMin} - {cpsMax} CPS";
        }
    }

    public static class KeyboardHook
    {
        public static event EventHandler<KeyPressedEventArgs> KeyPressed;

        private static GlobalKeyboardHook _globalKeyboardHook;

        public static void Start()
        {
            _globalKeyboardHook = new GlobalKeyboardHook();
            _globalKeyboardHook.KeyboardPressed += OnKeyPressed;
        }

        private static void OnKeyPressed(object sender, GlobalKeyboardHookEventArgs e)
        {
            if (e.KeyboardData == Keys.Oemtilde && e.KeyboardState == GlobalKeyboardHook.KeyboardState.KeyDown)
            {
                KeyPressed?.Invoke(null, new KeyPressedEventArgs(Keys.Oemtilde));
            }
        }

        public class KeyPressedEventArgs : EventArgs
        {
            public Keys Key { get; private set; }

            public KeyPressedEventArgs(Keys key)
            {
                Key = key;
            }
        }
    }

    public class GlobalKeyboardHook : IDisposable
    {
        public event EventHandler<GlobalKeyboardHookEventArgs> KeyboardPressed;

        private const int WH_KEYBOARD_LL = 13;
        private const int WM_KEYDOWN = 0x0100;
        private const int WM_KEYUP = 0x0101;

        private HookProc _proc;
        private IntPtr _hookID = IntPtr.Zero;

        public GlobalKeyboardHook()
        {
            _proc = HookCallback;
            _hookID = SetHook(_proc);
        }

        public void Dispose()
        {
            UnhookWindowsHookEx(_hookID);
        }

        private IntPtr SetHook(HookProc proc)
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
            }
        }

        private delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);

        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0 && (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_KEYUP))
            {
                int vkCode = Marshal.ReadInt32(lParam);
                Keys key = (Keys)vkCode;

                KeyboardState state = wParam == (IntPtr)WM_KEYDOWN ? KeyboardState.KeyDown : KeyboardState.KeyUp;

                KeyboardPressed?.Invoke(this, new GlobalKeyboardHookEventArgs(key, state));
            }
            return CallNextHookEx(_hookID, nCode, wParam, lParam);
        }

        public enum KeyboardState
        {
            KeyDown,
            KeyUp
        }

        public class GlobalKeyboardHookEventArgs : EventArgs
        {
            public Keys KeyboardData { get; private set; }
            public KeyboardState KeyboardState { get; private set; }

            public GlobalKeyboardHookEventArgs(Keys keyboardData, KeyboardState keyboardState)
            {
                KeyboardData = keyboardData;
                KeyboardState = keyboardState;
            }
        }

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, uint dwThreadId);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool UnhookWindowsHookEx(IntPtr hhk);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);
    }
}

Windows / Chrome 125.0.0.0