asynchronous asynchrone - Quelle est une méthode de remplacement pour Task.Run dans.NET 4.0 en utilisant C#?




without await (5)

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

J'utilise VB 2010 .NET 4.0 Des idées? des remplacements 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;
            });
    }
}
}

Answers

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

Il explique que Task.Run est fondamentalement une belle enveloppe introduite dans 4.5.


La réponse la plus élevée , malheureusement, n'est pas tout à fait 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 de manière fiable, de manière prévisible, le travail en file d'attente vers le pool de threads, vous devez utiliser une surcharge comme 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);

J'ai changé votre code avec Task.Factory.StartNew check detail blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

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

Il semble que Task.Factory.StartNew<T> est ce que vous recherchez.

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

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

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

Historique de la version C #:

C # est un langage de programmation orienté objet simple et puissant développé par Microsoft.

C # a beaucoup évolué depuis sa première publication en 2002. C # a été introduit avec .NET Framework 1.0.

Le tableau suivant répertorie les fonctionnalités importantes introduites dans chaque version de C #.

Et la dernière version de C # est disponible dans les versions C # .





c# .net asynchronous task-parallel-library