El Bruno

Buenas,

para cerrar una semana un tanto especial, hoy toca mostrar como crear un DataCollector personalizado, para agregar información extra al resultado de un set de pruebas de Visual Studio 2010. El gran Shai (ojo con la foto del header de su blog) explica un paso a paso detallado aquí. En el ejemplo de este post, crearé un DataCollector que agrega información muy importante al resultado de un proceso de test: el estado de mi página de Twitter @elbruno.

Para esto, me he basado en el siguiente código, que me permite descargar el contenido de una URI a un archivo temporal local, donde la función GetElBrunoTwitterInformation(), retorna la ubicación de un archivo temporal con el contenido de http://twitter.com/elbruno.

   public class TwitterInfo
    {
        public string GetElBrunoTwitterInformation()
        {
            // generate temp file
            var fileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".htm");
            if (File.Exists(fileName))
                File.Delete(fileName);

            // save local file
            GetUrl(new Uri(@"http://twitter.com/elbruno"), fileName);
            return fileName;
        }


        private bool GetUrl(Uri uri, string localFileName)
        {
            var ret = false;
            var request = WebRequest.Create(uri) as HttpWebRequest;
            var response = request.GetResponse() as HttpWebResponse;
            try
            {
                // Hope GetEncoding() knows how to parse the CharacterSet
                var encoding = Encoding.GetEncoding(response.CharacterSet);
                var reader = new StreamReader(response.GetResponseStream(), encoding);
                using (var sw = new StreamWriter(localFileName, false, encoding))
                {
                    sw.Write(reader.ReadToEnd());
                    sw.Flush();
                    sw.Close();
                    ret = true;
                }
            }
            catch
            {
                ret = false;
            }
            finally
            {
                response.Close();
            }
            return ret;
        }
    }

Ahora a crear el DataCollector, para esto agregamos las siguientes referencias:

• Microsoft.VisualStudio.QualityTools.Common
  C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.VisualStudio.QualityTools.Common.dll
• Microsoft.VisualStudio.QualityTools.ExecutionCommon
  C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.VisualStudio.QualityTools.ExecutionCommon.dll

y heredamos de DataCollector. En mi caso particular, además he decorado la clase para indicar la URI y descripción del DataCollector.

    [DataCollectorTypeUri("datacollector://ElBruno/TwitterCollector/1.0")]
    [DataCollectorFriendlyName("El Bruno Twitter Collector")]
    public class TwitterCollector : DataCollector
    {
        private DataCollectionSink _sink;

        public override void Initialize(XmlElement configurationElement, DataCollectionEvents events, DataCollectionSink sink, DataCollectionLogger logger, DataCollectionEnvironmentContext environmentContext)
        {
            _sink = sink;
            // suscribe to test run session end
            events.SessionEnd += EventsSessionEnd;
        }

        private void EventsSessionEnd(object sender, SessionEndEventArgs e)
        {
            // add file
            var file = new TwitterInfo().GetElBrunoTwitterInformation();
            _sink.SendFileAsync(e.Context, file, string.Format(@"ElBruno Twitter Homepage -> {0}", DateTime.Now), false);
        }
    }

El punto de entrada es DataCollector.Initialize(), ya que en este punto podemos:

• acceder a la configuración del test
• trabajar con la colección de eventos propios de la ejecución de un test
• trabajar con la colección de archivos relacionados con la ejecución de un test
• acceder al contexto de ejecución del test

En este ejemplo, he creado una suscripción al evento SessionEnd(), y en el mismo agrego como un archivo adjunto al test un htm con el contenido de http://twitter.com/elbruno.

Aclaración: ya lo sé, solo en muy pocas ocasiones esto será necesario, pero bueno, es un ejemplo.

Una vez compilado el ensamblado, debemos copiar el mismo al directorio de DataCollectors de Visual Studio 2010, por lo general es:

C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\DataCollectors\

A partir de este momento, en la configuración de la ejecución de tests, en la sección [Data and Diagnostics]; podremos ver un nuevo adaptador llamado [El Bruno Twitter Collector]

Si activamos el mismo, y lanzamos la ejecución de uno o más tests, podremos ver que una vez que han pasado los mismos, en el link [Test run completed] hay información adicional agregada:

En la ventana de resultados de tests, en la sección [Collected Files], hay adjunto un archivo (con nombre de GUID) que posee el contenido de http://twitter.com/elbruno, con su descripción correspondiente:

Para finalizar, si accedemos a la ubicación de resultados de tests en el disco local (tengo un post pendiente al respecto), podremos ver el archivo htm generado al final de la sessión de ejecución de test:

Y claro, que placer más grande que nos da, poder abrir el htm :D

Descarga el código de ejemplo si puedes que hoy skydrive está como está en: http://cid-bef06dffdb192125.office.live.com/self.aspx/Code%20Samples/2010%2007%2030%20Custom%20DataCollector.zip

Saludos @ Here

El Bruno

Referencias:

• http://msdn.microsoft.com/es-es/library/dd286737.aspx
• http://msdn.microsoft.com/es-es/library/microsoft.visualstudio.testtools.execution.datacollector.initialize.aspx

Buenas,

hace un rato el amigo Alfredo me preguntó si era posible conocer las variables de entorno (environment variables) con las que estaba trabajando Visual Studio 2010. La respuesta es rápida, ya que como el panel Command Window, permite trabajar con .Net puro y duro, pues a utilizar System.Environment.GetEnvironmentVariables(). La siguiente imagen, muestra un ejemplo de esta función en ejecución en el IDE:

Pero claro, seguro que lanzaste el IDE y después de copiar y pegar el comando, te encontraste con un error como este:

¿La solución? –> Carga un proyecto que te de acceso a “lo mínimo” del IDE -> jejeje

Saludos @ Here

El Bruno

Buenas,

como hoy es casi viernes (es martes), me apunto un pequeño tip que uso hace tiempo, pero que nunca he posteado:

Cómo lanzar una build en TFS2008 desde la línea de comandos.

Si necesitamos lanzar builds frecuentemente en TFS2008, la opción del IDE de Visual Studio 2008, puede llegar a ser un poco tediosa. Ojo, esto si entendemos “tedioso”, a una acción que involucra los siguientes pasos:

1. Acceder al panel Team Explorer

2. Acceder al Team Project con el que deseamos trabajar (por ejemplo, TPDemo)

3. Acceder al nodo [Builds]

4. Seleccionar la Build que deseamos lanzar (por ejemplo BuildDemo)

5. Desplegar el menú contextual

6. Seleccionar la opción [Queue new Build]

7. Completar la información de la build (si es necesario).

8. Done !!!

Pues a todos estos pasos los podemos reemplazar por una única llamada desde la línea de comandos con el siguiente formato:

TFSBuild start http://TfsServer:8080 TeamProject BuildDefinition

Donde para el ejemplo anterior, podría ser algo similar a lo siguiente:

TFSBuild start http://TfsServer:8080 TPDemo BuildDemo

Esto en un bat, puede darnos muchas alegrias :D

Saludos @ Here

El Bruno

Referencia: http://msdn.microsoft.com/en-us/library/aa337631%28VS.90%29.aspx

Buenas,

hace unos minutos Jose (@jfroma) me preguntó por Twitter:

@elbruno existe alguna forma de subscribirse por mail, a todos los issues de un proyecto especifico? aun si no esta asignado a mi. Gracias

La respuesta en modo Twitter es:

@jfroma Instalar TFSPower Tools http://bit.ly/cJOxSR –> Menu [Team/Alerts Explorer] –> Done !!!

Aunque claro, mejor un pequeño paso a paso.

Tutorial

1. Instalar Team Foundation Server Power Tools http://bit.ly/cJOxSR 

2. En el IDE de Visual Studio 2010, acceder al menú [Team // Alerts Explorer]

3. Una vez dentro del Alert Explorer, crear una nueva alerta con [New Alert]

4. Seleccionar [WorkItems // Blank Alert]

5. Definir un nombre para la alerta, en este caso [Demo Jose].

6. En la definición de la alerta, especificar el Team Project, y además el tipo de WorkItem, para acotar el criterio de filtrado. Completar además el tipo de formato y la dirección de correo a la que queremos enviar la alerta.

7. Done !!!

Saludos @ Home

El Bruno

Buenas,

Team Foundation Server 2010 incorpora como gran novedad que las Builds ya no se basan en MSBuild, sino que son gestionadas por Workflow Foundation. Esto es una gran noticia, pero lamentablemente si quieres comprender como funciona un proceso de compilacion de .Net, todavía tendrás que aprender MSBuild, ya que los archivos de proyecto, por ejemplo: csproj; se basan en esta tecnología.

Una de las preguntas más realizadas al respecto es:

¿cuándo utilizo @, cuándo utilizo % y cuándo utilizo $ para acceder a la información de una variable o propiedad?

Cada uno de los operadores responde a diferentes tipos de información. Por ejemplo:

• $(PROP), permite acceder al valor de una propiedad
• @(PROP), permite acceder a una lista de valores en formato Array
• %(PROP.ITEM), permite acceder a un valor específico de una propiedad en formato String

Estos operadores se describen en detalle en MSDN, en la sección de caracteres de escape en MSBuild.

En el próximo post, un par de ejemplos, que los que tengo no me funcionan :D

Saludos @ Here

El Bruno

Buenas,

ya que algunos lo preguntaron, esta es mi humilde opinión sobre las extensiones para Visual Studio 2010 que todo el mundo debería utilizar (o pensar en using them!!)

ReSharper

ReSharper es simplemente el mejor complemento para desarrolladores integrado en el IDE de Visual Studio 2010. Desde hace varias versiones, te permite no solo acelerar el tiempo de desarrollo, sino que además brinda una calidad de código muy buena, ya que implementa best practices a cholón (entre otras cosas).

Algunas personas ponen excusas para no utilizarlo, como por ejemplo: que consume mucha memoria, que es de pago, que pone lento el IDE, etc.; pero yo personalmente no tengo esta opinión. Una vez que te acostumbras a utilizarlo, es la extension IDEAL para trabajar en Visual Studio. A Must Have.

Me van a perdonar por no escribir las características de ReSharper, pero es que son tantas que debería dedicarle una semana de posts solo a R#. Van desde características para desarrolladores Web, donde si desarrollas ASP.Net MVC es impresionante (palabra de web developers), incoporación de análisis de código extendidos, etc. Lo dicho, date una vuelta por la página oficial y prueba el trial http://www.jetbrains.com/resharper/index.html.

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/EA4AC039-1B5C-4D11-804E-9BEDE2E63ECF

Nota: las versiones 4.x para Visual Studio 2008, también son imprescindibles.

Team Foundation Server Power Tools

¿Trabajas con Team Foundation Server 2010 y no tienes las TFS Power Tools?, pues entonces lamento comunicarte que no trabajas con Team Foundation Server 2010. Este paquete , incluye varias herramientas indispensables para trabajar con TFS, como por ejemplo:

• Explorador de alertas: un formulario integrado en el IDE donde podemos la gestionar de una forma muy simple las suscripciones a eventos de TFS2010.
• TFS 2010 BPA (Best Practices Analyzer): una herramienta de análisis y diagnóstico para nuestros servidores TFS2010.
• Paquete de políticas de CheckIn: pues nuevas políticas por si queremos ser más agresivos con el control del código fuente.
• Editor de Procesos: la herramienta más peligrosa del paquete. Nos permite editar las plantillas de los procesos de TFS, desde las definiciones de los WorkItems hasta la plantilla completa. Muy potente, y en malas manos, muy peligrosa !!!
• Team Members: es una extensión incoroporada dentro del panel del Team Explorere que permiten interactuar con otros integrantes del equipo de desarrollo, por ejemplo con algún sistema de mensajería instantanea, o para conocer el estado del trabajo de los mismos.
• Windows Shell Extensions: Junto con el Editor de Procesos es la mejor novedad, la capacidad de interactuar con elementos de TFS2010 desde Windows Explorer. Por ejemplo, agregar elementos al Source Control, CheckIn, CheckOut, etc.

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/3e8c9b68-6e39-4577-b9b7-78489b5cb1da 

Nota: También deberías descargar las TFS Power Tools para TFS2008 si las necesitas

Productivity Power Tools

Otro gran conjunto de herramientas que se integran en el IDE para hacernos la vida más fácil. Entre todas las que posee, yo destaco las siguientes:

• Solution Navigator: un excelente reemplazo para el Solution Explorer, donde no solo veremos las clases y elementos de nuestros proyectos, sino que además podremos ver funciones y propiedades, podremos realizar búsquedas avanzadas, previsualizacion de recursos como por ejemplo imágenes, etc.
• Quick Access: esta funcionalidad presenta un panel (al que accedemos con Ctrl+3), donde se registran todas las acciones del IDE, opciones de configuración del IDE, plantillas, etc.; y podemos acceder a las mismas con un filtro de búsqueda al estilo Windows Search. Imprescindible.
• Add References: la ventana de agregar referencias en Visual Studio no ha sufridos cambios desde sus inicios. En VS2010 le han dado un pequeño empujon, pero el cambio radical que proponen las VSPro Power Tools es muy bueno: filtros, capacidad de agregar y eliminar directamente desde el form, etc.

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/d0d33361-18e2-46c0-8ff2-4adea1e34fef

Nota: No lo niego, muchas de las funcionalidades de VSPro Power Tools, “están inspiradas en R#”, pero bueno, sigue siendo un complemento genial.

Italic Comments

El nombre de la extension ya te dice que hace: cambia el formato de los comentarios a Cursiva (Italic). Parece una tontería pero estéticamente, a mi me parece muy agradable y el código queda “más bonito). Además de cambiar el texto a cursiva, cambia el tamaño un punto más pequeño.

Aplica tanto a los comentarios inline dentro del código, como a las secciones de comentarios para la generación de documentación. y soporta los editores de C#, Visual Basic y C++ en el IDE de Visual Studio 2010.

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/0b439a8a-e21a-4e26-b82b-054fbf0acab7

Highlight all occurrences of a selected word

Visual Studio 2010 ya trae incorporada la capacidad de resaltar dentro de una clase, todas las ocurrencias del elemento seleccionado, ya sea una función, una variable, etc. Esta herramienta, brinda un comportamiento similar, pero además de resaltar el texto seleccionado (no trabaja a nivel de miembros), muestra un marcador en el margen izquierdo con lo que la navegación es más rápida.

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/4b92b6ad-f563-4705-8f7b-7f85ba3cc6bb

Nota: Ojo, que si tienes que recurrir a esta funcionalidad muy seguido, seguramente tu código es un espaguethi de los lindos :D 

Visual Studio Color Theme Editor

El IDE de Visual Studio 2010 está basado en WPF, con lo que podríamos hacer lo que quisieramos con el mismo, pues sí.

El equipo de producto de Visual Studio lo explica aquí, y gracias a esta extensión podremos cambiar el aspecto de casi todas las features del IDE.

Realmente aconsejable por si no te gusta el azulito que viene por defecto.

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/20cd93a2-c435-4d00-a797-499f16402378

Consejo: si no tienes buen gusto para los colores, por favor no retoques tu VS. Da un poco de yuyu sentarse frente a un IDE violeta con fuentes amarillas y estrellitas como iconos … :D 

Me quedan en el tintero un par más que uso más esporádicamente, pero iré completando la lista con las que uso en el día a día como developer.

Para la próxima, el editor de Configuracion de EntLib, TFS SideKicks, DSL Tools, VS2010 SDK, etc.

Saludos @ Home

El Bruno

Buenas,

hace unos días se libero la primera plantilla oficial de SCRUM de Microsoft para Visual Studio 2010 y Team Foundation Server 2010. Hay varios posts escritos sobre el tema, además de una comparativa de Luis entre MSF for Agile y esta plantilla; pero cuando lo fuí a instalar en un entorno con TFS2010 + Sharepoint Foundation 2010, me encontré con que la sección de configuración de Sharepoint está pensada sólo para WSS.

En el tutorial para instalar las extensiones de Sharepoint para la plantilla de SCRUM (ubicado en %Program Files%\Microsoft\Microsoft Visual Studio Scrum 1.0\Project Portal) se detallan los pasos para la instalación del WSP, pero como podemos ver en las siguientes líneas, está pensado para WSS 3.0 o para Sharepoint 2007.

3. Add the solution to SharePoint by running the following:

SET STSADM="%CommonProgramFiles%\Microsoft Shared\web server extensions\12\BIN\stsadm.exe"
%STSADM% -o addsolution -filename Microsoft.TeamFoundation.SharePoint.Scrum.wsp

La solución para poder utilizar Sharepoint 2010 o Sharepoint Foundation es utilizar el nuevo directorio de trabajo con la versión correcta de Office Sharepoint = 14

3. Add the solution to SharePoint by running the following:

SET STSADM="%CommonProgramFiles%\Microsoft Shared\web server extensions\14\BIN\stsadm.exe"
%STSADM% -o addsolution -filename Microsoft.TeamFoundation.SharePoint.Scrum.wsp

A partir de aquí, todo va sobre ruedas ^^

Saludos @ Here

El Bruno

Buenas,

si bien existe desde antes en otros Sistemas Operativos y con herramientas de 3ros en Windows XP, una de las cosas que más me marco en Windows Vista, es la capacidad de acceder a cualquier herramienta, documento, etc.; directamente desde la caja de búsqueda (Wnd->Search). Esta funcionalidad es indispensable para mi hoy, ya que accedo a todas mis herramientas, documentos, etc. directamente desde allí.

Ahora bien, en herramientas como Visual Studio 2010, donde todavía no existe esta funcionalidad, pues me tengo aprendidos muchas combinaciones de teclado para hacer mis tareas más comunes (Ctrl+º, Ctrl+m, para acceder al Team Explorer, Shift+Alt+Enter para full screen, etc.). Por suerte la última versión de las Visual Studio 2010 Productivity Power Tools, incorpora entre otras cosas un atajo de teclado que nos brinda una funcionalidad parecida: CTRL+3.

Una vez presionado, el AddIn de Visual Studio arma una colección con todas las opciones de menú del IDE de Visual Studio 2010, y de las opciones de Visual Studio. A partir de allí podemos introducir un criterio de búsqueda para acceder a los mismos. Por ejemplo, si tecleamos [Source] veremos que nos aparecen 7 accesos de menú y una opción para la configuración de Visual Studio 2010.

De la misma manera, si tecleamos [edit] podremos ver varias opciones de menú, opciones de configuración y plantillas de proyecto:

Un clásico como [Add], nos muestra tareas, opciones, plantillas, etc.

Finalmente, ese smile tan simpático que aparece abajo a la derecha, pues es un simple link a un correo para aportar ideas/sugerencias sobre esta funcionalidad

Saludos @ Here

El Bruno

Descarga: http://visualstudiogallery.msdn.microsoft.com/en-us/d0d33361-18e2-46c0-8ff2-4adea1e34fef

Buenas,

mientras me preparaba para hacer algunas pruebas con la nueva versión de Web Client Software Factory 2010, me encontré con el siguiente error mientras instalaba el paquete.

El formulario de error no es desagradable para la vista, pero se echa en falta un poco de información relacionada con el error. Como siempre lo mejor es ir al log, y empomarse todo el texto plano del mismo, para conocer el detalle. En mi caso este es el log de instalación:

   1: 7/19/2010 9:25:52 AM - Microsoft Visual Studio Extension Installer

   2: 7/19/2010 9:25:52 AM - -------------------------------------------

   3: 7/19/2010 9:25:53 AM - Initializing Install...

   4: 7/19/2010 9:25:57 AM - Extension Details...

   5: 7/19/2010 9:25:57 AM -     Identifier      : WebClientFactoryPackage2

   6: 7/19/2010 9:25:57 AM -     Name            : Web Client Software Factory 2010

   7: 7/19/2010 9:25:57 AM -     Author          : Microsoft

   8: 7/19/2010 9:25:57 AM -     Version         : 3.0

   9: 7/19/2010 9:25:57 AM -     Description     : The Web Client Software Factory is a Visual Studio extension 

  10:                                              that helps software teams create composite web applications.

  11: 7/19/2010 9:25:57 AM -     Locale          : en-US

  12: 7/19/2010 9:25:57 AM -     MoreInfoURL     : http://webclientguidance.codeplex.com/

  13: 7/19/2010 9:25:57 AM -     InstalledByMSI  : False

  14: 7/19/2010 9:25:57 AM -     MinFramework    : 4.0

  15: 7/19/2010 9:25:57 AM -     MaxFramework    : 4.0

  16: 7/19/2010 9:25:57 AM - 

  17: 7/19/2010 9:25:57 AM -     Supported Visual Studio Editions : 

  18: 7/19/2010 9:25:57 AM -         Version : 10.0

  19: 7/19/2010 9:25:57 AM -             Ultimate

  20: 7/19/2010 9:25:57 AM -             Premium

  21: 7/19/2010 9:25:57 AM -             Pro

  22: 7/19/2010 9:25:57 AM - 

  23: 7/19/2010 9:25:57 AM -     Supported Isolated Shells : 

  24: 7/19/2010 9:25:57 AM - 

  25: 7/19/2010 9:25:57 AM -     References      : 

  26: 7/19/2010 9:25:57 AM -         -------------------------------------------------------

  27: 7/19/2010 9:25:57 AM -         Identifier   : Microsoft.Practices.RecipeFramework.VisualStudio

  28: 7/19/2010 9:25:57 AM -         Name         : Guidance Automation Extensions

  29: 7/19/2010 9:25:57 AM -         MinVersion   : 2.0

  30: 7/19/2010 9:25:57 AM -         MaxVersion   : 

  31: 7/19/2010 9:25:57 AM -         MoreInfoURL  : 

  32: 7/19/2010 9:25:57 AM -         Nested       : No

  33: 7/19/2010 9:25:57 AM - 

  34: 7/19/2010 9:25:57 AM - 

  35: 7/19/2010 9:25:57 AM - Searching for applicable products...

  36: 7/19/2010 9:25:57 AM - Found installed product - Microsoft Visual Studio 2010 Ultimate

  37: 7/19/2010 9:26:01 AM - The extension with ID 'WebClientFactoryPackage2' is not installed to 

  38:                        Microsoft Visual Studio 2010 Ultimate.

  39: 7/19/2010 9:26:17 AM - The following target products have been selected...

  40: 7/19/2010 9:26:17 AM -     Microsoft Visual Studio 2010 Ultimate

  41: 7/19/2010 9:26:17 AM - 

  42: 7/19/2010 9:26:17 AM - Beginning to install extension to Microsoft Visual Studio 2010 Ultimate...

  43: 7/19/2010 9:26:17 AM - Install Error : 

  44:                        Microsoft.VisualStudio.ExtensionManager.MissingReferencesException: 

  45:                        This extension cannot be installed because the following references are missing:

  46:                          - Guidance Automation Extensions

  47:                          at Microsoft.VisualStudio.ExtensionManager.ExtensionManagerService.BeginInstall

  48:                            (IInstallableExtension installableExtension, Boolean perMachine, AsyncOperation asyncOp)

  49:                          at Microsoft.VisualStudio.ExtensionManager.ExtensionManagerService.InstallWorker

  50:                             (IInstallableExtension extension, Boolean perMachine, AsyncOperation asyncOp)

Por suerte el log, es pequeño y el problema está bien acotado (me falta un prerequisito de instalación). Ahora bien, lo siguiente es entrar a Connect, y proponer que brinden un poco más de información en la ventana del error, ya que las líneas 43 a la 50, son las que me interesan a mi :D. Si es por pedir ….

Saludos @ Here

El Bruno

Descargas:

• WebClient Software Factory 2010
  http://visualstudiogallery.msdn.microsoft.com/en-us/8fc2c9d6-5282-404b-9c58-e72b326b1e26
• GAX 2010
  http://visualstudiogallery.msdn.microsoft.com/en-us/25e4b5e9-65e4-4950-967d-5f1e6a9dcbeb

Buenas,

muchas veces cuando se publican ejemplos de tareas personalizadas para TFS2008, vemos como en las mismas se implementan propiedades “simples” para pasar información a la tarea o para que la misma retorne algo. Cuando tenemos que trabajar con listas (o vectores) de información, es necesario implementar una propiedad del tipo ITaskItem. Estas propiedades son bastante comunes en MSBuild, aunque trabajar con ellas es un poco delicado.

Por ejemplo, el siguiente script de MSBuild, se ejecutará en un servidor TFSBuild 2008. En el mismo, en el Target inicial de trabajo que poseemos [BeforeEndToEndIteration], se invoca a un target personalizado [TestStringConcatenate]. En este target, creamos un ItemGroup, con varios elementos dentro del mismo (líneas 10 a 15), y luego invocamos una tarea personalizada que concatena el valor de las cadenas de los elementos del ItemGroup y retorna un único string que se almacena en una propiedad llamada [StringResult] (línea 20). Finalmente, se muestra el resultado de esta propiedad en el log del build (líneas 23 a 25).

   1: <Target Name="BeforeEndToEndIteration">

   2:     <CallTarget Targets="TestStringConcatenate" />

   3:     <Error Text="Stop build"></Error>

   4: </Target>

   5: <Target Name="TestStringConcatenate" >

   6:    <BuildStep TeamFoundationServerUrl="$(TeamFoundationServerUrl)" 

   7:               BuildUri="$(BuildUri)" Status="Succeeded"

   8:               Message="INICIO [TestStringConcatenate]. Prueba de StringConcatenate" />

   9:     <!-- Crea un ITEMGROUP de ejemplo -->

  10:     <ItemGroup>

  11:       <TestSC Include="Bruno" />

  12:       <TestSC Include="Valentino" />

  13:       <TestSC Include="Martina" />

  14:       <TestSC Include="Gatito .Net" />

  15:     </ItemGroup>

  16:  

  17:     <!—Concatena cadenas -->

  18:     <ElBruno.StringConcatenate Items="@(TestSC)"

  19:                                Separator=”;” AppendLine="true">

  20:       <Output TaskParameter="StringResult" PropertyName="StringResult" />

  21:     </ElBruno.StringConcatenate>

  22:  

  23:     <BuildStep TeamFoundationServerUrl="$(TeamFoundationServerUrl)" 

  24:                BuildUri="$(BuildUri)" Status="Succeeded"

  25:                Message="-Resultado String Concatenate: [$(StringResult)]" />

  26:  

  27:     <BuildStep TeamFoundationServerUrl="$(TeamFoundationServerUrl)" 

  28:                BuildUri="$(BuildUri)" Status="Succeeded"

  29:                Message="-- FIN." />

  30: </Target>

La tarea personalizada [ElBruno.StringConcatenate], recibe la lista de elementos en una propiedad llamada [Items], y además otra propiedad “simple” de tipo Bool llamada [AppendLine] y otra propiedad “simple” de tipo string llamada [Separator], para definir si se agrega un salto de linea entre cada elemento.

El código de la tarea personalizada es el siguiente (quejas al margen, que ha sido picado en segundos !!! ^^)

   1: using Microsoft.Build.Utilities;

   2: using Microsoft.Build.Framework;

   3: using System.Collections.Generic;

   4: using System.Text;

   5: namespace ElBruno.TfsBuild

   6: {

   7:     public class StringConcatenate : Task

   8:     {

   9:         #region TFS Task Properties

  10:         /// <summary>

  11:         /// Gets or sets the separator.

  12:         /// </summary>

  13:         /// <value>The separator.</value>

  14:         public string Separator { get; set; }

  15:         /// <summary>

  16:         /// Gets or sets a value indicating whether [append line].

  17:         /// </summary>

  18:         /// <value><c>true</c> if [append line]; otherwise, <c>false</c>.</value>

  19:         public bool AppendLine { get; set; }

  20:         /// <summary>

  21:         /// Gets or sets the items.

  22:         /// </summary>

  23:         /// <value>The items.</value>

  24:         public ITaskItem[] Items { get; set; }

  25:         /// <summary>

  26:         /// Gets or sets the string result.

  27:         /// </summary>

  28:         /// <value>The string result.</value>

  29:         [Output]

  30:         public string StringResult { get; set; }

  31:         #endregion

  32:  

  33:         #region TFS Override members

  34:         /// <summary>

  35:         /// Executes this instance.

  36:         /// </summary>

  37:         /// <returns></returns>

  38:         public override bool Execute()

  39:         {

  40:             bool ret = true;

  41:             var sb = new StringBuilder();

  42:             if (Items != null)

  43:             {

  44:                 for (int i = 0; i < Items.Length; i++)

  45:                 {

  46:                     sb.Append(Items[i].ItemSpec);

  47:                     if (i < Items.Length - 1)

  48:                     {

  49:                         sb.Append(Separator);

  50:                         if (AppendLine)

  51:                             sb.AppendLine();

  52:                     }

  53:                 }

  54:             }

  55:             StringResult = sb.ToString();

  56:             return ret;

  57:         }

  58:         #endregion

  59:     }

  60: }

Cuando ejecutamos la tarea en un servidor TFS2008, podremos ver como la misma muestra los resultados esperados, con los strings concatenados utilizando un salto de línea y un punto y coma.

Apuntado … en la época de TFS2010, para proyectos de TFS2008 :P

Saludos @ Here

El Bruno

Buenas,

seguramente ya conoces las Quick Reference Guides que cada tanto libera el equipo de Visual Studio Rangers. Pues bien, el amigo Francisco Fagas (MVP y crack de los grandes) ha tenido el detalle de participar en este proyecto traduciendo al español parte de este contenido. Inicialmente es decir primero lo primero ha comenzado por la Visual Studio 2010 Quick Reference Guide, que es algo así como la Guía de Referencia Rápida de Visual Studio 2010 y es un doc que vale la pena revisar.

El mismo se puede descargar desde http://vs2010quickref.codeplex.com/releases/view/37144, haciendo click en [All Downloads] y aparecerá el link a [Spanish – Quick Reference Guide].

A ver cuando empiezan a salir los otros !!! ^^

Saludos @ Here

El Bruno

Descarga: http://vs2010quickref.codeplex.com/releases/view/37144

Buenas,

uno de los problemas más usuales con los que solemos encontrarnos en los entornos de compilación, es definir una forma para que las compilaciones resuelvan las dependencias con las que se compilan las soluciones. Si eres una persona organizada y utilizas referencias con paths relativos almacenados en el Source Control (por ejemplo: ..\..\References\EntLib.Common.dll); no tendrás ningún problemas. Pero si en cambio tienes una ensalada de referencias repartidas por directorios de red, o en la GAC, pues el MSBuild puede chillar un poco.

Para estos casos, lo ideal es conocer un poco como funciona la tarea ResolveAssemblyReference, que es una tarea que ejecuta MSBuild en tiempo de compilación para resolver las referencias con las que compila un proyecto. No voy a entrar en detalle sobre esta tarea, ya que el link de la MSDN explica cuales son los parámetros con los que trabaja, pero si comentar que para resolver referencias en ubicaciones externas, es posible utilizar AdditionalReferencePath para esto.

Por ejemplo, si tenemos dlls repartidas por varios sitios, un ejemplo como el siguiente puede sernos de ayuda:

   1: <!-- Paths adicionales que se utilizaran para la compilacion -->

   2: <ItemGroup Label="Additional Reference Path">

   3:   <AdditionalReferencePath Include="\\SERVER\referencias\" />

   4:   <AdditionalReferencePath Include="C:\MasReferencias\" />

   5:   <AdditionalReferencePath Include="C:\LasReferenciasQueFaltan\" />

   6: </ItemGroup>

En el ejemplo anterior, el compilador al momento de intentar resolver un ensamblado, intentará obtenerlo desde estas ubicaciones, respetando el orden con el que las hemos definido. Y si no lo encuentra, recién en este momento lo buscará en la GAC. Estos 2 puntos son importantes ya que si tienes ensamblados “repetidos” (un escenario que aborrezco, pero que es muy frecuente), pues ve tu a saber con que versión estás compilando.

Pequeño tip, que me apunto para no olvidarme en el futuro

Saludos @ Here

El Bruno

Buenas,

ayer escribí un post sobre una de las funcionalidades que tenemos disponibles si utilizamos Visualization and Modeling Feature Pack en Visual Studio 2010 trabajando con TFS2010 o TFS2008. Como es verlo y querer probarlo, me olvide de comentar que para que esto funcione es necesario instalar un plugin en el servidor TFS. De esta forma, aparecerá el nuevo tipo de relación [Model Link] en las opciones de relación en WorkItems.

Los siguientes pasos son necesarios para poder activar esta funcionalidad en Team Foundation Server 2010 y Team Foundation Server 2008.

TFS2010

1. En el equipo donde está instalada la extensión para Visual Studio 2010 acceder al directorio: [C:\Users\<USER>\AppData\Local\Microsoft\VisualStudio\10.0\Extensions\Microsoft\Visualization and Modeling Feature Pack\1.0], donde <USER> es el usuario de windows.

2. Copiar la dll [Microsoft.VisualStudio.ArchitectureTools.WorkItemLinking.ServerRegistration.dll].

3. Acceder al servidor TFS2010

4. Dentro del directorio de instalación de TFS2010, acceder a: [%Program Files%\Microsoft Team Foundation Server 2010\Application Tier\Web Services\bin\Plugins]

5. Copiar la dll en el directorio

6. Reiniciar el Application Pool con el que se ejecutan los servicios de TFS2010

7. Listo !!!

TFS2008

1. En el equipo donde está instalada la extensión para Visual Studio 2010 acceder al directorio: [C:\Users\<USER>\AppData\Local\Microsoft\VisualStudio\10.0\Extensions\Microsoft\Visualization and Modeling Feature Pack\1.0\

\Server Install Scripts], donde <USER> es el usuario de windows.

2. Copiar el archivo [ArchitectureToolsRegistrationEntriesTFS2008.xml]

3. Acceder al servidor TFS2008 y copiar el archivo XML en el directorio de instalación de TFS2008 [%Program Files%\Microsoft Visual Studio 2008 Team Foundation Server\Tools]

4. Lanzar a un command prompt con permisos elevados para ejecutar la aplicación TFSReg.exe. Usualmente esta aplicación se encuentra en el mismo directorio del paso anterior.

5. Lanzar el comando TFSReg.exe ArchitectureToolsRegistrationEntriesTFS2008.xml TeamFoundationServerDataTierServerName

6. Reiniciar el Application Pool con el que se ejecutan los servicios de TFS

7. Listo !!!

En ambos casos, es recomendable limpiar la cache local de Visual Studio, por las dudas:

1. Acceder al directorio: [C:\Users\<USER>\AppData\Local\Microsoft\Team Foundation\versionNum]

2. Eliminar el directorio  [CACHE]

Saludos @ Here

El Bruno

Buenas,

con la salida de Visualization and Modeling Feature Pack para Visual Studio 2010, se habilitaron nuevas capacidades dentro del IDE de Visual Studio para trabajar y extender las herramientas de modelado. Una de ellas, es la capacidad de poder relacionar WorkItems con elementos de diagramas UML. Actualmente existe la capacidad inversa para hacer relaciones, pero el Feature Pack cierra el ciclo completo para las relaciones.

Supongamos que tenemos el siguiente proyecto de ejemplo, con un par de actores, un par de casos de uso, y algunas clases. Sobre la base de estos elementos, que podemos navegar en el panel UML Model Explorer, ya es posible realizar relaciones en un WorkItem.

Por ejemplo, si abrimos una tarea y accedemos a la sección de elementos relacionados, podemos crear una nueva relación de tipo [Model Link]:

y en el momento de seleccionar un elemento para la misma, veremos que estamos navegando el repositorio local de elementos UML.

Cuando seleccionamos un elemento, ya podremos ver el mismo, con una relación del tipo [Model Link] en nuestro WorkItem.

Lo interesante de esta funcionalidad, es que al momento de hacer doble click sobre el elemento relacionado, se abre el diagrama correspondiente y podemos ver el elemento en el diseñador gráfico.

Y aquí un par de puntos importantes:

• Si tienes el proyecto de modelado cerrado, la accion de abrir elemento relacionado, abrirá el proyecto y cargará el diagrama correspondiente
• El Proyecto de modelado debe estar protegido en TFS para que pueda ser compartido por varias personas
• Si el proyecto esta compartido, pero no descargado, al momento de abrirlo nos encontraremos con un mensaje de error como el siguiente:

Yo lo veo interesante y muy útil, además de que es compatible tanto con TFS 2010 como con TFS 2008, lo que no deja fuera a los que todavía seguimos utilizando algun 2008 por ahi.

Saludos @ Home

El Bruno

Descargas:

• Visual Studio 2010 Ultimate (Downloads)
• Visual Studio 2010 SDK
• Visualization and Modeling Feature Pack
• Visualization and Modeling Feature Pack Runtime

Buenas,

si eres de aquellas personas a las que le gusta Entity Framework, pero te despiertas pegándote todos los días con un ORACLE, pues estarás al tanto de que la convivencia entre estas 2 tecnologías no era posible por ahora (salvo que utilizaras extensiones de pago). Pues la gente de ORACLE ha anunciado que crearán una extension para soportar Entity Framework para el año 2011. Durante el 2010 tendremos una versión BETA de este producto, al que ya espero poder echarle un guante, ya que más de una vez me ha tocado descartar EF por tener que utilizar ORACLE.

Asi que ya sabes, a estar atento a las próximas releases de ODP.Net, para ver cuando podemos tener acceso a este producto.

Saludos @ Here

El Bruno

Fuentes

• http://www.oracle.com/technology/tech/dotnet/index.html
• http://www.oracle.com/technology/tech/dotnet/col/ef/oracle_entity_framework_sod.pdf

Buenas,

después de pelear un poco con tareas de TFS2008 para comprimir archivos, llegué a una biblioteca de compresion de archivos en CodePlex que es realmente fantástica: DotNetZip Library.

Esta API posee una interfaz muy buena y 100% intuitiva, y si una imagen vale más que 1000 palabras, pues 6 líneas de código, tambien valen su peso en oro; por ejemplo para crear un ZIP:

   1: using (var zip = new ZipFile())

   2: {

   3:     zip.AddFile("Valentino Capuano-CV.docx");

   4:     zip.AddDirectory("c:\\FotosMiFerrari");

   5:     zip.Save("demo.zip");

   6: }

y para extraer el contenido de un ZIP:

   1: using (var zip = ZipFile.Read("demo.zip"))

   2: {

   3:     zip.ExtractAll( @"c:\content");

   4: }

Saludos @ Here

El Bruno

Descarga: http://dotnetzip.codeplex.com/

Buenas,

cuando trabajas con tareas personalizadas en Builds en TFS2008, el pack de tareas que posee MSBuildExtensionPack, es algo que debes conocer. Una de las tareas que más trabajo nos ahorra está dentro del namespace [MSBuild.ExtensionPack.Compression] y es la clase [Zip]. Supongo que no hará falta que detalle el funcionamiento de la misma, cuando un poco de código de MSBuild vale más que mil palabras:

   1: <Target Name="Sample1">

   2:   <ItemGroup>

   3:     <!-- Set the collection of files to Zip-->

   4:     <FilesToZip Include="C:\hotfixes\**\*"/>

   5:   </ItemGroup>

   6:   

   7:   <!-- Create a zip file based on the FilesToZip collection -->

   8:   <MSBuild.ExtensionPack.Compression.Zip TaskAction="Create" 

   9:     CompressFiles="@(FilesToZip)" 

  10:     RemoveRoot="C:\hotfixes\" 

  11:     ZipFileName="C:\newZipByFile.zip"/>

  12:   

  13:   <!-- Create a zip file based on a Path -->

  14:   <MSBuild.ExtensionPack.Compression.Zip TaskAction="Create" 

  15:     CompressPath="C:\hotfixes" 

  16:     RemoveRoot="C:\hotfixes\" 

  17:     ZipFileName="C:\newZipByPath.zip"/>

  18:   

  19:   <!-- Extract a zip file-->

  20:   <MSBuild.ExtensionPack.Compression.Zip TaskAction="Extract" 

  21:     ExtractPath="C:\aaa11" 

  22:     ZipFileName="C:\newZipByPath.zip"/>

  23: </Target>

Este ejemplo realiza varias acciones con la clase Zip, pero en tiempo de ejecución es probable que te encuentres con el siguiente error:

   1: Build FAILED.

   2:  

   3: "c:\b\Bruno\SampleClient\BuildType\TFSBuild.proj" (EndToEndIteration target) (1) ->

   4: (UpdaterGenerateFiles target) -> 

   5: C:\srcbrcp\Bruno\RefBuild\EB.Client.targets(58,5): error : 

   6:   FileNotFoundException: Could not load file or assembly 'vjslib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies. 

   7:   El sistema no puede hallar el archivo especificado. [c:\b\Bruno\SampleClient\BuildType\TFSBuild.proj]

   8: C:\srcbrcp\Bruno\RefBuild\EB.Client.targets(58,5): error :  

   9:   [c:\b\Bruno\SampleClient\BuildType\TFSBuild.proj]

  10:  

  11:     0 Warning(s)

  12:     1 Error(s)

  13:  

  14: Time Elapsed 00:00:34.39

Por suerte, la solución del error es lo primero que encuentras cuando buscas por internet (http://www.msbuildextensionpack.com/help/3.5.5.0/Prerequisites%20and%20Installation.htm) y básicamente nos invita a repasar los prerequisitos para utilizar esta tarea, ya que es necesario instalar [Microsoft Visual J#® 2.0 Redistributable Package – Second Edition (x86)]

Una vez instalado, pues ya comprimes sin problemas.

Saludos @ Here

El Bruno

Buenas,

algunas veces me preguntan como hago para organizar mi tiempo para jugar con el Valentino, probar cosas nuevas, intentar seguir alguna que otra serie, además de trabajar (que es lo que más tiempo me consume); y siempre respondo con la verdad: tengo un ejército de monos amaestrados que se encargan de tipear letras al azar y estadísticamente, una vez al día sale algo parecido a un post.

En el día de hoy, me apunto otro escenario para probar, porque últimamente estoy viendo bastante preguntas sobre el mismo: INTEGRACION ENTRE TEAM FOUNDATION SERVER 2010 y PROJECT SERVER 2010.

Como soy un poco vago y no tengo ganas de montar otra VM más con Project Server, una opción es descargar esta maquina virtual que ya posee TODO instalado, además de datos de ejemplo para ver los mecanismos de integracion entre ambos mundos. Pues lo dicho, me lo apunto para que lo pruebe alguno de los monos del 2do subsuelo.

Saludos @ Home

El Bruno

Descarga: http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=f221c660-161b-43ca-95f3-e0e4aad8d43e

Buenas,

hace un tiempo escribí sobre los cambios en la configuración que se debían realizar para poder compilar proyectos desarrollados con Visual Studio 2010 y con target .Net Framework 4.0 utilizando TFS 2008. Este cambio es el primer paso hacia una serie de momentos de iluminación que ocasionan que todo aquello que piensas que es trivial, se vuelva extremadamente complicado. Es decir, si bien son familiares cercanos VS2010 y TFS2008, se llevan un poco de los pelos en algunas cosas.

Por ejemplo, en la ejecución de pruebas unitarias. Un detalle a tener en cuenta es que si se trabaja con los valores por defecto de TFS2008, la ejecucion de pruebas unitarias se realizará con las herramientas de VS2008 y claro, el QTAgent es myy buena gente, pero ha evolucionado un poco en VS2010. Para no tener este problema es necesario “sobreescribir” el valor de 2 propiedades específicas de los builds de 2008 que son MSTestRefPath y TeamBuildRefPath.

• MSTestRefPath.  Esta propiedad define el path para las herramientas de testing (las que están en Microsoft.VisualStudio.QualityTools.MSBuildTasks.dll).  Desde la versión de 2005 es overridable, para que ensamblados que apunten a VS2005 puedan ser probados con el framework 8.0 de pruebas unitarias.
• TeamBuildRefPath. Proporciona la ruta de acceso a archivos binarios de Team Build. Por lo general está apuntando a %ProgramFiles%\Microsoft Visual Studio 10\Common7\IDE\PrivateAssemblies.

Para sobreescribir estas propiedades con los valores correctos de VS2010, he creado un target llamado [ElTargetDeLaMuerte] que llamo al principio de mi build y de esta forma ya puedo trabajar con las herramientas de testing en la versión correcta.

   1: <Target Name="ElTargetDeLaMuerte">

   2:  

   3:   <!-- MSTestRefPath -->

   4:   <CreateProperty 

   5:     Value="C:\Archivos de programa\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies">

   6:     <Output TaskParameter="Value" PropertyName="MSTestRefPath" /> 

   7:   </CreateProperty>

   8:   <BuildStep TeamFoundationServerUrl="$(TeamFoundationServerUrl)" BuildUri="$(BuildUri)"

   9:     Status="Succeeded" Message="- MSTestRefPath: [$(MSTestRefPath)]" /> 

  10:  

  11:   <!-- TeamBuildRefPath --> 

  12:   <CreateProperty 

  13:     Value="C:\Archivos de programa\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies">

  14:     <Output TaskParameter="Value" PropertyName="TeamBuildRefPath" /> 

  15:   </CreateProperty>

  16:   <BuildStep TeamFoundationServerUrl="$(TeamFoundationServerUrl)" BuildUri="$(BuildUri)" Status="Succeeded"

  17:     Message="- TeamBuildRefPath: [$(TeamBuildRefPath)]" /> 

  18:  

  19: </Target>

Saludos @ Home

El Bruno

PD: no hay ningun tipo de restricciones para cambiar el nombre del Target. Sé que a alguno no le gustará [ElTargetDeLaMuerte], otras opciones válidas para TFS2008 son [MasComplicadoQueJackBauer] o [NosFuimosEnCuartos].

Buenas,

ayer comentaba los pasos para desadjuntar (deattach) un Team Project Collection en el registro y configuración de un servidor Team Foundation Server 2010. Como ya he movido la base de datos del TPC a otro servidor, ahora es momento de volver a adjuntar (attach) la misma al server TFS2010. El siguiente tutorial muestra los pasos necesarios para realizar esta acción.

Tutorial

1. Lanzamos la consola de administración de Team Foundation Server 2010.

2. Seleccionamos el link [Attach Collection].

3. Esta acción inspeccionará todas las bases de datos que estén en la instancia de base de datos que configuramos en el asistente (por lo general es la misma donde esta la configuración del servidor TFS2010)  y mostrará los Team Project Collections disponibles en esa instancia de base de datos.

4. Seleccionamos un TPC y a continuación podremos modificar sus propiedades: nombre y descripción.

5. Antes de adjuntar el TPC, se da inicio a un proceso de verificación.

6. Cuando damos el inicio al proceso de adjuntar el TPC, se adjuntan los componentes del mismo: WorkItems, elementos de Reporting, etc.

7. Una vez finalizado, podremos ver el estado de los componentes relacionados con el TPC adjuntado.

8. En mi caso los warnings están relacionados con elementos que ya existen con el mismo nombre del TPC en la configuracion de Reporting, Sharepoint y Lab Management. No hay problema ya que el ejemplo es detach y attach.

9. El TPC ya está listo para ser utilizado con sus Team Project correspondientes. Si echamos un vistazo al estado del mismo, podremos ver las acciones de attach, prepare, detach, create y prepare que ejecuté para el ejemplo del post.

Saludos @ Here

El Bruno