I need to implement some sort of strategy pattern with tsyringe but can’t figure out how to dynamically inject the strategy into my context class without polluting the dependency container.
<code>interface IThing {
exec(): void;
}
@injectable()
class Thing1 implements IThing {
exec(): void {
console.log('thing 1');
}
}
@injectable()
class Thing2 implements IThing {
exec(): void {
console.log('thing 2');
}
}
@injectable()
class Test {
constructor(
// how would the container know which is which between Thing1 and Thing2?
@inject('??')
private readonly thing: IThing,
) {
thing.exec();
}
}
// find a way to resolve `Test` and give it Thing1 or Thing2
</code>
<code>interface IThing {
exec(): void;
}
@injectable()
class Thing1 implements IThing {
exec(): void {
console.log('thing 1');
}
}
@injectable()
class Thing2 implements IThing {
exec(): void {
console.log('thing 2');
}
}
@injectable()
class Test {
constructor(
// how would the container know which is which between Thing1 and Thing2?
@inject('??')
private readonly thing: IThing,
) {
thing.exec();
}
}
// find a way to resolve `Test` and give it Thing1 or Thing2
</code>
interface IThing {
exec(): void;
}
@injectable()
class Thing1 implements IThing {
exec(): void {
console.log('thing 1');
}
}
@injectable()
class Thing2 implements IThing {
exec(): void {
console.log('thing 2');
}
}
@injectable()
class Test {
constructor(
// how would the container know which is which between Thing1 and Thing2?
@inject('??')
private readonly thing: IThing,
) {
thing.exec();
}
}
// find a way to resolve `Test` and give it Thing1 or Thing2
I’m unsure how I could use container.resolve(Test)
and give it Thing1
/Thing2
.
I know I could do something like the following, but I not sure this is very elegant, as it pollutes the container and risks instantiating Test
with the wrong strategy:
<code>@injectable()
class Test {
constructor(
@inject('Thing')
private readonly thing: IThing,
) {
thing.exec();
}
}
container.provide("Thing", { useClass: Thing1/2 })
const test = container.resolve(Test) // test with proper strategy, but now the container is polluted
</code>
<code>@injectable()
class Test {
constructor(
@inject('Thing')
private readonly thing: IThing,
) {
thing.exec();
}
}
container.provide("Thing", { useClass: Thing1/2 })
const test = container.resolve(Test) // test with proper strategy, but now the container is polluted
</code>
@injectable()
class Test {
constructor(
@inject('Thing')
private readonly thing: IThing,
) {
thing.exec();
}
}
container.provide("Thing", { useClass: Thing1/2 })
const test = container.resolve(Test) // test with proper strategy, but now the container is polluted
Is there a more elegant way to implement this pattern?