it-swarm.com.de

Was ist eine Ersatzmethode für Task.Run in .NET 4.0 mit C #?

Ich habe dieses Programm erhalten, das den Syntaxfehler "System.Threading.Tasks.task enthält keine Definition für Run" ausgibt.

Ich verwende VB 2010 .NET 4.0 Irgendwelche Ideen? Irgendwelche Ersetzungen für 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;
            });
    }
}
}
73
Ace Caserya

Es sieht aus wie Task.Factory.StartNew<T> ist was du suchst.

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

Da der Compiler den Rückgabetyp ableiten kann, funktioniert dies auch:

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

Lesen Sie dies: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

Es erklärt, dass Task.Run im Grunde genommen ein Nice-Wrapper ist, der in 4.5 eingeführt wurde.

34
NPSF3000

Die am höchsten bewertete Antwort ist leider nicht genau richtig :

Leider erfordern die einzigen Überladungen für StartNew, die einen TaskScheduler benötigen, auch die Angabe von CancellationToken und TaskCreationOptions. Dies bedeutet, dass Sie eine Überladung wie die folgende verwenden müssen, um Task.Factory.StartNew für eine zuverlässige und vorhersehbare Warteschlangenfunktion für den Thread-Pool zu verwenden:

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

Also das Nächste zu Task.Run in 4.0 ist so etwas wie:

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

das kann verwendet werden wie:

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

Ich habe deinen Code mit Task.Factory.StartNew Geändert. Details überprüfen Link

 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

Falls Sie Microsoft.Bcl.Async verwenden, gehen Sie wie folgt vor:

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