How to: Objetos de interoperabilidade do Office Access usando recursos visuais C# 2010 (guia de programação C#)

Artigo
08/04/2011

Visual C# 2010 introduz novos recursos que simplificam o acesso a objetos de API do Office. Os novos recursos incluem argumentos nomeados e opcionais, chamado de um novo tipo de dynamice a capacidade de passar argumentos para os métodos COM parâmetros de referência, como se fossem parâmetros de valor.

Neste tópico, você usará os novos recursos para escrever código que cria e exibe uma planilha do Excel de Microsoft Office. Em seguida, você irá escrever o código para adicionar um documento do Office Word que contém um ícone que está vinculado à planilha do Excel.

Para concluir este passo a passo, você deve ter Microsoft Office Excel 2007 e o Microsoft Office Word 2007 instalado no seu computador.

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 criar um novo aplicativo de console

Inicie o Visual Studio.
No menu File, aponte para New, e em seguida, clique em Project. A caixa de diálogo New Project será exibida.
No Modelos instalados painel, expanda **Visual C#**e em seguida, clique em Windows.
Examine a parte superior da Novo projeto caixa de diálogo para certificar-se de que .NET Framework 4 está selecionado como uma estrutura de destino.
No modelos de painel, clique em Aplicativo de Console.
Digite um nome para o seu projeto no nome campo.
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 página, selecione Microsoft.Office.Interop.Word na Nome do componente lista e, em seguida, mantenha pressionada a tecla CTRL chave e selecione Microsoft.Office.Interop.Excel.
Clique em OK.

Para adicionar necessário usando diretivas

Em Solution Explorer, com o botão direito do Program. cs de arquivo e clique em Exibir código.

Adicione o seguinte using diretivas para a parte superior do arquivo de código.

using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;

Para criar uma lista de contas bancárias

Cole a seguinte definição de classe em Program, na Program classe.

public class Account
{
    public int ID { get; set; }
    public double Balance { get; set; }
}

Adicione o seguinte código para o Main método para criar um bankAccounts lista que contém duas contas.

// Create a list of accounts.
var bankAccounts = new List<Account> {
    new Account { 
                  ID = 345678,
                  Balance = 541.27
                },
    new Account {
                  ID = 1230221,
                  Balance = -127.44
                }
};

Para declarar um método que exporta as informações de conta para o Excel

Adicione o seguinte método para o Program classe para configurar uma planilha do Excel.

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 código a seguir, 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).

static void DisplayInExcel(IEnumerable<Account> accounts)
{
    var excelApp = new Excel.Application();
    // Make the object visible.
    excelApp.Visible = true;

    // Create a new, empty workbook and add it to the collection returned 
    // by property Workbooks. The new workbook becomes the active workbook.
    // Add has an optional parameter for specifying a praticular template. 
    // Because no argument is sent in this example, Add creates a new workbook. 
    excelApp.Workbooks.Add();

    // This example uses a single workSheet. The explicit type casting is
    // removed in a later procedure.
    Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet;
}

Adicione o seguinte código no final do DisplayInExcel. O código insere valores nas duas primeiras colunas da primeira linha da planilha.
```
// Establish column headings in cells A1 and B1.
workSheet.Cells[1, "A"] = "ID Number";
workSheet.Cells[1, "B"] = "Current Balance";
```
Adicione o seguinte código no final do DisplayInExcel. O foreach loop coloca as informações da lista de contas nas duas primeiras colunas de sucessivas linhas da planilha.
```
var row = 1;
foreach (var acct in accounts)
{
    row++;
    workSheet.Cells[row, "A"] = acct.ID;
    workSheet.Cells[row, "B"] = acct.Balance;
}
```
Adicione o seguinte código no final de DisplayInExcel para ajustar as larguras de coluna para caber o conteúdo.
```
workSheet.Columns[1].AutoFit();
workSheet.Columns[2].AutoFit();
```
Versões anteriores do C# requerem conversão explícita para essas operações, pois ExcelApp.Columns[1] retorna um Object, e AutoFit é um Excel intervalo método. As linhas seguintes mostram a transmissão.
```
((Excel.Range)workSheet.Columns[1]).AutoFit();
((Excel.Range)workSheet.Columns[2]).AutoFit();
```
Visual C# 2010Converte o retornado Object para dynamic automaticamente se o assembly é referenciado pela /link opção de compilador ou, de forma equivalente, se o Excel Incorporar tipos de interoperabilidade for definida como true. True é o valor padrão para essa propriedade.

Para executar o projeto.

Adicione a seguinte linha no final do Main.

// Display the list in an Excel spreadsheet.
DisplayInExcel(bankAccounts);

Pressione CTRL+F5.

Uma planilha do Excel aparece que contém os dados das duas contas.

Para adicionar um documento do Word

Para ilustrar a maneiras adicionais de Visual C# 2010 Office aprimora a programação, o código a seguir abre um aplicativo do Word e cria um ícone que se vincula a planilha do Excel.

O método Paste CreateIconInWordDoc, fornecido posteriormente nesta etapa, para o Program classe. CreateIconInWordDocusa argumentos nomeados e opcionais para reduzir a complexidade, as chamadas de método para Add e PasteSpecial. Essas chamadas incorporam dois outros novos recursos de Visual C# 2010 que simplificam a chamadas para métodos COM, que possuem parâmetros de referência. Primeiro, você pode enviar argumentos para os parâmetros de referência, como se fossem os parâmetros de valor. Ou seja, você pode enviar valores diretamente, sem criar uma variável para cada parâmetro de referência. O compilador gera variáveis temporárias para manter os valores de argumento e descarta as variáveis quando você retornar da chamada. Em segundo lugar, você pode omitir o ref palavra-chave na lista de argumento.

O Add método tem quatro parâmetros de referência, os quais são opcionais. Em Visual C# 2010, você pode omitir argumentos para qualquer ou todos os parâmetros, se você deseja usar em seus valores padrão. Em Visual C# 2008 e versões anteriores, um argumento deve ser fornecido para cada parâmetro, e o argumento deve ser uma variável porque os parâmetros são parâmetros de referência.

O PasteSpecial método insere o conteúdo da área de transferência. O método tem sete parâmetros de referência, os quais são opcionais. O código a seguir especifica os argumentos para os dois deles: Link, para criar um link para a origem do conteúdo da área de transferência, e DisplayAsIcon, para exibir o link como um ícone. Em Visual C# 2010, você pode usar argumentos nomeados para esses dois e omitir as outras. Embora esses são os parâmetros de referência, não é necessário usar o ref palavra-chave, ou criar variáveis de envie como argumentos. Você pode enviar os valores diretamente. Em Visual C# 2008 e versões anteriores, você deve enviar um argumento variável para cada parâmetro de referência.
```
static void CreateIconInWordDoc()
{
    var wordApp = new Word.Application();
    wordApp.Visible = true;

    // The Add method has four reference parameters, all of which are 
    // optional. Visual C# 2010 allows you to omit arguments for them if
    // the default values are what you want.
    wordApp.Documents.Add();

    // PasteSpecial has seven reference parameters, all of which are 
    // optional. This example uses named arguments to specify values 
    // for two of the parameters. Although these are reference 
    // parameters, you do not need to use the ref keyword, or to create 
    // variables to send in as arguments. You can send the values directly.
    wordApp.Selection.PasteSpecial( Link: true, DisplayAsIcon: true);
}
```
Em Visual C# 2008 ou versões anteriores da linguagem, o seguinte código mais complexo é necessário.
```
static void CreateIconInWordDoc2008()
{
    var wordApp = new Word.Application();
    wordApp.Visible = true;

    // The Add method has four parameters, all of which are optional. 
    // In Visual C# 2008 and earlier versions, an argument has to be sent 
    // for every parameter. Because the parameters are reference  
    // parameters of type object, you have to create an object variable
    // for the arguments that represents 'no value'. 

    object useDefaultValue = Type.Missing;

    wordApp.Documents.Add(ref useDefaultValue, ref useDefaultValue,
        ref useDefaultValue, ref useDefaultValue);

    // PasteSpecial has seven reference parameters, all of which are
    // optional. In this example, only two of the parameters require
    // specified values, but in Visual C# 2008 an argument must be sent
    // for each parameter. Because the parameters are reference parameters,
    // you have to contruct variables for the arguments.
    object link = true;
    object displayAsIcon = true;

    wordApp.Selection.PasteSpecial( ref useDefaultValue,
                                    ref link,
                                    ref useDefaultValue,
                                    ref displayAsIcon,
                                    ref useDefaultValue,
                                    ref useDefaultValue,
                                    ref useDefaultValue);
}
```

Adicione a seguinte instrução no final da Main.

// Create a Word document that contains an icon that links to
// the spreadsheet.
CreateIconInWordDoc();

Adicione a seguinte instrução no final da DisplayInExcel. O Copy método adiciona a planilha para a área de transferência.

// Put the spreadsheet contents on the clipboard. The Copy method has one
// optional parameter for specifying a destination. Because no argument  
// is sent, the destination is the Clipboard.
workSheet.Range["A1:B3"].Copy();

Pressione CTRL+F5.

Um documento do Word é exibida contendo um ícone. Clique duas vezes no ícone para trazer a planilha para o primeiro plano.

Para definir a propriedade de incorporar tipos de interoperabilidade

Aprimoramentos adicionais são possíveis quando você chamar um tipo de COM não requer um assembly de interoperabilidade primária (PIA) em tempo de execução. Removendo a dependência de resultados de PIAs na independência de versão e implantação mais fácil. Para obter mais informações sobre as vantagens de programação sem PIAs, consulte Demonstra Passo a passo: Tipos de incorporação de Assemblies gerenciados (C# e Visual Basic).

Além disso, programação é mais fácil porque os tipos que são necessários e retornados pelos métodos de COM podem ser representados usando o tipo dynamic em vez de Object. Variáveis que têm tipo dynamic não são avaliadas até que o tempo de execução, que elimina a necessidade de conversão explícita. Para obter mais informações, consulte Usando o Tipo dinâmico (guia de programação C#).

Em Visual C# 2010, a incorporação de informações de tipo em vez de usar PIAs é o comportamento do padrão. Devido esse padrão, vários dos exemplos anteriores são simplificados porque elenco explícito não é necessário. Por exemplo, a declaração de worksheet em DisplayInExcel é escrito como Excel._Worksheet workSheet = excelApp.ActiveSheet em vez de Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet. As chamadas para AutoFit no mesmo método também exigiria explícito elenco sem padrão, pois ExcelApp.Columns[1] retorna um Object, e AutoFit é um método do Excel. O código a seguir mostra a transmissão.
```
((Excel.Range)workSheet.Columns[1]).AutoFit();
((Excel.Range)workSheet.Columns[2]).AutoFit();
```
Para alterar o padrão e usar PIAs em vez de incorporar informações de tipo, expanda o referências nó Solution Explorer e selecione Microsoft.Office.Interop.Excel ou Microsoft.Office.Interop.Word.
Se você não vir o Propriedades janela, pressione F4.
Encontrar Incorporar tipos de interoperabilidade na lista de propriedades e alterar seu valor para False. De forma equivalente, você pode compilar usando o /reference opção de compilador em vez de /link em um prompt de comando.

Para adicionar formatação adicional à tabela

Substitua as duas chamadas para AutoFit em DisplayInExcel com a instrução a seguir.
```
// Call to AutoFormat in Visual C# 2010.
workSheet.Range["A1", "B3"].AutoFormat(
    Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
```
O AutoFormatação método tem sete parâmetros de valor, os quais são opcionais. Argumentos nomeados e opcionais permitem que você fornecer argumentos para nenhum, alguns ou todos eles. A instrução anterior, um argumento for fornecido para somente um dos parâmetros, Format. Porque Format é o primeiro parâmetro na lista de parâmetros, você não precisará fornecer o nome do parâmetro. No entanto, a declaração pode ser mais fácil de entender se o nome de parâmetro é incluído, como é mostrado no código a seguir.
```
// Call to AutoFormat in Visual C# 2010.
workSheet.Range["A1", "B3"].AutoFormat(Format:
    Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
```
Pressione CTRL + F5 para ver o resultado. Outros formatos listados na XlRangeAutoFormat enumeração.

Compare a instrução na etapa 1 com o seguinte código mostra os argumentos que são necessários em Visual C# 2008 ou versões anteriores.

// The AutoFormat method has seven optional value parameters. The
// following call specifies a value for the first parameter, and uses 
// the default values for the other six. 

// Call to AutoFormat in Visual C# 2008. This code is not part of the
// current solution.
excelApp.get_Range("A1", "B4").AutoFormat(Excel.XlRangeAutoFormat.xlRangeAutoFormatTable3, 
    Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, 
    Type.Missing);

Exemplo

O código a seguir mostra o exemplo completo.

using System;
using System.Collections.Generic;
using System.Linq;
using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;


namespace OfficeProgramminWalkthruComplete
{
    class Walkthrough
    {
        static void Main(string[] args)
        {
            // Create a list of accounts.
            var bankAccounts = new List<Account> 
            {
                new Account { 
                              ID = 345678,
                              Balance = 541.27
                            },
                new Account {
                              ID = 1230221,
                              Balance = -127.44
                            }
            };

            // Display the list in an Excel spreadsheet.
            DisplayInExcel(bankAccounts);

            // Create a Word document that contains an icon that links to
            // the spreadsheet.
            CreateIconInWordDoc();
        }

        static void DisplayInExcel(IEnumerable<Account> accounts)
        {
            var excelApp = new Excel.Application();
            // Make the object visible.
            excelApp.Visible = true;

            // Create a new, empty workbook and add it to the collection returned 
            // by property Workbooks. The new workbook becomes the active workbook.
            // Add has an optional parameter for specifying a praticular template. 
            // Because no argument is sent in this example, Add creates a new workbook. 
            excelApp.Workbooks.Add();

            // This example uses a single workSheet. 
            Excel._Worksheet workSheet = excelApp.ActiveSheet;

            // Earlier versions of C# require explicit casting.
            //Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet;

            // Establish column headings in cells A1 and B1.
            workSheet.Cells[1, "A"] = "ID Number";
            workSheet.Cells[1, "B"] = "Current Balance";

            var row = 1;
            foreach (var acct in accounts)
            {
                row++;
                workSheet.Cells[row, "A"] = acct.ID;
                workSheet.Cells[row, "B"] = acct.Balance;
            }

            workSheet.Columns[1].AutoFit();
            workSheet.Columns[2].AutoFit();

            // Call to AutoFormat in Visual C# 2010. This statement replaces the 
            // two calls to AutoFit.
            workSheet.Range["A1", "B3"].AutoFormat(
                Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);

            // Put the spreadsheet contents on the clipboard. The Copy method has one
            // optional parameter for specifying a destination. Because no argument  
            // is sent, the destination is the Clipboard.
            workSheet.Range["A1:B3"].Copy();
        }

        static void CreateIconInWordDoc()
        {
            var wordApp = new Word.Application();
            wordApp.Visible = true;

            // The Add method has four reference parameters, all of which are 
            // optional. Visual C# 2010 allows you to omit arguments for them if
            // the default values are what you want.
            wordApp.Documents.Add();

            // PasteSpecial has seven reference parameters, all of which are 
            // optional. This example uses named arguments to specify values 
            // for two of the parameters. Although these are reference 
            // parameters, you do not need to use the ref keyword, or to create 
            // variables to send in as arguments. You can send the values directly.
            wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
        }
    }

    public class Account
    {
        public int ID { get; set; }
        public double Balance { get; set; }
    }
}

Consulte também

Compartilhar via