VS2008: Source Code Outliner PowerToy

Hola a todos, acabo de toparme con este complemento que me parece interesante.
Se trata del Source Code Outliner PowerToy, el cual tiene como funcionalidad mostrar una vista estructurada de la clase que vayamos revisando, en resumen: hace un arbolito de nuestro código, claro entre métodos, campos y demás implementos!
La instalación es sencilla, nada fuera del otro mundo, así que luego de instalar, en el menú tendremos una nueva vista:
image

Bueno, hagamos click, no?
image

De por si, podrán notar cierta similitud con el Class View, pero la diferencia clave es: se centra en la clase que estés trabajando. Seleccionas y te ubica en la cabecera =D
image

Como tal, cuenta con un filtros y buscador, que como tiene limitante realizar búsquedas simples, no soporta buscar «entre palabras», aspecto que si considera el Class View (el cual los invito a revisar).
image
image
image 

De por si este complemento, tal como dije líneas arriba, me parece interesante, es gratuito e intuitivo aunque lamentablemente veo que no le están dando soporte para Visual Studio 2010 =(

Pero si les interesa darle una revisada, pues aquí el enlace de su espacio en la Galería de Visual Studio y su espacio en codeplex =O

Saludos y Muchas Gracias
@Jersson

VS2010: Impacto en las pruebas unitarias

A comenzar!
Hace unas horas mientras revisaba el Visual Studio 2010, encontré esta opcion, la cual no puedo dejar de comentar.
image

Cómo es que trabaja esta funcionalidad?
Pongámoslo de esta manera:
– Tenemos una serie de pruebas unitarias relacionadas a código que hemos construido.
– Hemos modificado parte del código que es verificado a traves de estas pruebas.
– Queremos saber que/cuales pruebas unitarias han sido afectadas.
– Es posible?

Bueno… lo es!
Comencemos con algo simple:
– Dos métodos con sus respectivos métodos de prueba
image 

image

Creo que no hay necesidad de verificar que al ejecutar nuestros métodos de prueba, no tendremos problemas, es decir, todo en verde =)
Pero antes de hacer esto, vayamos a la ventana Test Impact View
image

Como podrán notar, es necesario habilitar este complemento, asi que, haremos click en Enable the test…
image

Procedemos a ejecutar nuestros métodos de prueba:
image 

image

Hacemos un cambio en uno de los métodos, vamos, es un ejemplo, no sean tan exigentes =)
image

Luego del cambio podemos recompilar el proyecto, y vamos a la nueva ventana:
image 

Como podrán notar, al realizar cambios en nuestro código fuente, la vista de impacto muestra (asi es) las pruebas unitarias que deberiamos revisar, o bueno, volver a ejecutarlas, cómo mínimo!!
Esto de por sí nos da una ayuda clave a nivel programación ya que –ahora si- no hay opción a decir “bueno, ya termine de programar, ahora a probar todo de nuevo! o por cual comenzar?”

Hasta aquí los invito a revisar el detalle de esta funcionalidad, pero para terminar quiero complementar con una opción adicional…

Se ubican en los métodos que van construyendo, hacen click derecho…
image 

image
Favor notar que me he ubicado en un método que no ha generado impacto en las pruebas unitarias.

Los invito a revisar esta funcionalidad, espero les sea de utilidad.

Muchas Gracias.
@Jersson

VS2010: Cobertura de Código

Hola a todos,
Posiblemente, luego de haber ejecutado sus pruebas unitarias hayan encontrado la siguiente opción:
image

La cual muestra la cobertura del código realizada al momento de ejecutar las pruebas unitarias, es decir, ¿qué tanto código es cubierto por nuestras pruebas?

Pues bien, si queremos conocer esta información, click.

Si luego se encontraron con esto:
image 
Al parecer falta configurar algo no? Asi es.

Veamos que pasos seguir.
Tal como indica la imagen, deben dirigirse a la opción
TestEdit Test SettingsLocal
image
Lo que encontrarán es la ventana principal de configuración de proyectos de prueba, la cual los invito a revisar de manera “curiosa”, por favor, sean cuidadosos =)
image 
En la sección Data and Diagnostics, encontrarán la seccion de cobertura de código:
image

En este caso, lo que debe hacerse es dar click para habilitar dicha opción, y notar que el botón Configure ha sido habilitado.
image

Solo queda un paso, click en Configure.
image

Seleccionamos el assembly que necesitamos para cobertura de código, click en OK y Aplicar para regresar a nuestro Visual Studio.
image
Volvemos a correr nuestras pruebas
image

image 

Al seguir estos pasos se encontrarán con:
image 
Ahora, como podrán notar dice 50% de cobertura. Si desean cubrir un mayor %, digamos… 100% pues, se tendrían que programar muchas pruebas, para lo cual, lo recomendable sería automatizar o generar pruebas de una forma mas sencilla. Si están interesados en ese aspecto, los invito a revisar Microsoft Pex =D.

Sin más me despido.
Muchas Gracias

@Jersson

VS2010: Generador de Pruebas unitarias con Pex

image

Comenzamos este post con una clase, digamos que “simple”. La cual refleja dos operaciones básicas; sumar y dividir.
Agreguemos a esto que la directiva de desarrollo es:
– “todo método va con su prueba unitaria
Ante esto y ya lo he vivido en mas de un proyecto la respuesta común es:
– “me quita tiempo, lo dejaré para después, no es importante”
Entonces, solo me queda decir:
– “No hay pretexto que valga”

Esto por qué?
En primer lugar, no hay respuesta inválida, el problema es que muchas veces no hay un sustento concreto. Este es el caso de la frase “no es importante, me quita tiempo”, ya que, a pesar de ser cierto el hecho de tener que programar cada caso y prueba unitaria, es importante dejar este sustento.

Pero, el problema a relucir es muchas veces la cantidad de casos a probar y por ende, la cantidad de pruebas unitarias a preparar, vamos, tenemos que aceptar que el número de pruebas es variable. Dependiendo claro, de la lógica a ofrecer.
Tal es el caso de una división simple, que a pesar de tener dos parámetros, uno debe considerar aspectos importantes como el clásico caso de la división por cero.
Créanme, hay lugares donde he visto como se omitió esta variante y ERROR!!! LLAMEN A LOS BOMBEROS!! No es broma… pero bueno.

Entonces, si de división se trata, deberíamos tener al menos dos casos, o bueno, quizá mas… y ahora? a programar los casos? Nada que ver, usemos Microsoft Pex.
image 

Esperamos mientras Pex comienza a revisar el método, hasta que muestra la siguiente ventana de resultados:
image

Aquí me detendré en algunas secciones de la ventana, como esta, que te indica los mensajes de las excepciones que saldrían si no controlamos bien nuestro código:
image  

Si seleccionamos un registro, obtendremos información del método de prueba usado.
image 

image 

Por otro lado, en el extremo derecho de nuestro Visual Studio, encontraremos una nueva sección:
image 
La cual nos dará una idea más gráfica del estado de los métodos de prueba generados.

Ahora!
Qué sucede si queremos tener estos métodos en un proyecto de pruebas?
Pues seleccionamos
image

image

image 

Esperamos un momento y revisamos los cambios en nuestro Explorador de Soluciones:
image 

Revisamos nuestro archivo vsmdi, el cual al abrir nos mostrará un listado de las pruebas unitarias creadas en toda la solución:
image

El cual será:
image

Ya si queremos verificar el estado de las pruebas unitarias, pues, check a todas, click derecho…
image

Si verificamos el resultado:
image

El cual es similar a lo obtenido inicialmente. Lo cual demuestra el traslado de las pruebas unitarias creadas de manera automática.

De por si, aquí hay mucho por ver, como por ejemplo el código generado, el cual, los invito a revisar =)
Me despido sin más, esperando sus comentarios, y claro, que descarguen y usen Microsoft Pex.

Saludos y Gracias
@Jersson

VS2010: Diagrama de Secuencia (en reversa)

Buenos días =D
Hace poco mientras conversaba con unos amigos, y bueno, también en la ultima expo que tuve, mencioné esta funcionalidad UML.
De qué se trata? pues de momento, les comento algo que para muchos ya no es novedad, (de todas formas, espero darme un tiempo para el post) Visual Studio 2010 soporta UML 2.0
Como tal, podríamos dedicarle una serie de posts al respecto, como por ejemplo este enlace, que ubiqué sin muchos problemas en la red.

Pero bueno, la idea del post es mostrarles como es que se puede aprovechar la ingeniería reversa del Visual Studio 2010, y con esto (y un poco de suerte) generar un diagrama de secuencia. Debemos admitirlo, todos hemos pasado por la clásica pregunta ¿y los diagramas?

Bien, comenzamos con dos clases en una Biblioteca de Clases (si El Bruno dice que asi se llama, en mas de uno de sus posts, es cierto!)
image

Como podrán notar se trata de una clase con el objetivo particular de administrar entradas y salidas de stock, digamos que estamos manejando un almacén tradicional, en el cual se administran cierta cantidad de items.

Entonces, hemos creado un formulario que simula este tipo de movimientos (ingreso, salida y ver el disponible), es decir:
(no, no tengo plug-ins de código fuente =D)
image

Bien, aqui la interrogante… UML??? si, es factible. Facil, click derecho…
image 

Configuración de las llamadas incluir (los invito a revisar esta ventana)
image

Ingeniería reversa en progreso!
image
Y luego…
image
Diagrama de secuencias =)

Si hay algo mas para mostrar? pues la verdad, mucho… pero de momento, me despido no sin antes recomendar revisen su Visual Studio, queda mucho por aprender =)

Saludos
@Jersson

VS2010: Comparación entre ediciones?

Pues bien, esta es una de las preguntas que me hicieron hace poco en la UTP, cuando expuse sobre VS2010, de estas puedo listar las siguientes:
– Cuántas ediciones hay?
– En qué ediciones encuentro las funcionalidades de Arquitectura?
– Con qué versión de UML trabaja?
image

En el gráfico podrán encontrar respuesta, con características por edición. Más claro que eso, no se me ocurre =D

Seguiré respondiendo algunas preguntas y mencionaré algunas de las preguntas que fueron interesantes… y que, por suerte, pude responder =D

Saludos
@Jersson

VS2010: Comparación de Código

Pues bien, antes de dar un breve descanso, quería contarles de la última herramienta que he estado probando.
Code Compare, es uno de los complementos disponibles en la Galería de Visual Studio, o en todo caso, a través del administrador de excepciones, tal como podemos apreciar:
image 
Mayor explicación al Code Compare? pues es un complemento gratuito, que tiene como objetivo principal… comparar archivos! obvio no?
Bueno, las aclaraciones siempre son necesarias =)

Complejidad de uso? No mucha, por no decir, nula! ya que la he notado como una herramienta altamente intuitiva. Es cuestión de ubicarte, por ejemplo, en una clase, click derecho, comparar este documento…
image

Pues bien, si de comparaciones se trata, se requiere siempre algo contra que comparar, no? de momento, te genera:
image
Claro, no hay archivo o fuentes contra que comparar, para ello, he agregado una clase program.cs, es decir, tiene el código por defecto.

Si deseo comparar contra otro archivo, se puede usar el clásico botón punteado para seleccionar un archivo en partícular, es decir:
image  
O, pueden seleccionar una clase de la solución y arrastrar hacia el espacio en blanco, lo cual luego de realizar esta operación, te genera:
image
Ahora, que hay de interesante en esto? Sugiero que revisen los botones con flechitas que se pueden notar en las columnas centrales, aquí mas detalle:image

En este caso, la exploración y curiosidad es más que requerida, pues estos botones con flechitas, de ser presionados; generarán lo que uno siempre quiere realizar al hacer comparación de archivos… pues claro! un merge!
image

Si esta funcionalidad ya existe? pues si, pero si usan TFS o VSS, han notado los pasos que tienen que seguir? (click derecho, ver historial, comparar…), ahora bueno, si desean integrarlo con el TFS, les comento… si se puede!

Por otro lado, algo que acabo de descubrir, en el Windows Explorer, click derecho…
image 

Debo admitir que hay aspectos que me faltan mencionar, pero les pediría que revisen este complemento, además claro de la barra de herramientas que se agrega, de la cual, pondré el siguiente gráfico:
image 
Sin más, me despido.
Saludos
@Jersson

VS2010: Remover “usings” en la solución

Una de las características que siempre me ha llamado la atención en Visual Studio 2010 es la de remover “usings”.
De por si, esto nos ayuda a tener un código “más límpio”.
Por su parte, Visual Studio 2010 trae esta funcionalidad para C#, a nivel de clases, es decir, si te encuentras en una clase y deseas “limpiar” la sección de usings, pues luego de usar esto:
image 
Quedamos con:
image

Hasta aquí, para muchos, poca novedad, no?
Pero que tal si hacemos lo mismo a nivel de Proyecto?
image 

Y a nivel de Solución?
image

Si seleccionan esta opción, pues luego de revisar todas las clases de todos los proyectos, podrán asegurar con certeza que, estan considerando los namespaces necesarios, de manera que su código está en camino de ser “mas limpio”

Ahora, la prueba de rigor es verificar si es que luego de eliminar tantos using, la solución sigue compilando:
image

Interesante no?

Les recomiendo utilizar esta característica, no sin antes anotar algunas consideraciones :
– Se encuentra disponible para entornos basados en C#
– La funcionalidad a nivel de proyectos y solución, se obtiene al instalar el Visual Studio Power Commands, ya descrito anteriormente.

Saludos y Gracias
@Jersson

The Old JersSoft

Ayer por la tarde, el bueno de Jonathan Aldave mencionó algo que me llamó mucho la atención:

image
Es interesante pero no recordaba esos posts!!! hace mucho que habia dejado de ver el blog. Vamos, que por algo se llamaba el blog viejo, no? =D

En fin, luego de nostalgia y demás cosas, he decidido considerar algunos posts en el nuevo blog, tal como ha pasado con “Cómo nace un paradigma?” espero tomar algunos posts, actualizarlos y bueno, compartir esas ideas locas que tenía por esas épocas, no?
La dirección y nombre del blog viejo es: The Old JersSoft
El cual pueden ubicar en la columna izquierda de este blog =)

image

Bueno, ya es mucha propaganda, no? =D
Sin más me despido.

Saludos y Gracias
@Jersson