Este artigo foi traduzido por máquina.
Programação em F#
Criando um modelo de projeto do VSIX em F#/C#
Dan Mohl
Os desenvolvedores de software estão cada vez mais esperados para fornecer soluções complexas em menos tempo e com menos defeitos. Uma área que geralmente causa perda de produtividade é a configuração inicial de novos projetos de F#, C# ou Visual Basic exatamente da maneira que precisar. A melhor maneira para reduzir essas tarefas de configuração de projeto repetitivas é criar um modelo de projeto de extensão de Visual Studio (VSIX).
Você também poderá criar um modelo de projeto VSIX promover padrões de desenvolvimento de software, apresentar um novo produto ou fornecer uma inicialização rápida em uma nova tecnologia. Seja qual for seu motivo, adicionando a capacidade de criar esses modelos de projeto VSIX à sua lista de desenvolvimento de técnicas é certo ter benefícios.
Neste artigo, mostrarei como criar um modelo de projeto VSIX composto de um C# ASP.NET MVC 3 aplicativo da Web, uma biblioteca de F# que contém o código do lado do servidor e uma biblioteca de F# que pode ser usado para conter os testes de unidade. Além disso, você aprenderá algumas técnicas avançadas que podem ser usadas para adicionar flexibilidade e capacidade para seus modelos de projeto. No final, você vai conhecer o conhecimento para reduzir significativamente os tempo-wasters mencionados anteriormente através da criação de seus próprios modelos de projeto personalizado.
Obtendo configurar
Antes de começar, você deve concluir algumas tarefas para configurar seu ambiente de desenvolvimento. Primeiro, verifique se você tiver Visual Studio Professional de 2010 instalado ou superior com os componentes de F# e C#. Em seguida, instale o SDK de 2010 Visual Studio, que você pode baixar em bit.ly /-2010-SDK do vs. O SDK de 2010 Visual Studio fornece que tudo que for necessário para criar um projeto VSIX. Para ajudar a reduzir o tédio associado à criação de um modelo de multiprojeto, você deve também baixar e instalar o Assistente para exportação de modelo de bit.ly/export-modelo-wiz. Finalmente, para concluir o exemplo fornecido neste artigo, você deve Baixe e instale o ASP.NET MVC 3 ferramentas de atualização, disponível em bit.ly/mvc3-atualização de ferramentas. Esta atualização fornece inúmeros recursos úteis e ferramentas, incluindo NuGet 1.2. Para obter mais informações, consulte bit.ly/apresentando-mvc3--atualização de ferramentas.
Construção do aplicativo inicial
Agora que seu ambiente está configurado, você está pronto para criar o aplicativo base que será criado sempre que o modelo de projeto é iniciado a partir do Assistente para novo projeto dentro de Visual Studio. Isso permite que você configure exatamente o que precisa para reduzir o tempo perdido por tarefas repetitivas de inicialização de projeto. A solução desenvolvida neste momento pode ser simples ou complexos, conforme necessário.
O primeiro projeto que você precisa criar é uma C# ASP.MVC 3 NET que deve ser nomeado MsdnWeb. A função deste projeto é fornecer a camada de apresentação para a solução geral. Você deve iniciar o Assistente para novo projeto em Visual Studio e selecione ASP.NET MVC 3 Web Application, que pode ser encontrado dentro do Visual C# | Web. Neste exemplo, você deve garantir que o modelo "Vazio", o mecanismo de exibição Razor e a "HTML5 uso semântica marcação" opções estão selecionadas e clique em OK. Depois de Visual Studio termina gerando o projeto, localize os arquivos global. asax e Global.asax.cs. Você escreverá a maioria do código para o global. asax no F#, portanto, agora você pode remover o arquivo Global.asax.cs e atualizar a marcação de global. asax, conforme mostrado na a Figura 1. Como etapa final para este projeto, você pode criar uma nova pasta na pasta modos de exibição denominado Home e adicionar uma nova exibição dentro dela chamada Index.
.png)
Figura 1, atualizando a marcação de global. asax
Em seguida, crie um novo projeto de biblioteca F# chamado MsdnWebApp e remova os arquivos padrão .fs e .fsx que cria o Visual Studio. O objetivo principal deste projeto é conter os controladores, modelos e outros códigos de servidor que vai estimular os modos de exibição. Porque este é um projeto F#, você será capaz de criar esse código do lado do servidor no estilo sucinto, limpo e nítido que F# fornece. Para usar este projeto para sua finalidade planejada, você precisará adicionar referências ao System. Web, System.ComponentModel.DataAnnotations, System.Web.Abstractions e System.Web.Mvc (versão 3.0 +) ao assemblies. Você também precisará adicionar um arquivo que contém o código mostrado na Global.fs a Figura 2.
Figura 2 O arquivo Global.fs
namespace MsdnWeb
open System
open System.Web
open System.Web.Mvc
open System.Web.Routing
type Route = { controller : string
action : string
id : UrlParameter }
type Global() =
inherit System.Web.HttpApplication()
static member RegisterRoutes(routes:RouteCollection) =
routes.IgnoreRoute("{resource}.axd/{*pathInfo}")
routes.MapRoute("Default",
"{controller}/{action}/{id}",
{ controller = "Home"; action = "Index"
id = UrlParameter.Optional } )
member this.Start() =
AreaRegistration.RegisterAllAreas()
Global.RegisterRoutes(RoutTable.Routes)
Você também precisará adicionar um arquivo de HomeController.fs que contém o código mostrado aqui:
namespace MsdnWeb.Controllers
Open System.Web
Open System.Web.Mvc
[<HandleError>]
type HomeController() =
inherit Conroller()
member this.Index() =
this.View() :> ActionResult
Como uma tarefa final na construção do aplicativo inicial, você deve criar o projeto de biblioteca F# segundo e o nome MsdnWebAppTests. Como o nome sugere, o objetivo do projeto MsdnWebAppTests é conter os testes de unidade para MsdnWebApp. Uma versão de pronto para produção deste projeto poderia ser preparada com testes de unidade. No entanto, para manter as coisas simples, você pode remover os arquivos padrão .fs e .fsx que gera Visual Studio e deixar o projeto vazio como um contêiner para a criação de testes futuros. Para ver um exemplo de código que pode ser adicionado a este projeto, instale o pacote de NuGet de FsUnit.MvcSample em bit.ly/fsunit-mvc3-testes.
Criação do modelo de projeto VSIX
O modelo de projeto de exemplo que eu estou percorrendo o possui várias metas. Esses objetivos são a base na qual se baseia o restante deste artigo:
- Fornece um modelo de projeto VSIX composto de dois projetos F# e um projeto C#.
- Adicione dinamicamente cada um dos projetos para uma solução compartilhada durante a criação do novo projeto.
- Programaticamente adicione quaisquer referências de projeto necessário cada vez que o modelo de projeto é iniciado.
- Instale vários pacotes de NuGet para a página ASP criado.NET MVC 3 Web Application.
- Fornece uma interface de usuário que permite ao usuário especificar várias opções de criação do projeto.
Visual Studio fornece um modelo de extensibilidade sofisticado que o primeiro objetivo bastante trivial. A maneira mais fácil aproveitar isso é iniciar o Assistente para exportação de modelo indo até arquivo | Exporte o modelo como VSIX. Visual Studio, em seguida, será exibido um Assistente de criação do pacote VSIX que permite a seleção de vários projetos para ser compactado em um pacote VSIX. Enquanto isso lida com cenários de multiprojeto simples, ele não pode manipular requisitos mais avançados, como as metas de dois a cinco. Para fazer essas coisas, você precisará de um pouco mais energia.
Essa energia é fornecida na forma de composição por meio da interface IWizard. Isso é normalmente referenciado como a criação de um Assistente de modelo. Para construir um Assistente de modelo simples em F#, você precisará criar um novo projeto de biblioteca F#, adicionar uma classe que implementa a interface IWizard (consulte a Figura 3) e adicionar referências a EnvDTE e Microsoft.VisualStudio.TemplateWizardInterface.
Figura 3 Implementando a Interface IWizard
namespace MsdnFsTemplateWizard
open System
open System.Collections.Generic
open EnvDTE
open Microsoft.VisualStudio.TemplateWizard
type TemplateWizard() =
interface IWizard with
member this.RunStarted (automationObject:Object,)
replacementsDictionary:Dictionary<string,string>,
runKind:WizardRunKind, customParams:Object[]) =
"Not Implemented" |> ignore
member this.ProjectFinishedGenerating project = "Not Implemented" |> ignore
member this.ProjectItemFinishedGenerating projectItem =
"Not Implemented" |> ignore
member this.ShouldAddProjectItem filePath = true
member this.BeforeOpeningFile projectItem = "Not Implemented" |> ignore
member this.RunFinished() = "Not Implemented" |> ignore
Para tratar mais-avançada funcionalidade como programaticamente adicionar referências de projeto e instalar pacotes de NuGet, você também precisará adicionar referências a EnvDTE80, VSLangProj, VSLangProj80, Microsoft.VisualStudio.ComponentModelHost, Microsoft.VisualStudio.OLE.Interop, Microsoft.VisualStudio.Shell, Microsoft.VisualStudio.Shell.Interop, Microsoft.VisualStudio.Shell.Interop.8.0, NuGet.Core (versão 1.2 +) e NuGet.VisualStudio (versão 1.2 +). Se você seguiu as instruções sobre como configurar seu ambiente, todas essas bibliotecas estarão disponíveis em sua máquina local. Algumas das principais bibliotecas também podem ser encontradas na pasta lib do código-fonte que acompanha o artigo, que pode ser encontrada em fsharpmvc3vsix.codeplex.com.
Como etapa final para criar o Assistente de modelo básico, você precisará assinar o assembly do Assistente de modelo. Se você ainda não tiver um, você precisa primeiro gerar um forte chamado arquivo de chave (. snk) (consulte bit.ly/how-a-criar-snk para obter informações sobre como fazer isso). Depois de um arquivo. snk, você pode assinar o assembly de Assistente de modelo F# acessando as propriedades do projeto, selecionando a guia Build e digitando o seguinte para a "outros sinalizadores:" textbox (você deve substituir <Path> e < nome do arquivo snk > com os valores que se relacionam com seu arquivo. snk específico):
'--keyfile:"<Path><snk File Name>.snk"'
Para usar este assistente de modelo, você precisará criar um modelo de multiprojeto que referencia o assembly do Assistente de modelo assinado. A maneira mais fácil para fazer isso é usar a extensão de exportar modelo Assistente Visual Studio 2010 inicie o processo, em seguida, ajustar manualmente o resultado. No assistente que é exibida quando você inicia o arquivo | Exportar o modelo como VSIX, selecione os projetos de MsdnWeb, MsdnWebApp e MsdnWebAppTests e clique em Avançar. Na página resultante, digite o nome do modelo e a descrição que você deseja aparecem na janela do assistente Visual Studio para novo projeto e especifique a localização do DLL do Assistente de modelo para o Assembly do assistente. Depois de clicar em Avançar, você deve desmarcar a opção "Importar automaticamente o modelo para Visual Studio" e clique em Concluir. Visual Studio, em seguida, crie o pacote VSIX, iniciará o Windows Explorer e levá-lo para o diretório que contém o arquivo VSIX.
Isso lhe dará um ótimo ponto de partida, mas agora você deve ser prática e fazer algumas modificações manuais. Como os arquivos VSIX são na verdade, apenas os arquivos. zip com uma extensão diferente, você pode pesquisar nas entranhas deste pacote simplesmente alterando a extensão de arquivo para. zip e extrair todos os arquivos. Depois de concluído, navegue até o diretório "Solução" dentro da pasta que o processo de extração revelado e extraia o arquivo compactado encontrado dentro. Esse processo de extração revela os projetos que constituem o modelo de projeto, bem como um arquivo. vstemplate.
Para cumprir as metas para este modelo de projeto, você deve modificar esse arquivo. vstemplate. A primeira etapa, você deve fazer é renomear o arquivo para MsdnFsMvc3.vstemplate. Porque esse arquivo. vstemplate é um arquivo XML simples, agora você pode abrir o arquivo no seu editor de texto de escolha e faça o seguinte:
- Verifique o <Name> e <Description> elementos contêm as informações que você deseja ter exibido para este modelo de projeto no Assistente do Visual Studio para novo projeto.
- Alterar o valor de <ProjectType> elemento de FSharp.
- Remova todos os elementos filho de <ProjectCollection> elemento.
Você pode agora salvar e fechar o arquivo e então compactar as três pastas, como também o arquivo. vstemplate modificado em um arquivo denominado MsdnFsMvc3.zip.
O arquivo MsdnFsMvc3.zip pode ser facilmente combinado volta para um pacote VSIX neste momento, mas você poderia então ficar sem a capacidade de testar ou aprimorar o pacote com suporte à depuração. Seria muito melhor se Visual Studio poderia ser usada para esses tipos de tarefas. Felizmente, o SDK de 2010 Visual Studio instalada anteriormente fornece exatamente o tipo de ferramentas necessárias para fazer isso. Para começar, você primeiro precisa criar um novo projeto de VSIX, que pode ser encontrado no Assistente para novo projeto em Visual C# | Extensibilidade. O projeto que cria o Visual Studio inclui um arquivo de source.extension.vsixmanifest, que pode ser visualizado e editado por meio de um simples clique duas vezes. Agora você pode preencher as informações de metadados básicos sobre seu modelo de projeto. Figura 4 fornece um exemplo.
.png)
Figura 4 preenchendo metadados
O arquivo MsdnFsMvc3.zip agora pode ser adicionado ao projeto VSIX em Visual Studio. Para fazer isso, você primeiro navegue até a pasta raiz do projeto VSIX no Windows Explorer e crie uma nova pasta chamada ProjectTemplates. Dentro dessa pasta, você deve adicionar uma nova pasta chamada ASPNET. A criação dessa pasta segundo é o que determina o subtipo de projeto para o modelo de projeto. Agora você pode copiar o arquivo MsdnFsMvc3.zip para a pasta ASPNET.
Voltar no Visual Studio, no modo design do arquivo source.extension.vsixmanifest, você deve clicar no botão "Adicionar conteúdo". Figura 5 mostra as entradas que você pode especificar na janela resultante.
.png)
Figura 5, a adição de conteúdo na visualização de Design de um arquivo de manifesto
A estrutura de diretório que é criada automaticamente no projeto VSIX por esse processo agora precisa ajuste um pouco. Você pode fazer isso clicando com o botão direito na pasta ProjectTemplates e criando uma nova pasta chamada ASPNET. Por último, você deve mover o arquivo compactado da pasta ProjectTemplates para a pasta do ASPNET e clique em Sim quando solicitado a substituir o arquivo existente. Compilar a solução rapidamente revela que a criação do modelo de projeto VSIX por Visual Studio foi bem sucedida. Se desejar, você poderia adicionar agora esse modelo de projeto para Visual Studio clicando duas vezes no arquivo .vsix que foi criado por Visual Studio e percorrendo o Assistente de instalação resultantes.
Estendendo o modelo de projeto
As etapas concluídas até atingir o primeiro objetivo desse modelo e preparar o terreno para a obtenção do restante dos objetivos. Essas goals adicionais são realizadas principalmente, adicionando código para o método RunFinished da implementação do Assistente de modelo IWizard. Agora apresentarei você o código necessário para atingir os objetivos restantes para este modelo.
O código necessário para atingir a segunda meta dinamicamente adicionando cada um dos projetos na solução durante a criação do projeto é mostrado na a Figura 6.
Figura 6 adicionando dinamicamente projetos na solução
// This method can be found in the full source
// as part of the TemplateWizard class.
member this.RunFinished() =
// Non-relevant code omitted.
// this.solution is set in the RunStarted method.
let templatePath = this.solution.GetProjectTemplate("MsdnFsMvc3.zip", "FSharp")
let AddProject status projectVsTemplateName projectName =
// this.dte2 is set in the RunStarted method
this.dte2.StatusBar.Text <- status
let path =
templatePath.Replace("MsdnFsMvc3.vstemplate", projectVsTemplateName)
this.solution.AddFromTemplate(path,
Path.Combine(this.destinationPath, projectName),
projectName, false) |> ignore
// webName and webAppName are values that have been
// bound to strings that identify specific projects.
AddProject "Installing the C# Web project..."
(Path.Combine("MsdnWeb", "MsdnWeb.vstemplate")) webName
AddProject "Adding the F# Web App project..."
(Path.Combine("MsdnWebApp", "MsdnWebApp.vstemplate")) webAppName
// Non-relevant code omitted.
A primeira linha de código no método mostrado na a Figura 6 retorna o local do modelo de multiprojeto na máquina do qual o Assistente para novo projeto foi iniciado. A segunda define uma função chamada AddProject. Esta função contém o código necessário para atualizar a barra de status Visual Studio, especifica o arquivo. vstemplate apropriado que corresponde com o modelo de projeto desejado e adiciona o projeto do modelo para a solução. As últimas linhas de código chamar a função AddProject para os projetos MsdnWeb e MsdnWebApp. Uma chamada semelhante a AddProject poderia também foram adicionada para o projeto MsdnWebAppTests, se de que foram desejados.
Para atingir a meta terceira dinamicamente adicionando qualquer desejado referências do projeto, você precisa primeiro criar um mapa dos nomes de projeto e projeto associado objetos que formam a solução (consulte bit.ly/fsharp mapas para obter informações sobre F# mapeia). Isso é feito chamando uma função personalizada denominada BuildProjectMap com um argumento fornecido de uma coleção de projetos na solução.
Isso é então ligado a um valor chamado "projetos", conforme mostrado aqui:
// This function can be found in the full source
// as part of the ProjectService module.
let BuildProjectMap (projects:Projects) =
projects
|> Seq.cast<Project>
|> Seq.map(fun project -> project.Name, project)
|> Map.ofSeq
// This method can be found in the full source
// as part of the TemplateWizard class.
member this.RunFinished() =
// Non-relevant code omitted.
// this.dte is set in the RunStarted method.
let projects = BuildProjectMap (this.dte.Solution.Projects)
// Non-relevant code omitted.
Agora que você tem o mapa do projeto, você pode chamar outra função personalizada para disparar o processo de adicionar as referências do projeto. A primeira linha do código mostrado a seguir cria uma lista de tuplas:
// This method can be found in the full source
// as part of the TemplateWizard class.
member this.RunFinished() =
// Non-relevant code omitted.
// webName, webAppName and webAppTestsName are values that have been
// bound to strings that are used to identify specific projects.
[(webName, webAppName); (webAppTestsName, webAppName)]
|> BuildProjectReferences projects
// Non-relevant code omitted.
Cada tupla na lista representa o nome do projeto de destino, seguido do nome do projeto que está sendo referenciado. Por exemplo, a primeira tupla indica um nome de projeto de destino de "MsdnWeb" com um nome de referência de projeto associado de "MsdnWebApp". Esta lista, em seguida, é canalizada para a função BuildProjectReferences.
Este código mostra a função BuildProjectReferences:
// This function can be found in the full source
// as part of the ProjectService module.
let BuildProjectReferences (projects:Map<string, Project>) projectRefs =
projectRefs
|> Seq.iter (fun (target,source) ->
AddProjectReference (projects.TryFind target)
(projects.TryFind source))
Essa função simplesmente obtém a lista de tuplas, itera através dele, tenta recuperar o objeto de projeto apropriado do mapa do projeto pelo nome e chama a função AddProjectReference para fazer o trabalho real.
A função AddProjectReference termina o processo, confirmando que os argumentos projToReference e de destino contém um projeto válido, como mostrado aqui:
// This function can be found in the full source
// as part of the ProjectService module.
let AddProjectReference (target:Option<Project>)
(projToReference:Option<Project>) =
if ((Option.isSome target) && (Option.isSome projToReference)) then
let vsTarget = target.Value.Object :?> VSProject
vsTarget.References
|> Seq.cast<Reference>
|> Seq.filter(fun (reference) -> reference.Name = projToReference.Value.Name)
|> Seq.iter(fun reference -> reference.Remove())
vsTarget.References
.AddProject((projToReference.Value.Object :?> VSProject).Project)
|> ignore
Se elas contiverem projetos válidos, esta função remove qualquer referência existente. Finalmente, ele adiciona a referência ao projeto.
O quarto objetivo desse modelo de projeto é um conceito que foi introduzido recentemente pelo processo do ASP.Equipe NET MVC. Ele fornece uma ótima maneira de adicionar referências a bibliotecas ou estruturas que provavelmente ser aprimorado no futuro não-muito-distante. NuGet 1.2, que é fornecido com o ASP.NET MVC 3 ferramentas de atualização, inclui um assembly chamado NuGet.VisualStudio que permite que NuGet pacotes a serem instalados facilmente de dentro de um Assistente de modelo. O ASP.Instalação da atualização de ferramentas do NET MVC 3 também adiciona vários pacotes de NuGet na máquina local para permitir a instalação mais rápida desses pacotes específicos durante a criação do projeto.
Há algumas das diferentes funções na amostra que são usadas para realizar as instalações do pacote NuGet. Mais importante é mostrar aqui:
// This function can be found in the full source
// as part of the NuGetService module.
let InstallPackages (serviceProvider:IServiceProvider) (project:Project) packages =
let componentModel =
serviceProvider.GetService(typeof<SComponentModel>) :?> IComponentModel
let installer = componentModel.GetService<IVsPackageInstaller>()
let nugetPackageLocalPath = GetNuGetPackageLocalPath()
packages
|> Seq.iter (fun packageId ->
installer.InstallPackage(nugetPackageLocalPath,
project, packageId, null, false))
As três primeiras linhas de código nesta função são usadas para obter a implementação concreta da interface IVsPackageInstaller, que será usada para instalar os vários pacotes de NuGet no projeto especificado. A quarta linha de código chama a função de GetNuGetPackageLocalPath, que acessa o registro do sistema para determinar o caminho de instalação do ASP.NET MVC 3. Por último, lista de nomes de pacote fornecida é canalizada para a função Seq.iter, que percorre a lista e instala cada pacote.
Agora que toda essa funcionalidade foi implementada no seu assistente de modelo, basta adicionar o projeto do Assistente de modelo como conteúdo para o projeto VSIX com um tipo de Assistente de modelo. Figura 7 mostra a janela Adicionar conteúdo concluída. Isso conclui as metas de duas a quatro.
.png)
Figura 7 O concluído adicionar janela de conteúdo
Adição de um Windows Presentation Foundation da interface do usuário
O processo para realizar o objetivo final — a adição de uma interface de usuário que pode ser usado para coletar informações do usuário durante o processo de criação do projeto — não mudou muito nos últimos anos. Um artigo de 2007 do ' Reilly Media Inc. (oreil.ly/build-vs-proj-wiz) fornece uma boa visão geral para fazer isso. Enquanto a premissa do processo permanece o mesmo, você precisa saber algumas coisas para implementar essa funcionalidade no de Windows Presentation Foundation (WPF) e relacioná-lo no seu modelo de projeto.
Para começar, você precisa primeiro criar uma nova C# usuário biblioteca de controle. Você deve alterar a estrutura de destino a partir de agora.NET Framework 4 o perfil de cliente para.NET Framework 4. Em seguida, você pode remover o padrão UserControl1.xaml e adicionar uma nova janela do WPF. Por meio de qualquer método que preferir, você agora pode manipular o XAML para projetar a interface do usuário desejado. Finalmente, você precisa expor as propriedades desejadas e, em seguida, definir quaisquer manipuladores de eventos necessários. Um exemplo simples de aparência codebehind da janela do WPF é mostrado aqui:
// This can be found in the full source as part of the MsdnCsMvc3Dialog class.
public bool IncludeTestsProject { get; set; }
private void btnOk_Click(object sender, RoutedEventArgs e)
{
IncludeTestsProject =
cbIncludeTestsProject.IsChecked.HasValue ?
cbIncludeTestsProject.IsChecked.Value : false;
DialogResult = true;
Close();
}
private void btnCancel_Click(object sender, RoutedEventArgs e)
{
Close();
}
Depois de obter a interface do usuário exatamente da maneira desejada, você precisará assinar o assembly. Em seguida, você deve adicionar o projeto — como conteúdo com um tipo de conteúdo do Assistente de modelo — para o projeto VSIX. Dentro do projeto do Assistente de modelo, você adicionar uma referência para o projeto que contém a interface do usuário. Depois que isso tudo estiver concluído, você precisa adicionar código para o método RunStarted da implementação IWizard que mostrará a interface do usuário e capturar o resultado, conforme mostrado aqui:
// This method can be found in the full source
//as part of the TemplateWizard class.
member this.RunStarted () =
// Non-relevant code omitted.
let dialog = new TemplateView()
match dialog.ShowDialog().Value with
| true ->
this.includeTestProject <- dialog.IncludeTestsProject
| _ ->
raise (new WizardCancelledException())
Finalmente, você pode adicionar o seguinte código ao método RunFinished do Assistente de modelo:
// This method can be found in the full source
//as part of the TemplateWizard class.
member this.RunFinished() =
// Non-relevant code omitted
// webAppTestsName is a value that has been bound
// to a string that represents the tests project.
if this.includeTestProject then
AddProject "Adding the F# Web App Tests project..."
(Path.Combine("MsdnWebAppTests",
"MsdnWebAppTests.vstemplate")) webAppTestsName
// Non-relevant code omitted.
Reutilizar e reduzir o tempo
Criação de um F# /C # modelo de projeto VSIX é uma maneira fácil para incentivar a reutilização e reduzir o tempo gasto em tarefas de configuração do projeto repetitivas. Com essas habilidades agora em sua posse, você poderá aumentar a produtividade, criando modelos de projeto que contêm quanto ou menor complexidade como seu cenário exigir.
Daniel Mohl é um MVP da Microsoft e F# Insider. He bloga em blog.danielmohl.com e você poderá segui-lo Twitter no twitter.com/dmohl.
Graças aos seguintes especialistas técnicos para revisão deste artigo: Elijah Manor, Marinos de Chris e Richard Minerich