C# - Prozesse blockieren

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;

namespace Block
{
    public static class ProcessBlocker
    {
        private static Timer tm = null;
        private static List<string> blocked = new List<string>();
        
        /// <summary>
        /// Das Interval, in welchem die Abfrage gestartet wird, die die offenen Prozesse prüft.
        /// </summary>
        public static int CheckingInterval
        {
            get
            {
                return tm.Interval;
            }
            set
            {
                tm.Interval = value;
            }
        }


        public enum Block { IfContains, IfIs }
        /// <summary>
        /// Der Blockierungsmodus. IfContains: blockiert Prozesse, wenn der Prozessname eines der Elemente in der Liste geblockter Elemente enthällt.
        /// </summary>
        public static Block BlockMode { get; set; }
        /// <summary>
        /// Gibt an, ob Prozesse geblockt werden sollen.
        /// </summary>
        public static bool Enabled { get; set; }
        /// <summary>
        /// Gibt an, ob beim Abgleich von Prozessnamen und Elementen in der Liste zu blockender Prozesse die Groß- und Kleinschreibung beachtet wird.
        /// </summary>
        public static bool CaseSensitive { get; set; }
        /// <summary>
        /// Gibt an, ob beim Beenden des Prozesses eine Nachricht angezeigt werden soll.
        /// </summary>
        public static bool ShowKillMessage { get; set; }

        private static void tm_Tick(object sender, EventArgs e)
        {
            if (Enabled)
            {
                foreach (Process p in Process.GetProcesses())
                {
                    bool block = false;
                    string msgGerman = "Sie sind nicht zu der Ausführung dieses Prozesses berechtigt.";
                    string msgEnglish = "You're not allowed to run this process.";
                    string outp = string.Empty;
                    switch (BlockMode)
                    {
                        case Block.IfContains:
                            if (p.ProcessName.ContainsListItem(blocked, out outp))
                                block = true;
                            else if (!CaseSensitive & p.ProcessName.ToLower().ContainsListItem(blocked, out outp))
                                block = true;
                            if (block)
                            {
                                msgGerman = "Sie können keine Prozesse, deren Namen '" + outp + "' enthällt ausführen.";
                                msgEnglish = "You can't run processes, which's names contain '" + outp + "'.";
                            }
                            break;
                        case Block.IfIs:
                            if (blocked.Contains(p.ProcessName))
                                block = true;
                            else if (!CaseSensitive & blocked.ToLowerList().Contains(p.ProcessName.ToLower()))
                                block = true;
                            if (block)
                            {
                                msgGerman = "Sie können keine Prozesse, dmit dem Namen '" + outp + "' ausführen.";
                                msgEnglish = "You can't run processes, which are named '" + outp + "'.";
                            }
                            break;
                    }
                    if (block)
                    {
                        p.Kill();
                        if (ShowKillMessage)
                            MessageBox.Show("[English]\n" + msgEnglish + "\n\n[Deutsch]\n" + msgGerman, "Block", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
        }

        /// <summary>
        /// Fügt einen Prozess zur Liste zu blockender Prozesse hinzu.
        /// </summary>
        /// <param name="name">Der Prozessname.</param>
        public static void BlockProcess(string name)
        {
            try
            {
                if (tm == null)
                    Initialize(1000);
                blocked.Add(name);
            }
            catch
            {
            }
        }

        /// <summary>
        /// Entfernt alle Prozesse aus der Liste zu blocktender Prozesse.
        /// </summary>
        public static void StopAllProcessesBeBlocked()
        {
            while (blocked.Count >= 1)
                blocked.RemoveAt(0);
        }

        /// <summary>
        /// Entfernt einen Prozess aus der Liste zu blockender Prozesse.
        /// </summary>
        /// <param name="name">Der Prozessname.</param>
        public static void StopBlockProcess(string name)
        {
            try
            {
                blocked.Remove(name);
            }
            catch
            {
            }
        }

        /// <summary>
        /// Liefert eine Liste aller zu blockender Prozesse.
        /// </summary>
        /// <returns>Die Liste :)</returns>
        public static List<string> GetBlockedProcesses()
        {
            return blocked;
        }

        /// <summary>
        /// Stellt fest, ob ein Prozess eines speziellen Namens geblockt wird.
        /// </summary>
        /// <param name="name">Der Name dieses Prozesses.</param>
        /// <returns>Das Resultat der Prüfung. true: wird geblockt; false: wird nicht geblockt</returns>
        public static bool IsBlocked(string name)
        {
            List<string> blockedCS = blocked;
            if (!CaseSensitive)
            {
                name = name.ToLower();
                blockedCS = blocked.ToLowerList();
            }
            return blockedCS.Contains(name);
        }

        /// <summary>
        /// Initiallisiert den ProzessBlockierer
        /// </summary>
        /// <param name="checkingInterval"></param>
        public static void Initialize(int checkingInterval)
        {
            tm = new Timer();
            tm.Interval = checkingInterval;
            tm.Tick += new EventHandler(tm_Tick);
            tm.Enabled = true;
        }

        private static bool ContainsListItem(this string str, List<string> list)
        {
            string o;
            return str.ContainsListItem(list, out o);
        }

        private static bool ContainsListItem(this string str, List<string> list, out string listItem)
        {
            if (!CaseSensitive)
            {
                list = list.ToLowerList();
                str = str.ToLower();
            }
            foreach (string s in list)
            {
                if (str.Contains(s))
                {
                    listItem = s;
                    return true;
                }
            }
            listItem = string.Empty;
            return false;
        }

        private static List<string> ToLowerList(this List<string> list)
        {
            for (int i = 0; i < list.Count; i++)
                list[i] = list[i].ToLower();
            return list;
        }
    }
}