标签: task-parallel-library

为什么返回a的方法Task在返回它的实例时不会被执行.我认为这必须发生,因为await方法/委托会将它放入某个队列,然后执行生成的任务.

那么为什么这Task在调用时永远不会被执行Do()？

public void Do()
{
    SomeTask().Wait()
}

public async Task SomeTask()
{
    return new Task(() => { Console.WriteLine("Hello World!") });
}

编辑

或者我需要await Task.Run(...)吗？

非常感谢你!

如果在控制台应用程序中运行而不是将其抛出AggregateException并被外部捕获，以下的崩溃为什么会崩溃try/catch？

I've simplified the use case for the await for brevity, but in the relevant code I am indeed trying to execute an awaitable Task of importance.

var list = new List<string>() {"Error"};

        try
        {
            Parallel.ForEach(list, new ParallelOptions()
            {
                MaxDegreeOfParallelism = 8
            }, async listEntry =>
            {
                await Task.Delay(5000);
                throw new Exception("Exception");
            });
        }
        catch (Exception ex)
        {
            //never hits, the application crashes
        }

        Console.ReadLine();

I note that the following does not cause the application to …

我刚刚遇到这个代码.我立即开始畏缩和自言自语(不是好事).事情是我不明白为什么,也不能合理地阐明它.它对我来说真的很糟糕 - 也许我错了.

public async Task<IHttpActionResult> ProcessAsync()
{
     var userName = Username.LogonName(User.Identity.Name);    
     var user = await _user.GetUserAsync(userName);

     ThreadPool.QueueUserWorkItem((arg) =>
        {
            Task.Run(() => _billing.ProcessAsync(user)).Wait();
        });    
     return Ok();
}

这段代码让我觉得它不必要地用ThreadPool.QueueUserWorkItem和创建线程Task.Run.此外,它看起来有可能在重负载时出现死锁或造成严重的资源问题.我对么？

_billing.ProcessAsync()方法是等待的(异步),所以我希望一个简单的"await"关键字是正确的,而不是所有这些其他的包袱.

使用await多个等待任务与等待所有任务完成时有什么区别.我的理解是方案2在性能方面更好,因为asyncTask1和asyncTask2都是并行执行的.

方案1:

async Task Task()
{
   await asyncTask1();
   await asyncTask2();
}

方案2:

async Task Task()
{
    t1 = asyncTask1();
    t2 =  asyncTask2();
    await Task.WhenAll(createWorkflowtask, getTaskWorkflowTask);
}

我使用以下代码将文件上传到dropbox.

我正在使用nuget包Dropbox.Api并获取异常System.Threading.Tasks.TaskCanceledException("任务被取消.")

从这个SO问题看来,它似乎是一个超时问题.

那么如何修改以下代码来设置超时.

    public async Task<FileMetadata> UploadFileToDropBox(string fileToUpload, string folder)
    {
        DropboxClient client = new DropboxClient(GetAccessToken());

        using (var mem = new MemoryStream(File.ReadAllBytes(fileToUpload)))
        {
            string filename = Path.GetFileName(fileToUpload);

            try
            {
                string megapath = GetFullFolderPath(folder);
                string megapathWithFile = Path.Combine(megapath, Path.GetFileName(Path.GetFileName(filename))).Replace("\\", "/");
                var updated = client.Files.UploadAsync(megapathWithFile, WriteMode.Overwrite.Instance, body: mem);
                await updated;
                return updated.Result;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
    }

我有以下代码行,了解async-await和暂停,直到等待任务完成.

public async Task<string> WaitAsynchronouslyAsync()
    {
        var results = await WaitAsync();
        Console.WriteLine($@"I am not waiting");
        return results;
    }

    public async Task<string> WaitAsync()
    {
        await Task.Delay(10000).ConfigureAwait(false);
        return "Async programming suspension point demo.";
    }

的await操作者挂起执行,直到工作WaitAsync()(延迟10秒)的方法完成.

与此同时,我期待在将Console.WriteLine($@"I am not waiting");等待任务完成之前将文本写入输出窗口,因为控件将返回给调用者WaitAsync().当任务完成执行时,await表达式计算string("Async programming suspension point demo.").

我在这里与悬浮指针vs调试指针混淆了吗？

我正在编写一个实时应用程序,它每秒接收大约2000条消息,这些消息被推入队列中.我编写了一个后台线程来处理队列中的消息.

private void ProcessSocketMessage()
{
    while (!this.shouldStopProcessing)
    {
        while (this.messageQueue.Count > 0)
        {
            string message;
            bool result = this.messageQueue.TryDequeue(out message);
            if (result)
            {
               // Process the string and do some other stuff
               // Like updating the received message in a datagrid  
            }
        }
    }
}

上述代码的问题在于它使用了大约12%CPU(2.40 GHz双核处理器)的疯狂处理能力.

我有4个类似于上面的块,它实际上占用了50%的CPU计算能力.在上面的代码中有什么可以优化的吗？

在第二次循环结束之前添加100 ms的线程休眠似乎会使性能提高50%.但我做错了吗？

我有一个在foreach中更新的公共变量,它是一个计数器,所以我想让一个并行foreach中的下一个计数器.

我有类似的东西:

int myCommonCounter = 5;
Parallel.Foreach(myList, (iterator, state) =>
{
    if(iterator.MyProperty == X)
    {
        iterator.Position = miCommonCounter;
        miCommonCounter = miCommonCunter + 1;
    }
});

我想避免属性iterator.Position中的间隙,也避免重复.

我已经看到了一个例子来处理部分结果的总和,例如在本文档中,但它并不是我需要的相同情况.

因此,我想知道是否有任何更新计数器以避免在并行foreach内部更新时出现间隙和重复.

谢谢.

我有一个应用程序,我需要做两个I/O任务:获取GPS位置,通过蓝牙检索一些数据.这两项任务都可以在不同时间内完成,并且可能需要很长时间.为了提高应用程序的速度,我想同时启动两个活动,然后等待两个活动完成再继续.

如果我这样做:

bool locationStatus= await GetCurrentLocation();
bool vehicleStatus = await GetVehicleData();

第二个功能是否被启动,或者只是未被阻止的UI？

我需要调用并行任务吗？

我正在尝试运行一系列任务,然后一旦完成,就运行一个单独的任务集合.实质上,第一个任务集合负责写入某些数据库表,最终的任务集合将这些表中的数据整理到报告表中.

我正在使用的代码示例如下:

var dbWriteTasks = clients.Select(c => DoSomeWorkAsync(c)).ToArray();
var dbCollateTasks = clients.Select(c => DoSomeOtherWorkAsync(c));

Task.Factory.ContinueWhenAll(dbWriteTasks, t => dbCollateTasks.ToArray());

这是成功运行第一组任务,但没有运行任何第二组任务,所以我显然做错了.

我也试过这个无济于事:

var dbWriteTasks = clients.Select(c => DoSomeWorkAsync(c)).ToArray();
var dbCollateTasks = clients.Select(c => DoSomeOtherWorkAsync(c)).ToArray();

Task.Factory.ContinueWhenAll(dbWriteTasks, t => dbCollateTasks);

这会运行两组任务,但第二组在第一组任务完成插入之前开始运行并处理数据...

我还应该提一下,我已经尝试同步运行这两组任务,Task.WaitAll但这也没有用.我试图在Azure功能中执行所有这些操作,Task.WaitAll只是让它停止.

我对TPL比较陌生,所以任何建议都将不胜感激!