标签: task-parallel-library

我正在寻找除了CancellationTokenSource类之外还引入.NET CancellationToken结构的原因.我的理解是如何的API被使用,但想也明白为什么它就是这样设计的.

即,我们为什么要:

var cts = new CancellationTokenSource();
SomeCancellableOperation(cts.Token);

...
public void SomeCancellableOperation(CancellationToken token) {
    ...
    token.ThrowIfCancellationRequested();
    ...
}

而不是直接传递CancellationTokenSource,如:

var cts = new CancellationTokenSource();
SomeCancellableOperation(cts);

...
public void SomeCancellableOperation(CancellationTokenSource cts) {
    ...
    cts.ThrowIfCancellationRequested();
    ...
}

这是一个基于以下事实的性能优化:取消状态检查比传递令牌更频繁吗？

因此CancellationTokenSource可以跟踪和更新CancellationTokens,并且对于每个令牌,取消检查是本地字段访问？

鉴于两种情况下没有锁定的挥发性bool就足够了,我仍然无法理解为什么会更快.

谢谢!

我正在实现一个方法,Task<Result> StartSomeTask()并且在调用方法之前就已经知道了结果.如何创建已完成的Task <T>？

这就是我目前正在做的事情:

private readonly Result theResult = new Result();

public override Task<Result> StartSomeTask()
{
    var task = new Task<Result>(() => theResult);
    task.RunSynchronously(CurrentThreadTaskScheduler.CurrentThread);
    return task;
}

有更好的解决方案吗？

我想触发一个在后台线程上运行的任务.我不想等待任务完成.

在.net 3.5中,我会这样做:

ThreadPool.QueueUserWorkItem(d => { DoSomething(); });

在.net 4中,TPL是建议的方式.我见过的常见模式是:

Task.Factory.StartNew(() => { DoSomething(); });

但是,该StartNew()方法返回一个Task实现的对象IDisposable.推荐这种模式的人似乎忽视了这一点.有关该Task.Dispose()方法的MSDN文档说:

"在释放对任务的最后一个引用之前,始终调用Dispose."

你不能在任务完成之前调用dispose,所以让主线程等待并调用dispose会首先打破后台线程上的操作.似乎也没有任何已完成/已完成的事件可用于清理.

Task类上的MSDN页面没有对此进行评论,并且"Pro C#2010 ..."一书推荐了相同的模式,并且没有对任务处理做出评论.

我知道如果我离开它,终结者最终会抓住它,但当我做了大量的火灾并且忘记了这样的任务并且终结者线程被淹没时,它会回来咬我吗？

所以我的问题是:

• 是否可以接受不叫Dispose()就Task在这种情况下类？如果是这样,为什么会有风险/后果？
• 有没有讨论这个的文件？
• 或者是否有适当的方法来处理Task我错过的物体？
• 或者是否有其他方法可以使用TPL执行解雇和忘记任务？

有什么区别:

public ActionResult Login(LoginViewModel model, string returnUrl)
{
    if (ModelState.IsValid)
    {
        IdentityResult result = IdentityManager.Authentication.CheckPasswordAndSignIn(AuthenticationManager, model.UserName, model.Password, model.RememberMe);
        if (result.Success)
        {
            return Redirect("~/home");
        }
        else
        {
            AddErrors(result);
        }
    }
    return View(model);
}

和:

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
    if (ModelState.IsValid)
    {
        IdentityResult result = await IdentityManager.Authentication.CheckPasswordAndSignInAsync(AuthenticationManager, model.UserName, model.Password, model.RememberMe);
        if (result.Success)
        {
            return Redirect("~/home");
        }
        else
        {
            AddErrors(result);
        }
    }
    return View(model);
}

我看到MVC代码现在有异步,但有什么区别.一个人的表现比另一个人好得多吗？调试一个问题比另一个问题更容易吗？我是否应该为我的应用程序更改其他控制器以添加异步？

当用户加载页面时,它会发出一个或多个ajax请求,这些请求会命中ASP.NET Web API 2控制器.如果用户导航到另一个页面,则在这些ajax请求完成之前,浏览器会取消这些请求.然后,我们的ELMAH HttpModule为每个取消的请求记录两个错误:

错误1:

System.Threading.Tasks.TaskCanceledException: A task was canceled.
   at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter`1.GetResult()
   at System.Web.Http.Controllers.ApiControllerActionInvoker.<InvokeActionAsyncCore>d__0.MoveNext()
--- End of stack trace from previous location where exception was thrown ---
   at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()
   at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter`1.GetResult()
   at System.Web.Http.Controllers.ActionFilterResult.<ExecuteAsync>d__2.MoveNext()
--- End of stack trace from previous location where exception was thrown ---
   at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()
   at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at System.Web.Http.Filters.AuthorizationFilterAttribute.<ExecuteAuthorizationFilterAsyncCore>d__2.MoveNext()
--- End of stack trace from previous location where exception was …

我在当前项目中使用TPL并使用Parallel.Foreach来旋转多个线程.Task类包含Wait()以等待任务完成.像这样,我如何等待Parallel.ForEach完成然后执行下一个语句？

如果我不关心任务完成的顺序,只需要完成它们,我还应该使用await Task.WhenAll而不是多个await吗？例如,DoWork2低于优选的方法DoWork1(以及为什么？):

using System;
using System.Threading.Tasks;

namespace ConsoleApp
{
    class Program
    {
        static async Task<string> DoTaskAsync(string name, int timeout)
        {
            var start = DateTime.Now;
            Console.WriteLine("Enter {0}, {1}", name, timeout);
            await Task.Delay(timeout);
            Console.WriteLine("Exit {0}, {1}", name, (DateTime.Now - start).TotalMilliseconds);
            return name;
        }

        static async Task DoWork1()
        {
            var t1 = DoTaskAsync("t1.1", 3000);
            var t2 = DoTaskAsync("t1.2", 2000);
            var t3 = DoTaskAsync("t1.3", 1000);

            await t1; await t2; await t3;

            Console.WriteLine("DoWork1 results: {0}", String.Join(", ", …

我已经尝试了一段时间来获得一些我认为可以简单地使用.NET 4.5的东西

我想同时启动两个长时间运行的任务,并
以最佳的C#4.5(RTM)方式收集结果

以下作品,但我不喜欢它,因为:

• 我想Sleep成为一个异步方法,所以它可以是await其他方法
• 它看起来很笨拙 Task.Run()
• 我认为这甚至根本不使用任何新的语言功能!

工作代码:

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Task.Run(() => Sleep(5000));    
    var task2 = Task.Run(() => Sleep(3000));

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for a total of " + totalSlept + " ms");
}

private static int Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    Console.WriteLine("Sleeping for " + ms + " FINISHED");
    return ms;
}

非工作代码:

更新:这实际上是有效的,并且是正确的方法,唯一的问题是 Thread.Sleep

此代码不起作用,因为调用Sleep(5000)立即启动任务运行,因此Sleep(1000) …

有人可以解释,如果await和ContinueWith是在下面的例子中同义与否.我正在尝试第一次使用TPL并且已经阅读了所有文档,但是不明白其中的区别.

等待:

String webText = await getWebPage(uri);
await parseData(webText);

继续:

Task<String> webText = new Task<String>(() => getWebPage(uri));
Task continue = webText.ContinueWith((task) =>  parseData(task.Result));
webText.Start();
continue.Wait();

在特定情况下,一个优先于另一个吗？

// let's say there is a list of 1000+ URLs
string[] urls = { "http://google.com", "http://yahoo.com", ... };

// now let's send HTTP requests to each of these URLs in parallel
urls.AsParallel().ForAll(async (url) => {
    var client = new HttpClient();
    var html = await client.GetStringAsync(url);
});

这是问题所在,它会同时启动1000多个Web请求.有没有一种简单的方法来限制这些异步http请求的并发数量？这样在任何给定时间都不会下载超过20个网页.如何以最有效的方式做到这一点？