Jeu de délai d'attente pour une opération

J'ai de l'objet obj qui est la 3ème partie de la composante,

//this could take more than 30 seconds
int result = obj.PerformInitTransaction();

Je ne sais pas ce qui se passe à l'intérieur.
Ce que je sais, c'est si c'prendre plus de temps, il est échoué.

comment configurer un mécanisme d'expiration de cette opération, de sorte que si cela prend plus de 30 secondes, je viens de jeter MoreThan30SecondsException ?

InformationsquelleAutor Anwar Chandra | 2010-02-15

c#multithreading timeout

Vous pouvez exécuter l'opération dans un thread séparé et puis mettre un timeout sur le fil opération de jointure:

using System.Threading;

class Program {
    static void DoSomething() {
        try {
            //your call here...
            obj.PerformInitTransaction();         
        } catch (ThreadAbortException) {
            //cleanup code, if needed...
        }
    }

    public static void Main(params string[] args) {

        Thread t = new Thread(DoSomething);
        t.Start();
        if (!t.Join(TimeSpan.FromSeconds(30))) {
            t.Abort();
            throw new Exception("More than 30 secs.");
        }
    }
}

J'ai roulé en arrière de votre édition, le Exception je lance ne doit pas être un ThreadAbortException, qui est quelque chose qui arrive par le CLR lors d'un appel Abort est faite.
désolé et merci pour l'entrée 🙂
C'est un appel bloquant, si vous avez besoin de le thread principal de faire d'autres choses en ce moment cela ne marchera pas !
Cette solution bloque le thread parent

InformationsquelleAutor Paolo Tedesco

13

Plus simplement à l'aide de Tâche.Attendre(TimeSpan):
```
using System.Threading.Tasks;

var task = Task.Run(() => obj.PerformInitTransaction());
if (task.Wait(TimeSpan.FromSeconds(30)))
    return task.Result;
else
    throw new Exception("Timed out");
```
- C'est très simple et est disponible depuis .net 4.0.
- Cela ne va pas tuer le fil si
- Je vais courir dans cette réponse, là encore, et je suis en utilisant .NET Framework 4.0, donc s'il vous plaît laissez-moi de vous corriger: la Tâche.Run est disponible à partir de .NET 4.5 partir. lien
- Ce ne sera pas la fin du thread. Il est suggéré d'utiliser avec CancellationToken.
InformationsquelleAutor Colonel Panic
6

Si vous ne voulez pas bloquer le thread principal, vous pouvez utiliser un Système.Le filetage.Minuterie:
```
private Thread _thread;

void Main(string[] args)
{
    _thread = new ThreadStart(ThreadEntry);
    _thread.Start();
    Timer timer = new Timer(Timeout,null,30000,Timeout.Infinite);
}


void ThreadEntry()
{
    int result = obj.PerformInitTransaction(); 
}

void TimeOut(object state)
{
    //Abort the thread - see the comments
    _thread.Abort();

    throw new ItTimedOutException();
}
```
Jon Skeet a moins d'user de la manière forte (L'Arrêt De Threads De Travail Gracieusement) de l'arrêt du thread que de l'abandonner.

Cependant, comme vous n'êtes pas dans le contrôle des opérations PerformInitTransaction() fait il n'y a pas beaucoup que vous pouvez faire à partir de quand Abandonner échoue et les feuilles de l'objet dans un état non valide. Tel que mentionné si vous êtes en mesure pour le nettoyage de tout ce que l'abandon de la PerformInitTransaction a laissé en suspens, vous pouvez le faire par la capture de l' ThreadAbortException, même si, comme c'est un 3ème appel du parti, il va dire de deviner l'état où vous l'avez laissé leur méthode.

La PerformInitTransaction devrait vraiment être le seul à l'expiration du délai.

InformationsquelleAutor Chris S
2

Vous devez être prudent au sujet de l'abandon d'une opération de ce genre, surtout que c'est dans une 3ème partie composant que vous avez (peut-être) n'ont pas accès au code afin de le modifier.

Si vous annuler l'opération, alors vous ne savez pas dans quel état vous avez laissé la classe sous-jacente dans. Par exemple, il peut avoir acquis une serrure, et votre sujet a causé la serrure pour être libéré. Même si vous détruisez l'objet après l'abandon de l'opération, elle peut avoir modifié un certain état qui est globale et, par conséquent, vous ne serez pas en mesure fiable de créer une nouvelle instance, sans redémarrage.

InformationsquelleAutor Sean

Voici deux implémentations qui a également jeter toute exception qui se produit à l'intérieur de la tâche.

Pour les actions (pas de valeur de retour):

public static bool DoWithTimeout(Action action, int timeout)
{
    Exception ex = null;
    CancellationTokenSource cts = new CancellationTokenSource();
    Task task = Task.Run(() =>
    {
        try
        {
            using (cts.Token.Register(Thread.CurrentThread.Abort))
            {
                action();
            }
        }
        catch (Exception e)
        {
            if (!(e is ThreadAbortException))
                ex = e;
        }
    }, cts.Token);
    bool done = task.Wait(timeout);
    if (ex != null)
        throw ex;
    if (!done)
        cts.Cancel();
    return done;
}

Pour Funcs (avec une valeur de retour):

public static bool DoWithTimeout<T>(Func<T> func, int timeout, out T result)
{
    Exception ex = null;
    result = default(T);
    T res = default(T);
    CancellationTokenSource cts = new CancellationTokenSource();
    Task task = Task.Run(() =>
    {
        try
        {
            using (cts.Token.Register(Thread.CurrentThread.Abort))
            {
                res = func();
            }
        }
        catch (Exception e)
        {
            if (!(e is ThreadAbortException))
                ex = e;
        }
    }, cts.Token);
    bool done = task.Wait(timeout);
    if (ex != null)
        throw ex;
    if (done)
        result = res;
    else
        cts.Cancel();
    return done;
}

InformationsquelleAutor Gilad Rave

1

Vous pouvez regarder à l'invocation de la méthode dans un thread et sur le délai d'attente, interrompre le fil et de soulever l'exception. Aussi, vous avez à gérer la ThreadBorted Exception dans ce cas.
- Vous avez raison sur le ThreadAbortedException, +1.
InformationsquelleAutor Kangkan
0

Il est un bel exemple d'une solution générique à présent à l'aide d'une classe d'assistance ici.

Il utilise l'Action de déléguer afin d'éviter la création de Thread/destruction montré dans l'exemple précédent.

J'espère que cette aide.

InformationsquelleAutor BrianB

c'est ce que j'allais utiliser. fonctionne de manière similaire à la façon dont un javascript délai d'attente de travaux.

public class Toolz {
    public static System.Threading.Tasks.Task<object> SetTimeout(Func<object> func, int secs) {
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(secs));
        return System.Threading.Tasks.Task.Run(() => func());
    }
}

class Program {
    static void Main(string[] args) {
        Console.WriteLine(DateTime.Now);
        Toolz.SetTimeout(() => {
            Console.WriteLine(DateTime.Now);
            return "";
        }, 10);
    }

}

InformationsquelleAutor Mike

J'ai juste couru dans ce dans une .NET 4.0 application (pas d'accès à Task.Run, Task.Delay, etc.). Si vous voulez bien excuser la dernière ligne (ce qui est le setTimeout partie), c'est assez concis.

int sleepTime = 10000;
Action myAction = () => {
    //my awesome cross-thread update code    
    this.BackColor = Color.Red;
};
new System.Threading.Thread(() => { System.Threading.Thread.Sleep(sleepTime); if (InvokeRequired) myAction(); else myAction(); }).Start();

InformationsquelleAutor user875234

Je pense que c'est plus simple de toutes:

using System.Threading.Tasks;

var timeToWait = 30000; //ms
Task.Run(async () =>
{
    await Task.Delay(timeToWait);
    //do your timed task i.e. --
    int result = obj.PerformInitTransaction(); 
});

InformationsquelleAutor Ariful Islam

Vous devez vous connecter pour publier un commentaire.