VSCode 源码解读：IPC通信机制

export interface IMessagePassingProtocol {
	send(buffer: VSBuffer): void;
	onMessage: Event<VSBuffer>;
}

export class Protocol implements IMessagePassingProtocol {
	constructor(private sender: Sender, readonly onMessage: Event<VSBuffer>) { }
	// 发送消息
	send(message: VSBuffer): void {
		try {
			this.sender.send('vscode:message', message.buffer);
		} catch (e) {
			// systems are going down
		}
	}
	// 断开连接
	dispose(): void {
		this.sender.send('vscode:disconnect', null);
	}
}

/**
 * IChannel是对命令集合的抽象
 * call 总是返回一个至多带有单个返回值的 Promise
 */
export interface IChannel {
	call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T>;
	listen<T>(event: string, arg?: any): Event<T>;
}

// 客户端
export class ChannelClient implements IChannelClient, IDisposable {
	getChannel<T extends IChannel>(channelName: string): T {
		const that = this;
		return {
			call(command: string, arg?: any, cancellationToken?: CancellationToken) {
				return that.requestPromise(channelName, command, arg, cancellationToken);
			},
			listen(event: string, arg: any) {
				return that.requestEvent(channelName, event, arg);
			}
		} as T;
	}
	private requestPromise(channelName: string, name: string, arg?: any, cancellationToken = CancellationToken.None): Promise<any> {}
	private requestEvent(channelName: string, name: string, arg?: any): Event<any> {}
	private sendRequest(request: IRawRequest): void {}
	private send(header: any, body: any = undefined): void {}
	private sendBuffer(message: VSBuffer): void {}
	private onBuffer(message: VSBuffer): void {}
	private onResponse(response: IRawResponse): void {}
	private whenInitialized(): Promise<void> {}
	dispose(): void {}
}

// 服务端
export class ChannelServer<TContext = string> implements IChannelServer<TContext>, IDisposable {
	registerChannel(channelName: string, channel: IServerChannel<TContext>): void {
		this.channels.set(channelName, channel);
	}
	private sendResponse(response: IRawResponse): void {}
	private send(header: any, body: any = undefined): void {}
	private sendBuffer(message: VSBuffer): void {}
	private onRawMessage(message: VSBuffer): void {}
	private onPromise(request: IRawPromiseRequest): void {}
	private onEventListen(request: IRawEventListenRequest): void {}
	private disposeActiveRequest(request: IRawRequest): void {}
	private collectPendingRequest(request: IRawPromiseRequest | IRawEventListenRequest): void {}
	public dispose(): void {}
}

// 此处篇幅关系，以 deserialize 举例：
function deserialize(reader: IReader): any {
	const type = reader.read(1).readUInt8(0);
	switch (type) {
		case DataType.Undefined: return undefined;
		case DataType.String: return reader.read(readSizeBuffer(reader)).toString();
		case DataType.Buffer: return reader.read(readSizeBuffer(reader)).buffer;
		case DataType.VSBuffer: return reader.read(readSizeBuffer(reader));
		case DataType.Array: {
			const length = readSizeBuffer(reader);
			const result: any[] = [];

			for (let i = 0; i < length; i++) {
				result.push(deserialize(reader));
			}

			return result;
		}
		case DataType.Object: return JSON.parse(reader.read(readSizeBuffer(reader)).toString());
	}
}

interface Connection<TContext> extends Client<TContext> {
	readonly channelServer: ChannelServer<TContext>; // 服务端
	readonly channelClient: ChannelClient; // 客户端
}

// 客户端
export class IPCClient<TContext = string> implements IChannelClient, IChannelServer<TContext>, IDisposable {
	private channelClient: ChannelClient;
	private channelServer: ChannelServer<TContext>;
	getChannel<T extends IChannel>(channelName: string): T {
		return this.channelClient.getChannel(channelName) as T;
	}
	registerChannel(channelName: string, channel: IServerChannel<TContext>): void {
		this.channelServer.registerChannel(channelName, channel);
	}
}

// 由于服务端有多个服务，因此可能存在多个连接
export class IPCServer<TContext = string> implements IChannelServer<TContext>, IRoutingChannelClient<TContext>, IConnectionHub<TContext>, IDisposable {
	private channels = new Map<string, IServerChannel<TContext>>();
	private _connections = new Set<Connection<TContext>>();
	// 获取连接信息
	get connections(): Connection<TContext>[] {}
	/**
	 * 从远程客户端获取频道。
	 * 通过路由器后，可以指定它要呼叫和监听/从哪个客户端。
	 * 否则，当在没有路由器的情况下进行呼叫时，将选择一个随机客户端，而在没有路由器的情况下进行侦听时，将监听每个客户端。
	 */
	getChannel<T extends IChannel>(channelName: string, router: IClientRouter<TContext>): T;
	getChannel<T extends IChannel>(channelName: string, clientFilter: (client: Client<TContext>) => boolean): T;
	getChannel<T extends IChannel>(channelName: string, routerOrClientFilter: IClientRouter<TContext> | ((client: Client<TContext>) => boolean)): T {}
	// 注册频道
	registerChannel(channelName: string, channel: IServerChannel<TContext>): void {
		this.channels.set(channelName, channel);
		// 添加到连接中
		this._connections.forEach(connection => {
			connection.channelServer.registerChannel(channelName, channel);
		});
	}
}