我有一些异步方法:
// not ideal
private TaskCompletionSource<A> _tcsA;
private TaskCompletionSource<A> _tcsB;
private TaskCompletionSource<A> _tcsC;
...
public Task<A> GetAAsync() {
_currentTask = TaskType.A;
_tcsA = new TaskCompletionSource<A>();
// some complex non-sync task, using http/events that ends with Complete();
// QueueRequest?.Invoke(this, taskInfo); // raise request -- this does not return
return _tcsA.Task;
}
public Task<B> GetBAsync() {
_currentTask = TaskType.B;
_tcsB = new TaskCompletionSource<B>();
// some complex non-sync task, using http/events that ends with Complete();
// QueueRequest?.Invoke(this, taskInfo); // raise request -- this does not return
return _tcsB.Task;
}
public Task<C> GetCAsync() {
_currentTask = TaskType.C;
_tcsC = new TaskCompletionSource<C>();
// some complex non-sync task, using http/events that ends with Complete();
// QueueRequest?.Invoke(this, taskInfo); // raise request -- this does not return
return _tcsC.Task;
}
// called by an external source, a http listener / processor
// this should complete the async call by the client and return results
public void Complete(Result result) {
switch (_currentTask) {
case TaskType.A:
_tcsA.SetResult(new A());
break;
case TaskType.B:
_tcsB.SetResult(new B());
break;
case TaskType.C:
_tcsC.SetResult(new C());
break;
}
_currentTask = TaskType.None;
}
为简单起见,以上是半伪代码。我像这样调用其中一种方法:
A a = await service.GetAAsync();
现在的问题是TaskCompletionSource<T>
是泛型的,如果我有 100 个这样的方法,我将不得不为每个返回类型创建一个变量。但是由于一次只能调用一个方法,因此最好使用单个TaskCompletionSource
,但不键入它来object (TaskCompletionSource<object>)
。
我不想做:
object a = await service.GetAAsync();
因为这需要客户投射。所以最好的解决方案是有一个 TaskCompletionSource
,但以某种方式键入它。或者能够有一个 TaskCompletionSource
词典 .这对我来说似乎都是不可能的。
我应该如何解决这个问题?
更新:
有关我的情况的背景,请查看:在断开连接的场景中将同步代码包装为异步等待
我不想做
object a = await service.GetAAsync()
因为这需要客户投射。
不一定。保留相同的签名,但添加对ContinueWith
的调用以转换为适当的类型:
public Task<A> GetAAsync() {
_currentTask = TaskType.A;
_tcs = new TaskCompletionSource<object>();
// some complex task that ends with Complete();
return _tcs.Task.ContinueWith(t => (A)t.Result);
}
或者你可以使用 async/await 做同样的事情:
public async Task<A> GetAAsync() {
_currentTask = TaskType.A;
_tcs = new TaskCompletionSource<object>();
// some complex task that ends with Complete();
return (A)await _tcs.Task;
}
很容易通过 TaskCompletionSourceDictionary <TKey>
完成:
目标:
- 任何类型都可以用于密钥 - 我在此示例中使用了您的
TaskType
枚举 - 如果每种类型只有一个实例,则非泛型版本更简单
- 生产者和消费者的动态 #
- 结果的完成可以由多个消费者观察
- 强制实施类型安全 - 生产者和使用者必须指定相同的类型,否则强制转换异常会描述类型差异
- 生产者可以在消费者请求任务之前设置结果
- 使用者可以在生产者设置结果之前请求任务
我们可以在这个新类上使用 GetOrAdd
方法完成所有这些工作:
TaskCompletionSource<TValue> GetOrAdd<TValue>(TKey key)
用法示例:
private readonly TaskCompletionSourceDictionary<TaskType> _tasks = new TaskCompletionSourceDictionary<TaskType>();
public Task<A> GetAAsync() =>
_tasks.GetOrAdd<A>(TaskType.A).Task;
public Task<B> GetBAsync() =>
_tasks.GetOrAdd<B>(TaskType.B).Task;
public Task<C> GetCAsync() =>
_tasks.GetOrAdd<C>(TaskType.C).Task;
// called by an external source, a http listener / processor
// this should complete the async call by the client and return results
public void Complete(Result result)
{
switch (_currentTask)
{
case TaskType.A:
_tasks.GetOrAdd<A>(TaskType.A).TrySetResult(new A());
break;
case TaskType.B:
_tasks.GetOrAdd<B>(TaskType.B).TrySetResult(new B());
break;
case TaskType.C:
_tasks.GetOrAdd<C>(TaskType.C).TrySetResult(new C());
break;
}
_currentTask = TaskType.None;
}
除了GetOrAdd
,还有TryAdd
和TryRemove
。不过,删除可能很危险 - 删除最后一个消费者。