详解VSCode依赖注入的原理和实现

📦src
┣ 📂vs
┃ ┣ 📂platform
┃ ┃ ┣ 📂instantiation
┃ ┃ ┃ ┣ 📂common
┃ ┃ ┃ ┃ ┣ 📜descriptors.ts                 // 依赖描述符
┃ ┃ ┃ ┃ ┣ 📜extensions.ts                  // 插件系统和装饰器
┃ ┃ ┃ ┃ ┣ 📜graph.ts                       // 依赖关系图
┃ ┃ ┃ ┃ ┣ 📜instantiation.ts               // 依赖注入类型和装饰器
┃ ┃ ┃ ┃ ┣ 📜instantiationService.ts        // 实例化服务
┃ ┃ ┃ ┃ ┗ 📜serviceCollection.ts           // 服务收集
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂common
┃ ┃ ┃ ┃ ┃ ┣ 📜graph.test.ts                 // 依赖关系图单元测试
┃ ┃ ┃ ┃ ┃ ┣ 📜instantiationService.test.ts  // 实例化服务单元测试
┃ ┃ ┃ ┃ ┃ ┗ 📜instantiationServiceMock.ts   // 实例化服务模拟

export class SyncDescriptor<T> {

  readonly ctor: any;
  readonly staticArguments: any[];
  readonly supportsDelayedInstantiation: boolean;

  constructor(ctor: new (...args: any[]) => T, staticArguments: any[] = [], supportsDelayedInstantiation: boolean = false) {
    this.ctor = ctor;
    this.staticArguments = staticArguments;
    this.supportsDelayedInstantiation = supportsDelayedInstantiation;
  }
}

export interface SyncDescriptor0<T> {
  readonly ctor: new () => T;
}

const _registry: [ServiceIdentifier<any>, SyncDescriptor<any>][] = [];

export const enum InstantiationType {
  Eager = 0,
  Delayed = 1
}

export function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, ctor: new (...services: Services) => T, supportsDelayedInstantiation: InstantiationType): void;
export function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, descriptor: SyncDescriptor<any>): void;
export function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, ctorOrDescriptor: { new(...services: Services): T } | SyncDescriptor<any>, supportsDelayedInstantiation?: boolean | InstantiationType): void {
  if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
    ctorOrDescriptor = new SyncDescriptor<T>(ctorOrDescriptor as new (...args: any[]) => T, [], Boolean(supportsDelayedInstantiation));
  }

  _registry.push([id, ctorOrDescriptor]);
}

export function getSingletonServiceDescriptors(): [ServiceIdentifier<any>, SyncDescriptor<any>][] {
  return _registry;
}

export class Node<T> {

  readonly incoming = new Map<string, Node<T>>();
  readonly outgoing = new Map<string, Node<T>>();

  constructor(
    readonly key: string,
    readonly data: T
  ) { }
}

export class Graph<T> {

	private readonly _nodes = new Map<string, Node<T>>();

	constructor(private readonly _hashFn: (element: T) => string) {
		// empty
	}
}

roots(): Node<T>[] {
  const ret: Node<T>[] = [];
for (const node of this._nodes.values()) {
  if (node.outgoing.size === 0) {
    ret.push(node);
  }
}
return ret;
}

insertEdge(from: T, to: T): void {
  const fromNode = this.lookupOrInsertNode(from);
const toNode = this.lookupOrInsertNode(to);

fromNode.outgoing.set(toNode.key, toNode);
toNode.incoming.set(fromNode.key, fromNode);
}

removeNode(data: T): void {
  const key = this._hashFn(data);
this._nodes.delete(key);
for (const node of this._nodes.values()) {
  node.outgoing.delete(key);
  node.incoming.delete(key);
}
}

lookupOrInsertNode(data: T): Node<T> {
  const key = this._hashFn(data);
let node = this._nodes.get(key);

if (!node) {
  node = new Node(key, data);
  this._nodes.set(key, node);
}

return node;
}

lookup(data: T): Node<T> | undefined {
  return this._nodes.get(this._hashFn(data));
}

isEmpty(): boolean {
  return this._nodes.size === 0;
}

toString(): string {
  const data: string[] = [];
  for (const [key, value] of this._nodes) {
    data.push(`${key}\n\t(-> incoming)[${[...value.incoming.keys()].join(', ')}]\n\t(outgoing ->)[${[...value.outgoing.keys()].join(',')}]\n`);

  }
  return data.join('\n');
}

findCycleSlow() {
  for (const [id, node] of this._nodes) {
    const seen = new Set<string>([id]);
    const res = this._findCycle(node, seen);
    if (res) {
      return res;
    }
  }
  return undefined;
}

private _findCycle(node: Node<T>, seen: Set<string>): string | undefined {
  for (const [id, outgoing] of node.outgoing) {
    if (seen.has(id)) {
      return [...seen, id].join(' -> ');
    }
    seen.add(id);
    const value = this._findCycle(outgoing, seen);
    if (value) {
      return value;
    }
    seen.delete(id);
  }
  return undefined;
}

export namespace _util {

  export const serviceIds = new Map<string, ServiceIdentifier<any>>();

  export const DI_TARGET = '$di$target';
  export const DI_DEPENDENCIES = '$di$dependencies';

  export function getServiceDependencies(ctor: any): { id: ServiceIdentifier<any>; index: number }[] {
    return ctor[DI_DEPENDENCIES] || [];
  }
}

export type BrandedService = { _serviceBrand: undefined };

export interface IConstructorSignature<T, Args extends any[] = []> {
	new <Services extends BrandedService[]>(...args: [...Args, ...Services]): T;
}

export interface ServicesAccessor {
	get<T>(id: ServiceIdentifier<T>): T;
}

export interface ServiceIdentifier<T> {
  (...args: any[]): void;
  type: T;
}

export function createDecorator<T>(serviceId: string): ServiceIdentifier<T> {

  if (_util.serviceIds.has(serviceId)) {
    return _util.serviceIds.get(serviceId)!;
  }

  const id = <any>function (target: Function, key: string, index: number): any {
    if (arguments.length !== 3) {
      throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
    }
    storeServiceDependency(id, target, index);
  };

  id.toString = () => serviceId;

  _util.serviceIds.set(serviceId, id);
  return id;
}

export interface IInstantiationService {

  readonly _serviceBrand: undefined;

  createInstance<T>(descriptor: descriptors.SyncDescriptor0<T>): T;
  createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;

  invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R;

  createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService;

  dispose(): void;
}

function storeServiceDependency(id: Function, target: Function, index: number): void {
	if ((target as any)[_util.DI_TARGET] === target) {
		(target as any)[_util.DI_DEPENDENCIES].push({ id, index });
	} else {
		(target as any)[_util.DI_DEPENDENCIES] = [{ id, index }];
		(target as any)[_util.DI_TARGET] = target;
	}
}

export function refineServiceDecorator<T1, T extends T1>(serviceIdentifier: ServiceIdentifier<T1>): ServiceIdentifier<T> {
	return <ServiceIdentifier<T>>serviceIdentifier;
}

export class InstantiationService implements IInstantiationService {

	declare readonly _serviceBrand: undefined;
	readonly _globalGraph?: Graph<string>;
	private _globalGraphImplicitDependency?: string;
	private _isDisposed = false;
	private readonly _servicesToMaybeDispose = new Set<any>();
	private readonly _children = new Set<InstantiationService>();

  

}

private _createAndCacheServiceInstance<T>(id: ServiceIdentifier<T>, desc: SyncDescriptor<T>, _trace: Trace): T {

  type Triple = { id: ServiceIdentifier<any>; desc: SyncDescriptor<any>; _trace: Trace };
  const graph = new Graph<Triple>(data => data.id.toString());

  let cycleCount = 0;
  const stack = [{ id, desc, _trace }];
  while (stack.length) {
    const item = stack.pop()!;
    graph.lookupOrInsertNode(item);

    if (cycleCount++ > 1000) {
      throw new CyclicDependencyError(graph);
    }

    for (const dependency of _util.getServiceDependencies(item.desc.ctor)) {

      const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
      if (!instanceOrDesc) {
        this._throwIfStrict(`[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`, true);
      }

      this._globalGraph?.insertEdge(String(item.id), String(dependency.id));

      if (instanceOrDesc instanceof SyncDescriptor) {
        const d = { id: dependency.id, desc: instanceOrDesc, _trace: item._trace.branch(dependency.id, true) };
        graph.insertEdge(item, d);
        stack.push(d);
      }
    }
  }

  while (true) {
    const roots = graph.roots();

    if (roots.length === 0) {
      if (!graph.isEmpty()) {
        throw new CyclicDependencyError(graph);
      }
      break;
    }

    for (const { data } of roots) {
      const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);
      if (instanceOrDesc instanceof SyncDescriptor) {
        const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);
        this._setCreatedServiceInstance(data.id, instance);
      }
      graph.removeNode(data);
    }
  }
  return <T>this._getServiceInstanceOrDescriptor(id);
}

private _createServiceInstance < T > (id: ServiceIdentifier < T > , ctor: any, args: any[] = [],
    supportsDelayedInstantiation: boolean, _trace: Trace, disposeBucket: Set < any > ): T {
    if (!supportsDelayedInstantiation) {
        // eager instantiation
        const result = this._createInstance < T > (ctor, args, _trace);
        disposeBucket.add(result);
        return result;

    } else {
        const child = new InstantiationService(undefined, this._strict, this, this._enableTracing);
        child._globalGraphImplicitDependency = String(id);

        type EaryListenerData = {
            listener: Parameters < Event < any >> ;
            disposable ? : IDisposable;
        };

        const earlyListeners = new Map < string,
            LinkedList < EaryListenerData >> ();

        const idle = new GlobalIdleValue < any > (() => {
            const result = child._createInstance < T > (ctor, args, _trace);

            for (const [key, values] of earlyListeners) {
                const candidate = < Event < any >> ( < any > result)[key];
                if (typeof candidate === 'function') {
                    for (const value of values) {
                        value.disposable = candidate.apply(result, value.listener);
                    }
                }
            }
            earlyListeners.clear();
            disposeBucket.add(result);
            return result;
        });
        return <T > new Proxy(Object.create(null), {
            get(target: any, key: PropertyKey): any {

                if (!idle.isInitialized) {
                    // looks like an event
                    if (typeof key === 'string' && (key.startsWith('onDid') || key.startsWith('onWill'))) {
                        let list = earlyListeners.get(key);
                        if (!list) {
                            list = new LinkedList();
                            earlyListeners.set(key, list);
                        }
                        const event: Event < any > = (callback, thisArg, disposables) => {
                            if (idle.isInitialized) {
                                return idle.value[key](callback, thisArg, disposables);
                            } else {
                                const entry: EaryListenerData = {
                                    listener: [callback, thisArg, disposables],
                                    disposable: undefined
                                };
                                const rm = list.push(entry);
                                const result = toDisposable(() => {
                                    rm();
                                    entry.disposable ? .dispose();
                                });
                                return result;
                            }
                        };
                        return event;
                    }
                }

                // value already exists
                if (key in target) {
                    return target[key];
                }

                // create value
                const obj = idle.value;
                let prop = obj[key];
                if (typeof prop !== 'function') {
                    return prop;
                }
                prop = prop.bind(obj);
                target[key] = prop;
                return prop;
            },
            set(_target: T, p: PropertyKey, value: any): boolean {
                idle.value[p] = value;
                return true;
            },
            getPrototypeOf(_target: T) {
                return ctor.prototype;
            }
        });
    }
}

export class Trace {

	static all = new Set<string>();

	private static readonly _None = new class extends Trace {
		constructor() { super(TraceType.None, null); }
		override stop() { }
		override branch() { return this; }
	};

	static traceInvocation(_enableTracing: boolean, ctor: any): Trace {
		return !_enableTracing ? Trace._None : new Trace(TraceType.Invocation, ctor.name || new Error().stack!.split('\n').slice(3, 4).join('\n'));
	}

	static traceCreation(_enableTracing: boolean, ctor: any): Trace {
		return !_enableTracing ? Trace._None : new Trace(TraceType.Creation, ctor.name);
	}

	private static _totals: number = 0;
	private readonly _start: number = Date.now();
	private readonly _dep: [ServiceIdentifier<any>, boolean, Trace?][] = [];

	private constructor(
		readonly type: TraceType,
		readonly name: string | null
	) { }

	branch(id: ServiceIdentifier<any>, first: boolean): Trace {
		const child = new Trace(TraceType.Branch, id.toString());
		this._dep.push([id, first, child]);
		return child;
	}

	stop() {
		const dur = Date.now() - this._start;
		Trace._totals += dur;

		let causedCreation = false;

		function printChild(n: number, trace: Trace) {
			const res: string[] = [];
			const prefix = new Array(n + 1).join('\t');
			for (const [id, first, child] of trace._dep) {
				if (first && child) {
					causedCreation = true;
					res.push(`${prefix}CREATES -> ${id}`);
					const nested = printChild(n + 1, child);
					if (nested) {
						res.push(nested);
					}
				} else {
					res.push(`${prefix}uses -> ${id}`);
				}
			}
			return res.join('\n');
		}

		const lines = [
			`${this.type === TraceType.Creation ? 'CREATE' : 'CALL'} ${this.name}`,
			`${printChild(1, this)}`,
			`DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`
		];

		if (dur > 2 || causedCreation) {
			Trace.all.add(lines.join('\n'));
		}
	}
}

export class ServiceCollection {

	private _entries = new Map<ServiceIdentifier<any>, any>();

	constructor(...entries: [ServiceIdentifier<any>, any][]) {
		for (const [id, service] of entries) {
			this.set(id, service);
		}
	}

	set<T>(id: ServiceIdentifier<T>, instanceOrDescriptor: T | SyncDescriptor<T>): T | SyncDescriptor<T> {
		const result = this._entries.get(id);
		this._entries.set(id, instanceOrDescriptor);
		return result;
	}

	has(id: ServiceIdentifier<any>): boolean {
		return this._entries.has(id);
	}

	get<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T> {
		return this._entries.get(id);
	}
}

// IUserSettingsService.ts
export interface IUserSettingsService {
    getSetting(key: string): Promise<string | undefined>;
    setSetting(key: string, value: string): Promise<void>;
}

// UserSettingsService.ts
import { IUserSettingsService } from './IUserSettingsService';

export class UserSettingsService implements IUserSettingsService {

    private settings: Record<string, string> = {};

    async getSetting(key: string): Promise<string | undefined> {
        return this.settings[key];
    }

    async setSetting(key: string, value: string): Promise<void> {
        this.settings[key] = value;
    }
}

// extension.ts
import { IUserSettingsService } from './IUserSettingsService';
import { UserSettingsService } from './UserSettingsService';
import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions';

export function activate(context: vscode.ExtensionContext) {
    // Register your service implementation with the DI system
    registerSingleton(IUserSettingsService, UserSettingsService, InstantiationType.Delayed);
}

import { IUserSettingsService } from './IUserSettingsService';

class SomeOtherComponent {
    constructor(@IUserSettingsService private userSettingsService: IUserSettingsService) {
        // Now you can use the userSettingsService within this component
    }

    async doSomethingWithSettings() {
        // Use the settings service to get or set a value
        const someSetting = await this.userSettingsService.getSetting('someKey');
    }
}