构造函数中 class 字段的长 运行 初始化
Long running initialisation of class fields in constructor
假设我有下面的class
public class MyClass {
private readonly NinjaObject _myNinja;
MyClass(NinjaFactory ninjaFactory) {
_myNinja = ninjaFactory.CreateNinjaButItTakesTime();
}
public void NinjaAttack() {
_myNinja.Attack();
}
}
现在,构造函数应该尽一切努力初始化 class 并准备好供应用程序使用,即创建 Ninja 并准备好在调用时进行攻击。让您的构造函数快速执行操作也是一个好主意。但是,如果创建 Ninja 的过程需要很长时间,这可能是不可能的。我假设您可以通过某种静态工厂方法异步创建 Ninja,但是您 运行 风险(至少在理论上)Ninja 在被调用时没有准备好(即空对象)进行攻击通过应用程序。
如果 class 的字段对 class 的操作方式至关重要,但可能需要很长时间才能构建,那么创建它们的最佳模式是什么?在构造函数中保持同步,还是应用某种异步模式?
I presume you could create the Ninja asynchronously through some kind of static factory method, but then you run the risk (at least theoretically) of the Ninja not being ready (i.e. a null object) to attack when called to do so by the application.
嗯,这是异步静态工厂方法派上用场的地方:
public class MyClass
{
private readonly Ninja ninja;
private MyClass(Ninja ninja)
{
this.ninja = ninja;
}
public static async Task<MyClass> Create()
{
// Or however you create a ninja - ideally properly asynchronous
var ninja = await Ninja.Create();
return new MyClass(ninja);
}
public void NinjaAttack() => ninja.Attack();
}
您无法避免它花费很长时间 - 但您 可以 通过将构造函数调用保留到最后来使创建异步。这基本上解决了构造函数不能异步的限制。
另一种方法——但也是一种危险的方法——是开始创建忍者的任务并将 that 传递给构造函数,但稍后使用任务的结果:
public class MyClass
{
private readonly Task<Ninja> ninjaTask;
public MyClass(Task<Ninja> ninjaTask)
{
this.ninjaTask = ninjaTask;
}
public void NinjaAttack() => ninjaTask.Result.Attack();
}
这很危险,因为在某些情况下使用 Task<T>.Result
可能会死锁,如果任务需要在当前同步上下文中做更多工作才能完成。您可以通过使 NinjaAttack
方法异步来避免这种情况:
public class MyClass
{
private readonly Task<Ninja> ninjaTask;
public MyClass(Task<Ninja> ninjaTask)
{
this.ninjaTask = ninjaTask;
}
public async Task NinjaAttack() => (await ninjaTask).Attack();
}
根据您的上下文,您可能想要使用 await ninjaTask.ConfigureAwait(false)
。
假设我有下面的class
public class MyClass {
private readonly NinjaObject _myNinja;
MyClass(NinjaFactory ninjaFactory) {
_myNinja = ninjaFactory.CreateNinjaButItTakesTime();
}
public void NinjaAttack() {
_myNinja.Attack();
}
}
现在,构造函数应该尽一切努力初始化 class 并准备好供应用程序使用,即创建 Ninja 并准备好在调用时进行攻击。让您的构造函数快速执行操作也是一个好主意。但是,如果创建 Ninja 的过程需要很长时间,这可能是不可能的。我假设您可以通过某种静态工厂方法异步创建 Ninja,但是您 运行 风险(至少在理论上)Ninja 在被调用时没有准备好(即空对象)进行攻击通过应用程序。
如果 class 的字段对 class 的操作方式至关重要,但可能需要很长时间才能构建,那么创建它们的最佳模式是什么?在构造函数中保持同步,还是应用某种异步模式?
I presume you could create the Ninja asynchronously through some kind of static factory method, but then you run the risk (at least theoretically) of the Ninja not being ready (i.e. a null object) to attack when called to do so by the application.
嗯,这是异步静态工厂方法派上用场的地方:
public class MyClass
{
private readonly Ninja ninja;
private MyClass(Ninja ninja)
{
this.ninja = ninja;
}
public static async Task<MyClass> Create()
{
// Or however you create a ninja - ideally properly asynchronous
var ninja = await Ninja.Create();
return new MyClass(ninja);
}
public void NinjaAttack() => ninja.Attack();
}
您无法避免它花费很长时间 - 但您 可以 通过将构造函数调用保留到最后来使创建异步。这基本上解决了构造函数不能异步的限制。
另一种方法——但也是一种危险的方法——是开始创建忍者的任务并将 that 传递给构造函数,但稍后使用任务的结果:
public class MyClass
{
private readonly Task<Ninja> ninjaTask;
public MyClass(Task<Ninja> ninjaTask)
{
this.ninjaTask = ninjaTask;
}
public void NinjaAttack() => ninjaTask.Result.Attack();
}
这很危险,因为在某些情况下使用 Task<T>.Result
可能会死锁,如果任务需要在当前同步上下文中做更多工作才能完成。您可以通过使 NinjaAttack
方法异步来避免这种情况:
public class MyClass
{
private readonly Task<Ninja> ninjaTask;
public MyClass(Task<Ninja> ninjaTask)
{
this.ninjaTask = ninjaTask;
}
public async Task NinjaAttack() => (await ninjaTask).Attack();
}
根据您的上下文,您可能想要使用 await ninjaTask.ConfigureAwait(false)
。