我需要修改现有程序,它包含以下代码:
var inputs = events.Select(async ev => await ProcessEventAsync(ev))
.Select(t => t.Result)
.Where(i => i != null)
.ToList();
但这对我来说似乎很奇怪,首先是使用async和await选择.根据Stephen Cleary的回答,我应该能够放弃这些.
然后第二个Select选择结果.这是不是意味着任务根本不是异步的并且是同步执行的(没有任何努力),或者异步执行任务,何时完成查询的其余部分？
我应该根据Stephen Cleary的另一个答案写下面的代码如下:
var tasks = await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev)));
var inputs = tasks.Where(result => result != null).ToList();
这是完全一样的吗？
var inputs = (await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev))))
.Where(result => result != null).ToList();
当我正在研究这个项目时,我想更改第一个代码示例,但我不太热衷于更改(显然工作)异步代码.也许我只是担心什么都没有,所有3个代码示例完全相同？
ProcessEventsAsync如下所示:
async Task<InputResult> ProcessEventAsync(InputEvent ev) {...}
我在当前项目中使用TPL并使用Parallel.Foreach来旋转多个线程.Task类包含Wait()以等待任务完成.像这样,我如何等待Parallel.ForEach完成然后执行下一个语句？
// 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个网页.如何以最有效的方式做到这一点？
我想并行处理一个集合,但是我在实现它时遇到了麻烦,因此我希望得到一些帮助.
如果我想在并行循环的lambda中调用C#中标记为async的方法,则会出现问题.例如:
var bag = new ConcurrentBag<object>();
Parallel.ForEach(myCollection, async item =>
{
// some pre stuff
var response = await GetData(item);
bag.Add(response);
// some post stuff
}
var count = bag.Count;
计数为0时会出现问题,因为创建的所有线程实际上只是后台线程,并且Parallel.ForEach调用不等待完成.如果我删除async关键字,该方法如下所示:
var bag = new ConcurrentBag<object>();
Parallel.ForEach(myCollection, item =>
{
// some pre stuff
var responseTask = await GetData(item);
responseTask.Wait();
var response = responseTask.Result;
bag.Add(response);
// some post stuff
}
var count = bag.Count;
它工作,但它完全禁用等待聪明,我必须做一些手动异常处理..(为简洁起见删除).
如何实现一个Parallel.ForEach在lambda中使用await关键字的循环？可能吗？
Parallel.ForEach方法的原型采用Action<T>as参数,但我希望它等待我的异步lambda.
使用ForEach时是否可以使用Async？以下是我正在尝试的代码:
using (DataContext db = new DataLayer.DataContext())
{
db.Groups.ToList().ForEach(i => async {
await GetAdminsFromGroup(i.Gid);
});
}
我收到错误:
当前上下文中不存在名称"Async"
包含using语句的方法设置为async.
在这段代码中:
private async void button1_Click(object sender, EventArgs e) {
try {
await Task.WhenAll(DoLongThingAsyncEx1(), DoLongThingAsyncEx2());
}
catch (Exception ex) {
// Expect AggregateException, but got InvalidTimeZoneException
}
}
Task DoLongThingAsyncEx1() {
return Task.Run(() => { throw new InvalidTimeZoneException(); });
}
Task DoLongThingAsyncEx2() {
return Task.Run(() => { throw new InvalidOperation();});
}
我期望WhenAll创建并抛出一个AggregateException,因为至少有一个等待抛出异常的任务.相反,我正在收回其中一个任务抛出的单个异常.
难道WhenAll不总是创造AggregateException？
我有一些方法Task<T>可以随意返回await.我想让这些任务在自定义TaskScheduler而不是默认的上执行.
var task = GetTaskAsync ();
await task;
我知道我可以创建一个新的TaskFactory (new CustomScheduler ())并StartNew ()从中做一个,但是StartNew ()需要一个动作并创建它Task,我已经拥有了Task(在幕后由a返回TaskCompletionSource)
我怎样才能指定我自己TaskScheduler的await？
我有这样的方法:
public async Task<MyResult> GetResult()
{
MyResult result = new MyResult();
foreach(var method in Methods)
{
string json = await Process(method);
result.Prop1 = PopulateProp1(json);
result.Prop2 = PopulateProp2(json);
}
return result;
}
然后我决定使用Parallel.ForEach:
public async Task<MyResult> GetResult()
{
MyResult result = new MyResult();
Parallel.ForEach(Methods, async method =>
{
string json = await Process(method);
result.Prop1 = PopulateProp1(json);
result.Prop2 = PopulateProp2(json);
});
return result;
}
但现在我有一个错误:
在异步操作仍处于挂起状态时完成异步模块或处理程序.
我何时应该使用async/await,何时应该在C#中使用parallel.foreach？并行和异步/等待是否有同样的目的？它们有什么不同？
我有一个1000输入消息的集合来处理.我正在循环输入集合并为每个消息启动新任务以进行处理.
//Assume this messages collection contains 1000 items
var messages = new List<string>();
foreach (var msg in messages)
{
Task.Factory.StartNew(() =>
{
Process(msg);
});
}
我们可以猜测当时同时处理多少个最大消息(假设是普通的四核处理器),还是我们可以限制当时要处理的最大消息数？
如何确保以与Collection相同的顺序/顺序处理此消息？