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

Question

Ich habe dieses Programm, das gibt mir Syntaxfehler "System.Threading.Tasks.task enthält keine Definition für Ausführen."

Ich benutze VB 2010 .NET 4.0 Irgendwelche Ideen? irgendwelche Ersatz 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; 
      }); 
    } 
} 
} 

Answer 1

Es sieht wie Task.Factory.StartNew<T> ist, was Sie suchen.

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

Da der Compiler den Rückgabetyp entnehmen kann, funktioniert das auch:

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

Answer 2

Ich änderte den Code mit Task.Factory.StartNew Check Detail 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; 
      }); 
     } 

Answer 3

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

Es erklärt, dass Task.Run basic ist lly ein netter Wrapper, der in 4.5 eingeführt wurde.

Answer 4

Task.Factory.StartNew(() => 
     { 
      try 
      { 
       Thread.Sleep(200); 
       IntPtr TouchhWnd = IntPtr.Zero; 
       TouchhWnd = FindWindow(null, "屏幕键盘"); 
       if (TouchhWnd != IntPtr.Zero) 
       { 
        SetWindowPos(TouchhWnd, HWND_TOPMOST, 500, 500, 400, 300, SWP_SHOWWINDOW); 
       } 
      } 
      catch { } 
     }); 

Answer 5

Die highest voted answer, ist leider nicht genau correct:

Leider ist die einzigen Überlastungen für StartNew, die auch ein Taskscheduler nehmen Sie benötigen die CancellationToken und TaskCreationOptions angeben. Das bedeutet, dass, um Task.Factory.StartNew zu verwenden zuverlässig, vorhersagbar Arbeit des Thread-Pool Warteschlangen, müssen Sie eine Überlastung wie folgt verwenden:

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

So ist die nächste Sache, 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); 
} 

, die wie verwendet werden kann:

Task 
    .Factory 
    .StartNewOnDefaultScheduler(() => 
     result);