zeitgesteuerte Klasse

public Form1()
{
    InitializeComponent();
    to = new TL.TimeOutWatch.TimeOut();
}

private void LongThread()
{
    System.Threading.Thread.Sleep(5000);
    MessageBox.Show("Beendet");
}

private void LongThread(string message)
{
    System.Threading.Thread.Sleep(5000);
    MessageBox.Show(message);
}

private void button1_Click(object sender, EventArgs e)
{
    if(!to.DoIt(new RunMethodDelegate(LongThread), TimeSpan.FromSeconds(2)))
        MessageBox.Show("Achtung, festgelegte Zeit wurde überschritten.");
}

private void button2_Click(object sender, EventArgs e)
{
    if (!to.DoIt(new RunMethod2Delegate(LongThread), new object[] { textBox1.Text }, TimeSpan.FromSeconds(10)))
    {
        MessageBox.Show("Achtung, festgelegte Zeit wurde überschritten.");
    }
}




*
 * TimeOutWatch - Die Ausführungszeit einer Methode einschränken
 * --------------------------------------------------------------
 * Version: 1.0
 * Copyright © 2007 Konstantin Gross
 * http://www.texturenland.de
 *
*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace TL.TimeOutWatch
{
    /// <summary>
    /// Die Ausführungszeit einer Methode kontrollieren.
    /// </summary>
    public class TimeOut
    {
        private AutoResetEvent evnt = new AutoResetEvent(false);

        public delegate void RunMethodDelegate();

        /// <summary>
        /// Führt die Methode aus, die in einer festgesetzen Zeit erfolgen soll.
        /// </summary>
        /// <param name="runMethod">Methode zum ausführen</param>
        /// <param name="timeout">Zu erwartende Höchstzeit, bevor die Ausführung der Methode abgebrochen wird</param>
        /// <returns>True, wenn die Ausführung der Methode vor dem Timeout zu Ende gegangen ist. False wenn das Timeout überschritten wurde.</returns>
        public bool DoIt(Delegate runMethod, TimeSpan timeout)
        {
            return this.DoIt(runMethod, null, timeout);
        }

        /// <summary>
        /// Führt die Methode aus, die in einer festgesetzten Zeit erfolgen soll und übergibt die für sie bestimmte Parameter.
        /// </summary>
        /// <param name="runMethod">Methode zum ausführen</param>
        /// <param name="parameters">Parametertabelle</param>
        /// <param name="timeout">Zu erwartende Höchstzeit, bevor die Ausführung der Methode abgebrochen wird</param>
        /// <returns>True, wenn die Ausführung der Methode vor dem Timeout zu Ende gegangen ist. False wenn das Timeout überschritten wurde.</returns>
        public bool DoIt(Delegate runMethod, object[] parameters, TimeSpan timeout)
        {
            return this.DoItImp(runMethod, parameters, timeout);
        }

        /// <summary>
        /// Führt die Methode mittels Delegate und übergebenen Parametern, die in der festgesetzen Zeit ausgeführt wurde.
        /// </summary>
        /// <param name="d">Auszuführendes Delegate</param>
        /// <param name="parameters">Zu übergebende Paramter für das Delegate</param>
        /// <param name="timeout">Zu erwartende Höchstzeit, bevor die Ausführung des Delegates abgebrochen wird</param>
        /// <returns>True, wenn die Ausführung des Delegates vor dem Timeout zu Ende gegangen ist. False wenn das Timeout überschritten wurde.</returns>
        private bool DoItImp(Delegate d, object[] parameters, TimeSpan timeout)
        {
            Worker w = new Worker(d, parameters, this.evnt);
            Thread t = new Thread(new ThreadStart(w.Run));

            evnt.Reset();
            t.Start();

            if (evnt.WaitOne(timeout, false))
            {
                return true;
            }
            else
            {
                t.Abort();
                return false;
            }
        }

        #region Worker Klasse
        private class Worker
        {
            private AutoResetEvent evnt;
            public Delegate method;
            public object[] parameters;

            public Worker(Delegate method, object[] parameters, AutoResetEvent evnt)
            {
                this.method = method;
                this.parameters = parameters;
                this.evnt = evnt;
            }

            public void Run()
            {
                this.method.DynamicInvoke(parameters);
                evnt.Set();
            }
        }
        #endregion
    }
}