Si desarrollamos una aplicación con .NET que se comercializa en distintas ediciones (por ejemplo Standard y Professional), cada una de las cuales ofrece diferentes capacidades/características y diferentes precios, es interesante poder generar físicamente distintos .exe o .dll para cada edición. Por ejemplo, MiSuperApp-Standard.exe y MiSuperApp-PRO.exe.

Una opción muy poco apropiada es mantener dos proyectos diferentes para cada edición, o dos ramas en Git para gestionarlas.

Otra buena opción si no tenemos demasiadas ediciones distintas es la de crear diferentes configuraciones de compilación para poder generar físicamente ensamblados diferentes en cada caso.

Por defecto, cuando creamos un proyecto en Visual Studio solo tenemos dos configuraciones hechas: Debug y Release, que utilizamos respectivamente para desarrollar/depurar la aplicación y generar la versión que vamos a distribuir:

Lo primero que vamos a hacer es disponer de diferentes configuraciones para las diferentes ediciones. Para ello  pulsamos en la opción "Configuration Manager..." del menú de la figura anterior y nos aparecerá una ventana con la gestión de las configuraciones. Creamos una nueva configuración para cada edición de nuestro producto, tal y como muestro en esta animación:

En nuestro ejemplo creamos dos llamados "Standard" (que se ve en la animación anterior) y "Professional". Además eliminamos "Release" ya que no la necesitaremos y las otras dos las hemos copiado de ésta:

Ahora que ya tenemos las configuraciones, lo siguiente que debemos hacer es crear símbolos de compilación condicionada para dichas configuraciones. Esto nos va a permitir posteriormente incluir instrucciones para el compilador de modo que podamos excluir o incluir ciertos fragmentos de código dentro del ensamblado final (.exe o .dll que generemos).

Crear estos símbolos es muy sencillo. Solo es necesario pulsar con el botón derecho sobre el proyecto en el "Explorador de Soluciones" de Visual Studio e irnos a la pestaña "Build". En el desplegable de Configuración elegimos cada uno de las configuraciones nuevas que hemos creado y en el primer cuadro de texto escribimos, en mayúsculas preferiblemente, un nombre sencillo y corto con el que identificar cada una de ellas a la hora de compilar, por ejemplo, en nuestro caso hipotético "STD" y PRO", grabando a continuación. Lo vemos mejor en este mini-vídeo:

Ahora ya tenemos casi todo lo que necesitamos. Vamos a tocar nuestra súper-sencilla aplicación de ejemplo para que muestre por consola algo diferente en función de la configuración. Para ello haremos uso de pragmas condicionales de compilación, que nos permiten tomar decisiones en función de ciertas condiciones. Son líneas especiales que comienzan con una almohadilla. Por ejemplo, podemos escribir:

#if STD
//Código que sea...
#endif

y lo que está entre estos dos "pragmas" solo se compilará en caso de que se cumpla la condición: en este caso solo si estamos en el modo de configuración "Standard", ya que STD es el símbolo que hemos definido para este caso.

También podemos usar un #else:

#if STD
//Código que sea...
#else
//Código en caso de que no se cumpla
#endif

 En nuestro ejemplo podemos verlo en el siguiente vídeo corto:

Con esto ya tenemos mucho andado y conocemos lo básico de trabajar de esta manera.

De todos modos me gustaría comentar algo más que no es tan común:

Cómo generar un .exe o .dll de nombre diferente según la configuración

Puede que nos interese hacer esto y que, en el caso de nuestra hipotética aplicación de ejemplo, se llame de modo diferente según si es la edición estándar o la profesional, por ejemplo: MiApp-STD.exe y MiApp-PRO.exe respectivamente.

Para lograr esto no nos queda más remedio (al menos que yo sepa) que tocar directamente el archivo del proyecto de Visual Studio, es decir, el .csproj que tiene la información sobre el mismo.

Para ello debes cerrar el proyecto en Visual Studio, localizar el archivo .csproj, y abrirlo usando algún editor de texto (el propio Bloc de notas te vale, aunque yo prefiero usar Notepad++ que es mucho mejor y reconoce el archivo correctamente). Una vez abierto debes localizar los nodos <PropertyGroup> de cada una de tus configuraciones y añadirle un nuevo sub-nodo llamado <AssemblyName> que sirve para especificar el nombre exacto que queremos para el ejecutable o DLL final. Indicamos ahí el nombre que queramos, vamos a verlo:

Ahora ya podemos abrir el proyecto de nuevo y compilarlo usando las diferentes configuraciones. Obtendremos un ejecutable diferente según las indicaciones que hemos dado, con el nombre que nos interese. Veámoslo en un último vídeo corto:

Como podemos comprobar obtenemos exactamente lo que buscábamos.

Te dejo el proyecto de ejemplo en un ZIP (5 KB) para que puedas probarlo. Cambia la configuración del proyecto y genera el ejecutable correspondiente para poder probarlo.

¡Espero que te sea útil!

¿Este post te ha ayudado?, ¿has aprendido algo nuevo?
Pues NO te pido que me invites a un café... Te pido algo más fácil y que te hará sentir mejor