El Bruno

Buenas,

este es un post donde me apunto para no olvidarme las 10 líneas de código que se necesitan para lanzar el formulario de selección de Team Project en Visual Studio 2010.

El siguiente ejemplo, utiliza la clase TeamProjectPicker y muestra un formulario de selección modal para la selección de una Team Project Collection:

   1: private static Uri SelectTeamProjectCollection()

   2: {

   3:     Uri uri = null;

   4:     var projectPicker = new TeamProjectPicker(TeamProjectPickerMode.NoProject, false)

   5:                             {

   6:                                 Text = "Selección de Team Projects",

   7:                                 AcceptButtonText = "Seleccionar"

   8:                             };

   9:  

  10:     if (projectPicker.ShowDialog() == System.Windows.Forms.DialogResult.OK)

  11:         uri = projectPicker.SelectedTeamProjectCollection.Uri;

  12:     return uri;

  13: }

El formulario resultante es el siguiente, donde vemos que podemos seleccionar elementos a nivel de Team Project Collection:

Si en cambio queremos seleccionar un Team Project, la siguiente función es el ejemplo:

   1: private static Uri SelectTeamProject()

   2: {

   3:     Uri uri = null;

   4:     var projectPicker = new TeamProjectPicker(TeamProjectPickerMode.SingleProject, false)

   5:     {

   6:         Text = "Selección de Team Project",

   7:         AcceptButtonText = "Seleccionar"

   8:     };

   9:  

  10:     if (projectPicker.ShowDialog() == System.Windows.Forms.DialogResult.OK)

  11:         uri = projectPicker.SelectedTeamProjectCollection.Uri;

  12:     return uri;

  13: }

Y al ejecutar la misma, se nos mostrará el siguiente formulario:

El código fuente de los ejemplos se puede descargar desde

Saludos @ Alicante

El Bruno

Buenas,

hace una pila de tiempo, escribí un post donde mostraba como configurar el path del Cache para el Team System Web Access. Un par de versiones de Team Foundation después, esto es mucho más simple, y además también es mucho más simple el refresco de los datos con los que trabaja Visual Studio 2010 Team Web Access.

Para esto simplemente tenemos que desplegar el menú superior a la derecha y seleccionar la opción [Settings // Refresh Cache]

Más simple no se puede

Saludos @ Here

El Bruno

Buenas,

hacer un BackUp de los elementos de un servidor Team Foundation Server es una tarea que no tiene muchos problemas. Todo el contenido del servidor se encuentra en la base de datos SQL Server, con lo que si está bien configurado el BackUp del mismo, pues muchos más problemas no hay. Sin embargo, como también tenemos información en otros repositorios, como por ejemplo SharePoint, pues el concepto de BackUp se complica un poco más. Por suerte, con el lanzamiento de las TFS Power Tools de Marzo del 2011, se ha incorporado una feature más que nos ayuda a definir un BackUp y ejecutar el mismo.

El siguiente tutorial demuestra como crear un plan de BackUp para un servidor Team Foundation Server 2010.

Tutorial

1. Abrir la consola de administración de Team Foundation Server y seleccionar la opción [Team Foundation BackUp]

2. Dentro de la misma seleccionar la opción [Create Backup Plan]. Esta opción lanza el asistente para la definición de un plan de BackUp.

3. En primer paso es definir una ruta de red donde almacenar el resultado del proceso de BackUp. Además de opciones como la política de retención y las extensiones a guardar.

4. A continuación se definen los contenidos extras, además del TFS que se almacenarán en el BackUp. Las opciones son bases de datos de Reporting Services y bases de datos de SharePoint.

5. El próximo paso es definir la cuenta de usuario con la que se ejecutará el proceso de BackUp.

6. Si tenemos acceso a un servidor SMTP, podemos configurar una alerta por correo para la ejecución de cada BackUp. Hace un tiempo escribí un post al respecto sobre como hacer esto utilizando una cuenta de GMAIL.

7. El siguiente paso es la definición de la agenda de ejecución del Backup, con las opciones básicas para esta acción.

8. Se realiza una verificación de los datos del plan de BackUp.

9. Y listo, ya podemos crear el plan de BackUp de nuestros contenidos de TFS.

10. A partir de este momento, ya podemos lanzar un BackUp de forma manual, consultar el estado de los procesos de BackUp o restaurar los contenidos desde un Backup realizado anteriormente.

Saludos @ Here

El Bruno

Buenas,

si quieres un poco de ayuda al momento de generar tus pruebas: Spec Explorer puede serte de bastante utilidad. Esta extensión para visual Studio 2010, permite definir Behaviors a través de reglas en C# o de expresiones basadas en un patrón. A partir de estos contenidos, que se consideran “modelos”, luego la herramienta nos permite trabajar en modo “test-case”.

Ahora que en la versión 3.5 se incorpora la capacidad de reinspeccionar los cambios en un modelo para reflejar los mismos en las pruebas y que las “exploraciones” se han mejorado bastante, creo que ya lo considero bastante maduro como para dejar de utilizarlo en proyectos de prueba y darle una oportunidad en algún proyecto real.

Si te gusta probar algo nuevo, pues Spec Explorer puede darte una álegría

Saludos @ Alicante

El Bruno

Descarga: http://visualstudiogallery.msdn.microsoft.com/271d0904-f178-4ce9-956b-d9bfa4902745/

Buenas,

de la mano de los padres de Code Contracts y Reactive Extensions, los chicos de DevLabs se sacan otro productazo de la manga con “Debugger Canvas”. Debugger Canvas es una extensión para Visual Studio 2010 (Ultimate exclusivo) que nos permite ver para “step” en un proceso de depuración en un canvas nuevo, conectando a los mismos entre sí. Esto es realmente útil ya que podemos ver el flujo de ejecución de un proceso simplemente por los miembros que pasa el mismo. Es mucho más cercano al ideal de tratar a los objetos y clases como lo que son, en lugar de archivos de texto.

Bueno, es mucho pedir que siendo tan corto de expresiones como soy pueda explicar Debugger Canvas, mejor un video y a esperar hasta junio que será la fecha de release:

Saludos @ Here

El Bruno

Buenas,

hace unos minutos he terminado mi sesión sin demo sobre el SDK de Kinect para Windows. Ha sido la primera presentación en años que hago en la que no abro Visual Studio, cosa rara para mi. Las slides de la presentación se puede descargar desde:

Y el video completo de la presentación del SDK en el MIX se puede descargar desde http://channel9.msdn.com/Blogs/C9Team/Kinect-Demos-with-the-Channel-9-team

En el video, los minutos interesantes para ver son los siguientes:

• 01:00 Kinect for windows SDK
• 02:00 hello world app
• 03:00 DrawLine
• 07:00 KinectCar
• 10:15 Microsoft Worldwide telescope
• 14:45 NAVI
• 18:00 FROG Game

Saludos @ Here

El Bruno

Buenas,

hace un tiempo publiqué en un post, un truco no oficial para desactivar las validaciones en tiempo de ejcución en el editor de Workflow Foundation de Visual Studio 2010. Esto lo hice porque al momento de editar definiciones de Builds de Team Build 2010, pues el IDE de Visual Studio 2010 se iba a dar una vuelta por Narnia y era imposible trabajar con el mismo.

Después de tocar muchos los huevos seguir pidiendo soluciones al equipo de producto, pues parece que hay un HotFix por allí que ayuda a mejorar un poco más el rendimiento del editor, el mismo se puede descargar desde > http://support.microsoft.com/kb/2484841.

Un par de detalles relacionados con el HotFix:

• El editor sigue igual de lento, asi que un #FAIL en este punto
• Es probable que Visual Studio 2010 se cuelgue un par de veces antes de comenzar a funcionar correctamente. Deberías probar desinstalando e instalando el HotFix una segunda vez para ver si funciona mejor.

In the meantime, yo seguiré preguntado al equipo de producto de TFS para que molesten a los de VS que a su vez molestan a los de WF para ver si hay una solución decente por allí

Saludos @ Home

El Bruno

Buenas,

si todavía estas con resaca del MIX y no tenés tiempo para terminar de absorber las novedades del TechEd, el próximo lunes 23 en Madrid y el Martes 24 en Barcelona, te podes pegar un poco con parte de las novedades que se comentan estos días sobre desarrollos para Windows Phone, Azure, Kinect, HTML 5, Silverlight, etc.

Todo esto de la mano de Microsoft Spain y Netalia, y de grandes como Marino Posadas, Braulio Diez, Miguel Jimenez, Gisela Torres, Jose Luis Latorre, Jose Miguel Torres, Nicolas Sanchez, algún otro que se cuele por allí además del que suscribe.

El registro > http://msdn.microsoft.com/es-es/gg191710

Saludos @ Here

El Bruno

Buenas,

casi se me olvida, el equipo de Patterns & Practices de Microsoft ha liberado el Silverlight Integration Pack para Enterprise Library. Este conjunto de componentes nos permite aprovechar las ventajas de Enterprise Library para los desarrollos sobre Silverlight.

Inicialmente esta release incluye:

• Caching Application Block with support for:
  • In-memory cache
  • Isolated storage cache
  • Expiration and scavenging policies
  • Notification of cache purging
• Validation Application Block with support for:
  • Multi-level complex validation
  • Attribute-based specification of validation rules
  • Configuration-based specification of validation rules
  • Simple cross-field validation
  • Self-validation
  • Cross-tier validation (through WCF RIA Services integration)
  • Multiple rule-sets
  • Meta data type for updating entities with external classes in Silverlight
  • Rich set of built-in validators
• Logging Application Block, including:
  • Notification trace listener
  • Isolated storage trace listener
  • Remote service trace listener with support of batch logging
  • Implementation of a WCF Remote logging service that integrates with the desktop version of the Logging Application Block
  • Logging filters
  • Tracing
  • Logging settings runtime change API
• Exception Handling Application Block, including:
  • Simple configurable, policy-based mechanism for dealing with exceptions consistently
  • Wrap handler
  • Replace handler
  • Logging handler
• Unity Application Block – a dependency injection container
• Dependency injection container independence (Unity ships with the Enterprise Library, but can be replaced with a different container)
• Unity Interception mechanism, with support for:
  • Virtual method interception
  • Interface interception
• Policy Injection Application Block, including:
  • Validation handler
  • Exception Handling handler
  • Logging handler
• Flexible configuration options, including:
  • XAML-based configuration support
  • Asynchronous configuration loading
  • Interactive configuration console supporting profiles (desktop vs. Silverlight)
  • Translation tool for XAML config (needed to convert conventional XML configuration files):
    • Standalone command-line tool
    • Config console wizard
    • MS Build task
  • Programmatic configuration support via a fluent interface
• StockTrader V2 Reference Implementation (RI) (via a separate download; final version to be released in the coming days)

Otra de las novedades interesantes que posee EntLib desde hace tiempo, es que la además del instalador clásico de instalación, hoy podemos utilizar EntLib a través de paquetes NuGet. 

Descargas:

• Silverlight Integration Pack
• Optional Update 1
• Unity 2.1 for Silverlight
• Configuration tool VSIX package

Saludos @ Home

El Bruno

Fuente: http://blogs.msdn.com/b/agile/archive/2011/05/11/silverlight-integration-pack-for-microsoft-enterprise-library-5-0-released.aspx

Serie:

• El próximo Visual Studio vNext (I)

Buenas,

vamos con algunas de las novedades que se comentan en el TechEd sobre la nueva versión de Visual Studio:

IntelliTrace en Producción

Si utilizas IntelliTrace ya te puedes hacer una idea de la potencia que puede llegar a tener esta herramienta si la activamos en producción para la detección de bugs en tiempo real. Aquí no me quiero olvidar de recalcar que esto es “nefasto”, que nunca deberíamos buscar Bugs en Producción, pero cuando nos toca, mejor tener las mejores herramientas posibles. Las demos del TechEd son muy bonitas porque muestran un website, al que se le activa el IntelliTrace utilizando PowerShell en 5 segundos, se reproduce un error y luego se lee la traza histórica del IT hasta dar con el mismo. Esto en un entorno real es muchísimo más complejo, pero bueno, con tiempo y las trazas de IT bien seccionadas, es una ayuda más.

Nuevos DashBoards en Team Explorer Web Access

Seguramente este no será el nombre oficial al final, pero este es uno de los avances más esperados ya que incorpora funcionalidades 100% orientadas al trabajo ágil para la gestión de proyectos con Team Foundation Server. En el menú superior del WebAccess podemos ver los accesos a los WorkItems, Source, Build, etc. que ya conocemos.

Pero los interesantes en este punto son las 2 nuevas vistas de información que se incorporarán con vNext. Por ejemplo, en el caso de BackLog, en el mismo podremos ver un vistazo rápido de nuestro PB, con la capacidad para agregar elementos rápidamente al mismo y además la vista del trabajo pasado, actual y futuro. Se incorporan funcionalidades muy cool, como la de ordenar los elementos directamente con Drag & Drop, y luego nuevamente con Drag & Drop, poder colocar los elementos del PB en la situación que deseemos: pasado, actual y futuro. Arriba a la derecha, es posible ver un pequeño chart con los puntos de usuario que se han podido “utilizar” en las iteraciones pasadas, comparados con la capacidad disponible, de forma que podemos ir refinando nuestro concepto de capacidad a medida que avanzamos.

Otra vista en el nuevo Team Foundation Server Web App, es la que tenemos para analizar y trabajar con nuestros Sprints. La siguiente imagen, muestra como el siguiente dashboard nos permite ver de un plumazo el estado actual de los elementos del Sprint, tanto a nivel User Stories como Tasks, y además ver la carga de trabajo para cada uno de los integrantes del equipo. Una vez más en las secciones Top-Right tengo diferentes charts que me muestran información en tiempo real relacionada con mi proyecto. Si por ejemplo, veo que la capacidad de trabajo de mi equipo está en peligro, puedo arrastrar una User Story a una iteración futura y los datos de los charts se actualizarán en tiempo real.

Si eres un fanático de los tableros y los PostIts, pues esta nueva vista de Boards seguramente te gustará mucho. En la misma podemos descomponer cada una de las User Stories de nuestro PB en las tareas que tiene, y ver la clásica vista de pizarra con los elementos dentro de la misma. En este punto, el gran aliado es el Drag & Drop … . Existen reglas para validar los elementos, tiempos de vacaciones, filtros por personas, etc. para agilizar nuestro trabajo sin necesidad de jugar con Excel + VS para este trabajo.

Panel Team Navigator

Otro gran avance es este nuevo panel que además ser una especie de acceso directo a los elementos de trabajo con Team Foundation, nos pemite realizar acciones rápidas de CheckIn, revisión de Builds, status, etc. Un ejemplo interesante que se muestra en el TechEd, es un escenario donde se me pide una modificación urgente en un archivo, y para no perder mi entorno de trabajo actual, pues el mismo se graba con un snapshot (o shelveset), realizo el cambio que me han solicitado y luego puedo volver al mismo en 2 clics.

Análisis para identificar secciones de Copy & Paste

Un gran número de problemas en los desarrollos se dan por nuestro querido “Copy & Paste”, por lo general, copias una porción de código para “hacer una prueba” y a partir de allí, ese código queda vivo por siempre, desconectacto de su “origen verdadero”, etc. Vamos, que no cuento nada nuevo. Pues bueno, en vNext, se incorpora una nueva herramienta que analiza el código fuente buscando patrones de Copy & Paste (Code Clones para no ser tan agresivos).

Además de analizar el código completo de una solución,  es posible seleccionar una porción de código, que nos “huele mal” y a partir de la misma realizar una búsqueda de código duplicado.

Code Review incorporado

Una vez más utilizando el panel [Team Navigator] podemos aprovechar las nuevas funcionalidades de Code Review que se incorporarán en vNext. Para esto, y basado en el trabajo actual que estamos realizando, creamos una tarea (no es una task de TFS) de Code Review y la compartimos con un compañero de trabajo.

Cuando nuestro compañero de trabajo recibe la petición de Code Review, el mismo puede acceder a toda la información de contexto para esta actividad, incluyendo cosas tan potentes como ver las secciones de código modificadas en el estado original y el estado para el Code Review como muestra la siguiente imagen.

A partir de este momento, es posible hacer recomendaciones sobre clases, líneas de código, etc. con un flujo muy interesante para el ciclo de desarrollo.

Customer Feedback Tool

Finalmente llegamos a una versión de Microsoft Test Manager para clientes finales, en la que los mismos podrán aportar sus comentarios, sugerencias, etc. sobre un producto específico utilizando esta herramienta. por lo que tengo entendido, la misma funciona en modo offline, ya que no tiene sentido abrir nuestro servidor TFS hacia nuestros clientes y después es posible sincronizar esta información como datos locales para procesar este feedback.

Saludos @ Here

El Bruno

Fuente: http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/FDN03

Buenas,

que buenas semanas las de un TechEd o un evento parecido, por fin un monton de proyectos internos de los equipos de producto de Visual Studio y Team Foundation Server se comienzan a presentar y podemos hablar públicamente de los mismos. En este caso le toca a un SDK un tanto extraño comparados con los que nos suele presentar Microsoft, ya que se trata de un SDK para JAVA, con una serie de bibliotecas para facilitar la conexion a los servicios que provee Team Foundation Server desde entornos no Microsoft. Obviamente, fué Brian Harry quien lo presentó y además no se anduvieron con cortitas, con anuncios, promesas, etc.; este SDK YA ESTÁ DISPONIBLE para descargar desde aquí.

Los fuentes de este SDK se basan en los utilizados para Team Explorer Everywhere, que por si no lo sabías es una extensión para Eclipse que permite trabajar con TFS2010 desde el mismo. A partir de estos fuentes, es posible extender las capacidades de TFS en entornos no Microsoft utilizando Java como plataforma de desarrollo.

Brian Harry comenta los detalles muy bien en su post, así que no entraré a traducir los mismos, pero si comentar que además de las APIs de conexión con TFS, se incluyen otros elementos interesantes como por ejemplo, bibliotecas para resolver problemas de autenticación con entornos Windows (Kerberos), y todo el código disponible compilado para Windows (x86, x64), Mac (Universal), Linux(x86, x64, ppc), HP-UX (ia64_32, pa_risc), Solaris(sparc, x86, x64) y AIX (ppc). Toma mate !!!

Saludos @ Here

El Bruno

Fuente: http://blogs.msdn.com/b/bharry/archive/2011/05/16/announcing-a-java-sdk-for-tfs.aspx

Download: http://www.microsoft.com/downloads/details.aspx?FamilyID=7a3c4332-6998-48ec-b689-e434d4218012

Image Source: http://wcw.bignose.org/index.php?/archives/253-Java-2-Evil-Edition.html

Buenas,

hoy tocaba publicar la 2da parte del post para incorporar las métricas de código en las builds de Team Foundation Server 2010, pero como veo que ya es oficial parte de la información relacionada con la próxima versión de Visual Studio (code name vNext), pues aquí les dejo un repaso de las novedades:

Bienvenidos IT Pros.

En Visual Studio 2010 se hizo mucho foco por integrar a los perfiles de los testers en el ciclo de vida con Visual Studio 2010 y Microsoft Test Manager. En esta próxima versión, y aprovechando el ciclo Develop > Operate > Develop > Operate > Develop > Operate > Develop > Operate > … pues toca nuevas herramientas para trabajar codo a codo con los fabulosos amigos de sistemas.

Mejoras en Agile

Parece imposible mejorar algo que hace más de 10 años que se viene mejorando, pero yo he visto la luz algunas de las versiones internas con las mejoras para trabajar con Agile y la verdad es que se agradece la maduración que hacen de TFS + VS; y la incorporación de herramientas para mejorar el trabajo en equipos ágiles, por ejemplo tableros KANBAN, reportes dinámicos, etc.

Ojo cuando digo ágiles, no descarto SCRUM, ni ninguna de las variantes y metodologías que usualmente se utilizan.

Gestión de requerimientos/requisitos

El proceso de requisitos durante el desarrollo de una aplicación, suele ser un poco infernal si no se sabe como trabajar con los mismos. Visual Studio 2010 ALM, da un gran paso frente a versiones anteriores, pero para competir con herramientas especializadas en esta área, como DOORS de IBM, pues todavía queda mucho. Bueno en realidad, no queda tanto, vNext llegará para sorprender a más de uno.

No puedo decir nada, pero simplemente piensen cual es la mejor forma de tomar requisitos y el futuro de VS estará muy cerca de ese pensamiento. Como background y soporte estará Microsoft PowerPoint, que afortunadamente es una de las mejores herramientas de MS, y lamentablemente una de las peormente utilizadas. Ahora todos esos prototipos, propuestas, etc que se se hacen con PPTX, pues están un paso más cerca de ser artefactos reales en un proyecto de desarrollo.

Gestión de pruebas unitarias

Vamos a ver, soy el primero en admitir hay muchos framework de pruebas unitarias que son mucho mejores que el que provee por defecto Visual Studio 2010. Pero también reconozco que en muchos casos, con esta base alcanza para cubrir muchos aspectos de las pruebas unitarias en un proyecto (puristas a darme con un caño que yo paso de los comentarios). Sin embargo, un defecto MUY GRANDE que poseen las pruebas unitarias en Visual Studio 2010, es que la gestión de las mismas es muy triste, muy poco potente, etc. Vamos que si no tienes ReSharper, pues lo pasas fatal.

En vNext, puedes trabajar de forma mucho mas organizada con las pruebas unitarias y hay un par de paneles que serán las delicias de más de uno

Pues hasta aquí llega la primera tanda de novedades, en el próximo post, pues algo de Code Review, etc.

Saludos @ Home

El Bruno

More information: http://www.microsoft.com/visualstudio/en-us/roadmap?sf1468488=1

Buenas,

desde hace un par de versiones en el IDE de Visual Studio, tenemos la capacidad de realizar análisis de métricas de código en nuestras soluciones. En este análisis podremos ver la complejidad ciclomática del código, el acoplamiento entre clases, y otras métricas que nos ayudarán a ver si la calidad de nuestro código es aceptable. El problema con los resultados de esta herramienta es que no es posible incorporar esas métricas “out of the box” en el resultado de una build. En este post mostraré como se puede agregar este resultado a una build y trabajar sobre el mismo.

Para esto parto de un código que al momento de ejecutar las métricas de código retorna los siguientes valores:

Y antes de entrar al trapo, es decir un par de tareas personalizadas, interpretar xmls feos, veamos los prerequisitos. En este caso es uno y muy simple:

Descargar las Visual Studio Code Metrics Power Tools 10.0 para Visual Studio 2010 desde http://www.microsoft.com/downloads/en/details.aspx?FamilyID=edd1dfb0-b9fe-4e90-b6a6-5ed6f6f6e615

Las Visual Studio Code Metrics Power Tools 10.0 consisten en una herramienta de línea de comandos que nos permite analizar ensamblados .Net. Una vez descargadas e instaladas las PT, las mismas funcionan de una forma muy simple:

Sobre un ensamblado compilado de .Net, se lanza la aplicación [%Program Files%\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\metrics.exe] y la misma genera un xml con los resultados del análisis de métricas de código.

Por ejemplo, sobre la aplicación anterior que está compilada en la ubicación

E:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\bin\Debug\

debería lanzar el siguiente comando desde la línea de comandos:

   1:  

   2: C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop>;

   3: Metrics.exe 

   4:   /f:e:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\bin\Debug\teambuildcodemetrics.exe 

   5:   /out:e:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\bin\Debug\codemetrics.xml

   6:  

   7: Microsoft (R) Code Metrics Command-Line Tool, Version 10.0

   8: Copyright (C) Microsoft Corporation.  All rights reserved.

   9:  

  10: Calculating metrics for file 

  11: 'e:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\bin\Debug\TeamBuildCodeMetrics.exe'.

  12: Writing report to e:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCo

  13: deMetrics\bin\Debug\codemetrics.xml...

  14: Done.

  15:  

  16: C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop>

Esta acción crea el siguiente xml con toda la información de análisis de métricas de código del proyecto anterior.

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <CodeMetricsReport Version="10.0">

   3:   <Targets>

   4:     <Target Name="e:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\bin\Debug\TeamBuildCodeMetrics.exe">

   5:       <Modules>

   6:         <Module Name="TeamBuildCodeMetrics.exe" AssemblyVersion="1.0.0.0" FileVersion="1.0.0.0">

   7:           <Metrics>

   8:             <Metric Name="MaintainabilityIndex" Value="95" />

   9:             <Metric Name="CyclomaticComplexity" Value="24" />

  10:             <Metric Name="ClassCoupling" Value="14" />

  11:             <Metric Name="DepthOfInheritance" Value="12" />

  12:             <Metric Name="LinesOfCode" Value="47" />

  13:           </Metrics>

  14:           <Namespaces>

  15:             <Namespace Name="TeamBuildCodeMetrics">

  16:               <Metrics>

  17:                 <Metric Name="MaintainabilityIndex" Value="95" />

  18:                 <Metric Name="CyclomaticComplexity" Value="24" />

  19:                 <Metric Name="ClassCoupling" Value="14" />

  20:                 <Metric Name="DepthOfInheritance" Value="12" />

  21:                 <Metric Name="LinesOfCode" Value="47" />

  22:               </Metrics>

  23:               <Types>

  24:                 <Type Name="Program">

  25:                   <Metrics>

  26:                     <Metric Name="MaintainabilityIndex" Value="55" />

  27:                     <Metric Name="CyclomaticComplexity" Value="11" />

  28:                     <Metric Name="ClassCoupling" Value="13" />

  29:                     <Metric Name="DepthOfInheritance" Value="1" />

  30:                     <Metric Name="LinesOfCode" Value="32" />

  31:                   </Metrics>

  32:                   <Members>

  33:                     <Member Name="Main(string[]) : void" File="E:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\Program.cs" Line="8">

  34:                       <Metrics>

  35:                         <Metric Name="MaintainabilityIndex" Value="46" />

  36:                         <Metric Name="CyclomaticComplexity" Value="10" />

  37:                         <Metric Name="ClassCoupling" Value="13" />

  38:                         <Metric Name="LinesOfCode" Value="31" />

  39:                       </Metrics>

  40:                     </Member>

  41:                     <Member Name="Program()">

  42:                       <Metrics>

  43:                         <Metric Name="MaintainabilityIndex" Value="100" />

  44:                         <Metric Name="CyclomaticComplexity" Value="1" />

  45:                         <Metric Name="ClassCoupling" Value="0" />

  46:                         <Metric Name="LinesOfCode" Value="1" />

  47:                       </Metrics>

  48:                     </Member>

  49:                   </Members>

  50:                 </Type>

  51:                 <Type Name="Class1">

  52:                   <Metrics>

  53:                     <Metric Name="MaintainabilityIndex" Value="85" />

  54:                     <Metric Name="CyclomaticComplexity" Value="2" />

  55:                     <Metric Name="ClassCoupling" Value="1" />

  56:                     <Metric Name="DepthOfInheritance" Value="1" />

  57:                     <Metric Name="LinesOfCode" Value="4" />

  58:                   </Metrics>

  59:                   <Members>

  60:                     <Member Name="GetData() : int" File="E:\srcBcapuano\AgileLabs\Blog\TeamBuildCodeMetrics\TeamBuildCodeMetrics\Class1.cs" Line="8">

  61:                       <Metrics>

  62:                         <Metric Name="MaintainabilityIndex" Value="80" />

  63:                         <Metric Name="CyclomaticComplexity" Value="1" />

  64:                         <Metric Name="ClassCoupling" Value="1" />

  65:                         <Metric Name="LinesOfCode" Value="3" />

  66:                       </Metrics>

  67:                     </Member>

  68:                     <Member Name="Class1()">

  69:                       <Metrics>

  70:                         <Metric Name="MaintainabilityIndex" Value="100" />

  71:                         <Metric Name="CyclomaticComplexity" Value="1" />

  72:                         <Metric Name="ClassCoupling" Value="0" />

  73:                         <Metric Name="LinesOfCode" Value="1" />

  74:                       </Metrics>

  75:                     </Member>

  76:                   </Members>

  77:                 </Type>

  78:                 <Type Name="Class2">

  79:                   <Metrics>

  80:                     <Metric Name="MaintainabilityIndex" Value="100" />

  81:                     <Metric Name="CyclomaticComplexity" Value="1" />

  82:                     <Metric Name="ClassCoupling" Value="1" />

  83:                     <Metric Name="DepthOfInheritance" Value="2" />

  84:                     <Metric Name="LinesOfCode" Value="1" />

  85:                   </Metrics>

  86:                   <Members>

  87:                     <Member Name="Class2()">

  88:                       <Metrics>

  89:                         <Metric Name="MaintainabilityIndex" Value="100" />

  90:                         <Metric Name="CyclomaticComplexity" Value="1" />

  91:                         <Metric Name="ClassCoupling" Value="1" />

  92:                         <Metric Name="LinesOfCode" Value="1" />

  93:                       </Metrics>

  94:                     </Member>

  95:                   </Members>

  96:                 </Type>

  97:                 <Type Name="Class3">

  98:                   <Metrics>

  99:                     <Metric Name="MaintainabilityIndex" Value="100" />

 100:                     <Metric Name="CyclomaticComplexity" Value="1" />

 101:                     <Metric Name="ClassCoupling" Value="1" />

 102:                     <Metric Name="DepthOfInheritance" Value="3" />

 103:                     <Metric Name="LinesOfCode" Value="1" />

 104:                   </Metrics>

 105:                   <Members>

 106:                     <Member Name="Class3()">

 107:                       <Metrics>

 108:                         <Metric Name="MaintainabilityIndex" Value="100" />

 109:                         <Metric Name="CyclomaticComplexity" Value="1" />

 110:                         <Metric Name="ClassCoupling" Value="1" />

 111:                         <Metric Name="LinesOfCode" Value="1" />

 112:                       </Metrics>

 113:                     </Member>

 114:                   </Members>

 115:                 </Type>

 116:                 <Type Name="Class4">

 117:                   <Metrics>

 118:                     <Metric Name="MaintainabilityIndex" Value="100" />

 119:                     <Metric Name="CyclomaticComplexity" Value="1" />

 120:                     <Metric Name="ClassCoupling" Value="1" />

 121:                     <Metric Name="DepthOfInheritance" Value="4" />

 122:                     <Metric Name="LinesOfCode" Value="1" />

 123:                   </Metrics>

 124:                   <Members>

 125:                     <Member Name="Class4()">

 126:                       <Metrics>

 127:                         <Metric Name="MaintainabilityIndex" Value="100" />

 128:                         <Metric Name="CyclomaticComplexity" Value="1" />

 129:                         <Metric Name="ClassCoupling" Value="1" />

 130:                         <Metric Name="LinesOfCode" Value="1" />

 131:                       </Metrics>

 132:                     </Member>

 133:                   </Members>

 134:                 </Type>

 135:                 <Type Name="Class5">

 136:                   <Metrics>

 137:                     <Metric Name="MaintainabilityIndex" Value="100" />

 138:                     <Metric Name="CyclomaticComplexity" Value="1" />

 139:                     <Metric Name="ClassCoupling" Value="1" />

 140:                     <Metric Name="DepthOfInheritance" Value="5" />

 141:                     <Metric Name="LinesOfCode" Value="1" />

 142:                   </Metrics>

 143:                   <Members>

 144:                     <Member Name="Class5()">

 145:                       <Metrics>

 146:                         <Metric Name="MaintainabilityIndex" Value="100" />

 147:                         <Metric Name="CyclomaticComplexity" Value="1" />

 148:                         <Metric Name="ClassCoupling" Value="1" />

 149:                         <Metric Name="LinesOfCode" Value="1" />

 150:                       </Metrics>

 151:                     </Member>

 152:                   </Members>

 153:                 </Type>

 154:                 <Type Name="Class6">

 155:                   <Metrics>

 156:                     <Metric Name="MaintainabilityIndex" Value="100" />

 157:                     <Metric Name="CyclomaticComplexity" Value="1" />

 158:                     <Metric Name="ClassCoupling" Value="1" />

 159:                     <Metric Name="DepthOfInheritance" Value="6" />

 160:                     <Metric Name="LinesOfCode" Value="1" />

 161:                   </Metrics>

 162:                   <Members>

 163:                     <Member Name="Class6()">

 164:                       <Metrics>

 165:                         <Metric Name="MaintainabilityIndex" Value="100" />

 166:                         <Metric Name="CyclomaticComplexity" Value="1" />

 167:                         <Metric Name="ClassCoupling" Value="1" />

 168:                         <Metric Name="LinesOfCode" Value="1" />

 169:                       </Metrics>

 170:                     </Member>

 171:                   </Members>

 172:                 </Type>

 173:                 <Type Name="Class7">

 174:                   <Metrics>

 175:                     <Metric Name="MaintainabilityIndex" Value="100" />

 176:                     <Metric Name="CyclomaticComplexity" Value="1" />

 177:                     <Metric Name="ClassCoupling" Value="1" />

 178:                     <Metric Name="DepthOfInheritance" Value="7" />

 179:                     <Metric Name="LinesOfCode" Value="1" />

 180:                   </Metrics>

 181:                   <Members>

 182:                     <Member Name="Class7()">

 183:                       <Metrics>

 184:                         <Metric Name="MaintainabilityIndex" Value="100" />

 185:                         <Metric Name="CyclomaticComplexity" Value="1" />

 186:                         <Metric Name="ClassCoupling" Value="1" />

 187:                         <Metric Name="LinesOfCode" Value="1" />

 188:                       </Metrics>

 189:                     </Member>

 190:                   </Members>

 191:                 </Type>

 192:                 <Type Name="Class8">

 193:                   <Metrics>

 194:                     <Metric Name="MaintainabilityIndex" Value="100" />

 195:                     <Metric Name="CyclomaticComplexity" Value="1" />

 196:                     <Metric Name="ClassCoupling" Value="1" />

 197:                     <Metric Name="DepthOfInheritance" Value="8" />

 198:                     <Metric Name="LinesOfCode" Value="1" />

 199:                   </Metrics>

 200:                   <Members>

 201:                     <Member Name="Class8()">

 202:                       <Metrics>

 203:                         <Metric Name="MaintainabilityIndex" Value="100" />

 204:                         <Metric Name="CyclomaticComplexity" Value="1" />

 205:                         <Metric Name="ClassCoupling" Value="1" />

 206:                         <Metric Name="LinesOfCode" Value="1" />

 207:                       </Metrics>

 208:                     </Member>

 209:                   </Members>

 210:                 </Type>

 211:                 <Type Name="Class9">

 212:                   <Metrics>

 213:                     <Metric Name="MaintainabilityIndex" Value="100" />

 214:                     <Metric Name="CyclomaticComplexity" Value="1" />

 215:                     <Metric Name="ClassCoupling" Value="1" />

 216:                     <Metric Name="DepthOfInheritance" Value="9" />

 217:                     <Metric Name="LinesOfCode" Value="1" />

 218:                   </Metrics>

 219:                   <Members>

 220:                     <Member Name="Class9()">

 221:                       <Metrics>

 222:                         <Metric Name="MaintainabilityIndex" Value="100" />

 223:                         <Metric Name="CyclomaticComplexity" Value="1" />

 224:                         <Metric Name="ClassCoupling" Value="1" />

 225:                         <Metric Name="LinesOfCode" Value="1" />

 226:                       </Metrics>

 227:                     </Member>

 228:                   </Members>

 229:                 </Type>

 230:                 <Type Name="Class10">

 231:                   <Metrics>

 232:                     <Metric Name="MaintainabilityIndex" Value="100" />

 233:                     <Metric Name="CyclomaticComplexity" Value="1" />

 234:                     <Metric Name="ClassCoupling" Value="1" />

 235:                     <Metric Name="DepthOfInheritance" Value="10" />

 236:                     <Metric Name="LinesOfCode" Value="1" />

 237:                   </Metrics>

 238:                   <Members>

 239:                     <Member Name="Class10()">

 240:                       <Metrics>

 241:                         <Metric Name="MaintainabilityIndex" Value="100" />

 242:                         <Metric Name="CyclomaticComplexity" Value="1" />

 243:                         <Metric Name="ClassCoupling" Value="1" />

 244:                         <Metric Name="LinesOfCode" Value="1" />

 245:                       </Metrics>

 246:                     </Member>

 247:                   </Members>

 248:                 </Type>

 249:                 <Type Name="Class11">

 250:                   <Metrics>

 251:                     <Metric Name="MaintainabilityIndex" Value="100" />

 252:                     <Metric Name="CyclomaticComplexity" Value="1" />

 253:                     <Metric Name="ClassCoupling" Value="1" />

 254:                     <Metric Name="DepthOfInheritance" Value="11" />

 255:                     <Metric Name="LinesOfCode" Value="1" />

 256:                   </Metrics>

 257:                   <Members>

 258:                     <Member Name="Class11()">

 259:                       <Metrics>

 260:                         <Metric Name="MaintainabilityIndex" Value="100" />

 261:                         <Metric Name="CyclomaticComplexity" Value="1" />

 262:                         <Metric Name="ClassCoupling" Value="1" />

 263:                         <Metric Name="LinesOfCode" Value="1" />

 264:                       </Metrics>

 265:                     </Member>

 266:                   </Members>

 267:                 </Type>

 268:                 <Type Name="Class12">

 269:                   <Metrics>

 270:                     <Metric Name="MaintainabilityIndex" Value="100" />

 271:                     <Metric Name="CyclomaticComplexity" Value="1" />

 272:                     <Metric Name="ClassCoupling" Value="1" />

 273:                     <Metric Name="DepthOfInheritance" Value="12" />

 274:                     <Metric Name="LinesOfCode" Value="1" />

 275:                   </Metrics>

 276:                   <Members>

 277:                     <Member Name="Class12()">

 278:                       <Metrics>

 279:                         <Metric Name="MaintainabilityIndex" Value="100" />

 280:                         <Metric Name="CyclomaticComplexity" Value="1" />

 281:                         <Metric Name="ClassCoupling" Value="1" />

 282:                         <Metric Name="LinesOfCode" Value="1" />

 283:                       </Metrics>

 284:                     </Member>

 285:                   </Members>

 286:                 </Type>

 287:               </Types>

 288:             </Namespace>

 289:           </Namespaces>

 290:         </Module>

 291:       </Modules>

 292:     </Target>

 293:   </Targets>

 294: </CodeMetricsReport>

En próximos posts veremos como analizar este archivo XML de una forma simple y luego procesarlos en una tarea de Team Build

Saludos @ Home

El Bruno

Descarga: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=edd1dfb0-b9fe-4e90-b6a6-5ed6f6f6e615

Buenas,

post cortito de sábado para tener después los links a mano. Se han actualizado las máquinas virtuales de demo para Visual Studio 2010 y Team Foundation Server 2010 con un trial hasta el 1 de Noviembre de 2011.

Esta nueva versión incluye el Service Pack 1 para ambos productos y varios nuevos hand on labs. Se pueden descargar desde:

• Visual Studio 2010 RTM (Hyper-V)
• Visual Studio 2010 RTM (Windows [7] Virtual PC)
• Visual Studio 2010 RTM (Virtual PC 2007 SP1)

Saludos @ Home

El Bruno

Buenas,

ya no queda nada para que se distribuya el SDK oficial de Microsoft para desarrollar aplicaciones con Kinect. Este video es un excelente ejemplo de las capacidades que tendremos a nuestro alcance

Saludos @ Home

El Bruno

Buenas,

cuando realizas un updagre o una migración desde Team Foundation Server 2008 hacia Team Foundation Server 2010, un escenario muy común es que las definiciones de Branching y Merging se respeten, pero no se apliquen las nuevas capacidades que posee TFS2010 para Branching y Merging.

Por ejemplo, si vemos las propiedades de los elementos migrados en esta definición de Source Control, veremos que existen relaciones de Branching entre las ramas, pero no se aplican las new features de Team Foundation Server 2010.

Para poder explotar las nuevas capacidades de TFS2010, tenemos que:

- Identificar la rama raíz en la jerarquía de Branching

- Desplegar el menú contextual y seleccionar la opción [Branching and Merging // Convert To Branch]

- Importante: la opción [Recursively perform this conversion on all folders previously branched from this folder] debe estar seleccionada

- Done. Una vez finalizado el proceso ya podremos aprovechar las nuevas capacidades de B&M de TFS2010.

Saludos @ Here

El Bruno

Buenas,

cuando trabajas con TFS Integration Platform un escenario muy probable es:

Migrar los contenidos de un Team Project desde Team Foundation Server 2008 a Team Foundation Server 2010.

Si bien los conceptos básicos de Source Control y WorkItem Tracking siguen siendo similares entre ambas versiones, las plantillas de proceso han cambiado bastante y la migración de WorkItems puede traernos bastante dolores de cabeza. Si los has personalizado o extendido, pues mucho más. En estos casos, tendremos que modificar la definición de un proyecto de migración para en el mismo, definir mapeos personalizados para dar solución a estos casos.

Definir un tipo de WorkItem diferente

El siguiente Xml define una configuración donde todos los elementos del WorkItem Type [Error] se migrarán al WorkItem Type [Bug]. En este mapeo los campos de ambos WorkItem Types deben coincidir para que funcione el proceso de migración.

   1: <SettingXml>

   2:   <WITSessionCustomSetting>

   3:     <WorkItemTypes>

   4:       <WorkItemType LeftWorkItemTypeName="Error" RightWorkItemTypeName="Bug" fieldMap="@@ALL@@" />

   5:     </WorkItemTypes>

   6:   </WITSessionCustomSetting>

   7: </SettingXml>

   8: <SettingXmlSchema />

Definir un tipo de WorkItem diferente con mapeo de campos personalizado

El siguiente Xml define una configuración donde todos los elementos del WorkItem Type [Error] se migrarán al WorkItem Type [Bug], utilizando un mapeo especial de campos para los campos diferentes en ambas definiciones. En este caso el mapeo especial se denomina [Error2BugFieldMap] y en el mismo se definen los nombres de los campos y los mapeos correspondiente entre los mismos.

   1: <SettingXml>

   2:   <WITSessionCustomSetting>

   3:     <WorkItemTypes>

   4:       <WorkItemType LeftWorkItemTypeName="Error" RightWorkItemTypeName="Bug" fieldMap="Error2BugFieldMap" />

   5:     </WorkItemTypes>

   6:     <FieldMaps>

   7:       <FieldMap name="Error2BugFieldMap">

   8:         <MappedFields>

   9:           <MappedField LeftName="Headline" RightName="System.Title" MapFromSide="Left" valueMap="" />

  10:           <MappedField LeftName="Headline" RightName="System.Title" MapFromSide="Right" valueMap="" />

  11:           <MappedField LeftName="State" RightName="System.State" MapFromSide="Left" valueMap="" />

  12:           <MappedField LeftName="State" RightName="System.State" MapFromSide="Right" valueMap="" />

  13:           <MappedField LeftName="Description" RightName="System.Description" MapFromSide="Left" valueMap="" />

  14:           <MappedField LeftName="Description" RightName="System.Description" MapFromSide="Right" valueMap="" />

  15:         </MappedFields>

  16:       </FieldMap>

  17:     </FieldMaps>

  18:   </WITSessionCustomSetting>

  19: </SettingXml>

  20: <SettingXmlSchema />

Definir un tipo de WorkItem diferente con mapeo de campos personalizado y valores personalizados

El siguiente ejemplo extiende el escenario anterior ya que para los mapeos de campos, además define una serie de diccionarios donde se realizan los mapeos de los valores personalizados entre los campos de cada tipo de WorkItem (ejemplos en las líneas 11 y 19).

   1: <SettingXml>

   2:   <WITSessionCustomSetting>

   3:     <WorkItemTypes>

   4:       <WorkItemType LeftWorkItemTypeName="Error" RightWorkItemTypeName="Bug" fieldMap="Error2BugFieldMap" />

   5:     </WorkItemTypes>

   6:     <FieldMaps>

   7:       <FieldMap name="Error2BugFieldMap">

   8:         <MappedFields>

   9:           <MappedField LeftName="Headline" RightName="System.Title" MapFromSide="Left" valueMap="" />

  10:           <MappedField LeftName="Headline" RightName="System.Title" MapFromSide="Right" valueMap="" />

  11:           <MappedField LeftName="State" RightName="System.State" MapFromSide="Left" valueMap="StateMapCQ2TFS" />

  12:           <MappedField LeftName="State" RightName="System.State" MapFromSide="Right" valueMap="StateMapTFS2CQ" />

  13:           <MappedField LeftName="Description" RightName="System.Description" MapFromSide="Left" valueMap="" />

  14:           <MappedField LeftName="Description" RightName="System.Description" MapFromSide="Right" valueMap="" />

  15:         </MappedFields>

  16:       </FieldMap>

  17:     </FieldMaps>

  18:     <ValueMaps>

  19:       <ValueMap name="StateMapCQ2TFS">

  20:         <Value RightValue="Active" LeftValue="Assigned" />

  21:         <Value RightValue="Active" LeftValue="Duplicate" />

  22:         <Value RightValue="Active" LeftValue="Opened" />

  23:         <Value RightValue="Active" LeftValue="Submitted" />

  24:         <Value RightValue="Resolved" LeftValue="Postponed" />

  25:         <Value RightValue="Resolved" LeftValue="Resolved" />

  26:         <Value RightValue="Closed" LeftValue="Closed" />

  27:       </ValueMap>

  28:       <ValueMap name="StateMapTFS2CQ">

  29:         <Value RightValue="Active" LeftValue="Assigned" />

  30:         <Value RightValue="Resolved" LeftValue="Resolved" />

  31:         <Value RightValue="Closed" LeftValue="Closed" />

  32:       </ValueMap>

  33:  

  34:   </WITSessionCustomSetting>

  35: </SettingXml>

  36: <SettingXmlSchema />

He tomado como referencia los ejemplos que plantea Willy Peter Shaub en este post, para los elementos completos de migracion TFS2008 hacia TFS2010 pues consultar con El Bruno.

Saludos @ Home

El Bruno

Buenas,

un gran fallo, según mi punto de vista del lanzamiento de Visual Studio 2010, era que el soporte para IntelliTrace solo estaba disponible para entornos x86. Ahora bien, un añazo después del lanzamiento de Visual Studio 2010, y gracias al Service Pack 1, ya tenemos soporte para IntelliTrace para x64. Un collectivo de gente, por ejemplo los Sharepoint 2010 developers, lo agradeceran.

La descarga del Service Pack 1 se puede realizar desde http://go.microsoft.com/fwlink/?LinkId=209902

Saludos @ Home

El Bruno

Buenas,

antes de que los puristas me den con un latigo, les comento que la premisa que me guía para trabajar con comentarios es la siguiente:

“Comentarios los justos”

Esto significa que soy conciente de que el código tiene que ser autodescriptivo, para que no sea necesario poner comentarios, pero también entiendo que en ocaciones un par de líneas de comentarios pueden ahorrarnos bastantes dolores de cabeza.

Pues bien, si los comentarios son lo tuyo, pues esta extensión seguro que te alegra el viernes: http://visualstudiogallery.msdn.microsoft.com/17c68951-7743-40bd-ad35-608706f54a92/. La misma analiza los comentarios en el código y de acuerdo a pequeños patrones en los mismos formatea el código.

Por ejemplo, el prefijo “//+” incrementa el tamaño del texto del comentario.

otras opciones son “//x” para tachar un comentario

y hay varias más.

Saludos @ Here

El Bruno

Descarga: http://visualstudiogallery.msdn.microsoft.com/17c68951-7743-40bd-ad35-608706f54a92/

Buenas,

a continuación os dejo un enlace con la presentación que realizamos esta mañana con Juan Luis sobre Visual Studio 2010 LightSwitch y Azure en las oficinas de microsoft.

Visual Studio 2010 Ligthswitch + AZURE + Zero Code