What is a replacement method for Task.Run in .NET 4.0 using C#?

The highest voted answer, unfortunately, is not exactly correct:

Unfortunately, the only overloads for StartNew that take a TaskScheduler also require you to specify the CancellationToken and TaskCreationOptions. This means that in order to use Task.Factory.StartNew to reliably, predictably queue work to the thread pool, you have to use an overload like this:

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

So the closest thing to Task.Run in 4.0 is something like:

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

that can be used like:

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

I changed your code with 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;
            });
        }

In case you're using Microsoft.Bcl.Async here you go:

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

It looks like Task.Factory.StartNew<T> is what you're after.

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

Since the compiler can infer the return type, this also works:

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