标签: task-parallel-library

何时使用TaskEx.Run与TaskEx.RunEx

我想知道何时使用TaskEx.Run.我提供了下面写的两个代码示例,它们产生相同的结果.我没有看到为什么我会采取Task.RunEx TaskEx.RunEx方法,我确信有一个很好的理由,并希望有人可以填补我.

async Task DoWork(CancellationToken cancelToken, IProgress<string> progress)
{
    int i = 0;
    TaskEx.RunEx(async () =>
        {
            while (!cancelToken.IsCancellationRequested)
            {
                progress.Report(i++.ToString());
                await TaskEx.Delay(1, cancelToken);
            }
        }, cancelToken);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
    if (button.Content.ToString() == "Start")
    {
        button.Content = "Stop";
        cts.Dispose();
        cts = new CancellationTokenSource();
        listBox.Items.Clear();
        IProgress<string> progress = new Progress<string>(s => 
        {
            listBox.Items.Add(s); 
            listBox.ScrollIntoView(listBox.Items[listBox.Items.Count - 1]);
        });
        DoWork(cts.Token, progress);
    }
    else
    {
        button.Content = "Start";
        cts.Cancel();
    }
}
Run Code Online (Sandbox Code Playgroud)

我可以像这样取得同样的结果

  async Task DoWork(CancellationToken …
Run Code Online (Sandbox Code Playgroud)

c# wpf task-parallel-library async-await async-ctp

8
推荐指数
2
解决办法
1万
查看次数

我该如何从任务UI线程更新?

我有一项任务,执行一些繁重的工作.我需要把结果归结为LogContent

Task<Tuple<SupportedComunicationFormats, List<Tuple<TimeSpan, string>>>>.Factory
    .StartNew(() => DoWork(dlg.FileName))
    .ContinueWith(obj => LogContent = obj.Result);
Run Code Online (Sandbox Code Playgroud)

这是属性:

public Tuple<SupportedComunicationFormats, List<Tuple<TimeSpan, string>>> LogContent
{
    get { return _logContent; }
    private set
    {
        _logContent = value;
        if (_logContent != null)
        {
            string entry = string.Format("Recognized {0} log file",_logContent.Item1);
            _traceEntryQueue.AddEntry(Origin.Internal, entry);
        }
    }
}
Run Code Online (Sandbox Code Playgroud)

问题是_traceEntryQueue绑定到UI的数据,因为我会在这样的代码上有异常.

所以,我的问题是如何让它正常工作?

.net c# wpf task task-parallel-library

8
推荐指数
2
解决办法
3万
查看次数

如何生成任务<任务>以解包

有人可以解释这两个陈述之间的区别:

Task<Task> bTask = backup.BackupCurrentDatabaseAsync()
    .ContinueWith(_ => CompressArchiveAsync());
//unwrap the tasks to produce one entire task
Task t = bTask.Unwrap();
Run Code Online (Sandbox Code Playgroud)

VS

Task<Task> bTask = backup.BackupCurrentDatabaseAsync()
    .ContinueWith(_ => 
{
    CompressArchiveAsync();
});
//unwrap the tasks to produce one entire task
Task t = bTask.Unwrap();
Run Code Online (Sandbox Code Playgroud)

该方法ExtractArchiveAsync(),BackupCurrentDatabaseAsync(),RestoreDatabaseAsync()全部返回Task.

这里,第一个Continuation返回a Task<Task>.然后我可以Unwrap()将此任务放在结果(内部)任务上.

第二个版本不编译.这里唯一不同的是周围的牙箍CompressArchiveAsync().

我试图访问结果(内部)Task来检查Task.Status.如果我使用第二种方法,Task.Status将报告BackupCurrentDatabaseAsync()任务的结果.

.net c# task-parallel-library async-await

8
推荐指数
1
解决办法
1294
查看次数

Task.StartNew()vs Parallel.ForEach:多个Web请求场景

我已经阅读了SO中的所有相关问题,但对于我的场景中触发多个Web服务调用的最佳方法有点困惑.

我有一个聚合器服务,它接受输入,解析并将其转换为多个Web请求,进行Web请求调用(不相关,因此可以并行触发)并合并发送回调用者的响应.现在使用以下代码 -

list.ForEach((object obj) =>
{
     tasks.Add(Task.Factory.StartNew((object state) => 
     {
           this.ProcessRequest(obj);
     }, obj, CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default));
});
await Task.WhenAll(tasks);
Run Code Online (Sandbox Code Playgroud)

在await Task.WhenAll(tasks)来自斯科特Hanselman的帖子在那里说,

斯蒂芬说:"从可伸缩性的角度来看,更好的解决方案是利用异步I/O.当你通过网络呼叫时,没有理由(除了方便之外)在等待响应来阻止线程时背部"

现有代码似乎消耗了太多线程,并且处理器时间在生产负载上高达100%,这让我思考.

另一个替代方法是使用Parallel.ForEach,它使用分区器,但也"阻塞"调用,这对我的场景来说很好.

考虑到这是所有"异步IO"工作而不是"CPU绑定"工作,并且Web请求不会长时间运行(最多返回3秒),我倾向于认为现有代码足够好.但是这会提供比Parallel.ForEach更好的吞吐量吗?Parallel.ForEach可能使用"最小"数量的任务,因为分区因此最佳使用线程(?).我用一些本地测试测试了Parallel.ForEach,它似乎没有更好.

目标是减少CPU时间并提高吞吐量,从而提高可扩展性.是否有更好的方法来并行处理Web请求?

感谢任何投入.

编辑: 代码示例中显示的ProcessRequest方法确实使用HttpClient及其异步方法来触发请求(PostAsync,GetAsync,PutAsync).

c# parallel-processing multithreading task-parallel-library parallel.foreach

8
推荐指数
1
解决办法
2702
查看次数

异步和等待 - 如何维护执行顺序?

我实际上正在阅读有关任务并行库和使用async和await的异步编程的一些主题."Nutshell中的C#5.0"一书指出,在使用await关键字等待表达式时,编译器会将代码转换为如下所示:

var awaiter = expression.GetAwaiter();
awaiter.OnCompleted (() =>
{
var result = awaiter.GetResult();
Run Code Online (Sandbox Code Playgroud)

让我们假设,我们有这个异步函数(也来自参考书):

async Task DisplayPrimeCounts()
{
for (int i = 0; i < 10; i++)
Console.WriteLine (await GetPrimesCountAsync (i*1000000 + 2, 1000000) +
" primes between " + (i*1000000) + " and " + ((i+1)*1000000-1));
Console.WriteLine ("Done!");
}
Run Code Online (Sandbox Code Playgroud)

"GetPrimesCountAsync"方法的调用将在池化线程上排队并执行.通常,在for循环中调用多个线程有可能引入竞争条件.

那么CLR如何确保请求按照它们的顺序进行处理?我怀疑编译器只是将代码转换为上述方式,因为这会将'GetPrimesCountAsync'方法与for循环分离.

c# multithreading asynchronous task-parallel-library async-await

8
推荐指数
2
解决办法
5737
查看次数

使用F#中的Task.WhenAll重写C#代码

我有以下接口方法:

Task<string[]> GetBlobsFromContainer(string containerName);
Run Code Online (Sandbox Code Playgroud)

及其在C#中的实现:

var container = await _containerClient.GetContainer(containerName);
var tasks = container.ListBlobs()
                     .Cast<CloudBlockBlob>()
                     .Select(b => b.DownloadTextAsync());
return await Task.WhenAll(tasks);
Run Code Online (Sandbox Code Playgroud)

当我尝试在F#中重写它时:

member this.GetBlobsFromContainer(containerName : string) : Task<string[]> =
    let task = async {
        let! container = containerClient.GetContainer(containerName) |> Async.AwaitTask
        return container.ListBlobs()
               |> Seq.cast<CloudBlockBlob>
               |> Seq.map (fun b -> b.DownloadTextAsync())
               |> ??
    }
    task |> ??
Run Code Online (Sandbox Code Playgroud)

我坚持最后一行.

如何正确返回Task<string[]>F#?

f# task-parallel-library c#-to-f# async-await

8
推荐指数
1
解决办法
550
查看次数

Task.Delay是否值得取消?

我最近使用我在很多地方描述的取消模式重新实现了一大堆异步WCF服务方法 - 在等待Task.WhenAny启动任务和Task.Delay的地方.当然,现有任务不可取消,但希望在以后的版本中解决.

在我的情况下,默认持续时间Task.Delay由服务设置控制.在绝大多数情况下,结果是希望的任务在必要的时间内完成.环境通常很慷慨.

大多数(但不是全部)我见过的例子都没有打扰取消Task.Delay.它是如此便宜,不值得担心吗?我知道取消会引发异常.如果我取消延迟,我应该处理异常吗?

这是我所做的所有服务方法调用的方法:

private async Task<T> GetOrTimeout<T>( Task<T> task, [CallerMemberName] string caller = "" )
{
  using ( var cts = new CancellationTokenSource( ) )
  {
    try
    {
      var timeout = GetDelay( cts.Token );
      var first = await Task.WhenAny( task, timeout );
      if ( first == timeout ) throw new TimeoutException( Properties.Resources.TimeoutOccurredInService.Fmt( caller ) );
      cts.Cancel( );  //--> haven't been doing this. Should I?
      return await task;
    }
    catch ( Exception …
Run Code Online (Sandbox Code Playgroud)

.net c# wcf task-parallel-library async-await

8
推荐指数
1
解决办法
1246
查看次数

C#:CancellationToken不取消阻止方法

.NET 4.5.1:看来,我无法使用CancellationTokenSource内置超时取消在任务内运行的阻塞方法.

class Program
{
    static void Main(string[] args)
    {
        var cts = new System.Threading.CancellationTokenSource();

        System.Console.CancelKeyPress += (s, e) =>
        {
            e.Cancel = true;
            cts.Cancel();
        };

        MainAsync(args, cts.Token).Wait();
    }

    // MainAsync from http://stackoverflow.com/questions/9208921/async-on-main-method-of-console-app
    static async Task MainAsync(string[] args, System.Threading.CancellationToken token)
    {
        Console.WriteLine("Starting MainAsync");
        var cts = new System.Threading.CancellationTokenSource(3000);
        var task = Task.Factory.StartNew(() =>
        {
            Console.WriteLine("Starting task...");
            var t = new System.Net.Sockets.TcpClient();
            var buffer = new byte[t.ReceiveBufferSize];
            t.Connect(new System.Net.IPEndPoint(System.Net.IPAddress.Parse("127.0.0.1"), 1337));

            Console.WriteLine("Recieving...");
            t.Client.Receive(buffer);
            Console.WriteLine("Finished Recieving...");

            return true;
        }, cts.Token);

        var success = …
Run Code Online (Sandbox Code Playgroud)

c# task-parallel-library

8
推荐指数
1
解决办法
1101
查看次数

为什么C#Func <interface> lambda表达式需要强制转换为结果

我需要更深入地了解Func类型表达式.

public class TheResult : IResultEntry {
    ...
}
Run Code Online (Sandbox Code Playgroud)

上面的类,为什么下面的第二种方法需要演员?

我当然可以阅读错误信息,但很难理解.

// Success
public Task<IResultEntry> ProcessAsync_1()
{
    return Task.Factory.StartNew(() => (IResultEntry) new TheResult());
}

// Fail: Compiler error. Cannot implicitly convert...
public Task<IResultEntry> ProcessAsync_2()
{
    return Task.Factory.StartNew(() => new TheResult());
}
Run Code Online (Sandbox Code Playgroud)

如果我们在ReSharper的帮助下将其更改为命名方法,我们可以不进行强制转换.

public Task<IResultEntry> ProcessAsync_2_Changed()
{
    return Task.Factory.StartNew(function);
}

private IResultEntry function()
{
    return new TheResult();
}
Run Code Online (Sandbox Code Playgroud)

c# lambda func task-parallel-library

8
推荐指数
0
解决办法
56
查看次数

Task.Delay没有被取消?

我正在尝试为游戏构建界面.游戏运行1分钟.该GetStop方法后60秒游戏停止.该游戏方法在游戏开始时和退出方法退出游戏.理想情况下,我想要的是当我在30秒后退出游戏时,计时器应该重置,点击"播放"按钮,计时器应该再次运行1分钟.这样下一场比赛就可以运行1分钟.如果我再次按退出按钮,则应重置计时器以进行下一场比赛.

但是,我的代码中似乎存在某个问题.每当我执行quit方法时,计时器似乎都保存在该状态.所以,如果我在30秒内退出比赛,那么下一场比赛将持续30秒.如果我在50秒内退出比赛,下一场比赛将只持续10秒.理想情况下,计时器应该重置但不会重置.

我在这里没有想法.任何人都可以提供一些建议?

private async Task GetStop(CancellationToken token)
{ 
    await Task.Run(async () =>
    {
        token.ThrowIfCancellationRequested();
        await Task.Delay(TimeSpan.FromSeconds(60), token);

        token.ThrowIfCancellationRequested();
        if (!token.IsCancellationRequested)
        {
            sendMessage((byte)ACMessage.AC_ESCAPE); 
        }
    }, token);
}

public async void Play()
{         
        sendMessage((byte)ACMessage.AC_START_RACE); 
        _cts.Cancel();

        if (_cts != null)
        {
            _cts.Dispose();
            _cts = null;
        }
        _cts = new CancellationTokenSource(); 
        await GetStop(_cts.Token);
   }

public void Quit()
{
        _cts.Cancel();
        if (_cts != null)
        {
            _cts.Dispose();
            _cts = null;
        }
    //
}
Run Code Online (Sandbox Code Playgroud)

c# task-parallel-library cancellation cancellationtokensource

8
推荐指数
1
解决办法
285
查看次数