泛型类型的类型擦除，更好的替代动态

Question

我正在尝试创建一个可以将任何Func<T>或Action作为输入的工作线程池，返回一个任务并在将来的某个线程中安排该任务的结果。

我知道我可以使用ThreadPool或Task.Factory但我这样做是为了学习。

现在，我在下面的实现依赖于我能够通过将其包装在TaskWrapper中的dynamic来排队TaskCompletionSource<T>。我觉得这样做不舒服(因为我可以想象这有一个不可忽视的运行时成本(，但我不知道有任何替代方案。

public class WorkerHub
{
private readonly ConcurrentQueue<TaskWrapper> _tasks;
private readonly Timer _timer;
public WorkerHub()
{
_timer = new Timer();
_tasks = new ConcurrentQueue<TaskWrapper>();
}
public Task<TResult> Post<TResult>(Func<TResult> func)
{
var cts = new TaskCompletionSource<TResult>();
var wrapper = new TaskWrapper {CompletionSource = cts, Function = func};
_tasks.Enqueue(wrapper);
return cts.Task;
}
public Task Post(Action action)
{
var cts = new TaskCompletionSource<bool>();
var wrapper = new TaskWrapper {CompletionSource = cts, Function = action, isVoid = true};
_tasks.Enqueue(wrapper);
return cts.Task;
}
private TaskWrapper Pop()
{
_tasks.TryDequeue(out var wrapper);
return wrapper;
}

public void Start()
{
_timer.Enabled = true;
_timer.AutoReset = true;
_timer.Interval = 2500;
_timer.Elapsed += (sender, args) =>
{
var wrapper = Pop();
if (wrapper != null) wrapper.CompletionSource.SetResult(wrapper.isVoid ? true : wrapper.Function());
};
_timer.Start();
}
public void Stop()
{
}
private class TaskWrapper
{
public bool isVoid { get; set; }
public dynamic Function { get; set; }
public dynamic CompletionSource { get; set; }
}

能够绑定到同一集合中不同类型的完成源和不同类型的输入函数的"正确"方法是什么？

Answer 1

另一种不涉及保留委托或任务完成源的方法是通过 lambda 表达式

public class WorkerHub {
private readonly ConcurrentQueue<TaskWrapper> _tasks;
private readonly Timer _timer;
public WorkerHub() {
_timer = new Timer();
_tasks = new ConcurrentQueue<TaskWrapper>();
}
public Task<TResult> Post<TResult>(Func<TResult> func) {
var cts = new TaskCompletionSource<TResult>();
Action handler = () => {
cts.SetResult(func());
};
var wrapper = new TaskWrapper { Invoke = handler };
_tasks.Enqueue(wrapper);
return cts.Task;
}
public Task Post(Action action) {
var cts = new TaskCompletionSource<bool>();
Action handler = () => {
action();
cts.SetResult(true);
};
var wrapper = new TaskWrapper { Invoke = handler };
_tasks.Enqueue(wrapper);
return cts.Task;
}
private TaskWrapper Pop()
{
_tasks.TryDequeue(out var wrapper);
return wrapper;
}

public void Start() {
_timer.Enabled = true;
_timer.AutoReset = true;
_timer.Interval = 2500;
_timer.Elapsed += (sender, args) => {
var wrapper = Pop();
if (wrapper != null)
wrapper.Invoke();
};
_timer.Start();
}
public void Stop() {
}
private class TaskWrapper {
public Action Invoke { get; set; }
}
}

创建一个Action委托来处理所需的行为，并在需要时提供给要调用的包装器。

包装器现在变得多余，可以完全删除

public class WorkerHub {
private readonly ConcurrentQueue<Action> _tasks;
private readonly Timer _timer;
public WorkerHub() {
_timer = new Timer();
_tasks = new ConcurrentQueue<Action>();
}
public Task<TResult> Post<TResult>(Func<TResult> func) {
var cts = new TaskCompletionSource<TResult>();
Action handler = () => {
cts.SetResult(func());
};
_tasks.Enqueue(handler);
return cts.Task;
}
public Task Post(Action action) {
var cts = new TaskCompletionSource<bool>();
Action handler = () => {
action();
cts.SetResult(true);
};
_tasks.Enqueue(handler);
return cts.Task;
}
public void Start() {
_timer.Enabled = true;
_timer.AutoReset = true;
_timer.Interval = 2500;
_timer.Elapsed += (sender, args) => {
Action handler = null;
if (_tasks.TryDequeue(out  handler) && handler != null)
handler.Invoke();
};
_timer.Start();
}
public void Stop() {
}
}

是的，可以做更多的重构来改进这个设计，但这应该足以让总体思路变得清晰起来。

Answer 2

我认为将一些功能移动到TaskWrapper中并定义一个派生自它的通用实现很有意义：

private class TaskWrapper
{
private readonly Action _function;
private readeonly TaskCompletionSource<bool> _cts;
public TaskWrapper (Action function, TaskCompletionSource<bool> cts) {
_function = function;
_cts = cts;
}
protected TaskWrapper () {
_function = null;
_cts = null;
}
public virtual void DoWork() {
_function();
cts.SetResult(true);
}
}
private class TaskWrapper<T> : TaskWrapper {
private readonly Func<T> _function;
private readeonly TaskCompletionSource<T> _cts;
public TaskWrapper (Func<T> function, TaskCompletionSource<T> cts) : base() {
_function = function;
_cts = cts;
}
public override void DoWork(){
_cts.SetResult(_function());
}
}

现在，您的调度员可以只调用DoWork，而不知道通用是否是施工期间使用的通用。

---

我还要指出，您当前的实现应该让您感到不舒服。它无法为Action项调用Function。