Feedback

C# - Die Ausführungszeit einer Methode einschränken

Veröffentlicht von am 07.12.2007
(3 Bewertungen)
Es ist manchmal nützlich, die Zeit zu begrenzen, die eine Methode braucht um sich auszuführen. Zum Beispiel kann man der Ansicht sein, dass nach 30 Sekunden eine Aktion wirklich zu lange braucht und sie in diesem Fall abbricht.

Im unteren Beispiel, zeige ich wie man auf zwei verschiedene Arten die Klasse benutzt. Die die Ausführung einer Methode unterbricht wenn sie zuviel Zeit in Anspruch nimmt.

Benutzung:
private delegate void RunMethodDelegate();
private delegate void RunMethod2Delegate(string message);
private TL.TimeOutWatch.TimeOut to;

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.");
}
}

Viel Spaß :)
Snippet in VB übersetzen
/*
 * 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
    }
}

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!