跳到主要内容
版本：7.x

绑定语法

绑定语法是使用 容器 API 或 容器模块 API 产生的流畅接口。

BoundServiceSyntax​

interface BoundServiceSyntax {
  getIdentifier(): BindingIdentifier;
}

所有绑定语法接口实现的基础接口。提供对绑定唯一标识符的访问。

getIdentifier​

getIdentifier(): BindingIdentifier;

返回此特定绑定的唯一标识符。此标识符可与 container.unbind() 一起使用，以仅删除此绑定，而不是删除服务的所有绑定。

示例：

const container: Container = new Container();

// The identifier can be used to unbind this specific binding later
export const bindingIdentifier: BindingIdentifier = container
  .bind('MyService')
  .to(MyServiceImpl)
  .getIdentifier();

BindToFluentSyntax​

interface BindToFluentSyntax<T> extends BoundServiceSyntax {
  // ...
}

表示给定服务标识符的服务绑定。实现 BoundServiceSyntax 以提供对绑定唯一标识符的访问。

const bindingToSyntax = container.bind('service-id');

进一步的文档将此服务标识符称为“给定服务标识符”。

to​

to(type: Newable<T>): BindInWhenOnFluentSyntax<T>;

将类实例化绑定到给定的服务绑定。每当解析服务时，都会调用类构造函数来构建解析值。

const container: Container = new Container();
container.bind<Weapon>('Weapon').to(Katana);

const katana: Weapon = container.get<Weapon>('Weapon');

toSelf​

toSelf(): BindInWhenOnFluentSyntax<T>;

如果给定的服务标识符是一个类，则建立到该类的类型绑定。

const container: Container = new Container();
container.bind<Weapon>(Katana).toSelf();

const katana: Weapon = container.get<Weapon>(Katana);

toConstantValue​

toConstantValue(value: T): BindWhenOnFluentSyntax<T>;

将单例作用域中的值绑定到给定的服务标识符。

const container: Container = new Container();
container.bind<Weapon>('Weapon').toConstantValue(new Katana());

const katana: Weapon = container.get<Weapon>('Weapon');

toDynamicValue​

toDynamicValue(builder: DynamicValueBuilder<T>): BindInWhenOnFluentSyntax<T>;

将函数绑定到给定的服务标识符。每当解析服务时，都会调用传递的函数来构建解析值。

信息

请记住，如果服务缓存在当前作用域中，则不会解析该服务。

const container: Container = new Container();
container.bind<Weapon>('Weapon').toDynamicValue((): Weapon => new Katana());

const katana: Weapon = container.get<Weapon>('Weapon');

toFactory​

toFactory(
  factory: T extends Factory<unknown, any>
    ? (context: ResolutionContext) => T
    : never,
): BindWhenOnFluentSyntax<T>;

将工厂绑定到给定的服务标识符。每当解析服务时，工厂将作为解析值传递。

container.bind<Engine>('Engine').to(PetrolEngine).whenNamed('petrol');
container.bind<Engine>('Engine').to(DieselEngine).whenNamed('diesel');

container
  .bind<Factory<(displacement: number) => Engine, [string]>>('Factory<Engine>')
  .toFactory((context: ResolutionContext) => {
    return (named: string) => (displacement: number) => {
      const engine: Engine = context.get<Engine>('Engine', {
        name: named,
      });
      engine.displacement = displacement;
      return engine;
    };
  });

@injectable()
class DieselCarFactory implements CarFactory {
  readonly #dieselFactory: (displacement: number) => Engine;

  constructor(
    @inject('Factory<Engine>')
    factory: (category: string) => (displacement: number) => Engine, // Injecting an engine factory
  ) {
    // Creating a diesel engine factory
    this.#dieselFactory = factory('diesel');
  }

  public createEngine(displacement: number): Engine {
    // Creating a concrete diesel engine
    return this.#dieselFactory(displacement);
  }
}

toProvider​

已弃用

toProvider() 已弃用，将在 v8 中删除。请改用 toFactory()。

提供者的存在是由于 v5 的历史原因，当时不支持异步依赖项。在 v6+ 中，支持异步依赖项，使提供者过时。工厂更灵活，可以处理同步和异步操作。

toProvider(
  provider: T extends Provider<unknown, any>
    ? (context: ResolutionContext) => T
    : never,
): BindWhenOnFluentSyntax<T>;

将与目标服务标识符关联的服务提供者绑定到给定的服务标识符。提供者只是一个异步工厂。

const container: Container = new Container();

interface Sword {
  material: string;
  damage: number;
}

@injectable()
class Katana implements Sword {
  public material!: string;
  public damage!: number;
}

type SwordProvider = (material: string, damage: number) => Promise<Sword>;

container.bind<Sword>('Sword').to(Katana);

container
  .bind<SwordProvider>('SwordProvider')
  .toProvider((context: ResolutionContext) => {
    return async (material: string, damage: number): Promise<Sword> => {
      // Custom args!
      return new Promise<Sword>(
        (resolve: (value: Sword | PromiseLike<Sword>) => void) => {
          setTimeout(() => {
            const katana: Sword = context.get<Sword>('Sword');
            katana.material = material;
            katana.damage = damage;
            resolve(katana);
          }, 10);
        },
      );
    };
  });

const katanaProvider: SwordProvider =
  container.get<SwordProvider>('SwordProvider');

const powerfulGoldKatana: Promise<Sword> = katanaProvider('gold', 100);

const notSoPowerfulGoldKatana: Promise<Sword> = katanaProvider('gold', 10);

toResolvedValue​

toResolvedValue(factory: () => T): BindInWhenOnFluentSyntax<T>;
toResolvedValue<TArgs extends unknown[] = any[]>(
  factory: (...args: TArgs) => T,
  injectOptions?: MapToResolvedValueInjectOptions<TArgs>,
): BindInWhenOnFluentSyntax<T>;

将值绑定到服务标识符。此值是在接收解析服务的函数之上生成的。你可以通过将服务标识符作为参数传递来指定要解析的服务：

const container: Container = new Container();

container.bind(Katana).toSelf();
container
  .bind<Weapon>('Weapon')
  .toResolvedValue((weapon: Weapon): Weapon => weapon, [Katana]);

const katana: Weapon = container.get<Weapon>('Weapon');

你还可以提供更详细的选项以接收解析的服务：

const container: Container = new Container();

container.bind(Katana).toSelf().whenNamed('katana');

container.bind<Arsenal>('Arsenal').toResolvedValue(
  (weapon: Weapon): Arsenal => ({
    weapons: [weapon],
  }),
  [
    {
      name: 'katana',
      serviceIdentifier: Katana,
    },
  ],
);

const arsenal: Arsenal = container.get('Arsenal');

toService​

toService(service: ServiceIdentifier<T>): void;

将绑定到目标服务标识符的服务绑定到给定的服务标识符。

const container: Container = new Container();

container.bind(lorcanaCardCatalogProviderSymbol).to(LorcanaCardCatalogProvider);
container.bind(mtgCardCatalogProviderSymbol).to(MtgCardCatalogProvider);

container
  .bind(cardCatalogProviderSymbol)
  .toService(lorcanaCardCatalogProviderSymbol);
container
  .bind(cardCatalogProviderSymbol)
  .toService(mtgCardCatalogProviderSymbol);

const cardCatalogProviders: CardCatalogProvider<unknown>[] = container.getAll(
  cardCatalogProviderSymbol,
);

BindInFluentSyntax​

interface BindInFluentSyntax<T> extends BoundServiceSyntax {
  // ...
}

表示给定服务标识符和服务解析（如构造函数、工厂或提供者）的服务绑定。实现 BoundServiceSyntax 以提供对绑定唯一标识符的访问。

inSingletonScope​

inSingletonScope(): BindWhenOnFluentSyntax<T>;

将绑定作用域设置为单例。有关更多信息，请参阅 文档。

inTransientScope​

inTransientScope(): BindWhenOnFluentSyntax<T>;

将绑定作用域设置为瞬态。有关更多信息，请参阅 文档。

inRequestScope​

inRequestScope(): BindWhenOnFluentSyntax<T>;

将绑定作用域设置为请求。有关更多信息，请参阅 文档。

BindOnFluentSyntax​

interface BindOnFluentSyntax<T> extends BoundServiceSyntax {
  // ...
}

允许设置绑定激活和停用处理程序。实现 BoundServiceSyntax 以提供对绑定唯一标识符的访问。

onActivation​

onActivation(activation: BindingActivation<T>): BindWhenFluentSyntax<T>;

设置绑定激活处理程序。激活处理程序在依赖项解析之后且添加到作用域缓存之前调用。如果依赖项取自作用域缓存，则不会调用激活处理程序。

@injectable()
class Katana {
  public use(): string {
    return 'hit!';
  }
}

container
  .bind<Katana>('Katana')
  .to(Katana)
  .onActivation((_context: ResolutionContext, katana: Katana) => {
    const handler: ProxyHandler<() => string> = {
      apply: function (
        target: () => string,
        thisArgument: unknown,
        argumentsList: [],
      ) {
        console.log(`Starting: ${new Date().getTime().toString()}`);
        const result: string = target.apply(thisArgument, argumentsList);
        console.log(`Finished: ${new Date().getTime().toString()}`);
        return result;
      },
    };

    katana.use = new Proxy(katana.use.bind(katana), handler);

    return katana;
  });

onDeactivation​

onDeactivation(deactivation: BindingDeactivation<T>): BindWhenFluentSyntax<T>;

在单例作用域绑定上设置绑定停用处理程序。当绑定从容器中解绑时，将调用停用处理程序。

注意

只有单例作用域绑定可以具有停用处理程序。如果你尝试向非单例绑定添加停用处理程序，则会抛出错误。

BindWhenFluentSyntax​

interface BindWhenFluentSyntax<T> extends BoundServiceSyntax {
  // ...
}

允许设置绑定约束。实现 BoundServiceSyntax 以提供对绑定唯一标识符的访问。

when​

为当前绑定设置约束。

when(
  constraint: (metadata: BindingConstraints) => boolean,
): BindOnFluentSyntax<T>;
const ninjaId: symbol = Symbol.for('Ninja');
const weaponId: symbol = Symbol.for('Weapon');

@injectable()
class Ninja {
  constructor(
    @inject(weaponId)
    @named('shuriken')
    public readonly weapon: Weapon,
  ) {}
}

container.bind<Ninja>(ninjaId).to(Ninja);

const whenTargetNamedConstraint: (
  name: string,
) => (bindingconstraints: BindingConstraints) => boolean =
  (name: string) =>
  (bindingconstraints: BindingConstraints): boolean =>
    bindingconstraints.name === name;

container
  .bind<Weapon>(weaponId)
  .to(Katana)
  .when(whenTargetNamedConstraint('katana'));

container
  .bind<Weapon>(weaponId)
  .to(Shuriken)
  .when(whenTargetNamedConstraint('shuriken'));

const ninja: Ninja = container.get(ninjaId);

// Returns 5
const ninjaDamage: number = ninja.weapon.damage;

在前面的示例中，实现了一个自定义约束，以便当且仅当目标名称为特定名称时才使用绑定。

whenAnyAncestor​

whenAnyAncestor(
  constraint: (metadata: BindingConstraints) => boolean,
): BindOnFluentSyntax<T>;

约束绑定仅在给定约束的情况下，任何祖先服务匹配给定约束时使用。

whenAnyAncestorIs​

whenAnyAncestorIs(
  serviceIdentifier: ServiceIdentifier,
): BindOnFluentSyntax<T>;

约束绑定仅在给定服务标识符的情况下，使用给定标识符请求任何祖先服务时使用。

whenAnyAncestorNamed​

whenAnyAncestorNamed(name: MetadataName): BindOnFluentSyntax<T>;

约束绑定仅在给定名称的情况下，使用给定名称请求命名父服务时使用。

whenAnyAncestorTagged​

whenAnyAncestorTagged(
  tag: MetadataTag,
  tagValue: unknown,
): BindOnFluentSyntax<T>;

约束绑定仅在给定标签的情况下，使用给定标签请求标记的父服务时使用。

whenDefault​

whenDefault(): BindOnFluentSyntax<T>;

约束绑定仅在未使用任何名称或标签请求服务时使用。

whenNamed​

约束绑定仅在给定名称的情况下，使用给定名称请求命名服务时使用。

whenNamed(name: MetadataName): BindOnFluentSyntax<T>;

whenNoAncestor​

whenNoAncestor(
  constraint: (metadata: BindingConstraints) => boolean,
): BindOnFluentSyntax<T>;

约束绑定仅在给定约束的情况下，没有祖先服务匹配给定约束时使用。

whenNoAncestorIs​

whenNoAncestorIs(serviceIdentifier: ServiceIdentifier): BindOnFluentSyntax<T>;

约束绑定仅在给定服务标识符的情况下，没有使用给定标识符请求祖先服务时使用。

whenNoAncestorNamed​

whenNoAncestorNamed(name: MetadataName): BindOnFluentSyntax<T>;

约束绑定仅在给定名称的情况下，没有使用给定名称请求祖先服务时使用。

whenNoAncestorTagged​

whenNoAncestorTagged(
  tag: MetadataTag,
  tagValue: unknown,
): BindOnFluentSyntax<T>;

约束绑定仅在给定标签的情况下，没有使用给定标签请求祖先服务时使用。

whenNoParent​

whenNoParent(
  constraint: (metadata: BindingConstraints) => boolean,
): BindOnFluentSyntax<T>;

约束绑定仅在给定约束的情况下，没有父服务匹配给定约束时使用。

whenNoParentIs​

whenNoParentIs(serviceIdentifier: ServiceIdentifier): BindOnFluentSyntax<T>;

约束绑定仅在给定服务标识符的情况下，没有使用给定标识符请求父服务时使用。

whenNoParentNamed​

whenNoParentNamed(name: MetadataName): BindOnFluentSyntax<T>;

约束绑定仅在给定名称的情况下，没有使用给定名称请求父服务时使用。

whenNoParentTagged​

whenNoParentTagged(
  tag: MetadataTag,
  tagValue: unknown,
): BindOnFluentSyntax<T>;

约束绑定仅在给定标签的情况下，没有使用给定标签请求父服务时使用。

whenParent​

whenParent(
  constraint: (metadata: BindingConstraints) => boolean,
): BindOnFluentSyntax<T>;

约束绑定仅在给定约束的情况下，父服务匹配给定约束时使用。

whenParentIs​

whenParentIs(serviceIdentifier: ServiceIdentifier): BindOnFluentSyntax<T>;

约束绑定仅在给定服务标识符的情况下，使用给定标识符请求父服务时使用。

whenParentNamed​

whenParentNamed(name: MetadataName): BindOnFluentSyntax<T>;

约束绑定仅在给定名称的情况下，使用给定名称请求父服务时使用。

whenParentTagged​

whenParentTagged(tag: MetadataTag, tagValue: unknown): BindOnFluentSyntax<T>;

约束绑定仅在给定标签的情况下，使用给定标签请求父服务时使用。

whenTagged​

whenTagged(tag: MetadataTag, tagValue: unknown): BindOnFluentSyntax<T>;

约束绑定仅在给定标签的情况下，使用给定标签请求标记的服务时使用。

BindWhenOnFluentSyntax​

BindWhenFluentSyntax 和 BindOnFluentSyntax 的联合。

export interface BindWhenOnFluentSyntax<T>
  extends BindWhenFluentSyntax<T>,
    BindOnFluentSyntax<T> {}

BindInWhenOnFluentSyntax​

BindInFluentSyntax 和 BindWhenOnFluentSyntax 的联合。

export interface BindInWhenOnFluentSyntax<T>
  extends BindInFluentSyntax<T>,
    BindWhenOnFluentSyntax<T> {}