标签: task-parallel-library

围绕现有对象创建任务包装器

我有一个方法返回一个Task,其中实现可能需要或可能不需要执行慢速操作以检索结果.我希望能够简单地将结果值包装到一个任务中,该任务在值已经可用的情况下被标记为已同步完成.今天我有这样的事情:

public Task<Foo> GetFooAsync(int key) {
  lock(this) {
    if(_Cache.ContainsKey(key) ) {
      Task<Foo> ret = new Task<Foo>(()=>_Cache[key]);
      ret.RunSynchronously();
      return ret;
    }
    else {
      return Task.Factory.StartNew<Foo>(SomethingSlow());
    }
  }
}
Run Code Online (Sandbox Code Playgroud)

当我已经知道结果时,是否有更简单的方法来执行此操作并不需要我使用委托构造任务?

c# task task-parallel-library

15
推荐指数
2
解决办法
8387
查看次数

如何使用.NET try/catch链来决定生成一个minidump

我们遇到了混乱任务与我们的顶级崩溃处理程序,并试图找到一个解决方法.我希望有人有一些想法.

我们的工具有一个顶级崩溃处理程序(来自AppDomain的UnhandledException事件),我们用它来用minidump提交bug报告.它运作得很好.不幸的是,任务在这方面引起了轰动.

我们刚刚开始使用4.0任务,并在Task动作执行代码内部发现了一个try/catch,它抓取异常并存储它以传递任务链.不幸的是,存在catch (Exception)放松堆栈,当我们创建minidump时,调用站点丢失了.这意味着我们在崩溃时没有任何局部变量,或者它们已被收集,等等.

异常过滤器似乎是这项工作的正确工具.我们可以通过扩展方法将一些Task动作代码包装在过滤器中,并且在抛出异常时调用我们的崩溃处理程序代码来报告minidump的错误.但是,我们不希望在每个异常上执行此操作,因为在我们自己的代码中可能存在忽略特定异常的try-catch.如果catchin Task要处理它,我们只想做崩溃报告.

有没有办法走向try/catch处理程序链?我想如果我能做到这一点,我可以向上走,寻找捕获,直到命中任务,然后触发崩溃处理程序,如果是真的.

(这似乎是一个很长的镜头,但我想我还是会问.)

或者,如果有人有任何更好的想法,我很乐意听到他们!

UPDATE

我创建了一个小示例程序来演示这个问题.我道歉,我试图让它尽可能短,但它仍然很大.:/

在下面的示例中,您可以#define USETASK或#define USEWORKITEM(或没有)测试三个选项中的一个.

在非异步情况和USEWORKITEM情况下,生成的minidump是在调用站点构建的,正是我们需要的.我可以在VS中加载它(在一些浏览后找到正确的线程),我看到我在呼叫站点拍摄了快照.真棒.

在USETASK案例中,快照从终结器线程中获取,该线程正在清理任务.抛出异常后很长时间,因此在此时抓取一个minidump是没用的.我可以对任务执行Wait()以更快地处理异常,或者我可以直接访问它的Exception,或者我可以在TestCrash本身的包装器中创建minidump,但所有这些仍然有相同的问题:这太晚了,因为堆栈已经解开了一个或另一个.

请注意,我故意在TestCrash中放置一个try/catch来演示我们希望如何正常处理某些异常,以及其他异常被捕获.USEWORKITEM和非异步案例正是我们所需要的.任务几乎做得对!如果我能以某种方式使用异常过滤器让我走向try/catch链(实际上没有展开),直到我点击Task内部的catch,我可以自己做必要的测试,看看是否需要运行崩溃处理程序或不.因此,我原来的问题.

这是样本.

using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        AppDomain.CurrentDomain.UnhandledException += (_, __) =>
            {
                using (var stream = File.Create(@"c:\temp\test.dmp"))
                {
                    var process = Process.GetCurrentProcess();
                    MiniDumpWriteDump(
                        process.Handle,
                        process.Id,
                        stream.SafeFileHandle.DangerousGetHandle(),
                        MiniDumpType.MiniDumpWithFullMemory,
                        IntPtr.Zero,
                        IntPtr.Zero,
                        IntPtr.Zero);
                }
                Process.GetCurrentProcess().Kill();
            };
        TaskScheduler.UnobservedTaskException += …
Run Code Online (Sandbox Code Playgroud)

c# task-parallel-library

15
推荐指数
1
解决办法
1696
查看次数

使用线程处理队列的最有效方法

我有一个队列,其上放置了待处理的傅立叶变换请求(相对耗时的操作) - 在某些情况下,我们每秒可以获得数千个变换请求,因此它必须快速.

我正在升级旧代码以使用.net 4,以及移植到TPL.我想知道处理这个队列的最有效(最快的吞吐量)方式是什么样的.我想使用所有可用的核心.

目前我正在尝试使用BlockingCollection.我创建了一个队列处理程序类,它产生4个任务,阻塞BlockingCollection并等待传入​​的工作.然后他们处理挂起的转换.码:

public class IncomingPacketQueue : IDisposable
    {
        BlockingCollection<IncomingPacket> _packetQ = new BlockingCollection<IncomingPacket>();

        public IncomingPacketQueue(int workerCount)
        {
            for (int i = 0; i < workerCount; i++)
            {
                Task.Factory.StartNew(Consume);
            }
        }

        public void EnqueueSweep(IncomingPacket incoming)
        {
            _packetQ.Add(incoming);
        }

        private void Consume()
        {
            foreach (var sweep in _packetQ.GetConsumingEnumerable())
            {
                //do stuff
                var worker = new IfftWorker();
                Trace.WriteLine("  Thread {0} picking up a pending ifft".With(Thread.CurrentThread.ManagedThreadId));
                worker.DoIfft(sweep);                

            }
        }

        public int QueueCount
        {
            get
            {
                return _packetQ.Count;
            }
        }

    #region …
Run Code Online (Sandbox Code Playgroud)

c# multithreading task-parallel-library c#-4.0

15
推荐指数
1
解决办法
5722
查看次数

如何清空BlockingCollection

我有一个线程添加项目到BlockingCollection.

在我正在使用的另一个线程上 foreach (var item in myCollection.GetConsumingEnumerable())

如果有问题我想要摆脱我的foreach和我的方法并清除剩下的东西,BlockingCollection但是我找不到办法去做.

有任何想法吗?

.net c# .net-4.0 task-parallel-library c#-4.0

15
推荐指数
4
解决办法
2万
查看次数

在IHttpAsyncHandler中使用Task或async/await

自从我想要添加线程时编写ASP.NET应用程序以来,我可以通过3种简单的方法在ASP.NET应用程序中完成线程化:

  • 使用System.Threading.ThreadPool.
  • 使用自定义委托并调用其BeginInvoke方法.
  • 在System.Threading.Thread类的帮助下使用自定义线程.

前两种方法提供了一种快速方法来为您的应用程序启动工作线程.但不幸的是,它们损害了应用程序的整体性能,因为它们使用ASP.NET使用的相同池中的线程来处理HTTP请求.

然后我想使用新的Task或async/await来编写IHttpAsyncHandler.您可以找到的一个例子是Drew Marsh在这里解释的:https://stackoverflow.com/a/6389323/261950

我的猜测是使用Task或async/await仍然消耗来自ASP.NET线程池的线程,我不想要显而易见的原因.

你可以告诉我,如果我可以在后台线程上使用Task(async/await),就像使用System.Threading.Thread类而不是线程池一样吗?

在此先感谢您的帮助.

托马斯

asp.net ihttpasynchandler threadpool task-parallel-library async-await

15
推荐指数
2
解决办法
9869
查看次数

.Net 4.5 Svcutil生成两个具有相同名称的操作(Method and MethodAsync)

我正在使用svcutil a la消耗预定义的wsdl:

svcutil some_service.wsdl
Run Code Online (Sandbox Code Playgroud)

生成的方法之一具有以下签名:

[System.ServiceModel.OperationContractAttribute(Action="http://ws.example.org/SubmitData", ReplyAction="*")]
SubmitDataResponse SubmitData( SubmitDataRequest request )
Run Code Online (Sandbox Code Playgroud)

而从VS2010 scvutil/.net35仅生成上述和VS没有问题lanuching服务,则SvcUtil工具程序,它是VS2012/.net45的一部分还产生方法与签名

[System.ServiceModel.OperationContractAttribute(Action="http://ws.example.org/SubmitData", ReplyAction="*")]
Task<SubmitDataResponse> SubmitDataAsync( SubmitDataRequest request );
Run Code Online (Sandbox Code Playgroud)

这会导致运行时异常:

System.InvalidOperationException:无法在具有相同名称相同的合同两种操作,方法SubmitDataAsync和SubmitData型的MyType违反此规则.您可以通过更改方法名称或使用OperationContractAttribute的Name属性来更改其中一个操作的名称.

我可以通过删除Async附加方法或简单地使用VS2010中的svcutil来解决这个问题.不过,我很奇怪,为什么SvcUtil工具生成,导致运行时异常(这是一个错误吗?),以及是否有额外的东西,我应该做的,使其工作的接口.

svcutil.exe task-parallel-library async-await .net-4.5 visual-studio-2012

15
推荐指数
1
解决办法
9015
查看次数

在ContinueWith中重新抛出先前的异常

介绍

在困惑我的代码一段时间后,我发现异常不一定传播通过ContinueWith:

int zeroOrOne = 1;
Task.Factory.StartNew(() => 3 / zeroOrOne)
    .ContinueWith(t => t.Result * 2)
    .ContinueWith(t => Console.WriteLine(t.Result))
    .ContinueWith(_ => SetBusy(false))
    .LogExceptions();
Run Code Online (Sandbox Code Playgroud)

在这个例子中,该SetBusy行"复位"异常链,所以通过零异常的鸿沟是没有看到,随后在我的脸炸毁"任务的异常(S),未观察到......"

所以......我给自己写了一个小扩展方法(有很多不同的重载,但基本上都是这样做的):

public static Task ContinueWithEx(this Task task, Action<Task> continuation)
{
     return task.ContinueWIth(t =>
     {
         if(t.IsFaulted) throw t.Exception;
         continuation(t);
     });
}
Run Code Online (Sandbox Code Playgroud)

周围多一点搜索,我碰到这个博客帖子,在那里,他提出了一个类似的解决方案,但使用TaskCompletionSource,其中(转述)看起来是这样的:

public static Task ContinueWithEx(this Task task, Action<Task> continuation)
{
     var tcs = new TaskCompletionSource<object>();
     return task.ContinueWith(t =>
     {
         if(t.IsFaulted) tcs.TrySetException(t.Exception);
         continuation(t);
         tcs.TrySetResult(default(object));
     });
     return tcs.Task;
} …
Run Code Online (Sandbox Code Playgroud)

c# exception task-parallel-library

15
推荐指数
1
解决办法
3929
查看次数

为什么Ruby中的这个算法运行得比Parallel'd C#快?

以下ruby代码在〜15秒内运行.它几乎不使用任何CPU /内存(约占一个CPU的25%):

def collatz(num)
   num.even? ? num/2 : 3*num + 1
end

start_time = Time.now
max_chain_count = 0
max_starter_num = 0
(1..1000000).each do |i|
    count = 0
    current = i
    current = collatz(current) and count += 1 until (current == 1)
    max_chain_count = count and max_starter_num = i if (count > max_chain_count)
end

puts "Max starter num: #{max_starter_num} -> chain of #{max_chain_count} elements. Found in: #{Time.now - start_time}s"
Run Code Online (Sandbox Code Playgroud)

以下TPL C#将我的所有4个内核的使用率提高到100%,并且比ruby版本慢了几个数量级:

static void Euler14Test()
{
    Stopwatch sw = new Stopwatch();
    sw.Start(); …
Run Code Online (Sandbox Code Playgroud)

c# ruby algorithm performance task-parallel-library

15
推荐指数
2
解决办法
534
查看次数

在TPL中返回一个空的静态任务是一种不好的做法?

有些情况下我想要有条件地运行任务.我使用某种类似的扩展方法:

public static class MyTaskExtension{
  private static Task theEmptyTask = Task.Factory.StartNew(() => {}); //This is the question

  public static Task ContinueWith(this Task task, Task continuationTask, Func<bool> condition)
  {
    if condition(){
       ... do the work
    }
    return theEmptyTask;
  }
}
Run Code Online (Sandbox Code Playgroud)

我的期望是,theEmptyTask已经完成,所以基本上如果我不想做任何事情我只返回这个任务,而不是null或一个新的空任务.

我觉得这种方法应该有一些小问题.有人能看到吗?

c# static task task-parallel-library

15
推荐指数
1
解决办法
5789
查看次数

将异步 - 等待C#代码转换为与调度程序相关的F#

我想知道这是否是一个太广泛的问题,但最近我让自己遇到了一段我想确定如何从C#转换为适当的F#的代码.旅程从这里开始(1)(TPL-F#交互的原始问题),并继续这里(2)(我正在考虑转换为F#的一些示例代码).

示例代码在这里重现的时间太长,但有趣的功能是ActivateAsync,RefreshHubs和AddHub.特别有趣的是

  1. AddHub有签名private async Task AddHub(string address).
  2. RefreshHubsAddHub在循环中调用并收集一个列表tasks,然后它在最后等待await Task.WhenAll(tasks),因此返回值与其签名匹配private async Task RefreshHubs(object _).
  3. RefreshHubs被称为ActivateAsync一样await RefreshHubs(null),然后在年底有一个叫await base.ActivateAsync()匹配函数签名public override async Task ActivateAsync().

题:

将这些函数签名正确转换为F#仍然保持接口和功能并尊重默认的自定义调度程序是什么?而且我也不太确定这个"在F#中异步/等待".至于如何"机械地"做到这一点.:)

原因是在链接"here(1)"中似乎存在问题(我没有验证这一点),因为F#异步操作不遵循(Orleans)运行时设置的自定义协作调度程序.此外,这里声明TPL操作逃脱调度程序并进入任务池,因此禁止使用它们.

我能想到解决这个问题的一种方法是使用F#函数,如下所示

//Sorry for the inconvenience of shorterned code, for context see the link "here (1)"...
override this.ActivateAsync() =
    this.RegisterTimer(new Func<obj, Task>(this.FlushQueue), null, TimeSpan.FromMilliseconds(100.0), …
Run Code Online (Sandbox Code Playgroud)

c# f# task-parallel-library c#-to-f# orleans

15
推荐指数
1
解决办法
1090
查看次数