run - task method c#

¿Qué es un método de reemplazo para Task.Run en.NET 4.0 utilizando C#?

Question

Obtuve este programa que me da error de sintaxis "System.Threading.Tasks.task no contiene una definición para Ejecutar".

Estoy usando VB 2010 .NET 4.0 ¿Alguna idea? cualquier reemplazo para Ejecutar en .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

Cambié tu código con 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;
            });
        }

Answer 2

La respuesta más votada , lamentablemente, no es exactamente correct :

Desafortunadamente, las únicas sobrecargas para StartNew que toman TaskScheduler también requieren que especifique CancellationToken y TaskCreationOptions. Esto significa que para usar Task.Factory.StartNew para colacionar de manera confiable y predecible el grupo de subprocesos, debe usar una sobrecarga como esta:

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

Entonces, lo más parecido a Task.Run en 4.0 es algo así como:

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

que se puede usar como:

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

Answer 3

Lea esto: blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

Explica que Task.Run es básicamente un buen contenedor introducido en 4.5.

Answer 4

Parece que Task.Factory.StartNew<T> es lo que buscas.

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

Como el compilador puede inferir el tipo de retorno, esto también funciona:

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

Answer 5

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