Tutorial: Programación de Office (C# y Visual Basic)

Artículo
06/10/2015

Visual Studio 2010 presenta características nuevas en C# y Visual Basic que mejoran la programación de Microsoft Office. Cada lenguaje ha agregado características que ya existen en el otro idioma.

Entre las nuevas características de C# se incluyen argumentos opcionales y con nombre, valores devueltos de tipo dynamic y, en la programación COM, la capacidad para omitir la palabra clave ref y tener acceso a las propiedades indizadas. Entre las nuevas características de Visual Basic se incluyen propiedades implementadas automáticamente, instrucciones de expresiones lambda e inicializadores de colección.

En ambos lenguajes se puede insertar información de tipo, lo que permite la implementación de ensamblados que interactúan con componentes COM sin necesidad de implementar ensamblados de interoperabilidad primarios (PIA) en el equipo del usuario. Para obtener más información, vea Tutorial: Incrustar los tipos de los ensamblados administrados (C# y Visual Basic).

Este tutorial muestra las nuevas características en el contexto de la programación de Office, pero muchas de ellas también son útiles en programación general. En el tutorial, se utilizará primero una aplicación complemento de Excel para crear un libro de Excel. Después se creará un documento de Word que contiene un vínculo al libro. Por último, se verá cómo se puede activar y desactivar la dependencia de un PIA.

Requisitos previos

Debe tener Microsoft Office Excel 2013 (o la versión 2007 o posterior) y Microsoft Office Word 2013 (o la versión 2007 o posterior) instalados en el equipo para poder completar este tutorial.

Si usa un sistema operativo anterior a Windows Vista, asegúrese de que .NET Framework 2,0 esté instalado.

Nota
Es posible que tu equipo muestre nombres o ubicaciones diferentes para algunos de los elementos de la interfaz de usuario de Visual Studio en las siguientes instrucciones. La edición de Visual Studio que se tenga y la configuración que se utilice determinan estos elementos. Para obtener más información, consulte Personalizar la configuración de desarrollo en Visual Studio.

Para configurar una aplicación complemento de Excel

Inicie Visual Studio.
En el menú Archivo, elija Nuevo y haga clic en Proyecto.
En el panel Plantillas instaladas, expanda Visual Basic o Visual C#, expanda Office y luego haga clic en 2013 (o 2010 o 2007).
En el panel Plantillas, haga clic en Complemento de Excel 2013 (o Complemento de Excel 2010 o Complemento de Excel 2007).
En la parte superior del panel Plantillas, asegúrese de que .NET Framework 4 o una versión posterior aparece en el cuadro Marco de trabajo de destino.
Si lo desea, escriba un nombre para el proyecto en el cuadro Nombre.
Haga clic en Aceptar.
El proyecto nuevo aparece en el Explorador de soluciones.

Para agregar referencias

En el Explorador de soluciones, haga clic con el botón secundario en el nombre del proyecto y seleccione Agregar referencia. Aparecerá el cuadro de diálogo Agregar referencia.
En la pestaña Ensamblados, seleccione Microsoft.Office.Interop.Excel, versión 15.0.0.0 (o versión 14.0.0.0 para Excel 2010 o versión 12.0.0.0 para Excel 2007) en la lista Nombre de componente, mantenga presionada la tecla CTRL y seleccione Microsoft.Office.Interop.Word, versión 15.0.0.0 (o versión 14.0.0.0 para Word 2010 o 12.0.0.0 para Word 2007). Si no ve los ensamblados, asegúrese de que están instalados y que se muestran (vea Cómo: Instalar ensamblados de interoperabilidad primarios de Office).
Haga clic en Aceptar.

Para agregar las instrucciones Imports necesarias o las directivas using

En el Explorador de soluciones, haga clic con el botón secundario en el archivo ThisAddIn.vb o ThisAddIn.cs y, a continuación, haga clic en Ver código.

Agregue las siguientes instrucciones Imports (Visual Basic) o directivas using (C#) en la parte superior del archivo de código si no están presentes.

Imports Microsoft.Office.Interop

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

Para crear una lista de las cuentas bancarias

En el Explorador de soluciones, haga clic con el botón secundario en el nombre del proyecto, haga clic en Agregar y, a continuación, haga clic en Clase. Denomine la clase Account.vb si está utilizando Visual Basic o Account.cs si está utilizando C#. Haga clic en Agregar.
Reemplace la definición de la clase Account por el código siguiente. Las definiciones de clase usan propiedades autoimplementadas, lo que supone una novedad para Visual Basic en Visual Studio 2010. Para obtener más información, vea Propiedades implementadas automáticamente (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 crear una lista bankAccounts que contenga dos cuentas, agregue el código siguiente al método ThisAddIn_Startup en ThisAddIn.vb o ThisAddIn.cs. Las declaraciones de lista usan inicializadores de colección, lo que supone una novedad para Visual Basic en Visual Studio 2010. Para obtener más información, vea Inicializadores de colección (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 datos a Excel

En el mismo archivo, agregue el siguiente método a la clase ThisAddIn. El método configura un libro de Excel, a donde exporta los datos.
```
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();
}
```
En este método se utilizan dos características de C# nuevas. Ambas características ya existen en Visual Basic.
- El método Add tiene un parámetro opcional para especificar una plantilla determinada. Los parámetros opcionales introducidos en Visual C# 2010 permiten omitir el argumento para ese parámetro si se desea utilizar el valor predeterminado del parámetro. Dado que en el ejemplo anterior no se envía ningún argumento, Add usa la plantilla predeterminada y crea un libro nuevo. La instrucción equivalente en versiones anteriores de C# requiere un argumento de marcador de posición: excelApp.Workbooks.Add(Type.Missing).
  
  Para obtener más información, vea Argumentos opcionales y con nombre (Guía de programación de C#).
- Las propiedades Range y Offset del objeto Range usan la característica de propiedades indizadas. Esta característica permite utilizar estas propiedades de los tipos COM mediante la siguiente sintaxis típica de C#. Las propiedades indizadas también permiten utilizar la propiedad Value del objeto Range, eliminando la necesidad de utilizar la propiedad Value2. La propiedad Value está indizada, pero el índice es opcional. Los argumentos opcionales y las propiedades indizadas funcionan conjuntamente en el ejemplo siguiente.
```
// Visual C# 2010 provides indexed properties for COM programming.
excelApp.Range["A1"].Value = "ID";
excelApp.ActiveCell.Offset[1, 0].Select();
```
  En las versiones anteriores del lenguaje, se requiere la siguiente sintaxis especial.
```
// 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();
```
  No es posible crear propiedades indizadas propias. La característica solo admite el uso de las propiedades indizadas existentes.
  
  Para obtener más información, vea Cómo: Utilizar propiedades indizadas en la programación de interoperabilidad COM (Guía de programación de C#).
Agregue el código siguiente al final de DisplayInExcel para ajustar los anchos de columna a fin de adaptarlos al contenido.
```
' 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();
```
Estas adiciones muestran otra característica nueva de C# 2010: el tratamiento de valores Object devueltos por hosts COM (como Office) como si tuvieran un tipo dinámico. Esto sucede automáticamente cuando Incrustar tipos de interoperabilidad se establece en su valor predeterminado True o, de igual modo, cuando la opción del compilador /link hace referencia al ensamblado. El tipo dynamic permite el enlace en tiempo de ejecución, ya disponible en Visual Basic, y evita la conversión explícita que se requiere en Visual C# 2008 y versiones anteriores del lenguaje.

Por ejemplo, excelApp.Columns[1] devuelve un Object y AutoFit es un método Range de Excel. Sin dynamic, debe convertir el objeto devuelto por excelApp.Columns[1] como una instancia de Range antes de llamar al 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 obtener más información sobre cómo insertar tipos de interoperabilidad, consulte los procedimientos “Para buscar la referencia a un PIA” y “Para restaurar la dependencia de un PIA” más adelante en este tema. Para obtener más información sobre dynamic, vea dynamic (Referencia de C#) o Uso de tipo dinámico (Guía de programación de C#).

Para invocar DisplayInExcel

Agregue el código siguiente al final del método ThisAddIn_StartUp. La llamada a DisplayInExcel contiene dos argumentos. El primer argumento es el nombre de la lista de cuentas que se va a procesar. El segundo argumento es una expresión lambda de varias líneas que define cómo se procesarán los datos. Los valores ID y balance de cada cuenta se muestran en las celdas adyacentes y la fila se muestra en rojo si el saldo es inferior a cero. Las expresiones lambda de varias líneas son una característica nueva en Visual Basic 2010. Para obtener más información, vea Lambda (expresiones) (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;
    }
});

Presione F5 para ejecutar el programa. Aparece una hoja de cálculo de Excel que contiene los datos de las cuentas.

Para agregar un documento de Word

Agregue el código siguiente al final del método ThisAddIn_StartUp para crear un documento de Word que contenga un vínculo al libro de 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);
```
Este código muestra algunas de las nuevas características de C#: capacidad para omitir la palabra clave ref en programación COM, argumentos con nombre y argumentos opcionales. Estas características ya existen en Visual Basic. El método PasteSpecial tiene siete parámetros, y todos se definen como parámetros de referencia opcional. Antes de Visual C# 2010, había que definir variables de objeto para utilizar como argumentos de los siete parámetros, incluso cuando no se tenía ningún valor significativo para enviarles. Los argumentos opcionales y con nombre permiten designar los parámetros a los que se desea tener acceso por nombre, y enviar argumentos únicamente a esos parámetros. En este ejemplo se envían argumentos para indicar que se debe crear un vínculo al libro en el Portapapeles (parámetro Link), y que el vínculo se mostrará en el documento de Word como un icono (parámetro DisplayAsIcon). Visual C# 2010 también permite omitir la palabra clave ref para estos argumentos. Compare el siguiente segmento de código de Visual C# 2008 con la única línea necesaria en 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 ejecutar la aplicación

Presione F5 para ejecutar la aplicación. Excel se abre y muestra una tabla que contiene la información de las dos cuentas de bankAccounts. Entonces aparece un documento de Word que contiene un vínculo a la tabla de Excel.

Para limpiar el proyecto completado

En Visual Studio, haga clic en Limpiar solución en el menú Compilación. De lo contrario, el complemento se ejecutará cada vez que abra Excel en el equipo.

Para buscar la referencia a un PIA

Ejecute de nuevo la aplicación, pero no haga clic en Limpiar solución.
En el menú Inicio, haga clic en Todos los programas. A continuación, haga clic en Microsoft Visual Studio 2013, después en Visual Studio Tools y luego en Símbolo del sistema de Visual Studio (2013).
Escriba ildasm en la ventana del símbolo del sistema de Visual Studio (2013) y después presione ENTRAR. Aparecerá la ventana IL DASM.
En el menú Archivo de la ventana de IL DASM, haga clic en Abrir. Haga doble clic en Visual Studio 2013 y luego haga doble clic en Proyectos. Abra la carpeta de su proyecto y, en la carpeta bin/Debug, busque su_proyecto.dll. Haga doble clic en su_proyecto.dll. Una nueva ventana muestra los atributos del proyecto, además de las referencias a otros módulos y ensamblados. Tenga en cuenta que los espacios de nombres Microsoft.Office.Interop.Excel y Microsoft.Office.Interop.Word se incluyen en el ensamblado. De forma predeterminada en Visual Studio 2013, el compilador importa los tipos necesarios desde un PIA con referencia a su ensamblado.

Para obtener más información, vea Cómo: Ver el contenido de un ensamblado.

Haga doble clic en el icono MANIFIESTO. Aparecerá una ventana con una lista de ensamblados que contienen los elementos a los que hace referencia el proyecto. Microsoft.Office.Interop.Excel y Microsoft.Office.Interop.Word no están incluidos en la lista. Dado que los tipos que su proyecto necesita se han importado en el ensamblado, las referencias a un PIA no son necesarias. Esto facilita la implementación. Los PIA no tienen que estar presentes en el equipo del usuario y, puesto que una aplicación no requiere la implementación de una versión concreta de un PIA, se pueden diseñar aplicaciones que trabajen con varias versiones de Office, siempre que las API necesarias existan en todas las versiones.

Dado que la implementación de los PIA ya no es necesaria, puede crear una aplicación en escenarios avanzados que funcione con varias versiones de Office, incluidas versiones anteriores. Sin embargo, esto solo funciona si el código no utiliza ninguna API que no esté disponible en la versión de Office con la que está trabajando. No siempre está claro si una API concreta estaba disponible en una versión anterior y por ese motivo no recomendamos trabajar con versiones anteriores de Office.

Nota
Office no publicó ensamblados PIA antes de Office 2003.Por lo tanto, la única manera de generar un ensamblado de interoperabilidad para Office 2002 o versiones anteriores es mediante la importación de la referencia COM.

Cierre la ventana del manifiesto y la del ensamblado.

Para restaurar la dependencia de un PIA

En el Explorador de soluciones, haga clic en el botón Mostrar todos los archivos. Expanda la carpeta Referencias y seleccione Microsoft.Office.Interop.Excel. Presione F4 para que se muestre la ventana Propiedades.
En la ventana Propiedades, cambie la propiedad Incrustar tipos de interoperabilidad de True a False.
Repita los pasos 1 y 2 de este procedimiento para Microsoft.Office.Interop.Word.
En C#, marque como comentario las dos llamadas a Autofit al final del método DisplayInExcel.
Presione F5 para comprobar que el proyecto sigue ejecutándose correctamente.
Repita los pasos 1 a 3 del procedimiento anterior para abrir la ventana de ensamblado. Observe que Microsoft.Office.Interop.Word y Microsoft.Office.Interop.Excel ya no están en la lista de ensamblados insertados.
Haga doble clic en el icono MANIFIESTO y desplácese por la lista de ensamblados de referencia. Tanto Microsoft.Office.Interop.Word como Microsoft.Office.Interop.Excel están en la lista. Dado que la aplicación hace referencia a los PIA de Excel y Word y la propiedad Incrustar tipos de interoperabilidad se establece en False, ambos ensamblados deben existir en el equipo del usuario final.
En Visual Studio, haga clic en Limpiar solución en el menú Compilación para limpiar el proyecto completado.

Vea también

Compartir a través de