ExpressionControl: Control personalizado para elementos de trabajo de Team Foundation Server

Acabo de publicar en The Code Project un artículo en el que presento un control personalizado para elementos de trabajo de Team Foundation Server. Se trata de un cuadro de texto que tiene asociada una expresión (una fórmula, vamos) en la que pueden tomar parte los campos del elemento de trabajo. Cuando uno de los campos cambia, el valor del campo se recalcula automáticamente:



Si te interesa, aquí puedes echarle un ojo: Expression Control for TFS Work Items

Recursos incrustados y propiedades extendidas

Los recursos incrustados (embedded resources in inglish) son un mecanismo que nos permite incluir ficheros dentro de un ensamblado. Constituyen una forma limpia y eficaz de distribuir ficheros con una aplicación, cuando no queremos que dichos ficheros pululen por el directorio de la aplicación y puedan por tanto ser chafardeados por los juanquercillos de turno (deberán ser juanquers de cierta categoría si quieren ver algo).

Incluir recursos incrustados desde Visual Studio 2005 es muy sencillo: basta agregar (o crear) los ficheros deseados en el proyecto, abrir la ventana de propiedades de los mismos, y en Acción de generación seleccionar Recurso incrustado. Para recuperar estos ficheros una vez generado el ensamblado, viene al rescate la clase Assembly, en concreto sus métodos GetManifestResourceNames y GetManifestResourceStream.

Veamos un ejemplo. Tomemos un proyecto chorra tal que este:


Supongamos que queremos que todo lo que hay bajo el directorio DatabaseChangeScripts se almacene en el ensamblado como recursos incrustados. No tenemos más que seleccionar todos los ficheros (ya sabes, Shift o Ctrl y clics a discteción), botón derecho, propiedades y:


El siguiente código muestra cómo obtener la lista de todos los recursos incrustados del ensamblado:

Si copias este código en el método Main de Program.cs, al ejecutar el proyecto desde el propio Visual Studio verás lo siguiente en la ventana de resultados:


Fíjate en el interesante detalle de que la jerarquía de carpetas se mantiene en el nombre del recurso. Esto da pie a numerosas e interesantes piruladas, como la que os voy a mostrar ahora. Pero antes, veamos cómo recuperar el contenido de un recurso incrustado una vez conocido su nombre:

En este caso, suponemos que el recurso en cuestión es un fichero de texto, por tanto ponemos su contenido en una cadena.

Pues bien, una estructura como la del ejemplo es la que yo uso para mantener un control de versiones en la base de datos que usan las aplicaciones en las que trabajo. Cada vez que necesito hacer un cambio con respecto a la estructura que tiene la base de datos ya instalada al cliente, creo una nueva carpeta de versión y pongo dentro todas las secuencias de comandos SQL necesarias para la actualización. Al inicio de la aplicación compruebo la versión de la base de datos, y si no es la última, leo las secuencias de comandos incrustadas y las ejecuto, tras lo cual actualizo el número de versión de la base de datos (por supuesto, todo con las pertinentes transacciones de por medio, de forma que nunca queden actualizaciones a medias).

Para guardar el número de versión en la base de datos uso una propiedad extendida. Las propiedades extendidas de SQL Server son atributos globales a nivel de base de datos, no dependen de ninguna tabla ni procedimiento almacenado y constan de un nombre y un valor (en realidad ambién es posible establecer propiedades extendidas para otros objetos, no sólo para las propias bases de datos).

Para crear una propiedad extendida hay que usar el siguiente procedimiento almacenado del sistema (el nombre y el valor son ejemplos):

Para borrar una propiedad extendida existente:

Para modificar el valor de una propiedad extendida:

Finalmente, para consultar el valor de una propiedad extendida:

Si tienes el SQL Server Management Studio, también puedes controlar las propiedades extendidas visualmente, mediante la ventana de propiedades de la base de datos:


Pues hala, dada la tremenda utilidad de los recursos incrustados, incrustaos bien esta parrafada en el cerebro (¿lo pillais? ¿Lo pillais? Bueno, al menos no me pegueis muy fuerte...)

Fragmentos de código

Visual Studio 2005 proporciona un mecanismo útil para insertar rápidamente esos pequeños trozos de código que usamos una y otra vez. El mecanismo se llama, precisamente, fragmentos de código (en inglés Code Snippets).

Un fragmento de código se almacena como un fichero XML y consiste en una porción de código fijo con algunos campos variables. Cada fragmento tiene un nombre corto que sirve para invocarlo desde el editor de Visual Studio: basta escribir el nombre del fragmento y pulsar TAB. Todo el código del fragmento aparecerá ante nuestros ojos como por arte de birlibirloque, y podremos movernos entre los campos editables con la tecla TAB. Cuando lo hayamos editado todo a nuestra conveniencia, bastará pulsar ENTER y seguir programando como si nada hubiera pasado.

Haz la prueba. Desde el editor de código de C#, escribe prop y pulsa TAB. Aparecerá tal que esto:


prop es uno de los fragmentos que Visual Studio incorpora de fábrica, y permite añadir propiedades con un campo privado de respaldo (lo cual debe hacerse siempre en vez de usar campos públicos, como todo programador educado sabe). Por supuesto, la gracia del asunto consiste en que puedes definir tus propios fragmentos y añadirlos al arsenal (menú Herramientas - Administrador de fragmentos de código).

Por ejemplo, para mi quehacer diario he creado un fragmento llamado propt basándome en el prop existente. Los cambios son dos: establece como nombre del campo de respaldo el mismo que el de la propiedad, con un carácter de subrayado delante; y añade un boceto de comentario XML. La invocación de propt genera lo siguiente:


Y por si os interesa, teneis el código del fragmento aquí mismo: podeis descargarlo e importarlo desde Visual Studio.

Más información sobre el tema en la web del tito Puertas.