Demonstra Passo a passo: Criar um novo projeto do Office usando a automação de projeto de Visual Studio

Artigo
08/08/2011

Esta explicação passo a passo demonstra como criar uma macro que usa o modelo de objeto de Visual Studio para automatizar a criação de um projeto do Office. O projeto utiliza configurações personalizadas na Visual Studio Tools for Office Project Wizard, em vez de depender de padrões de projeto.

Aplicável a: As informações neste tópico se aplicam a projetos de nível de documento para Excel 2010. Para obter mais informações, consulte Recursos disponíveis pelo aplicativo do Office e o tipo de projeto.

O código cria um novo projeto com as configurações do assistente personalizado para que o projeto automatizado seja criado usando uma pasta de trabalho do Excel de Microsoft Office existente em vez de criar uma nova pasta de trabalho.

Para obter mais informações sobre macros, consulte Automatizar ações repetitivas usando Macros.

This walkthrough illustrates the following tasks:

Criando uma nova macro Visual Studio.
Criando um arquivo de modelo de temporários (. vstemplate) com configurações personalizadas.
A definição de parâmetros para um assistente e iniciar o assistente.

Pré-requisitos

You need the following components to complete this walkthrough:

Uma edição do Visual Studio 2010 que inclua as ferramentas de desenvolvedor do Microsoft Office. Para obter mais informações, consulte [Configurando um computador para desenvolver soluções do Office](bb398242\(v=vs.100\).md).

Excel 2010.

Criando a pasta de trabalho do Excel

Você deve criar uma pasta de trabalho do Excel é usada como a pasta de trabalho existente no novo projeto.

Para criar a pasta de trabalho do Excel

Crie uma pasta na unidade c do computador, denominada criarnovoarquivo.
Crie uma subpasta em criarnovoarquivo chamado teste: C:\CreateNewFile\Test.
Open Excel 2010.
Tipo esta é a pasta de trabalho criarnovoarquivo na célula A1.
Salve a pasta de trabalho como CreateNewFile.xls no local C:\CreateNewFile.
Feche o Excel.

A subpasta de teste é usada como o local para o projeto concluído.

Criando uma nova Macro

Nesta etapa, você criará uma macro de Visual Studio de nova e vazia.

Para criar uma nova macro.

Visual Studio de abrir e fechar todos os projetos abertos.
Sobre o Ferramentas , aponte para Macrose, em seguida, clique em IDE de Macros.

O Macros do Microsoft Visual Studio integrado abre (IDE) do ambiente de desenvolvimento.
Expanda o MyMacros o nó, se ainda não estiver expandida.
Sobre o projeto menu, clique em Adicionar módulo.
Nomeie o módulo CreateNewProject e clique em Add.

O novo módulo é aberto no IDE de Macros. Agora você pode adicionar código para criar um novo projeto.

Criando um arquivo de modelo (. vstemplate)

Para criar um novo projeto usando as configurações padrão do assistente, use um dos arquivos de modelo predefinido. No Visual Studio, o padrão de projeto é criar um novo documento ou pasta de trabalho para uso no projeto. Para usar uma pasta de trabalho existente em seu projeto, você deve gerar um arquivo. vstemplate de temporário personalizado com as configurações corretas.

Para obter mais informações sobre arquivos. vstemplate, consulte Modelos Visual Studio.

Para usar um documento existente, adicione o parâmetro personalizado VSTOExistingDocumentPath no arquivo. vstemplate.

Para gerar um arquivo temporário vsz

On the Project menu, click Add Reference.
Selecione System.Xml.dll, clique em Adde em seguida, clique em OK.
Adicione as seguintes instruções Imports no início do arquivo de código.
```
Imports System.Xml
Imports System.IO
```

No módulo CreateNewProject, adicione o seguinte método para definir o conteúdo da pasta temporária do modelo.

Sub CreateVstemplateFile(ByVal defaultTemplateFilePath As String, _
    ByVal templateFilePath As String, ByVal docFilePath As String)

    ' Copy the default template in the temporary location.
    Dim defaultTemplateDirectory = _
        Path.GetDirectoryName(defaultTemplateFilePath)
    Dim templateDirectory = Path.GetDirectoryName(templateFilePath)
    If Not Directory.Exists(templateDirectory) Then
        Directory.CreateDirectory(templateDirectory)
    End If
    For Each fileToCopy As String In Directory. _
        GetFiles(defaultTemplateDirectory)
        File.Copy(fileToCopy, Path.Combine(templateDirectory, _
            Path.GetFileName(fileToCopy)), True)
    Next

    ' Create the vstemplate namespace.
    Dim vstemplateNamespace As String = _
        "https://schemas.microsoft.com/developer/vstemplate/2005"

    ' Load the XML document.
    Dim doc As XmlDocument = New XmlDocument()
    doc.Load(templateFilePath)
    Dim xmlNsManager As XmlNamespaceManager = _
        New XmlNamespaceManager(doc.NameTable)
    xmlNsManager.AddNamespace("vstemplns", vstemplateNamespace)

    ' Get 'CustomParameters' XML node.
    Dim customParametersNode As XmlNode = doc.SelectSingleNode( _
        "/vstemplns:VSTemplate/vstemplns:TemplateContent/" _
        & "vstemplns:CustomParameters", xmlNsManager)

    ' Create a new XML CustomParameter node with 
    ' the existing document data.
    ' <CustomParameter Name="VSTOExistingDocumentPath" _
    ' Value="C:\CreateNewFile\CreateNewFile.xls" />
    Dim newNode As XmlNode
    newNode = doc.CreateElement("CustomParameter", _
        vstemplateNamespace)
    Dim nameAttribute As XmlAttribute
    nameAttribute = doc.CreateAttribute("Name")
    Dim valueAttribute As XmlAttribute
    valueAttribute = doc.CreateAttribute("Value")

    nameAttribute.Value = "VSTOExistingDocumentPath"
    valueAttribute.Value = docFilePath

    newNode.Attributes.Append(nameAttribute)
    newNode.Attributes.Append(valueAttribute)

    customParametersNode.AppendChild(newNode)
    doc.Save(templateFilePath)
End Sub

O próximo método define os parâmetros e chama o LaunchWizard método.

Starting the Wizard

Para criar um novo projeto, use o LaunchWizard o método do objeto DTE.

Para iniciar o Assistente

Adicione o seguinte método para o CreateNewProject module para preencher a matriz de parâmetros e iniciar o Assistente:

Sub LaunchWizard(ByVal projectName As String, _
    ByVal projectFolder As String, _
    ByVal templateFilePath As String)

    Dim params(6) As Object

    ' New project.
    params(0) = "{0F90E1D0-4999-11D1-B6D1-00A0C90F2744}"

    ' Project name.
    params(1) = projectName

    ' Project location.
    params(2) = projectFolder

    ' Install location.
    params(3) = ""

    ' Close solution.
    params(4) = False

    ' Solution name.
    params(5) = ""

    ' Silent - do not display any user interface.
    params(6) = False

    DTE.LaunchWizard(templateFilePath, params)
End Sub

Finalmente, adicione um método para chamar os dois métodos que você acabou de criar e passa os parâmetros apropriados.

Creating the Project

O método a seguir define e passa os parâmetros corretos para o CreateVstemplateFile e LaunchWizard métodos.

To create the project

Adicione o seguinte método para o CreateNewProject module:

Sub CreateProject()
    Dim sol As Solution2 = DTE.Solution

    ' Get the path of the default .vstemplate file using 
    ' the name of the template zip file and the language.
    ' The zip files are "VSTOExcelWorkbook.zip", 
    ' "VSTOExcelTemplate.zip", ' "VSTOWordDocument.zip", 
    ' or "VSTOWordTemplate.zip".
    ' The languages are "VisualBasic" and "CSharp".
    Dim defaultTemplateFilePath As String = _
        sol.GetProjectTemplate("VSTOExcel2010WorkbookV4.zip", _
        "VisualBasic")

    ' Get the temporary .vstemplate file containing 
    ' the specification.
    Dim templateDirectory As String = "C:\CreateNewFile\template"
    Dim templateFilePath = Path.Combine(templateDirectory, _
        Path.GetFileName(defaultTemplateFilePath))

    ' Get an existing document to use in project creation.
    Dim docFilePath As String = "C:\CreateNewFile\CreateNewFile.xls"

    ' Create a temporary template with the wizard specification.
    CreateVstemplateFile(defaultTemplateFilePath, _
        templateFilePath, docFilePath)

    ' Launch the CreateProject wizard.
    Dim projectName As String = "CreateNewFile"
    Dim projectFolder As String = "c:\CreateNewFile\test"
    LaunchWizard(projectName, projectFolder, templateFilePath)
End Sub

Salve a macro.
Feche as macros IDE.

Teste a Macro.

Agora você pode testar sua macro para certificar-se de que ele cria um novo projeto.

Para testar a macro

Sobre o Ferramentas , aponte para Macrose em seguida, clique em Macro Explorer.
Em Macro Explorer, em MyMacros, expanda o CreateNewProject macro.
Em CreateNewProject, clique duas vezes em CreateProject.

O Visual Studio Tools for Office Project Wizard abre.
No Selecionar um documento para seu aplicativo página, clique em OK.
Verificar se o novo projeto é criado na subpasta de teste.

Consulte também

Compartilhar via