Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Crie uma janela de ferramenta acoplável com a interface do usuário associada a dados usando Remote UI e o SDK do VisualStudio.Extensibility.
Note
Este guia usa o SDK VisualStudio.Extensibility . Consulte Escolher o modelo de extensibilidade correto para comparação de modelos.
Exemplo completo
A implementação completa:
A definição da janela de ferramentas:
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
namespace ToolWindowSample;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.VisualStudio.Extensibility;
using Microsoft.VisualStudio.Extensibility.Commands;
using Microsoft.VisualStudio.Extensibility.ToolWindows;
using Microsoft.VisualStudio.RpcContracts.RemoteUI;
/// <summary>
/// A sample tool window.
/// </summary>
[VisualStudioContribution]
public class MyToolWindow : ToolWindow
{
private object? dataContext;
/// <summary>
/// Initializes a new instance of the <see cref="MyToolWindow" /> class.
/// </summary>
public MyToolWindow()
{
this.Title = "My Tool Window";
}
/// <inheritdoc />
public override ToolWindowConfiguration ToolWindowConfiguration => new()
{
Placement = ToolWindowPlacement.DocumentWell,
Toolbar = new ToolWindowToolbar(Toolbar),
};
[VisualStudioContribution]
private static ToolbarConfiguration Toolbar => new("%ToolWindowSample.MyToolWindow.Toolbar.DisplayName%")
{
Children = [ToolbarChild.Command<MyToolbarCommand>()],
};
/// <inheritdoc />
public override Task InitializeAsync(CancellationToken cancellationToken)
{
this.dataContext = new MyToolWindowData(this.Extensibility);
return Task.CompletedTask;
}
/// <inheritdoc />
public override Task<IRemoteUserControl> GetContentAsync(CancellationToken cancellationToken)
{
return Task.FromResult<IRemoteUserControl>(new MyToolWindowControl(this.dataContext));
}
}
O comando para abrir a janela de ferramentas:
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
namespace ToolWindowSample;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.VisualStudio.Extensibility;
using Microsoft.VisualStudio.Extensibility.Commands;
/// <summary>
/// A sample command for showing a tool window.
/// </summary>
[VisualStudioContribution]
public class MyToolWindowCommand : Command
{
/// <inheritdoc />
public override CommandConfiguration CommandConfiguration => new("%ToolWindowSample.MyToolWindowCommand.DisplayName%")
{
Placements = [CommandPlacement.KnownPlacements.ToolsMenu],
Icon = new(ImageMoniker.KnownValues.ToolWindow, IconSettings.IconAndText),
};
/// <inheritdoc />
public override async Task ExecuteCommandAsync(IClientContext context, CancellationToken cancellationToken)
{
await this.Extensibility.Shell().ShowToolWindowAsync<MyToolWindow>(activate: true, cancellationToken);
}
}
Tip
Veja o exemplo funcional completo: ToolWindowSample ↗
Conceitos relacionados:Interface do usuário remota — o modelo de associação de dados usado para conteúdo da janela de ferramentas, Contribuições e configurações — como as contribuições da janela de ferramentas são declaradas
Entenda o exemplo
Etapa 1: Definir a classe da janela de ferramentas
Estenda ToolWindow e marque-o com [VisualStudioContribution]:
[VisualStudioContribution]
internal class MyToolWindow : ToolWindow
{
private MyDataModel? dataModel;
public MyToolWindow(VisualStudioExtensibility extensibility)
: base(extensibility)
{
Title = "My Tool Window";
}
public override ToolWindowConfiguration ToolWindowConfiguration => new()
{
Placement = ToolWindowPlacement.DocumentWell,
AllowAutoCreation = true,
};
public override async Task InitializeAsync(CancellationToken cancellationToken)
{
dataModel = new MyDataModel();
await dataModel.LoadAsync(cancellationToken);
}
public override Task<IRemoteUserControl> GetContentAsync(CancellationToken cancellationToken)
{
return Task.FromResult<IRemoteUserControl>(new MyToolWindowControl(dataModel!));
}
}
Etapa 2: Criar o modelo de dados
Use NotifyPropertyChangedObject com [DataContract] e [DataMember] para associação de dados da interface do usuário remota:
[DataContract]
internal class MyDataModel : NotifyPropertyChangedObject
{
private string message = "Hello from the tool window!";
[DataMember]
public string Message
{
get => message;
set => SetProperty(ref message, value);
}
public async Task LoadAsync(CancellationToken cancellationToken)
{
// Load data asynchronously
}
}
Etapa 3: Criar o controle da interface do usuário remota
Adicione uma classe RemoteUserControl e um modelo de dados XAML correspondente.
MyToolWindowControl.cs:
internal class MyToolWindowControl : RemoteUserControl
{
public MyToolWindowControl(MyDataModel dataModel)
: base(dataContext: dataModel)
{
}
}
MyToolWindowControl.xaml — defina a ação de build como EmbeddedResource (não Página):
<DataTemplate xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:vs="http://schemas.microsoft.com/visualstudio/extensibility/2022/xaml">
<StackPanel Margin="10">
<TextBlock Text="{Binding Message}" FontSize="14" />
</StackPanel>
</DataTemplate>
Important
O arquivo XAML deve usar a ação EmbeddedResource de build. Defini-lo como Page fará com que a janela de ferramentas seja renderizada vazia.
Etapa 4: Adicionar um comando para mostrar a janela da ferramenta
[VisualStudioContribution]
internal class ShowMyToolWindowCommand : Command
{
public ShowMyToolWindowCommand(VisualStudioExtensibility extensibility)
: base(extensibility)
{
}
public override CommandConfiguration CommandConfiguration => new("My Tool Window")
{
Placements = [CommandPlacement.KnownPlacements.ViewOtherWindowsMenu],
Icon = new(ImageMoniker.KnownValues.ToolWindow, IconSettings.IconAndText),
};
public override async Task ExecuteCommandAsync(IClientContext context, CancellationToken cancellationToken)
{
await Extensibility.Shell().ShowToolWindowAsync<MyToolWindow>(activate: true, cancellationToken);
}
}
Etapa 5 (opcional): Adicionar uma barra de ferramentas
Defina uma barra de ferramentas e faça referência a ela em ToolWindowConfiguration:
[VisualStudioContribution]
public static ToolbarConfiguration MyToolbar => new("%MyToolbar.DisplayName%")
{
Children = [
ToolbarChild.Command<RefreshCommand>(),
ToolbarChild.Separator,
ToolbarChild.Command<ClearCommand>(),
],
};
public override ToolWindowConfiguration ToolWindowConfiguration => new()
{
Placement = ToolWindowPlacement.DocumentWell,
Toolbar = new(MyToolbar),
};
Tips
✅ DO
- Marque arquivos XAML como ação de build EmbeddedResource (não Page).
- Use
[DataContract]e[DataMember]nas propriedades do ViewModel para a interface do usuário remota. - Use
NotifyPropertyChangedObjectcomo base para modelos de dados. - Inicialize dados em
InitializeAsync(), crie a interface do usuário emGetContentAsync(). - Use
ShowToolWindowAsync<T>(activate: true)para mostrar a partir dos comandos.
❌ O QUE NÃO FAZER
- Não use WPF diretamente — a interface do usuário remota é necessária para extensões fora do processo.
- Não defina a ação de build XAML como
Page(a janela de ferramentas não será renderizada). - Não crie recursos caros no construtor — use
InitializeAsync.
🔧 Solução de problemas
| Sintoma | Corrigir |
|---|---|
| A janela de ferramentas está vazia | Verificar se a ação de build XAML está EmbeddedResource |
| A associação de dados não é atualizada | Verifique se o ViewModel herda NotifyPropertyChangedObject e as propriedades têm [DataMember] |
| A janela não aparece | Verifique se as chamadas de comando ShowToolWindowAsync estão corretas |
| Barra de ferramentas não aparece | Verificar se ToolWindowConfiguration.Toolbar está definido |
Próximas Etapas
- Visão geral da interface do usuário remota – entenda o modelo de renderização
- Adicione um comando — para abrir a janela da ferramenta
- Temas e cores — personalize sua interface do usuário