Demonstra Passo a passo: Programação (C# e Visual Basic) do Office

Artigo
08/01/2011

Visual Studio 2010apresenta novos recursos no C# e Visual Basic, melhoram a programação de Microsoft Office. Cada idioma acrescentou recursos que já existem em outro idioma.

Os novos recursos do C# incluir argumentos nomeados e opcionais, valores que têm o tipo de retorno dynamice, COM a programação, a capacidade para omitir a ref palavra-chave e para acessar propriedades indexadas. Os novos recursos do Visual Basic incluem propriedades de auto-implementada, instruções em expressões lambda e inicializadores de coleção.

As duas linguagens permitem a incorporação de informações de tipo, que permite a implantação dos assemblies que interagem com componentes COM sem implantar assemblies de interoperabilidade primários (PIAs) para o computador do usuário. Para obter mais informações, consulte Demonstra Passo a passo: Tipos de incorporação de Assemblies gerenciados (C# e Visual Basic).

Esta explicação passo a passo demonstra os novos recursos no contexto de programação do Office, mas muitos deles também são úteis em geral de programação. Explicação passo a passo, você primeiro usará um aplicativo de suplemento do Excel para criar uma pasta de trabalho do Excel. Você irá criar um documento do Word que contém um link para a pasta de trabalho. Finalmente, você verá como a dependência PIA pode ser ativada e desativado.

Pré-requisitos

Você deve ter Microsoft Office Excel 2007 ou 2010 e 2010 do Microsoft Office Word ou 2007 instalado no seu computador para concluir este passo a passo.

Se você estiver usando um sistema operacional mais antigos que Windows Vista, certifique-se de que .NET Framework 2.0 está instalado.

Observação
Seu computador pode mostrar nomes ou locais diferentes para alguns dos elementos da interface do usuário do Visual Studio nas instruções a seguir. A edição do Visual Studio que você possui e as configurações que você usa determinam esses elementos. Para obter mais informações, consulte Configurações do Visual Studio.

Para configurar um aplicativo Excel Add-in.

Inicie o Visual Studio.
No menu File, aponte para New, e em seguida, clique em Project.
No Modelos instalados painel, expanda Visual Basic ou Visual C#, expanda Officee, em seguida, clique em 2010 (ou 2007 se você estiver usando o Office 2007).
No modelos de painel, clique em Excel Add-in 2010 (ou suplemento do Excel 2007).
Examine a parte superior da modelos de painel para certificar-se de que .NET Framework 4 consta o Target Framework caixa.
Digite um nome para o seu projeto no nome caixa, se desejar.
Clique em OK.
O novo projeto aparece na Solution Explorer.

Para adicionar referências

Em Solution Explorer, o nome do projeto com o botão direito e, em seguida, clique em Adicionar referência de. O Add Reference caixa de diálogo aparece.
Sobre o .NET guia, selecione Microsoft.Office.Interop.Excel, versão 14.0.0.0 (ou versão 12.0.0.0 para o Excel 2007), o Nome do componente lista e, em seguida, mantenha pressionada a tecla CTRL chave e selecione Microsoft.Office.Interop.Word, versão 14.0.0.0 (ou 12.0.0.0 para o Word 2007).
Clique em OK.

Para adicionar instruções de importações necessárias ou usando diretivas

Em Solution Explorer, com o botão direito do ThisAddIn. vb ou ThisAddIn.cs de arquivo e clique em Exibir código.
Adicione o seguinte Imports instruções (Visual Basic) ou using diretivas (C#) na parte superior do arquivo de código se eles estiverem ainda não estiver presente.
```
Imports Microsoft.Office.Interop
```
```
using System.Collections.Generic;
using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;
```

Para criar uma lista de contas bancárias

Em Solution Explorer, o botão direito do mouse o nome do projeto, clique em Adde em seguida, clique em classe. O nome da classe Account.vb se você estiver usando Visual Basic ou Account.cs, se você estiver usando C#. Clique em Adicionar.
Substituir a definição de Account classe com o código a seguir. As definições de classe usam Propriedades implementadas para auto, novos para a Visual Basic em 2010 de Visual Studio. Para obter mais informações, consulte Propriedades autoimplementadas (Visual Basic).
```
Public Class Account
    Property ID As Integer = -1
    Property Balance As Double
End Class
```
```
class Account
{
    public int ID { get; set; }
    public double Balance { get; set; }
}
```

Para criar um bankAccounts lista que contém duas contas, adicione o seguinte código para o ThisAddIn_Startup método em ThisAddin. vb ou ThisAddIn.cs. A declarações de lista usa inicializadores de coleção, novos para a Visual Basic em 2010 de Visual Studio. Para obter mais informações, consulte Visão geral sobre inicializadores de coleção (Visual Basic).

Dim bankAccounts As New List(Of Account) From {
    New Account With {
                          .ID = 345,
                          .Balance = 541.27
                     },
    New Account With {
                          .ID = 123,
                          .Balance = -127.44
                     }
    }

var bankAccounts = new List<Account> {
    new Account {
        ID = 345,
        Balance = 541.27
    },
    new Account {
        ID = 123,
        Balance = -127.44
    }
};

Para exportar dados para o Excel

No mesmo arquivo, adicione o seguinte método para o ThisAddIn classe. O método configura uma pasta de trabalho do Excel e exporta dados para ele.
```
Sub DisplayInExcel(ByVal accounts As IEnumerable(Of Account),
               ByVal DisplayAction As Action(Of Account, Excel.Range))

    With Me.Application
        ' Add a new Excel workbook.
        .Workbooks.Add()
        .Visible = True
        .Range("A1").Value = "ID"
        .Range("B1").Value = "Balance"
        .Range("A2").Select()

        For Each ac In accounts
            DisplayAction(ac, .ActiveCell)
            .ActiveCell.Offset(1, 0).Select()
        Next

        ' Copy the results to the Clipboard.
        .Range("A1:B3").Copy()
    End With
End Sub
```
```
void DisplayInExcel(IEnumerable<Account> accounts,
           Action<Account, Excel.Range> DisplayFunc)
{
    var excelApp = this.Application;
    // Add a new Excel workbook.
    excelApp.Workbooks.Add();
    excelApp.Visible = true;
    excelApp.Range["A1"].Value = "ID";
    excelApp.Range["B1"].Value = "Balance";
    excelApp.Range["A2"].Select();

    foreach (var ac in accounts)
    {
        DisplayFunc(ac, excelApp.ActiveCell);
        excelApp.ActiveCell.Offset[1, 0].Select();
    }
    // Copy the results to the Clipboard.
    excelApp.Range["A1:B3"].Copy();
}
```
Dois novos C# recursos são usados neste método. Esses dois recursos já existirem no Visual Basic.
- Método Adicionar tem um parâmetro opcional para especificar um modelo específico. Parâmetros opcionais, novos no Visual C# 2010, que permitem que você omita o argumento para esse parâmetro se desejar usar o valor padrão. do parâmetro Porque nenhum argumento é enviado no exemplo anterior, Add usa o modelo padrão e cria uma nova pasta de trabalho. A instrução equivalente em versões anteriores do C# requer um argumento de espaço reservado: excelApp.Workbooks.Add(Type.Missing).
  
  Para obter mais informações, consulte Nome e argumentos Opcional (guia de programação TRANSLATION FROM VPE FOR CSHARP).
- O Range e Offset Propriedades de intervalo uso de objeto do indexado propriedades recurso. Este recurso permite consumir essas propriedades de tipos COM usando a seguinte C# sintaxe típica. Propriedades indexadas também permitem que você use o Value propriedade da Range o objeto, eliminando a necessidade de usar o Value2 propriedade. O Value propriedade é indexada, mas o índice é opcional. Argumentos opcionais e propriedades indexadas trabalham juntos no exemplo a seguir.
```
// Visual C# 2010 provides indexed properties for COM programming.
excelApp.Range["A1"].Value = "ID";
excelApp.ActiveCell.Offset[1, 0].Select();
```
  Nas versões anteriores da linguagem, a seguinte sintaxe especial é necessária.
```
// In Visual C# 2008, you cannot access the Range, Offset, and Value
// properties directly.
excelApp.get_Range("A1").Value2 = "ID";
excelApp.ActiveCell.get_Offset(1, 0).Select();
```
  Não é possível criar propriedades indexadas de sua preferência. O recurso suporta apenas o consumo de propriedades indexadas existentes.
  
  Para obter mais informações, consulte Como: uso indexado Propriedades no <>Interop COM>(guia de programação TRANSLATION FROM VPE FOR CSHARP) de programação..
Adicione o seguinte código no final de DisplayInExcel para ajustar as larguras de coluna para caber o conteúdo.
```
' Add the following two lines at the end of the With statement.
.Columns(1).AutoFit()
.Columns(2).AutoFit()
```
```
excelApp.Columns[1].AutoFit();
excelApp.Columns[2].AutoFit();
```
Essas adições demonstram a outro recurso novo no C# 2010: Tratando Object valores retornados de hosts de COM, como o Office, como se tivessem o tipo de dinâmico. Isso acontece automaticamente quando Incorporar tipos de interoperabilidade é definido como o valor padrão, True, ou, de forma equivalente, quando o assembly é referenciado pela /link opção de compilador. Tipo de dynamic permite a vinculação tardia, já disponível em Visual Basic e evita a transmissão explícita necessária no Visual C# 2008 e versões anteriores do idioma.

Por exemplo, excelApp.Columns[1] retorna um Object, e AutoFit é um Excel intervalo método. Sem dynamic, você deve converter o objeto retornado por excelApp.Columns[1] como uma instância de Range antes de chamar o método AutoFit.
```
// Casting is required in Visual C# 2008.
((Excel.Range)excelApp.Columns[1]).AutoFit();

// Casting is not required in Visual C# 2010.
excelApp.Columns[1].AutoFit();
```
Para obter mais informações sobre como incorporar tipos de interoperabilidade, consulte procedimentos "para encontrar a referência PIA" e "para restaurar a dependência PIA" neste tópico. Para obter mais informações sobre dynamic, consulte dinâmico (referência de TRANSLATION FROM VPE FOR CSHARP) ou Usando o Tipo dinâmico (guia de programação TRANSLATION FROM VPE FOR CSHARP).

Para chamar DisplayInExcel

Adicione o seguinte código no final do ThisAddIn_StartUp método. A chamada para DisplayInExcel contém dois argumentos. O primeiro argumento é o nome da lista de contas a serem processadas. O segundo argumento é uma expressão lambda de várias linhas que define como os dados a serem processados. O ID e balance valores para cada conta são exibidos em células adjacentes, e a linha é exibida em vermelho se o saldo for menor que zero. As expressões lambda multilinha são um novo recurso em 2010 de Visual Basic. Para obter mais informações, consulte Expressões Lambda (Visual Basic).

DisplayInExcel(bankAccounts,
       Sub(account, cell)
           ' This multiline lambda expression sets custom
           ' processing rules for the bankAccounts.
           cell.Value = account.ID
           cell.Offset(0, 1).Value = account.Balance

           If account.Balance < 0 Then
               cell.Interior.Color = RGB(255, 0, 0)
               cell.Offset(0, 1).Interior.Color = RGB(255, 0, 0)
           End If
       End Sub)

DisplayInExcel(bankAccounts, (account, cell) =>
// This multiline lambda expression sets custom processing rules  
// for the bankAccounts.
{
    cell.Value = account.ID;
    cell.Offset[0, 1].Value = account.Balance;
    if (account.Balance < 0)
    {
        cell.Interior.Color = 255;
        cell.Offset[0, 1].Interior.Color = 255;
    }
});

Para executar o programa, pressione F5. Uma planilha do Excel aparece que contém os dados das contas.

Para adicionar um documento do Word

Adicione o seguinte código no final do ThisAddIn_StartUp método para criar um documento do Word que contém um link para a pasta de trabalho do Excel.
```
Dim wordApp As New Word.Application
wordApp.Visible = True
wordApp.Documents.Add()
wordApp.Selection.PasteSpecial(Link:=True, DisplayAsIcon:=True)
```
```
var wordApp = new Word.Application();
wordApp.Visible = true;
wordApp.Documents.Add();
wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
```
Esse código demonstra vários dos novos recursos do C#: a capacidade para omitir o ref palavra-chave na COM programação, chamados argumentos e argumentos opcionais. Esses recursos já existirem no Visual Basic. O PasteSpecial método tem sete parâmetros, os quais são definidos como parâmetros de referência opcionais. Antes para o Visual C# 2010, você precisava definir variáveis de objeto para usar como argumentos para os parâmetros de sete, mesmo quando você não tinha nenhum valor significativo para enviar. Argumentos nomeados e opcionais permitem que você designar os parâmetros que você deseja acessar pelo nome e argumentos de enviar apenas esses parâmetros. Neste exemplo, os argumentos são enviados para indicar que um link para a pasta de trabalho na área de transferência deve ser criado (parâmetro Link), e o link será exibido no documento do Word como um ícone (parâmetro DisplayAsIcon). Visual C# 2010 também permite que você omitir o ref palavra-chave para esses argumentos. Compare o segmento de código a seguir do Visual C# 2008 com a linha única, necessária no Visual C# 2010:
```
// Call to PasteSpecial in Visual C# 2008.
object iconIndex = Type.Missing;
object link = true;
object placement = Type.Missing;
object displayAsIcon = true;
object dataType = Type.Missing;
object iconFileName = Type.Missing;
object iconLabel = Type.Missing;
wordApp.Selection.PasteSpecial(ref iconIndex,
                               ref link,
                               ref placement,
                               ref displayAsIcon,
                               ref dataType,
                               ref iconFileName,
                               ref iconLabel);

// Call to PasteSpecial in Visual C# 2010.
wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
```

Para executar o aplicativo

Pressione F5 para executar o aplicativo. Excel é iniciado e exibe uma tabela que contém as informações de duas contas em bankAccounts. Um documento do Word será exibido, que contém um link para a tabela do Excel.

Para limpar o projeto concluído

Na Visual Studio, clique em Limpar solução sobre o Build menu. Caso contrário, o suplemento será executado toda vez que abrir o Excel no seu computador.

Para encontrar a referência PIA

Executar o aplicativo novamente, mas não clique em Limpar solução.
Sobre o Iniciar menu, clique em Todos os programas. Em seguida clique em 2010 do Microsoft Visual Studio, em seguida, Visual Studio Tools, em seguida, Prompt de comando Visual Studio (2010).
Tipo de ildasm no comando Visual Studio (2010) janela do Prompt e pressione ENTER. A janela de IL DASM aparece.
Sobre o arquivo menu na janela IL DASM, clique em Abrir. Clique duas vezes em Visual Studio 2010 dee clique duas vezes em projetos. Abra a pasta para o seu projeto e procure na pasta bin/Debug para o nome do projeto. dll. Clique duas vezes em o nome do projeto. dll. Uma nova janela exibe os atributos do projeto, além de referências a outros módulos e assemblies. Observe que os namespaces Microsoft.Office.Interop.Excel e Microsoft.Office.Interop.Word estão incluídos no assembly. Por padrão em 2010 de Visual Studio, o compilador importa os tipos que você precisa de um PIA referenciado em seu assembly.

Para obter mais informações, consulte Como: Exibir o conteúdo do Assembly.

Clique duas vezes o MANIFESTO ícone. Aparecerá uma janela que contém uma lista de assemblies que contêm itens referenciados pelo projeto. Microsoft.Office.Interop.Excele Microsoft.Office.Interop.Word não são incluídos na lista. Porque os tipos de seu projeto precisa ter sido importado para seu assembly, não são necessárias referências a um PIA. Isso facilita a implantação. Os PIAs não precisam estar presente no computador do usuário e porque um aplicativo não requer a implantação de uma versão específica de um PIA, aplicativos podem ser projetados para trabalhar com várias versões do Office, desde que as APIs necessárias existem em todas as versões.

Porque a implantação de PIAs não é mais necessária, você pode criar um aplicativo em cenários avançados que funciona com várias versões do Office, incluindo versões anteriores. No entanto, isso só funcionará se seu código não usa as APIs que não estão disponíveis na versão do Office que você estiver trabalhando com. Nem sempre é claro se uma API específica estava disponível em uma versão anterior e, para que o motivo para trabalhar com versões anteriores do Office não é recomendado.

Observação
Office não publicou PIAs antes do Office 2003. Portanto, a única maneira de gerar um assembly de interoperabilidade para Office 2002 ou versões anteriores é através da importação de referência COM.

Feche a janela de manifesto e a janela do assembly.

Para restaurar a dependência PIA

Em Solution Explorer, clique na Mostrar todos os arquivos botão. Expanda o referências pasta e selecione Microsoft.Office.Interop.Excel. Pressione F4 para exibir a Propriedades janela.
No Propriedadesjanela de s, alterar o Incorporar tipos de interoperabilidade a propriedade de True para False.
Repita as etapas 1 e 2 deste procedimento para Microsoft.Office.Interop.Word.
No C#, comentar as duas chamadas para Autofit no final de DisplayInExcel método.
Pressione F5 para verificar que o projeto ainda seja executado corretamente.
Repita as etapas de 1 a 3 do procedimento anterior para abrir a janela do assembly. Observe que Microsoft.Office.Interop.Word e Microsoft.Office.Interop.Excel não está mais na lista de módulos (assemblies) incorporado.
Clique duas vezes o MANIFESTO ícone e percorra a lista de assemblies de referência. Ambos Microsoft.Office.Interop.Word e Microsoft.Office.Interop.Excel estão na lista. Porque o aplicativo faz referência o Excel e Word PIAs e o Incorporar tipos de interoperabilidade for definida como False, os dois assemblies devem existir no computador do usuário final.
Na Visual Studio, clique em Limpar solução sobre o Build menu para limpar o projeto concluído.

Consulte também

Partilhar via