VisualStudio.Extensibility Documentation

The New_Extensibility_Model/Samples directory contains various implementation examples for the Visual Studio out-of-process extensibility model. These samples cover a wide range of capabilities, from basic command handling to advanced UI integration and debugger visualizers.

Available Sample Scenarios

VisualStudio.Extensibility is a modern framework for developing Visual Studio extensions that run out-of-process from the IDE. This architecture provides several key benefits:

• Increased reliability: Because extensions run in a separate process, a crash or hang in your extension will not cause the Visual Studio IDE to crash or become unresponsive.
• Improved performance: The out-of-process model helps maintain IDE responsiveness.
• Hot-loading: Extensions can be installed without requiring a restart of Visual Studio.
• Modern API: Features a streamlined, asynchronous API designed for developer productivity.

In-process extensions: If you need functionality that is not yet available in the VisualStudio.Extensibility SDK, you can develop an in-process extension by leveraging VisualStudio.Extensibility APIs while relying on the traditional VSSDK to cover feature gaps.

When dealing with potentially large objects (like a MatchCollection), implement TransferData in your VisualizerObjectSource. This allows the client to request specific pieces of data via an index, preventing timeout exceptions that occur if GetData attempts to transfer the entire collection at once.

In the TransferData implementation:

• Deserialize the index from incomingData.
• Retrieve the specific item from the target object.
• Serialize the result to outgoingData.
• Return null (via serialization) when the index is out of bounds to signal the end of the collection.

public override void TransferData(object target, Stream incomingData, Stream outgoingData)
{
    var index = (int)DeserializeFromJson(incomingData, typeof(int))!;
    if (target is MatchCollection matchCollection && index < matchCollection.Count)
    {
        var result = RegexMatchObjectSource.Convert(matchCollection[index]);
        result.Name = $"[{index}]";
        SerializeAsJson(outgoingData, result);
    }
    else
    {
        SerializeAsJson(outgoingData, null);
    }
}

When GenerateObserverClass is set to true on a SettingCategory, Visual Studio generates an observer class (e.g., [CategoryName]Observer) under the Settings child namespace of your extension.

To use the observer:

1. Register: Call serviceCollection.AddSettingsObservers(); in your extension setup.
2. Inject: Request the generated observer in your class constructor (e.g., a Tool Window).
3. Listen: Subscribe to the Changed event. The event provides a snapshot of the current settings.

Note: The Changed event is invoked at least once with the current values upon subscription, so you do not need separate logic for the initial read.

// In your tool window constructor
public MyToolWindowData(VisualStudioExtensibility extensibility, SettingsSampleCategoryObserver settingsObserver)
{
    this.settingsObserver = Requires.NotNull(settingsObserver);
    settingsObserver.Changed += this.SettingsObserver_ChangedAsync;
}

// Event handler for changes
private Task SettingsObserver_ChangedAsync(Settings.SettingsSampleCategorySnapshot settingsSnapshot)
{
    // Access values via the snapshot
    this.ManualUpdate = !settingsSnapshot.AutoUpdateSetting.ValueOrDefault(defaultValue: true);
    return Task.CompletedTask;
}

In-proc extensions can consume traditional Visual Studio SDK services (like DTE or IVsTextManager) using .NET dependency injection.

To inject these services into a command, add them to the command's constructor using the following wrappers:

• AsyncServiceProviderInjection<TService, TLegacyService>: For services available via the AsyncServiceProvider (e.g., DTE).
• MefInjection<TService>: For services available via MEF (e.g., IBufferTagAggregatorFactoryService).

Note: While VisualStudio.Extensibility APIs are async, some Visual Studio SDK services are restricted to the UI thread. Use await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); to switch to the UI thread when interacting with them.

public RemoveAllComments(
    TraceSource traceSource,
    AsyncServiceProviderInjection<DTE, DTE2> dte,
    MefInjection<IBufferTagAggregatorFactoryService> bufferTagAggregatorFactoryService,
    MefInjection<IVsEditorAdaptersFactoryService> editorAdaptersFactoryService,
    AsyncServiceProviderInjection<SVsTextManager, IVsTextManager> textManager)
    : base(traceSource, dte, bufferTagAggregatorFactoryService, editorAdaptersFactoryService, textManager)
{
}