¿Referenciar o no referenciar?

Si bien se han publicado diferentes ejemplos sobre la forma de gestionar las referencias de nuestras aplicaciones, yo nunca he con seguido que funcionen. Para mí es complicado entender que, si un código no se ejecuta por referencias, el propio código *que no puede ejecutarse* lo pueda corregir. Así que presento la solución que yo he aplicado.

En mis aplicaciones es muy usual que se interactúe con Excel por lo que, durante el desarrollo, es mucho más cómodo tener marcada la referencia de Excel para tener a mano los comandos con el IntelliSense  y las constantes.
El problema es la disparidad de versiones que Office que conviven y que los chicos de Microsoft han resuelto bastante bien la «subida» de referencias, pero en absoluto la «bajada».

Tabla de versiones
2007	12.0
2010	14.0
2013	15.0
2016	16.0

En los siguientes escenarios se marca la referencia en desarrollo y no se desmarca al enviar la aplicación al cliente.

Escenario 1
Desarrollamos en Office 2013
Cliente dispone de Office 2013 o 2016

Al enviar nuestra aplicación al cliente, aquellos PC’s con Office 2013 mantendrán la versión 15.0 de la librería; los que tuvieran 2016, «subirían» a 16.0

Escenario 2
Desarrollamos en Office 2016
Cliente dispone de Office 2013 o inferiores

Al enviar la aplicación al cliente, todos los PC’s mantendrán la versión 16.0 y, como ninguno de ellos la tiene instalada, obtendremos un error y no podremos ejecutar la aplicación.

Caso especial
Aplicaciones desarrolladas en versiones antiguas (97, 2000) que tienen referencias a otras aplicaciones Office de esas versiones (8.0, 9.0) no son capaces de «subir» la versión cuando se ejecutan en, por ejemplo, una versión 2010.

Así pues, podemos tener un problema entre la comodidad de programar con las referencias y la distribución de las aplicaciones.

Dado que tener todas las versiones de las librerías de Office se antoja complicado, la solución pasa por entregar la aplicación sin las referencias de Office. Para cambiar a trabajar sin referencias es necesario cambiar nuestra táctica de declaración. Lo que hasta ahora declarábamos como Excel.Application habrá que declararlo como Object. Ello nos privará del IntelliSense y del acceso a las constantes específicas de la aplicación Office que queramos utilizar.

¿Como solucionamos eso? Expongo mi técnica.

La técnica se basa en la utilización de directivas a nivel de compilador que, en función del valor, toman un camino u otro.

Imaginemos que queremos utilizar 2 constantes a nivel de directiva para definir si utilizamos las librerías de Excel y Outlook.

‘ Constante de utilización de librerías de Office
#Const UseOL_XLS = True
#Const UseOL_OLK = False

Como ha descubierto Tonny Sanjiao, el alcance de las constantes de compilación condicional es únicamente en el módulo dónde se declaran. Cuando se intenta acceder a cualquiera de ellas desde otro módulo, el valor obtenido es False. Nuestro gozo en un pozo. Una solución es replicar esa asignación de constantes en cada módulo dónde fuera necesario, pero estamos de acuerdo en que no es práctico.

Gracias a Javier Mendiburu hemos descubierto un artículo dónde se mencionaba justamente eso y se apuntaba una alternativa para definir constantes de compilación condicional utilizando la ventana de propiedades del proyecto que encontramos en el editor de VBA, Herramientas, propiedades. Ahí encontraremos un cuadro de texto dónde, separado por : podremos colocar los distintos valores de contantes de compilación condicional.

Así que nos olvidaríamos del código anterior y podríamos ir a esa ventana para definir las constantes:

UseOL_XLS = 1 : UseOL_OLK = 0

Primero observamos que no acepta valores True/False y que estos deben convertirse a enteros. Eso ya nos da una pista de que tampoco admitirá valores alfanuméricos (cosa que si admiten las declaraciones #Const dentro de VBA)

También nos obliga a que, cada vez que cambiamos un valor de esas condiciones, ir a esa pantalla y modificar ese valor.

Ahora que tenemos definidas las constantes en la ventana de propiedades las podemos utilizar para crear directivas #If

En este caso vamos a utilizar una variable Public para decidir qué tipo será la variable xlsApp en función de la constante condicional.
Nota: en mis aplicaciones acostumbro a utilizar un solo fichero de Excel cada vez por lo que no es necesario ir dimensionando en cada utilización.

#If UseOL_XLS Then
  Public xlsApp As Excel.Application
#Else
  Public xlsApp As Object
#End If

Este trocito de código dice que, si la constante condicional está establecida a true (<>0) significa que se utiliza la librería de Excel (ergo está referenciada) y cualquier instancia de xlsApp se declarará como Excel.Application. Si, por contra, la constante es False, se declara como Object. Se entiende, ¿no?

Si necesitara declarar otra instancia de Excel, utilizaría la misma técnica, pero dentro del procedimiento:

#If UseOL_XLS Then
  Dim xlsAppOtro As Excel.Application
#Else
  Dim xlsAppOtro As Object
#End If

Si durante la fase de desarrollo necesito acceder a las propiedades, métodos y constantes de Excel, simplemente marco la referencia y cambio la propiedad del proyecto de forma que puedo acceder a la librería.

¿Y las constantes específicas de la otra aplicación?
Pues para las constantes hay que ir manteniendo una lista en la zona #Else de manera que, cuando no tengamos marcada la librería, siga funcionando.

Ejemplos de constantes:

    Public Const xlVeryHidden = 2
    Public Const xlPrintNoComments = -4142
    Public Const xlLandscape = 2
    Public Const xlAutomatic = -4105
    Public Const xlDownThenOver = 1
    Public Const xlPrintErrorsDisplayed = 0
    Public Const xlDown = -4121
    Public Const xlUp = -4162
    Public Const xlLeft = -4159
    Public Const xlRight = -4161
    Public Const xlCenter = -4108
    Public Const xlBottom = -4107
    Public Const xlToLeft = -4159
    Public Const xlToRight = -4161
    Public Const xlEdgeLeft = 7
    Public Const xlEdgeTop = 8
    Public Const xlEdgeBottom = 9
    Public Const xlEdgeRight = 10
    Public Const xlInsideVertical = 11
    Public Const xlInsideHorizontal = 12
    Public Const xlContinuous = 1
    Public Const xlColorIndexAutomatic = -4105
    Public Const xlHairline = 1
    Public Const xlMedium = -4138
    Public Const xlThick = 4
    Public Const xlThin = 2

La precaución que debemos tener a la hora de programar es la de añadir cualquier nueva constante que utilicemos.

Pero ya sabéis que esto no puede quedar aquí y estaría bien que en alguna parte del código pudiéramos definir nuestras constantes y estas se salvaran en la hoja de propiedades.

Para ello tendremos las constantes declaradas de forma «normal». En este caso simplemente las llamaré como antes quitando la palabra Use

' Constante de utilización de librerías de Office
Const OL_XLS = True
Const OL_OLK = False

Cuando voy a desarrollar y necesito ambas librerías
– Marco las 2 referencias
– Lanzo una función como esta

Function SetCCC()
    Dim strCCC          As String

    strCCC = "UseOL_XLS = " & Abs(OL_XLS) & ":" _
            & "UseOL_OLK = " & Abs(OL_OLK)
    Application.SetOption "Conditional Compilation Arguments", strCCC
End Function

Con esa función se genera una cadena que toma los valores de las constantes «normales» (OL_XLS y OL_OLK) para crear una cadena que asignamos a la propiedad.

¿Y a la hora de distribuir?
Sencillo.
– Quitar la referencia de Excel
– Cambiar la constante OL_XLS a False
– Lanzar la función SetCCC para cambiar las directivas
– Compilar por si me hubiera dejado alguna constante no definida o alguna «cosa rara» en cuyo caso lo corregiría

Con esta forma de trabajar me he ahorrado tener un montón de «dobles declaraciones» y estar poniendo/quitando la adecuada:

Dim xlsApp As Excel.Application
'Dim xlsApp As Object

Truco: ¿Como mantengo mi lista de #constantes?
Yo lo tengo en un módulo independiente dónde, en el encabezado, consta la versión del módulo. Cada vez que añado una constante lo registro en el log de cambios y subo el número de versión. El módulo lo exporto a una determinada carpeta. Además, llevo un registro de versiones de todos los módulos en un Excel.

Cuando debo actualizar una aplicación, lo primero es revisar las versiones de los módulos por si tuviera versiones más actuales. Si el módulo de directivas de mi archivo es más moderno del de la aplicación, simplemente importo el nuevo módulo.

Espero que os sirva para «salvar» el problema de las referencias.

Artículo publicado originalmente el 27/07/2022 en Access de Xavi