web-dev-qa-db-fra.com

Quelle est la méthode de remplacement pour Task.Run dans .NET 4.0 en utilisant C #?

J'ai ce programme qui me donne l'erreur de syntaxe "System.Threading.Tasks.task ne contient pas de définition pour Run."

J'utilise VB 2010 .NET 4.0 Des idées? Des remplaçants pour Run in .net 4.0?

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

namespace ChatApp
{
class ChatProg
{
    static void Main(string[] args)
    {
        Task<int> wakeUp = DoWorkAsync(2000,"Waking up");
        Task.WaitAll(wakeUp);
    }

    static Task<int> DoWorkAsync(int milliseconds, string name)
    {

        //error appears below on Word Run
        return Task.Run(() =>
            {
                Console.WriteLine("* starting {0} work", name);
                Thread.Sleep(milliseconds);
                Console.WriteLine("* {0} work one", name);
                return 1;
            });
    }
}
}
c#.netasynchronoustask-parallel-library
73
Ace Caserya

Ça ressemble à Task.Factory.StartNew<T> est ce que vous recherchez.

return Task.Factory.StartNew<int>(() => {
    // ...
    return 1;
});

Comme le compilateur peut déduire le type de retour, cela fonctionne aussi:

return Task.Factory.StartNew(() => {
    // ...
    return 1;
});
85
McGarnagle

Lisez ceci: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

Il explique que Task.Run est fondamentalement un wrapper Nice introduit dans la version 4.5.

34
NPSF3000

Le réponse la plus votée , malheureusement, n'est pas exactement correct :

Malheureusement, les seules surcharges pour StartNew qui prennent un TaskScheduler nécessitent également que vous spécifiiez CancellationToken et TaskCreationOptions. Cela signifie que pour utiliser Task.Factory.StartNew afin de mettre en file d'attente de manière fiable et prévisible le travail dans le pool de threads, vous devez utiliser une surcharge telle que celle-ci:

Task.Factory.StartNew (A, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

Donc, la chose la plus proche de Task.Run dans 4.0 est quelque chose comme:

/// <summary>
/// Starts the new <see cref="Task"/> from <paramref name="function"/> on the Default(usually ThreadPool) task scheduler (not on the TaskScheduler.Current).
/// It is a 4.0 method nearly analogous to 4.5 Task.Run.
/// </summary>
/// <typeparam name="T">The type of the return value.</typeparam>
/// <param name="factory">The factory to start from.</param>
/// <param name="function">The function to execute.</param>
/// <returns>The task representing the execution of the <paramref name="function"/>.</returns>
public static Task<T> StartNewOnDefaultScheduler<T>(this TaskFactory factory, Func<T> function)
{
    Contract.Requires(factory != null);
    Contract.Requires(function != null);

    return factory
        .StartNew(
            function,
            cancellationToken: CancellationToken.None,
            creationOptions: TaskCreationOptions.None,
            scheduler: TaskScheduler.Default);
}

qui peut être utilisé comme:

Task
    .Factory
    .StartNewOnDefaultScheduler(() => 
        result);
9
Eugene Podskal

J'ai changé votre code avec Task.Factory.StartNew détail de vérification lien

 static Task<int> DoWorkAsync(int milliseconds, string name)
        {


            //error appears below on Word Run
            return   Task.Factory.StartNew(() =>
            {
                Console.WriteLine("* starting {0} work", name);
                Thread.Sleep(milliseconds);
                Console.WriteLine("* {0} work one", name);
                return 1;
            });
        }
5
Saroop Trivedi

Si vous utilisez Microsoft.Bcl.Async vous allez:

return TaskEx.Run(() =>
{
    Console.WriteLine("* starting {0} work", name);
    Thread.Sleep(milliseconds);
    Console.WriteLine("* {0} work one", name);
    return 1;
});
1
Karmakulov Kirill