VSCode源码分析 - 实例化服务

目录

实例化服务

SyncDescriptor负责注册这些服务，当用到该服务时进程实例化使用

src/vs/platform/instantiation/common/descriptors.ts

  1. export class SyncDescriptor<T> {
  2.     readonly ctor: any;
  3.     readonly staticArguments: any[];
  4.     readonly supportsDelayedInstantiation: boolean;
  5.     constructor(ctor: new (...args: any[]) => T, staticArguments: any[] = [], supportsDelayedInstantiation: boolean = false) {
  6.         this.ctor = ctor;
  7.         this.staticArguments = staticArguments;
  8.         this.supportsDelayedInstantiation = supportsDelayedInstantiation;
  9.     }
  10. }

main.ts中startup方法调用invokeFunction.get实例化服务

  1. await instantiationService.invokeFunction(async accessor => {
  2.     const environmentService = accessor.get(IEnvironmentService);
  3.     const configurationService = accessor.get(IConfigurationService);
  4.     const stateService = accessor.get(IStateService);
  5.     try {
  6.         await this.initServices(environmentService, configurationService as ConfigurationService, stateService as StateService);
  7.     } catch (error) {
  9.         // Show a dialog for errors that can be resolved by the user
  10.         this.handleStartupDataDirError(environmentService, error);
  12.         throw error;
  13.     }
  14. });

get方法调用_getOrCreateServiceInstance，这里第一次创建会存入缓存中 下次实例化对象时会优先从缓存中获取对象。

src/vs/platform/instantiation/common/instantiationService.ts

  1. invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R {
  2.     let _trace = Trace.traceInvocation(fn);
  3.     let _done = false;
  4.     try {
  5.         const accessor: ServicesAccessor = {
  6.             get: <T>(id: ServiceIdentifier<T>, isOptional?: typeof optional) => {
  8.                 if (_done) {
  9.                     throw illegalState('service accessor is only valid during the invocation of its target method');
  10.                 }
  12.                 const result = this._getOrCreateServiceInstance(id, _trace);
  13.                 if (!result && isOptional !== optional) {
  14.                     throw new Error(`[invokeFunction] unknown service '${id}'`);
  15.                 }
  16.                 return result;
  17.             }
  18.         };
  19.         return fn.apply(undefined, [accessor, ...args]);
  20.     } finally {
  21.         _done = true;
  22.         _trace.stop();
  23.     }
  24. }
  25. private _getOrCreateServiceInstance<T>(id: ServiceIdentifier<T>, _trace: Trace): T {
  26.     let thing = this._getServiceInstanceOrDescriptor(id);
  27.     if (thing instanceof SyncDescriptor) {
  28.         return this._createAndCacheServiceInstance(id, thing, _trace.branch(id, true));
  29.     } else {
  30.         _trace.branch(id, false);
  31.         return thing;
  32.     }
  33. }