Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Crie uma janela de ferramenta acoplável com interface de utilizador ligada a dados usando o Remote UI e o VisualStudio.Extensibility SDK.
Note
Este guia utiliza o SDK VisualStudio.Extensibility . Veja Escolher o modelo de extensibilidade certo para comparação de modelos.
Exemplo completo
A implementação completa:
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 da ferramenta:
// 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 completo de trabalho: ToolWindowSample ↗
Conceitos relacionados:Remote UI — o modelo de ligação de dados usado para o conteúdo da janela da ferramenta, Contribuições e configurações — como as contribuições da janela da ferramenta são declaradas
Compreenda o exemplo
Passo 1: Defina a classe da janela da ferramenta
Expanda ToolWindow e marque 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!));
}
}
Passo 2: Criar o modelo de dados
Use NotifyPropertyChangedObject com [DataContract] e [DataMember] para associação de dados da IU 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
}
}
Passo 3: Criar o controlo da interface 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 — definir a ação de compilação para EmbeddedResource (não Page):
<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 ficheiro XAML deve usar a EmbeddedResource ação de compilação. Definir para Page fará com que a janela da ferramenta fique vazia.
Passo 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);
}
}
Passo 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 ficheiros XAML como ação de build EmbeddedResource (não Página).
- Utilize
[DataContract]e[DataMember]nas propriedades do ViewModel para a interface remota. - Utilize
NotifyPropertyChangedObjectcomo base para modelos de dados. - Inicialize dados em
InitializeAsync(), crie UI emGetContentAsync(). - Use
ShowToolWindowAsync<T>(activate: true)para mostrar através de comandos.
❌ NÃO
- Não utilize a WPF diretamente — a IU remota é necessária para extensões fora de processo.
- Não definas a ação de compilação do XAML como
Page(a janela de ferramentas não será apresentada). - Não crie recursos caros no construtor — use
InitializeAsync.
🔧 Resolução de problemas
| Symptom | Corrigir |
|---|---|
| A janela da ferramenta está vazia | Verifique se a ação de compilação do XAML é EmbeddedResource |
| A associação de dados não atualiza | Certifique-se de que a ViewModel herda de NotifyPropertyChangedObject e de que 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 visível | Verifique se ToolWindowConfiguration.Toolbar está definido |
Passos seguintes
- Visão geral da interface remota — compreenda o modelo de renderização
- Adicionar um comando — para abrir a janela da ferramenta
- Temas e cores — estiliza a tua interface