Feedback

C# - Prozesse blockieren

Veröffentlicht von am 18.02.2014
(1 Bewertungen)
Mit der folgednen Klasse kann man einfach beliebige Prozesse blockieren.

Die Eigenschaft Enabled steht standardmäßig auf false und muss auf true gesetzt werden, um den ProcessBlocker zu aktivieren.

Den Rest halte ich auf Grund der Summary für selbsterklärend.. :)
GFU-Schulungen  [Anzeige]

C# Grundlagen

Die Schulung vermittelt Ihnen die Grundlagen von C# in der Arbeit mit Datentypen sowie bei Klassenbibliotheken. Sie lernen, mit Variablen umzugehen und deren verschiedene Formen zu konvertieren. 

VB.NET Komplett

Sie stehen vo der Aufgabe, individuelle Anwendungen für Windows zu schreiben. Hier ist VB.NET die optimale Sprache. Sie erlernt sich recht leicht und passt sich komplett in die .NET Umgebung von Microsoft ein. Nach der Schulung entwickeln Sie anwenderfreundliche Programme in VB.NET . Mit den objektorientierten Modellen in VB.NET erzeugen Sie außerdem wiederverwendbare Komponenten.

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;
        }
    }
}

1 Kommentare zum Snippet

Koopakiller schrieb am 19.02.2014:
Statt dem Timer wäre es besser, sich darum zu kümmern, benachrichtigt zu werden, wenn ein neuer Prozess auftaucht. Auch StackOverflow habe ich mal eine Lösung gefunden, die bei mir ohne Probleme lief. Auch das implementieren war nicht all zu schwer.
http://stackoverflow.com/questions/1986249/net-process-monitor
Wenn du dein Snippet also noch verbessern willst ;)
 

Logge dich ein, um hier zu kommentieren!