如何调整VS Code发送codeLens与codeAction消息的间隔以优化性能？

Absolutely, you can tweak how often these LSP requests are sent to your server—this is a super common pain point for extension developers, and there are several straightforward ways to fix the performance hit. Let’s break down the options based on where you can apply the fix:

Client-Side Configuration (VS Code Example) #

Since most LSP extensions target VS Code, let’s start with its built-in settings that let you control request timing:

• CodeLens Refresh Delay: Use the editor.codeLens.refreshDelay setting (in milliseconds) to delay sending textDocument/codeLens requests until the user pauses typing. For example, setting it to 500 means the request will only fire 500ms after the user stops entering text, instead of on every keystroke. You can add this to your extension’s recommended settings to guide users, or set it programmatically in your extension code.
• CodeAction Trigger Tuning: For automatic code action suggestions, VS Code’s editor.quickSuggestionsDelay can help delay when the client checks for available actions. If you’re handling code actions on save, adjust editor.codeActionsOnSave.timeout to prevent overwhelming the server with rapid consecutive requests.

Server-Side Optimization #

Even with client-side delays, optimizing your server’s response logic will amplify performance gains:

• Cache Results: Store previously computed CodeLens or CodeAction results, and only re-calculate them when the document’s relevant content changes (e.g., a function definition is modified, not just a comment). This avoids redundant work on every request.
• Scope Down Computations: For CodeActions, only generate suggestions for the diagnostics near the current cursor or the modified line, instead of scanning the entire document. For CodeLens, focus on visible lines first if your editor supports partial range requests.

Custom Debouncing in Your Extension #

If you want full control over request timing, implement a debounce function in your extension’s client code to throttle how often you send requests to the server. Here’s a quick example using TypeScript:

import { debounce } from 'lodash';
import { workspace, TextDocument } from 'vscode';
import { LanguageClient } from 'vscode-languageclient';

let client: LanguageClient; // Assume this is your initialized LSP client

// Debounce CodeLens requests to fire only after 500ms of inactivity
const debouncedFetchCodeLens = debounce(async (doc: TextDocument) => {
  const codeLenses = await client.sendRequest('textDocument/codeLens', {
    textDocument: { uri: doc.uri.toString() }
  });
  // Update CodeLens display here
}, 500);

// Listen for document changes and trigger the debounced request
workspace.onDidChangeTextDocument((event) => {
  debouncedFetchCodeLens(event.document);
});

This ensures you’re not flooding the server with requests on every single keystroke.

By mixing these strategies—client-side delays, server-side caching, and custom debouncing—you’ll see a big drop in unnecessary requests while keeping your extension’s functionality intact.

内容的提问来源于stack exchange，提问作者Tyler James Leonhardt