C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Threading;

// Lösung Scavanger 2013

namespace ProcessList
{
    class Program
    {
        // Hinweis: Programm mit STRG+C beenden.
        static void Main(string[] args)
        {
            ProcessList procList = new ProcessList(new string[] { "explorer" });
            Dictionary<string, string> oldProcesses = procList.GetProcesses();
            Dictionary<string, string> curProcesses = null;

            Print(oldProcesses);

            while (true)
            {
                Thread.Sleep(500);
                curProcesses = procList.GetProcesses();
                if (curProcesses.CompareByKeys(oldProcesses))
                {
                    Console.Clear();
                    Print(curProcesses);
                   
                }
                oldProcesses = curProcesses;
            }
        }

        private static void Print(Dictionary<string, string> processes)
        {
            foreach (KeyValuePair<string, string> process in processes)
            {
                Console.WriteLine("Fenstername: {0}", process.Key);
                Console.WriteLine("Prozessname: {0}{1}", process.Value, Environment.NewLine);
            }
        }
    }

    /// <summary>
    /// Listet alle laufenden Prozesse auf die ein Fenster besitzen. (Prozessname, Fenstertitel)
    /// </summary>
    public class ProcessList
    {
        // List, da für Arrays keine Exists()-Erweiterung existiert.
        private List<string> _exculudeList;

        /// <summary>
        /// Erstellt eine neue ProcessList-Klasse, 
        /// </summary>
        /// <param name="exculdeList">Liste von Prozessnamen die nicht aufgelistet werden sollen. </param>
        /// <param name="listSelf">Wenn True, wird der aufrufende Prozess mit aufgelistet (Standard: False).</param>
        public ProcessList(string[] exculdeList, bool listSelf = false)
        {
            if (exculdeList == null)
                throw new ArgumentNullException("exculdeList");

            this._exculudeList = new List<string>(exculdeList);

            if (listSelf)
                this._exculudeList.Add(Process.GetCurrentProcess().ProcessName);
        }

        public Dictionary<string, string> GetProcesses()
        {
            return Process.GetProcesses()
                .Where(proc => proc.HasWindow() && this._exculudeList.Exists(excludeName => excludeName != proc.ProcessName))
                .ToDictionary(
                    proc => proc.MainWindowTitle,
                    proc => string.Format("{0} (PID: {1})", proc.ProcessName, proc.Id));
        }
    }

    public static class Extensions
    {
        /// <summary>
        /// Bestimmt ob ein Prozess ein Fenster besitzt.
        /// </summary>
        /// <param name="proc">Zu überpfrüfender Prozess</param>
        /// <returns>True wenn der Prozess ein Fenster besitzt.</returns>
        public static bool HasWindow(this Process proc)
        {
            return proc.MainWindowHandle != IntPtr.Zero;
        }

        /// <summary>
        /// Bestimmt ob zwei Dictionarys die gleichen Schlüssel besitzen.
        /// </summary>
        /// <typeparam name="TKey">Der Typ von Element Key</typeparam>
        /// <typeparam name="TElement">Der Typ von Element Element</typeparam>
        /// <param name="source">Das Dictionary</param>
        /// <param name="target">Das zu vergleichende Dictionary</param>
        /// <returns>True wenn die Dictionarys die gleichen Schlüssel besitzen.</returns>
        public static bool CompareByKeys<TKey, TElement>(this Dictionary<TKey, TElement> source, Dictionary<TKey, TElement> target)
        {
            return source.OrderBy(pair => pair.Key).SequenceEqual(target.OrderBy(pair => pair.Key));
        }
    }
}