Délai d'expiration de la tâche C #

Je dois exécuter un long processus de fonctionnement dans un thread et continuer en retournant le résultat d'une fonction. Voici mon code :

Task<ProductEventArgs>.Factory.StartNew(() =>
    {
        try
        {
             //long operation which return new ProductEventArgs with a list of product

        }
        catch (Exception e)
        {
            return new ProductEventArgs() { E = e };
        }

    }).ContinueWith((x) => handleResult(x.Result), TaskScheduler.FromCurrentSynchronizationContext());

Le problème est en réalité je n'ai pas de délai d'attente. J'ai envie de mettre une minuterie afin de retourner quelque chose comme ceci :

   new ProductEventArgs() { E = new Exception("timeout") };

si le délai est atteint.
Ne pouvez pas utiliser les attendent/async.
Merci beaucoup !

source d'informationauteur Rototo

  1. 5

    Ce code fait ce que vous avez exprimé ici:

    var timeout = TimeSpan.FromSeconds(5);

var actualTask = new Task<ProductEventArgs>(() =>
{
    var longRunningTask = new Task<ProductEventArgs>(() =>
    {
        try
        {
            Thread.Sleep(TimeSpan.FromSeconds(10)); //simulates the long running computation
            return new ProductEventArgs();
        }
        catch (Exception e)
        {
            return new ProductEventArgs() { E = e };
        }
    }, TaskCreationOptions.LongRunning);

    longRunningTask.Start();

    if (longRunningTask.Wait(timeout)) return longRunningTask.Result;

    return new ProductEventArgs() { E = new Exception("timed out") };
});

actualTask.Start();

actualTask.Wait();

Console.WriteLine("{0}", actualTask.Result.E); //handling E

    Comme vous le voyez longRunningTask est créé avec TaskCreationOptions.LongRunning option. De cette façon, il aura un dédié Thread pour son exécution et ne pas interférer avec le comportement normal de ThreadPool par l'occupation d'un thread il y a trop longtemps - qui seront nécessaires pour autre chose comme par exemple l'INTERFACE utilisateur. Qui est important pour les tâches longues.

    Remarque: Vous pouvez ensuite gérer actualTask avec ContinueWith mais j'ai voulu exprimer l'essence ici.

  2. 12

    Vous devez utiliser CancellationTokens:

    var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
var token = cts.Token;
Task<ProductEventArgs>.Factory.StartNew(() =>
{
    try
    {
        //occasionally, execute this line:
        token.ThrowIfCancellationRequested();
    }
    catch (OperationCanceledException)
    {
        return new ProductEventArgs() { E = new Exception("timeout") };
    }
    catch (Exception e)
    {
        return new ProductEventArgs() { E = e };
    }

}).ContinueWith((x) => handleResult(x.Result), TaskScheduler.FromCurrentSynchronizationContext());
  3. 3

    Vous pouvez utiliser retourné objet de tâche pour StartNew méthode, puis l'utilisateur d'Attendre méthode pour déterminer le délai d'attente.

    Task<ProductEventArgs> task = Task<ProductEventArgs>.Factory.StartNew(() => {...});
if (!Task.Wait(new TimeSpan(0,0,1,0)) //wait for 1 minute
{
   //throw exception or something else if timeout
}
  4. 1

    Vous pouvez exécuter une Task.Delay(timeout) tâche en parallèle et vérifier ce que la tâche a été la première à terminer (Task.WhenAny() est très pratique dans ce cas):

    public void FetchProduct(TimeSpan timeout)
{
    var fetchTask = Task<ProductEventArgs>.Factory.StartNew(
        () =>
        {
            try
            {
                //long operation which return new ProductEventArgs with a list of product
            }
            catch(Exception e)
            {
                return new ProductEventArgs() { E = e };
            }
        });
    Task<ProductEventArgs> resultTask;
    if(timeout != Timeout.InfiniteTimeSpan)
    {
        var timeoutTask = Task.Delay(timeout);
        resultTask = Task.WhenAny(resultTask, timeoutTask).ContinueWith<ProductEventArgs>(
            t =>
            {
                //completed task is the result of WhenAny
                if(t.Result == fetchTask)
                {
                    return fetchTask.Result;
                }
                else
                {
                    return new ProductEventArgs() { E = new TimeoutException() };
                }
            });
    }
    else
    {
        resultTask = fetchTask;
    }
    resultTask.ContinueWith(x => handleResult(x.Result), TaskScheduler.FromCurrentSynchronizationContext());
}

    Noter que cette solution n'a pas toute annulation de la logique, vos tâches en cours d'exécution sera toujours en cours d'exécution, même si c'.

  5. 0

    Juste de commencer une autre tâche à l'intérieur de la tâche principale (de substitution):

    Task.Factory.StartNew(() => 
        {
            //returns a string result
            var tsk = new Task<string>(() => { return VeryImportantThingsToDo(); });
            try
            {
                tsk.Start();
                if (!tsk.Wait(5000))
                    throw new TimeoutException();
                return tsk.Result;
            }
            catch (TimeoutException)
            {
                //Jabba Dabba Doooooooohhhhhh
            }

            return "<unknown>";
        }).ContinueWith((o) => string result = o.Result));