Porady: uzyskiwanie dostępu do obiektów międzyoperacyjności pakietu Office za pomocą funkcji Visual C# (Przewodnik po programowaniu w języku C#)How to: Access Office Interop Objects by Using Visual C# Features (C# Programming Guide)

Wizualizacja C# zawiera funkcje, które upraszczają dostęp do obiektów interfejsu API pakietu Office.Visual C# has features that simplify access to Office API objects. Nowe funkcje obejmują argumenty nazwane i opcjonalne, nowy typ o nazwie dynamic i możliwość przekazywania argumentów do parametrów odwołań w metodach COM, tak jakby były parametrami wartości.The new features include named and optional arguments, a new type called dynamic, and the ability to pass arguments to reference parameters in COM methods as if they were value parameters.

W tym temacie zostaną użyte nowe funkcje do napisania kodu, który tworzy i wyświetla Microsoft Office arkusz programu Excel.In this topic you will use the new features to write code that creates and displays a Microsoft Office Excel worksheet. Następnie napiszesz kod, aby dodać dokument programu Office Word, który zawiera ikonę, która jest połączona z arkuszem programu Excel.You will then write code to add an Office Word document that contains an icon that is linked to the Excel worksheet.

Aby ukończyć ten przewodnik, musisz mieć Microsoft Office Excel 2007 i Microsoft Office Word 2007 lub nowszą wersję zainstalowanego na komputerze.To complete this walkthrough, you must have Microsoft Office Excel 2007 and Microsoft Office Word 2007, or later versions, installed on your computer.

Uwaga

Na komputerze w poniższych instrukcjach mogą być wyświetlane inne nazwy i lokalizacje niektórych elementów interfejsu użytkownika programu Visual Studio.Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. Te elementy są określane przez numer wersji Visual Studio oraz twoje ustawienia.The Visual Studio edition that you have and the settings that you use determine these elements. Aby uzyskać więcej informacji, zobacz personalizowanie środowiska IDE.For more information, see Personalizing the IDE.

Aby utworzyć nową aplikację konsolowąTo create a new console application

  1. Uruchom program Visual Studio.Start Visual Studio.

  2. W menu plik wskaż polecenie Nowy, a następnie kliknij pozycję projekt.On the File menu, point to New, and then click Project. Pojawi się okno dialogowe Nowy projekt .The New Project dialog box appears.

  3. W okienku zainstalowane szablony rozwiń pozycję Wizualizacja C# , a następnie kliknij pozycję Windows.In the Installed Templates pane, expand Visual C#, and then click Windows.

  4. Sprawdź u góry okna dialogowego Nowy projekt , aby upewnić się, że jako platforma docelowa została wybrana wersja .NET Framework 4 (lub nowsza).Look at the top of the New Project dialog box to make sure that .NET Framework 4 (or later version) is selected as a target framework.

  5. W okienku Szablony kliknij pozycję Aplikacja konsolowa.In the Templates pane, click Console Application.

  6. Wpisz nazwę projektu w polu Nazwa .Type a name for your project in the Name field.

  7. Kliknij przycisk OK.Click OK.

    Nowy projekt zostanie wyświetlony w Eksplorator rozwiązań.The new project appears in Solution Explorer.

Aby dodać odwołaniaTo add references

  1. W Eksplorator rozwiązańkliknij prawym przyciskiem myszy nazwę projektu, a następnie kliknij pozycję Dodaj odwołanie.In Solution Explorer, right-click your project's name and then click Add Reference. Zostanie wyświetlone okno dialogowe Dodawanie odwołania .The Add Reference dialog box appears.

  2. Na stronie zestawy wybierz pozycję Microsoft. Office. Interop. Word na liście Nazwa składnika , a następnie przytrzymaj naciśnięty klawisz Ctrl i wybierz pozycję Microsoft. Office. Interop. Excel.On the Assemblies page, select Microsoft.Office.Interop.Word in the Component Name list, and then hold down the CTRL key and select Microsoft.Office.Interop.Excel. Jeśli zestawy nie są widoczne, może być konieczne zagwarantowanie, że są one zainstalowane i wyświetlane.If you do not see the assemblies, you may need to ensure they are installed and displayed. Zobacz jak: Instalowanie podstawowych zestawów międzyoperacyjnych pakietu Office.See How to: Install Office Primary Interop Assemblies.

  3. Kliknij przycisk OK.Click OK.

Aby dodać wymagane dyrektywy usingTo add necessary using directives

  1. W Eksplorator rozwiązańkliknij prawym przyciskiem myszy plik program.cs , a następnie kliknij polecenie Wyświetl kod.In Solution Explorer, right-click the Program.cs file and then click View Code.

  2. Dodaj następujące dyrektywy using na początku pliku kodu:Add the following using directives to the top of the code file:

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

Aby utworzyć listę kont bankowychTo create a list of bank accounts

  1. Wklej następującą definicję klasy do program.cs, w obszarze klasy Program.Paste the following class definition into Program.cs, under the Program class.

    public class Account
    {
        public int ID { get; set; }
        public double Balance { get; set; }
    }
    
  2. Dodaj następujący kod do metody Main w celu utworzenia listy bankAccounts zawierającej dwa konta.Add the following code to the Main method to create a bankAccounts list that contains two accounts.

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

Aby zadeklarować metodę, która eksportuje informacje o koncie do programu ExcelTo declare a method that exports account information to Excel

  1. Dodaj następującą metodę do klasy Program, aby skonfigurować arkusz programu Excel.Add the following method to the Program class to set up an Excel worksheet.

    Metoda Add ma opcjonalny parametr służący do określania określonego szablonu.Method Add has an optional parameter for specifying a particular template. Parametry opcjonalne, nowość w C# 4, umożliwiają pominięcie argumentu dla tego parametru, jeśli ma być używana wartość domyślna parametru.Optional parameters, new in C# 4, enable you to omit the argument for that parameter if you want to use the parameter's default value. Ponieważ żaden argument nie jest wysyłany w poniższym kodzie, Add używa szablonu domyślnego i tworzy nowy skoroszyt.Because no argument is sent in the following code, Add uses the default template and creates a new workbook. Równoważna instrukcja we wcześniejszych wersjach programu C# wymaga argumentu symbolu zastępczego: ExcelApp.Workbooks.Add(Type.Missing).The equivalent statement in earlier versions of C# requires a placeholder argument: 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;
    }
    
  2. Dodaj następujący kod na końcu DisplayInExcel.Add the following code at the end of DisplayInExcel. Kod wstawia wartości do pierwszych dwóch kolumn pierwszego wiersza arkusza.The code inserts values into the first two columns of the first row of the worksheet.

    // Establish column headings in cells A1 and B1.
    workSheet.Cells[1, "A"] = "ID Number";
    workSheet.Cells[1, "B"] = "Current Balance";
    
  3. Dodaj następujący kod na końcu DisplayInExcel.Add the following code at the end of DisplayInExcel. Pętla foreach umieszcza informacje z listy kont w pierwszych dwóch kolumnach arkusza.The foreach loop puts the information from the list of accounts into the first two columns of successive rows of the worksheet.

    
    var row = 1;
    foreach (var acct in accounts)
    {
        row++;
        workSheet.Cells[row, "A"] = acct.ID;
        workSheet.Cells[row, "B"] = acct.Balance;
    }
    
  4. Dodaj następujący kod na końcu DisplayInExcel, aby dopasować szerokości kolumn w celu dopasowania do zawartości.Add the following code at the end of DisplayInExcel to adjust the column widths to fit the content.

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

    Wcześniejsze wersje programu C# wymagają jawnego rzutowania tych operacji, ponieważ ExcelApp.Columns[1] zwraca Object, a AutoFit to metoda Range programu Excel.Earlier versions of C# require explicit casting for these operations because ExcelApp.Columns[1] returns an Object, and AutoFit is an Excel Range method. W poniższych wierszach przedstawiono rzutowanie.The following lines show the casting.

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

    C#4 i nowsze wersje konwertuje zwracane Object do dynamic automatycznie, jeśli odwołanie do zestawu jest przywoływane przez opcję kompilatora -link lub, równoważne, jeśli właściwość " Osadź typy międzyoperacyjna programu Excel" ma wartość true.C# 4, and later versions, converts the returned Object to dynamic automatically if the assembly is referenced by the -link compiler option or, equivalently, if the Excel Embed Interop Types property is set to true. Wartość true jest wartością domyślną dla tej właściwości.True is the default value for this property.

Aby uruchomić projektTo run the project

  1. Dodaj następujący wiersz na końcu Main.Add the following line at the end of Main.

    // Display the list in an Excel spreadsheet.
    DisplayInExcel(bankAccounts);
    
  2. Naciśnij klawisze CTRL + F5.Press CTRL+F5.

    Zostanie wyświetlony arkusz programu Excel zawierający dane z dwóch kont.An Excel worksheet appears that contains the data from the two accounts.

Aby dodać dokument programu WordTo add a Word document

  1. Aby zilustrować dodatkowe sposoby, w których C# 4 i nowsze wersje rozszerzają Programowanie Office, poniższy kod otwiera aplikację Word i tworzy ikonę, która łączy się z arkuszem programu Excel.To illustrate additional ways in which C# 4, and later versions, enhances Office programming, the following code opens a Word application and creates an icon that links to the Excel worksheet.

    Wklej metodę CreateIconInWordDoc, która znajduje się w dalszej części tego kroku, do klasy Program.Paste method CreateIconInWordDoc, provided later in this step, into the Program class. CreateIconInWordDoc używa argumentów nazwanych i opcjonalnych w celu zmniejszenia złożoności wywołań metod do Add i PasteSpecial.CreateIconInWordDoc uses named and optional arguments to reduce the complexity of the method calls to Add and PasteSpecial. Te wywołania obejmują dwie inne nowe funkcje wprowadzone w C# 4, które upraszczają wywołania metod com, które mają parametry referencyjne.These calls incorporate two other new features introduced in C# 4 that simplify calls to COM methods that have reference parameters. Najpierw można wysłać argumenty do parametrów odwołania, tak jakby były one parametrami wartości.First, you can send arguments to the reference parameters as if they were value parameters. Oznacza to, że można wysyłać wartości bezpośrednio, bez tworzenia zmiennej dla każdego parametru odwołania.That is, you can send values directly, without creating a variable for each reference parameter. Kompilator generuje zmienne tymczasowe do przechowywania wartości argumentów i odrzuca zmienne po powrocie z wywołania.The compiler generates temporary variables to hold the argument values, and discards the variables when you return from the call. Następnie można pominąć słowo kluczowe ref na liście argumentów.Second, you can omit the ref keyword in the argument list.

    Metoda Add ma cztery parametry referencyjne, z których wszystkie są opcjonalne.The Add method has four reference parameters, all of which are optional. W C# 4,0 i nowszych wersjach można pominąć argumenty dla dowolnego lub wszystkich parametrów, jeśli chcesz użyć ich wartości domyślnych.In C# 4.0 and later versions, you can omit arguments for any or all of the parameters if you want to use their default values. W C# 3,0 i wcześniejszych wersjach argument musi być podany dla każdego parametru, a argument musi być zmienną, ponieważ parametry są parametrami odwołania.In C# 3.0 and earlier versions, an argument must be provided for each parameter, and the argument must be a variable because the parameters are reference parameters.

    Metoda PasteSpecial Wstawia zawartość schowka.The PasteSpecial method inserts the contents of the Clipboard. Metoda ma siedem parametrów referencyjnych, z których wszystkie są opcjonalne.The method has seven reference parameters, all of which are optional. Poniższy kod określa argumenty dla dwóch z nich: Link, aby utworzyć łącze do źródła zawartości Schowka, a DisplayAsIcon, aby wyświetlić łącze jako ikonę.The following code specifies arguments for two of them: Link, to create a link to the source of the Clipboard contents, and DisplayAsIcon, to display the link as an icon. W C# 4,0 i nowszych wersjach, można użyć nazwanych argumentów dla tych dwóch i pominąć pozostałe.In C# 4.0 and later versions, you can use named arguments for those two and omit the others. Chociaż są to parametry odwołania, nie trzeba używać słowa kluczowego ref ani do tworzenia zmiennych, które mają być wysyłane jako argumenty.Although these are reference parameters, you do not have to use the ref keyword, or to create variables to send in as arguments. Można wysłać wartości bezpośrednio.You can send the values directly. W C# 3,0 i wcześniejszych wersjach, należy podać zmienną argumentu dla każdego parametru odwołania.In C# 3.0 and earlier versions, you must supply a variable argument for each reference parameter.

    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# 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);
    }
    

    W C# 3,0 i wcześniejszych wersjach języka wymagany jest Poniższy kod złożony.In C# 3.0 and earlier versions of the language, the following more complex code is required.

    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);
    }
    
  2. Dodaj następującą instrukcję na końcu Main.Add the following statement at the end of Main.

    // Create a Word document that contains an icon that links to
    // the spreadsheet.
    CreateIconInWordDoc();
    
  3. Dodaj następującą instrukcję na końcu DisplayInExcel.Add the following statement at the end of DisplayInExcel. Metoda Copy dodaje arkusz do Schowka.The Copy method adds the worksheet to the Clipboard.

    // 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();
    
  4. Naciśnij klawisze CTRL + F5.Press CTRL+F5.

    Zostanie wyświetlony dokument programu Word zawierający ikonę.A Word document appears that contains an icon. Kliknij dwukrotnie ikonę, aby przenieść arkusz na pierwszy plan.Double-click the icon to bring the worksheet to the foreground.

Aby ustawić właściwość Osadź typy współdziałaniaTo set the Embed Interop Types property

  1. Dodatkowe ulepszenia są możliwe w przypadku wywołania typu COM, który nie wymaga podstawowego zestawu międzyoperacyjnego (PIA) w czasie wykonywania.Additional enhancements are possible when you call a COM type that does not require a primary interop assembly (PIA) at run time. Usunięcie zależności od zestawów Pia powoduje niezależność wersji i łatwiejsze wdrażanie.Removing the dependency on PIAs results in version independence and easier deployment. Aby uzyskać więcej informacji na temat korzyści z programowania bez zestawów Pia, zobacz Przewodnik: osadzanie typów z zarządzanych zestawów.For more information about the advantages of programming without PIAs, see Walkthrough: Embedding Types from Managed Assemblies.

    Ponadto programowanie jest łatwiejsze, ponieważ typy, które są wymagane i zwracane przez metody modelu COM mogą być reprezentowane przy użyciu typu dynamic, a nie Object.In addition, programming is easier because the types that are required and returned by COM methods can be represented by using the type dynamic instead of Object. Zmienne o typie dynamic nie są oceniane do czasu uruchomienia, co eliminuje konieczność jawnego rzutowania.Variables that have type dynamic are not evaluated until run time, which eliminates the need for explicit casting. Aby uzyskać więcej informacji, zobacz Korzystanie z typu dynamicznego.For more information, see Using Type dynamic.

    W C# 4, osadzanie informacji o typie zamiast używania zestawów PIA jest zachowaniem domyślnym.In C# 4, embedding type information instead of using PIAs is default behavior. Ze względu na to, że niektóre z powyższych przykładów są uproszczone, ponieważ jawne rzutowanie nie jest wymagane.Because of that default, several of the previous examples are simplified because explicit casting is not required. Na przykład deklaracja worksheet w DisplayInExcel jest zapisywana jako Excel._Worksheet workSheet = excelApp.ActiveSheet a nie Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet.For example, the declaration of worksheet in DisplayInExcel is written as Excel._Worksheet workSheet = excelApp.ActiveSheet rather than Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet. Wywołania AutoFit w tej samej metodzie również wymagają jawnego rzutowania bez użycia domyślnego, ponieważ ExcelApp.Columns[1] zwraca Object, a AutoFit jest metodą programu Excel.The calls to AutoFit in the same method also would require explicit casting without the default, because ExcelApp.Columns[1] returns an Object, and AutoFit is an Excel method. Poniższy kod przedstawia rzutowanie.The following code shows the casting.

    ((Excel.Range)workSheet.Columns[1]).AutoFit();
    ((Excel.Range)workSheet.Columns[2]).AutoFit();
    
  2. Aby zmienić wartość domyślną i użyć zestawów Pia zamiast osadzania informacji o typie, rozwiń węzeł odwołania w Eksplorator rozwiązań a następnie wybierz pozycję Microsoft. Office. Interop. Excel lub Microsoft. Office. Interop. Word.To change the default and use PIAs instead of embedding type information, expand the References node in Solution Explorer and then select Microsoft.Office.Interop.Excel or Microsoft.Office.Interop.Word.

  3. Jeśli nie widzisz okna Właściwości , naciśnij klawisz F4.If you cannot see the Properties window, press F4.

  4. Znajdź Osadź typy międzyoperacyjności na liście właściwości i zmień jej wartość na false.Find Embed Interop Types in the list of properties, and change its value to False. Analogicznie, można skompilować przy użyciu opcji kompilatora -Reference zamiast -link w wierszu polecenia.Equivalently, you can compile by using the -reference compiler option instead of -link at a command prompt.

Aby dodać dodatkowe formatowanie do tabeliTo add additional formatting to the table

  1. Zastąp dwa wywołania AutoFit w DisplayInExcel z następującą instrukcją.Replace the two calls to AutoFit in DisplayInExcel with the following statement.

    // Call to AutoFormat in Visual C# 2010.
    workSheet.Range["A1", "B3"].AutoFormat(
        Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
    

    Metoda AutoFormat ma siedem parametrów wartości, z których wszystkie są opcjonalne.The AutoFormat method has seven value parameters, all of which are optional. Argumenty nazwane i opcjonalne umożliwiają podanie argumentów dla braku, niektórych lub wszystkich z nich.Named and optional arguments enable you to provide arguments for none, some, or all of them. W poprzedniej instrukcji argument jest dostarczany tylko dla jednego z parametrów, Format.In the previous statement, an argument is supplied for only one of the parameters, Format. Ponieważ Format jest pierwszym parametrem na liście parametrów, nie trzeba podawać nazwy parametru.Because Format is the first parameter in the parameter list, you do not have to provide the parameter name. Jednak instrukcja może być łatwiejsza do zrozumienia, jeśli nazwa parametru jest uwzględniona, jak pokazano w poniższym kodzie.However, the statement might be easier to understand if the parameter name is included, as is shown in the following code.

    // Call to AutoFormat in Visual C# 2010.
    workSheet.Range["A1", "B3"].AutoFormat(Format:
        Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);
    
  2. Naciśnij klawisze CTRL + F5, aby zobaczyć wynik.Press CTRL+F5 to see the result. Inne formaty są wymienione w wyliczeniu XlRangeAutoFormat.Other formats are listed in the XlRangeAutoFormat enumeration.

  3. Porównaj instrukcję w kroku 1 z poniższym kodem, który pokazuje argumenty wymagane w C# 3,0 i wcześniejszych wersjach.Compare the statement in step 1 with the following code, which shows the arguments that are required in C# 3.0 and earlier versions.

    // 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);
    

PrzykładExample

Poniższy kod przedstawia kompletny przykład.The following code shows the complete example.

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#. 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# 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; }
    }
}

Zobacz takżeSee also