标签: task-parallel-library

我正在使用带有C#的.NET 4.0任务并行库(我第一次使用TPL)

我有一个任务A,我想在完成一系列其他任务(B,C,D等)之前完成任务.因此,我想创建任务B,C,D等作为任务A的延续.但是,我想将"状态"对象传递给任务B,将另一个状态对象传递给任务C等.

我可以通过简单地使用带有状态对象的Task构造函数重载将状态对象传递给任务A,例如http://msdn.microsoft.com/en-us/library/dd783035.aspx描述了这个Task构造函数重载:

Task(Action<Object>, Object, CancellationToken) 

这工作正常,第二个参数是我的"状态"对象.

我想创建一个延续任务,例如任务B:

Task taskB = taskA.ContinueWith(/* args here*/)

但是,我看不到ContinueWith()重载(请参阅http://msdn.microsoft.com/en-us/library/dd235663.aspx),它允许我将"状态"对象传递给延续任务.如何才能做到这一点？

笔记:

1. 在创建taskA时,我没有taskB的'state'对象
2. taskB的'state'对象不是taskA的输出(返回值)

对于某些上下文,我正在做的是在几个循环中创建taskB,taskC等,所以我使用状态对象将循环变量的值传递给taskB,taskC等,以避免问题总是以任务中的循环变量的最终值结束(闭包问题).

我已经做了一些阅读,并且认为我已经掌握了await和async关键字的基础知识,关于System.Threading.Task.

但是,我不确定我是否对一个小问题是正确的,我正在寻找验证或有人纠正我.

我正在使用此签名实现异步方法:

public Task ProcessUploadedFile(FileInfo info, string contentType);

显然,如果我想等待方法内的任何内容,我需要在签名中添加async关键字,

我的问题是这样的:如果我的方法做的最后一件事是调用另一个异步方法,或者返回一个任务,那么等待它有什么意义吗？

例如.

1:

public async Task ProcessUploadedFile(FileInfo info, string contentType)
{
  foreach (var something in someCollection)
    DoSomething();

  DoSomethingElse();

  await DoMethodAsync();
}

2:

public Task ProcessUploadedFile(FileInfo info, string contentType)
    {
      foreach (var something in someCollection)
        DoSomething();

      DoSomethingElse();

      return DoMethodAsync();
    }

我最初写的是前者,但是不能再看到添加等待的重点了.如果我要编写后者,我会完成同样的事情,两个方法的调用者仍然可以使用await关键字,如果他们选择,不是吗？

上面有什么不同吗？哪个更好"？

有关功能和含义的区别是什么

TaskCompletionSource + SetResult vs Task + FromResult

在SendAsync方法？

protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
    if (request.RequestUri.Scheme != Uri.UriSchemeHttps)
    {
        var response = new HttpResponseMessage(HttpStatusCode.Forbidden) {ReasonPhrase = "HTTPS Required"};
        var taskCompletionSource = new TaskCompletionSource<HttpResponseMessage>();
        taskCompletionSource.SetResult(response);
        return taskCompletionSource.Task;
    }
    return base.SendAsync(request, cancellationToken);
}

protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
    if (!request.RequestUri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
    {
        HttpResponseMessage reply = request.CreateErrorResponse(HttpStatusCode.BadRequest, "HTTPS is required for security reason.");
        return Task.FromResult(reply);
    }

    return base.SendAsync(request, cancellationToken);
}

我正在运行一个多线程循环:

protected ParallelOptions parallelOptions = new ParallelOptions();

parallelOptions.MaxDegreeOfParallelism = 2;
Parallel.ForEach(items, parallelOptions, item =>
{
// Loop code here
});

我想在执行并行循环期间更改parallelOptions.MaxDegreeOfParallelism以减少或增加多个线程.

parallelOptions.MaxDegreeOfParallelism = 5;

它似乎没有增加线程.有没有人有任何想法？

我试图找出Parallel.Foreach的异常和取消工作方式.所有示例似乎都涉及任务.

Parallel.Foreach中的异常会发生什么？
- 我将整个循环包装在try/catch(AggregateException)中吗？
- 循环中的所有其他任务,即使是尚未启动的任务,也会在异常被捕获之前运行完成吗？

与CancelationToken相同的问题

为什么我们需要Task.ContinueWith()方法.我们不能只在Task体内写下"延续代码"吗？

想象一下这样的函数:

private static ConcurrentList<object> list = new ConcurrentList<object>();
public void Add(object x)
{
   Task.Factory.StartNew(() =>
   {
      list.Add(x); 
   }
}

我不在乎什么时候确实将fentry添加到列表中,但我需要将它添加到最后(显然;))

我没有看到一种方法来正确地单元测试这样的东西而不返回任何回调处理程序或某事.因此,添加程序不需要的逻辑

你会怎么做？

经过几天的googleing后,我想我无法确定哪一个是针对什么情况.当然我想使用一个结合两者的完美框架(当然是不现实的).我甚至知道可以一起使用它们.但真正的问题是,每个核心设计元素中的核心设计元素是什么,使得无法模仿另一个核心设计元素.这些是我发现的:

• 在RX中存在虚拟时间,因此调度程序有效地控制整个网络,但这在TDF中是不可能的,因为每个块使用不同的任务并且它们独立运行
• 在TDF中,一个块可以重试接收消息/重发和类似的东西但是在RX中它是不可能的.
• 在rx中,数据流是序列化的,但在TDF中,这是可选的

如果有一些不是列表的理解而是试图从一个只讨论结构差异的公共抽象类/类别派生出来的东西,那将是很好的.

我一直在看到Cancellation.Register与结果中的using子句一起使用的代码CancellationTokenRegistration:

using (CancellationTokenRegistration ctr = token.Register(() => wc.CancelAsync()))
{
    await wc.DownloadStringAsync(new Uri("http://www.hamster.com"));
}

我得到你应该确保你Dispose的IDisposable,但为什么它甚至工具IDisposable？有什么资源需要发布？它认为平等的唯一方法.

如果你不这样做Dispose会怎么样？你泄漏了什么？

为简单起见,我们假设我们有一个方法应该在执行一些繁重的操作时返回一个对象.有两种实现方式:

public Task<object> Foo()
{
    return Task.Run(() =>
    {
        // some heavy synchronous stuff.

        return new object();
    }
}

和

public async Task<object> Foo()
{
    return await Task.Run(() =>
    {
        // some heavy stuff
        return new object();
    }
}

在检查生成的IL之后,生成了两个完全不同的东西:

.method public hidebysig 
    instance class [mscorlib]System.Threading.Tasks.Task`1<object> Foo () cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 42 (0x2a)
    .maxstack 2
    .locals init (
        [0] class [mscorlib]System.Threading.Tasks.Task`1<object>
    )

    IL_0000: nop
    IL_0001: ldsfld class [mscorlib]System.Func`1<object> AsyncTest.Class1/'<>c'::'<>9__0_0'
    IL_0006: dup …