Как обойти проблемку с NullReferenceException?

using System;
using Microsoft.Win32;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using ARTool;
 
namespace warhey
{
    public interface IKeyDownEventHandler
    {
        bool Handle(KeyEventArgs e);
    }
 
    public interface IWarKeyControl
    {
        void Save(string name, IWarKeyModel model);
        IWarKeyModel Load(string name);
    }
    public interface IWarKeyModel
    {
        string Name { get; }
 
        bool DisplayEnemysHP { get; }
        bool DisplayAlliesHP { get; }
 
        IDictionary<int, int> KeyMappers { get; }
    }
    public interface IWarKeyModelRepository
    {
        void Create(string name, IWarKeyModel model);
        void Update(string name, IWarKeyModel model);
        void Delete(string name);
 
        IWarKeyModel Read(string name);
    }
    public interface IWarKeyView
    {
        IWarKeyModel GetCurrent();
        void Update(IWarKeyModel model);
    }
 
    //keyboard
 
    public class Keyboard
    {
        private const int WM_KEYDOWN = 0x100;   //Сообщение для прессы  
        private const int WM_KEYUP = 0x101;     //Отпустить сообщение  
        private const int WM_SYSKEYDOWN = 0x104;
        private const int WM_SYSKEYUP = 0x105;
 
        private IKeyDownEventHandler handler;
 
        public Keyboard(IKeyDownEventHandler handler)
        {
            this.handler = handler;
            Start();//можете прочесть коды это не для хоткей? нет
        }
 
        private static IntPtr hKeyboardHook = IntPtr.Zero;
 
        // Константы клавиатуры  
        public const int WH_KEYBOARD_LL = 13;
 
        public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);
 
        // Объявите тип события перехвата клавиатуры
        private HookProc KeyboardHookProcedure;
 
        /// <summary>  
        /// Объявите маршалинг структуры типа клавиатуры хук
        /// Declare the marshaling structure type of keyboard hook
        /// </summary>  
        [StructLayout(LayoutKind.Sequential)]
        public class KeyboardHookStruct
        {
            public int vkCode;      // Представляет код виртуальной клавиатуры от 1 до 254  
            public int scanCode;    // Указывает код сканирования оборудования  
            public int flags;
            public int time;
            public int dwExtraInfo;
        }
 
        [DllImport("kernel32.dll")]
        public static extern IntPtr GetModuleHandle(string lpModuleName);
        // Монтажный крюк  mounted
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
        // Следующий крюк  
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(IntPtr hhk, int nCode, Int32 wParam, IntPtr lParam);
        // Удалить крючок  
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int UnhookWindowsHookEx(IntPtr hhk);
 
        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            if (nCode < 0)
                return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
 
            KeyboardHookStruct MyKBHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
 
            if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)
            {
                Keys keyData = (Keys)MyKBHookStruct.vkCode;
                KeyEventArgs e = new KeyEventArgs(keyData);
 
                if (handler.Handle(e) == false)
                    return 1;
            }
 
            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
        }
 
        public void Start()
        {
            if (hKeyboardHook == IntPtr.Zero)
            {
                KeyboardHookProcedure = new HookProc(KeyboardHookProc);
 
                using (System.Diagnostics.Process curProcess = System.Diagnostics.Process.GetCurrentProcess())
                using (System.Diagnostics.ProcessModule curModule = curProcess.MainModule)
                    hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, GetModuleHandle(curModule.ModuleName), 0);
 
                if (hKeyboardHook == IntPtr.Zero)
                    Stop();
            }
        }
 
        public void Stop()
        {
            if (hKeyboardHook != IntPtr.Zero)
            {
                UnhookWindowsHookEx(hKeyboardHook);
                hKeyboardHook = IntPtr.Zero;
            }
        }
 
        // Разгрузить крюк в деструкторе
        ~Keyboard()
        {
            Stop();
        }
    }
 
    //keyboarddecription
 
    public static class KeyboardDescription
    {
        private static char[] Alphabet = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
        private static Dictionary<int, string> KeyToDescriptionDictionary = new Dictionary<int, string>();
        private static Dictionary<string, int> DescriptionToKeyDictionary = new Dictionary<string, int>();
 
        static KeyboardDescription()
        {
            InitializeKeyToDescriptionDictionary();
            InitializeDescriptionToKeyDictionary();
        }
 
        private static void InitializeKeyToDescriptionDictionary()
        {
            
            
            //ROBIT
            KeyToDescriptionDictionary.Add(13, "Enter");
            KeyToDescriptionDictionary.Add(0x10, "Shift");
            KeyToDescriptionDictionary.Add(0x11, "ctrl");
 
 
            KeyToDescriptionDictionary.Add(9, "Tab");
            KeyToDescriptionDictionary.Add(20, "CapsLock");
            KeyToDescriptionDictionary.Add(32, "Space");
            KeyToDescriptionDictionary.Add(112, "F1");
            KeyToDescriptionDictionary.Add(113, "F2");
            KeyToDescriptionDictionary.Add(114, "F3");
            KeyToDescriptionDictionary.Add(115, "F4");
            KeyToDescriptionDictionary.Add(192, "`");
 
            // Буква A-Z
            for (int i = 65; i <= 90; i++)
            {
                KeyToDescriptionDictionary.Add(i, Alphabet[i - 65].ToString());
            }
 
            // Алфавитные номера клавиатуры
            for (int i = 48; i <= 57; i++)
                KeyToDescriptionDictionary.Add(i, (i - 48).ToString());
 
            // Область цифровой клавиатуры
            for (int i = 96; i <= 105; i++)
                KeyToDescriptionDictionary.Add(i, "D" + (i - 96));
        }
 
        private static void InitializeDescriptionToKeyDictionary()
        {
            foreach (var pair in KeyToDescriptionDictionary)
            {
                DescriptionToKeyDictionary.Add(pair.Value, pair.Key);
            }
        }
 
        public static string GetDescription(int keyValue)
        {
            if (KeyToDescriptionDictionary.ContainsKey(keyValue))
                return KeyToDescriptionDictionary[keyValue];
 
            return ((char)keyValue).ToString();
        }
 
        public static int GetKey(string description)
        {
            if (DescriptionToKeyDictionary.ContainsKey(description))
                return DescriptionToKeyDictionary[description];
 
            return 0;
        }
    }
    public class KeyTextBox : TextBox
    {
        public KeyTextBox()
        {
            this.TextAlign = HorizontalAlignment.Center;
            this.Font = new System.Drawing.Font("Times New Roman", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(134)));
        }
 
        public int KeyValue
        {
            get
            {
                return KeyboardDescription.GetKey(this.Text);
            }
            set
            {
                this.Text = KeyboardDescription.GetDescription(value);
            }
        }
 
        protected override bool IsInputKey(Keys keyData)
        {
            switch (keyData)
            {
                case Keys.Tab:
                    return true;
                default:
                    return base.IsInputKey(keyData);
            }
        }
 
        protected override void OnKeyUp(KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete || e.KeyCode == Keys.Back)
            {
                this.Text = "";
            }
            else
            {
                this.Text = KeyboardDescription.GetDescription(e.KeyValue);
                e.Handled = true;
            }
 
            base.OnKeyUp(e);
        }
 
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            e.Handled = true;
 
            base.OnKeyPress(e);
        }
    }
    public class WarKeyController : IWarKeyControl, IKeyDownEventHandler
    {
        private IWarKeyModel model;
        private IWarKeyView view;
        private IWarKeyModelRepository repository;
        private Keyboard keyboard;
        private frmMain frmMain;
 
        public WarKeyController(IWarKeyView view)
        {
            this.view = view;
            this.model = view.GetCurrent();
            this.repository = new WarKeyModelRepository();
 
            keyboard = new Keyboard(this);
        }
 
        public WarKeyController(frmMain frmMain)
        {
            this.frmMain = frmMain;
        }
 
        public void Save(string name, IWarKeyModel model)
        {
            this.model = model;
            repository.Update(name, model);
        }
 
        public IWarKeyModel Load(string name)
        {
            IWarKeyModel model = repository.Read(name);
            return model;
        }
 
        public bool Handle(KeyEventArgs e)
        {
            if (WarcraftWindow.IsForeground == false)
                return true;
 
            if (model.DisplayEnemysHP)
                WarcraftWindow.DisplayEnemysHP();
            if (model.DisplayAlliesHP)
                WarcraftWindow.DisplayAlliesHP();
 
            if (model.KeyMappers.ContainsKey(e.KeyValue))
            {
                WarcraftWindow.Send(model.KeyMappers[e.KeyValue]);
 
                // Когда пространство сопоставлено и не находится в состоянии чата, экран WAR переносится на ближайшую военную точку.
                if (e.KeyValue == 32 && WarcraftWindow.IsChating == false)
                    return false;
            }
 
            return true;
        }
    }
 
    public class WarKeyModelRepository : IWarKeyModelRepository
    {
        public void Create(string name, IWarKeyModel model)
        {
            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream stream = new MemoryStream();
            formatter.Serialize(stream, model);
            RegistryKey hklm = Registry.LocalMachine;
            RegistryKey hkSoftware = hklm.OpenSubKey("Software", true);
            RegistryKey hkWarKey = hkSoftware.CreateSubKey("WarKey");
            hkWarKey.SetValue(name, stream.ToArray());
 
            hkWarKey.Close();
        }
 
        public void Update(string name, IWarKeyModel model)
        {
            Create(name, model);
        }
 
        public void Delete(string name)
        {
            RegistryKey hklm = Registry.LocalMachine;
            RegistryKey hkSoftware = hklm.OpenSubKey("Software", true);
            RegistryKey hkWarKey = hkSoftware.CreateSubKey("WarKey");
            hkWarKey.DeleteValue(name, false);
 
            hkSoftware.Close();
        }
 
        public IWarKeyModel Read(string name)
        {
            IWarKeyModel model;
            byte[] bytesSaved;
 
            RegistryKey hklm = Registry.LocalMachine;
            RegistryKey hkSoftware = hklm.OpenSubKey("Software", true);
            RegistryKey hkWarKey = hkSoftware.CreateSubKey("WarKey");
            if (hkWarKey.GetValue(name) == null)
                bytesSaved = (byte[])hkWarKey.GetValue("default");
            else
                bytesSaved = (byte[])hkWarKey.GetValue(name);
 
            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream stream = new MemoryStream(bytesSaved);
            model = (IWarKeyModel)formatter.Deserialize(stream);
 
            return model;
        }
    }
    public static class WarcraftWindow
    {
        private static readonly uint WM_KEYDOWN = 0x100;
        private static readonly uint WM_KEYUP = 0x101;
        private static readonly int KEY_QUOTLEFT = 219;   // [ 
        private static readonly int KEY_QUOTRIGHT = 221;  // ] 
 
        // Используется для включения и отключения разрешения в токене доступа
        private static readonly int TOKEN_ADJUST_PRIVILEGES = 0x20;
        // Используется для запроса токена доступа
        private static readonly int TOKEN_QUERY = 0x8;
        // Флаг разрешения доступа
        private static readonly int SE_PRIVILEGE_ENABLED = 0x2;
 
        //private static readonly int PROCESS_ALL_ACCESS = 0x1F0FFF;
        private static readonly int PROCESS_VM_READ = 0x0010;
        private static readonly int PROCESS_VM_WRITE = 0x0020;
 
        [DllImport("user32.dll")]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
        [DllImport("user32.dll")]
        public static extern IntPtr GetForegroundWindow();
        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);
        //[DllImport("user32.dll")]
        //public static extern void keybd_event(Byte bVk, Byte bScan, Int32 dwFlags, Int32 dwExtraInfo);
 
        //API необходимы для повышения
        [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        public static extern int OpenProcessToken(IntPtr ProcessHandle, int DesiredAccess, ref IntPtr TokenHandle);
        [DllImport("advapi32.dll", EntryPoint = "LookupPrivilegeValueA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        public static extern int LookupPrivilegeValue(string lpSystemName, string lpName, ref LUID lpLuid);
        [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        public static extern int AdjustTokenPrivileges(IntPtr TokenHandle, int DisableAllPrivileges, ref TOKEN_PRIVILEGES NewState, int BufferLength, ref TOKEN_PRIVILEGES PreviousState, ref int ReturnLength);
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        public static extern int GetWindowThreadProcessId(IntPtr hwnd, out int ID);
 
        //Читать память
        [DllImportAttribute("kernel32.dll", EntryPoint = "ReadProcessMemory")]
        public static extern bool ReadProcessMemory(IntPtr hProcess, int lpBaseAddress, IntPtr lpBuffer, int nSize, IntPtr lpNumberOfBytesRead);
        [DllImport("kernel32.dll")]
        private static extern void CloseHandle(IntPtr hObject);
 
        #region 提升权限所需的结构体
        public struct LUID
        {
            // Младшие 32 бита локального уникального знака
            public int LowPart;
            // Верхние 32 бита местного уникального логотипа
            public int HighPart;
        }
 
        public struct LUID_AND_ATTRIBUTES
        {
            public LUID pLuid;
            // Атрибут LUID указан, и его значением может быть 32-битный флаг
            public int Attributes;
        }
 
        public struct TOKEN_PRIVILEGES
        {
            // Содержит набор сведений о разрешениях для токена доступа: разрешения, которые имеет токен доступа
            // Определяет емкость массива разрешений
            public int PrivilegeCount;
            // Укажите группу структур LUID_AND_ATTRIBUTES, каждая структура содержит атрибуты LUID и разрешения
            public LUID_AND_ATTRIBUTES Privileges;
        }
        #endregion
 
 
        /// <summary>
        /// Существует ли окно Warcraft? 
        /// </summary>
        public static bool Exisits
        {
            get { return FindWindow(null, "Warcraft III") != IntPtr.Zero; }
        }
 
        /// <summary>
        /// Является ли окно Warcraft передним фокусом
        /// </summary>
        public static bool IsForeground
        {
            get
            {
                IntPtr war3 = FindWindow(null, "Warcraft III");
                return war3 == GetForegroundWindow();
            }
        }
 
        /// <summary>
        /// В чате ли окно Warcraft?
        /// </summary>
        public static bool IsChating
        {
            get
            {
                // Считайте значение в адресе памяти, измененном во время состояния чата, открытый чат - 1, закрытый - 0, предустановка 0
                int isChating = 0;
                IntPtr tokenHandle = IntPtr.Zero;
                LUID privilegeLUID = new LUID();
                TOKEN_PRIVILEGES newPrivileges = new TOKEN_PRIVILEGES();
                TOKEN_PRIVILEGES tokenPrivileges = default(TOKEN_PRIVILEGES);
                OpenProcessToken(Process.GetCurrentProcess().Handle, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref tokenHandle);
                LookupPrivilegeValue("", "SeDebugPrivilege", ref privilegeLUID);
 
                tokenPrivileges.PrivilegeCount = 1;
                tokenPrivileges.Privileges.Attributes = SE_PRIVILEGE_ENABLED;
                tokenPrivileges.Privileges.pLuid = privilegeLUID;
                int Size = 4;
                IntPtr dota = FindWindow(null, "Warcraft III");
                if ((AdjustTokenPrivileges(tokenHandle, 0, ref tokenPrivileges, 4 + (12 * tokenPrivileges.PrivilegeCount), ref newPrivileges, ref Size)) != 0)
                {
                    int dotaID;
                    IntPtr dotaProcess;
                    GetWindowThreadProcessId(dota, out dotaID);
                    dotaProcess = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE, false, dotaID);
                    byte[] buffer = new byte[4];
                    IntPtr byteAddress = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);     //Получить адрес буфера
                    ReadProcessMemory(dotaProcess, 0x6FAE8450, byteAddress, 4, IntPtr.Zero);    //Считать значение в указанной памяти в буфер
                    CloseHandle(dotaProcess);
                    isChating = Marshal.ReadInt32(byteAddress);
                }
                return isChating == 1;
            }
        }
 
        /// <summary>
        /// Отправить ключ-значение (блок чата)
        /// </summary>
        /// <param name="keyValue"></param>
        public static void Send(int keyValue)
        {
            IntPtr war3 = FindWindow(null, "Warcraft III");
 
            if (war3 == IntPtr.Zero || IsChating)
                return;
 
            SendMessage(war3, WM_KEYDOWN, keyValue, 0); //это WInAPI и есть c++ если тебе интересна эта штука, то читай pinvoke  сайт и там все есть как вызывать функцию, как передать перехватить и т.тд я этими делами не занимаюсь и интереса нет к этому, так что увы, рад бы помочь
            SendMessage(war3, WM_KEYUP, keyValue, 0);
        }
 
        /// <summary>
        /// Показать врага HP
        /// </summary>
        public static void DisplayEnemysHP()
        {
            IntPtr war3 = FindWindow(null, "Warcraft III");
 
            if (war3 == IntPtr.Zero)
                return;
 
            SendMessage(war3, WM_KEYDOWN, KEY_QUOTRIGHT, 0);
        }
 
        /// <summary>
        /// Покажи дружескую кровь
        /// </summary>
        public static void DisplayAlliesHP()
        {
            IntPtr war3 = FindWindow(null, "Warcraft III");
 
            if (war3 == IntPtr.Zero)
                return;
 
            SendMessage(war3, WM_KEYDOWN, KEY_QUOTLEFT, 0);
        }
    }
 
 
    [Serializable]
    public class WarKeyModel : IWarKeyModel
    {
        private string name;
        private bool displayEnemysHP;
        private bool displayAlliesHP;
        private IDictionary<int, int> keyMappers;
 
        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="name">Название проекта</param>
        /// <param name="displayEnemysHP">Показать вражеские бары крови</param>
        /// <param name="displayAlliesHP">Покажи дружескую кровь</param>
        /// <param name="keyMappers">Раскладка клавиатуры</param>
        public WarKeyModel(string name, bool displayEnemysHP, bool displayAlliesHP, IDictionary<int, int> keyMappers)
        {
            this.name = name;
            this.displayEnemysHP = displayEnemysHP;
            this.displayAlliesHP = displayAlliesHP;
            this.keyMappers = keyMappers;
        }
 
        /// <summary>
        /// Название проекта
        /// </summary>
        public string Name
        {
            get { return this.name; }
        }
 
        /// <summary>
        /// Показать вражеские бары крови
        /// </summary>
        public bool DisplayEnemysHP
        {
            get { return this.displayEnemysHP; }
        }
 
        /// <summary>
        /// Покажи дружескую кровь
        /// </summary>
        public bool DisplayAlliesHP
        {
            get { return this.displayAlliesHP; }
        }
 
        /// <summary>
        /// Раскладка клавиатуры
        /// </summary>
        public IDictionary<int, int> KeyMappers
        {
            get { return this.keyMappers; }
        }
    }
 
}