Method get

packages/core/src/di/r3_injector.ts:323–423

(
    token: ProviderToken<T>,
    notFoundValue: any = THROW_IF_NOT_FOUND,
    options?: InjectOptions,
  )

  }

  override get<T>(
    token: ProviderToken<T>,
    notFoundValue: any = THROW_IF_NOT_FOUND,
    options?: InjectOptions,
  ): T {
    assertNotDestroyed(this);

    if (token.hasOwnProperty(NG_ENV_ID)) {
      return (token as any)[NG_ENV_ID](this);
    }

    const flags = convertToBitFlags(options) as InternalInjectFlags;

    // Set the injection context.
    let prevInjectContext: InjectorProfilerContext;
    if (ngDevMode) {
      prevInjectContext = setInjectorProfilerContext({injector: this, token: token as Type<T>});
    }
    const previousInjector = setCurrentInjector(this);
    const previousInjectImplementation = setInjectImplementation(undefined);
    try {
      // Check for the SkipSelf flag.
      if (!(flags & InternalInjectFlags.SkipSelf)) {
        // SkipSelf isn't set, check if the record belongs to this injector.
        let record: Record<T> | undefined | null = this.records.get(token);
        if (record === undefined) {
          // No record, but maybe the token is scoped to this injector. Look for an injectable
          // def with a scope matching this injector.
          const def = couldBeInjectableType(token) && getInjectableDef(token);
          if (def && this.injectableDefInScope(def)) {
            // Found an injectable def and it's scoped to this injector. Pretend as if it was here
            // all along.

            if (ngDevMode) {
              runInInjectorProfilerContext(this, token as Type<T>, () => {
                emitProviderConfiguredEvent(token as TypeProvider);
              });
            }

            record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
          } else {
            record = null;
          }
          this.records.set(token, record);
        }
        // If a record was found, get the instance for it and return it.
        if (record != null /* NOT null || undefined */) {
          return this.hydrate(token, record, flags);
        }
      }

      // Select the next injector based on the Self flag - if self is set, the next injector is
      // the NullInjector, otherwise it's the parent.
      const nextInjector = !(flags & InternalInjectFlags.Self) ? this.parent : getNullInjector();
      // Set the notFoundValue based on the Optional flag - if optional is set and notFoundValue
      // is undefined, the value is null, otherwise it's the notFoundValue.
      notFoundValue =
        flags & InternalInjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND