How to create custom Add New Item dialog

[WiktorElAttar]

Hey everyone,

At the beggining of this week I have started playing with VSIX extensions. As my first extension, I decided to create simple VSIX with some Item Templates and the context menu command that will open a Add New Item Dialog with my own category already selected.

Item templates, I have created them following guides at docs.microsoft.com.
Command was created by following VSIX Cookbook.

The tricky part was to open New Item Dialog with my category already selected. After some googling I have found this thread with solution: https://social.msdn.microsoft.com/Forums/en-US/80ca5bbb-2475-4cf7-a74d-c0bbcbbf6946/add-project-menu-option?forum=vsx. I have implememnted it with some minor tweaks and achieved what I wanted, an Add New Item Dialog with my category already selected. As the next step, I have decided to re-implement it using VSIX Tookit. This is the result:

My custom Add New Item Dialog

public class MyCustomAddNewItemDialog
{
    public MyCustomAddNewItemDialog()
    { }

    public async Task<int> OpenAddNewItemDialogAsync(
        Guid projectTypeGuid,
        uint uiFlags,
        string categoryName,
        string itemName,
        string filter)
    {
        await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

        SolutionItem item = await VS.Solutions.GetActiveItemAsync();
        item.GetItemInfo(out var hierarchy, out var itemId, out _);

        var vsProject = hierarchy as IVsProject;
        var directoryPath = item.FullPath;

        var newItemDialog = await VS.GetRequiredServiceAsync<SVsAddProjectItemDlg, IVsAddProjectItemDlg>();

        return newItemDialog.AddProjectItemDlg(
            itemId,
            ref projectTypeGuid,
            vsProject,
            uiFlags,
            categoryName,
            itemName,
            ref directoryPath,
            ref filter,
            out int iDontShowAgain);
    }
}

And my command, which is invoking it:

[Command(PackageIds.MyCommand)]
internal sealed class MyCommand : BaseCommand<MyCommand>
{
    protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
    {
        await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

        var categoryName = "CommonTemplates";
        var itemName = "Public Interface";
        var uiFlags = (uint)(
            __VSADDITEMFLAGS.VSADDITEM_AddNewItems |
            __VSADDITEMFLAGS.VSADDITEM_SuggestTemplateName |
            __VSADDITEMFLAGS.VSADDITEM_AllowHiddenTreeView);
        var stringFilter = string.Empty;
        var projectTypeGuid = new Guid(ProjectTypes.CSHARP);

        var addItemDialog = new MyCustomAddNewItemDialog();
        var result = await addItemDialog.OpenAddNewItemDialogAsync(
            projectTypeGuid,
            uiFlags,
            categoryName,
            itemName,
            stringFilter);
    }
}

VSCT:

<Commands package="VSIXProject2">
<Groups>
	<Group guid="VSIXProject2" id="MyMenuGroup" priority="0x0001">
		<Parent guid="guidSHLMainMenu" id="IDM_VS_CSCD_PROJECT_ADD" />
	</Group>
</Groups>

<!--This section defines the elements the user can interact with, like a menu command or a button
      or combo box in a toolbar. -->
<Buttons>
	<Button guid="VSIXProject2" id="MyCommand" priority="0x0001" type="Button">
		<Parent guid="VSIXProject2" id="MyMenuGroup" />
		<Icon guid="ImageCatalogGuid" id="NewItem" />
		<CommandFlag>IconIsMoniker</CommandFlag>
		<Strings>
			<ButtonText>My Command</ButtonText>
			<LocCanonicalName>.VSIXProject2.MyCommand</LocCanonicalName>
		</Strings>
	</Button>
</Buttons>
</Commands>

<CommandPlacements>
        <CommandPlacement guid="VSIXProject2" id="MyMenuGroup" priority="0x0001">
	        <Parent guid="VSIXProject2" id="MyMenuGroup" />
        </CommandPlacement>
</CommandPlacements>

What do you thing about my implementation? This is my first attemp of creating VSIX extension.
All feedback is welcomed.

[madskristensen]

This is awesome stuff!!! I've never seen anyone using the IVsAddProjectItemDlg including myself and now I'm wondering if I should use it for something :)

You'd want you command placement to be in the Add fly-out instead of the root of the context menu, I would assume?

I always use Ctrl+Shift+A to open the New Item Dialog, and as such I wouldn't get the benefit from your command. Would it make sense that your command takes over the keybinding for certain project types where your templates apply? You can do that by simple intercepting the regular Add Item command run your command instead. Just an idea.

[WiktorElAttar]

Did you mean binding MyCommand to Ctrl+Shift+A and then intercepting it?
Like this:

public class AddNewItemCommandInterceptor
{
    public static CommandProgression Intercept()
    {
        return InterceptAsync().GetAwaiter().GetResult();
    }

    public static async Task<CommandProgression> InterceptAsync()
    {
        await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

        SolutionItem item = await VS.Solutions.GetActiveItemAsync();
        item.GetItemInfo(out var hierarchy, out _, out _);
        var isCsharpProj = hierarchy.IsCapabilityMatch("CSharp");

        if (isCsharpProj)
        {
            await VS.Commands.ExecuteAsync(MyCommand.CommandID);
            return CommandProgression.Stop;
        }

        return CommandProgression.Continue;
    }
}

and registering it in your Package:

protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
{
    await this.RegisterCommandsAsync();

    await VS.Commands.InterceptAsync(MyCommand.CommandID, AddNewItemCommandInterceptor.Intercept);
}

[WiktorElAttar]

Or creating Classificator for calculating type of AddNewDialog and its parameters:

public class AddNewDialogClassificator
{
    public async Task<AddNewItemDialogClassification> GetClassificationAsync()
    {
        await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

        SolutionItem selectionItem = await VS.Solutions.GetActiveItemAsync();
        var selectionFolder = selectionItem as PhysicalFolder ?? selectionItem.FindParent(SolutionItemType.PhysicalFolder) as PhysicalFolder;

        var projectItem = selectionItem as Project ?? selectionItem.FindParent(SolutionItemType.Project) as Project;
        projectItem.GetItemInfo(out var projecthierarchy, out _, out _);

        var isCSharp = projecthierarchy.IsCapabilityMatch("CSHARP");
        var isAspNetCore = projecthierarchy.IsCapabilityMatch("AspNetCore");
        var isControllersFolder = selectionFolder?.Text.Equals("Controllers", StringComparison.OrdinalIgnoreCase) ?? false;

        var result = new AddNewItemDialogClassification();
        result.DialogType = AddNewItemDialogType.Custom;
        result.CategoryName = "CommonTemplates";

        if (isAspNetCore && isControllersFolder)
        {
            result.ItemName = "Controller with MediatR";
        }
        else if (isCSharp)
        {
        }
        else
        {
            result.DialogType = AddNewItemDialogType.BuiltIn;
        }

        return result;
    }
}

public class AddNewItemDialogClassification
{
    public AddNewItemDialogType DialogType { get; set; }

    public string CategoryName { get; set; }

    public string ItemName { get; set; }
}

public enum AddNewItemDialogType
{
    BuiltIn,
    Custom
}

and then using it in Command or Interceptor:

protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
{
    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();

    var uiFlags = (uint)(
        __VSADDITEMFLAGS.VSADDITEM_AddNewItems |
        __VSADDITEMFLAGS.VSADDITEM_SuggestTemplateName |
        __VSADDITEMFLAGS.VSADDITEM_AllowHiddenTreeView);
    var stringFilter = string.Empty;
    var projectTypeGuid = new Guid(ProjectTypes.CSHARP);

    var classificator = new AddNewDialogClassificator();
    var classification = await classificator.GetClassificationAsync();

    switch (classification.DialogType)
    {
        case AddNewItemDialogType.Custom:
            var addItemDialog = new AddNewItemDialog();
            var result = await addItemDialog.OpenAddNewItemDialogAsync(
                projectTypeGuid,
                uiFlags,
                classification.CategoryName,
                classification.ItemName,
                stringFilter);
            break;

        case AddNewItemDialogType.BuiltIn:
            await VS.Commands.ExecuteAsync(KnownCommands.Project_AddNewItem);
            break;
    }
}

[madskristensen]

Instead of doing the work in InitializeAsync to get the IVsHierarchy of the selection, you could simply do this:

SolutionItem item = await VS.Solutions.GetActiveItemAsync();
item.GetItemInfo(out var hierarchy, out _, out _);

[WiktorElAttar]

Thank you for your suggestion.

I have updated implementation to not use InitializeAsync

[madskristensen]

This looks so good now. Excellent job!!

The latest CI build now exposes a IsCapabilityMatch method directly on the Project type, so you no longer have to get the IVsHierarchy. It will be available by the next release to NuGet which hasn't been scheduled yet.