[TFS] 2007 September Power Tools released !!!

Buenas

interesantes news from BHarry’s blog; se he liberado la version de Septiembre de 2007 de las Power Tools para Team Foundation Server. El detalle de las novedades se puede leer aquí, pero básicamente posee 2 novedades:

  • TFS Work Item Templates
    Esta herramienta permite automatizar el “rellenado” de los campos de los WorkItems de Team Foundation Server, creando plantillas con los campos predefinidos con valor y luego creando WorkItems a partir de estas plantillas.
  • TFS Best Practices Analyzer
    Esta herramienta permite analizar instancias de Team Foundation Server y detecta en las mismas posibles errores de configuración, fallos de instalación, etc.

La descarga se puede realizar desde http://msdn2.microsoft.com/en-us/teamsystem/aa718351.aspx y espero ansioso volver a mostrar estas novedades para ver que impacto tienen en proyectos ya existentes.

 

Saludos @ Home

El Bruno

Crossposting from ElBruno.com

Software Factories: donde, cuando y como




Buenas,

una pregunta que usualmente muchas personas se hacen cuando comienzan un nuevo proyecto de desarrollo, suele estar relacionada con la utilización/creación de Factorias de Software.


No conozco a casi ningún desarrollador que no aproveche alguna de las factorías existentes, pero creo que antes de embarcarnos en la 2da opción (creación de una SF) debemos tener varios aspectos en cuenta. En este post no hablaré sobre la teoría que subyace las Software Factories, sino que comentaré mi experiencia personal trabajando en un proyecto para la creación de las mismas.


Comencemos por la definición de una Software Factory:



“A software factory is a structured collection of related software assets. When a software factory is installed
in a development environment, it helps architects and developers predictably and efficiently create high-quality instances of specific types of applications.”

Microsoft Patterns and Practices

In software engineering and enterprise software architecture, a software factory is defined as a software organization structured such that software projects are built in discrete work centers. Work centers generally represent, or specialize in, certain software disciplines such as architecture, design, construction, integration, test, maintenance, packaging, release, etc. Much like a true manufacturing facility, software factories require clearly defined product creation and management processes. By utilizing the fundamentals of industrial manufacturing – standardized components, specialized skill sets, parallel processes, and a predictable and scalable consistency of quality – a true Software Factory can achieve a superior level of application assembly even when assembling new or horizontal solutions. Industrialization of the software process can provide benefits in terms of economies of scale, geographic distribution, load leveling, and rigorous product and process control. Software factories have gained recent popularity as a cost-efficient way to reduce the time it takes to develop, create and/or construct software solutions.

Wikipedia


En otras palabras, y enfocándonos desde el punto de vista de un developer; podemos describir a una Software Factory como una o más herramientas que automarizan la creación de artefactos para resolver un problema de un dominio específico. Por lo general, las Software Factory generan código, pero también pueden generar documentacion, scripts, guidelines, etc.


El proceso de desarrollo de una Software Factory, es un proceso complicado y que difiere mucho al proceso clásico de creación de una pieza de software. Por ejemplo; en Avanade estamos distribuidos globalmente, y el número de empleados crece año a año. Como la mayoría de los proyectos son desarrollos basados en tecnologías Microsoft; existe un área de I+D en Seattle que se dedica a la creación de Assets/Activos para que los demás equipos en el mundo seamos más productivos y tal vez más eficientes. Desde mi punto de vista de usuario/developer de estos activos, pienso que algunos son muy poco aplicables pero también estoy muy contento con otros (Aca.Net/Enterprise Library es un buen ejemplo).


 


Dónde


Este tipo de apuestas por parte de una empresa, supone el primer filtro para decidir quienes van a apostar por la construcción de una Software Factory. La misma supone un coste adicional para una empresa. Entre otras cosas, porque los resultados de la aplicación de la misma no son visibles inmediatamente.


Es necesario ser concientes que la creación de una Software Factory como proyecto tiene las siguientes características:



  • Suele ser mas largo que un proyecto común de desarrollo, generalmente 2 ó 3 veces más largos .  
  • El ROI sobre el mismo, se puede esperar después de la 5ta o 6ta implantación de la SF.
  • Identificar este tipo de proyectos, requiere una gran visión de negocios; ya que el resultado final del mismo deberá ser implementado en 5 o mas proyectos para ser rentables.
  • Además de la inversión para la creación de la Software Factories, es necesario tener en cuenta otra inversión posterior para la formación de los profesionales que utilicen los assets que involucra la Software Factories.

 


Cuando


Si trabajas como consultor, seguramente cada tanto pensarás en automatizar algún tipo de proceso repetitivo que realizas en diferentes proyectos. Sin embargo, una Software Factory es algo más que un asset que se pueda reutilizar en varios proyectos.



  • Para comenzar a construir una Software Factories necesitamos tener un alto conocimiento sobre el dominio específico de la aplicación sobre la que trabajará los assets de nuestra Software Factory.
  • Cuando sin llegar a ser una factoría completa, tengamos una serie de assets que nos ayudan en el proceso de desarrollo; y se presente la oportunidad para empaquetar los mismos, es un buen momento.
  • Cuando nuestro negocio requiera un tipo de implementación frecuente que puede ser automatizada de forma organizada.

 


Cómo


Si después de realizar una evaluación, finalmente nos decidimos por la construcción de una serie de herramientas que puedan conformar una Software Factory; este pequeño diagrama puede ilustrar una primera aproximación para ver como gestionar el ciclo de vida de la misma.



 


Como podemos ver a diferencia de un proceso estandar de desarrollo, una Software Factory comienza a madurar luego de generar un producto a partir de la misma. Un detalle muy importante es que por lo general, este tipo de proyectos son proyectos muy ágiles y dinámicos que constantemente están madurando y adaptándose a las nuevos cambios del dominio donde trabajan. Además siempre es conveniente que estén basados en una implementación de referencia sobre la que se basarán las diferentes implementaciones de una versión específica de la Software Factory.


 


Actualmente, Visual Studio 2005 posee muchos recursos para la construccion de este tipo de proyectos. Visual Studio Extensibility Developer Center es un punto de referencia imprescindible para comenzar a conocer como extender las herramientas que posee Visual Studio. Particularmente creo que un buen punto para comenzar es conocer:



Además un recurso imprescindible puede ser Visual Studio Extensibility Guided Tour.


 


 


Saludos @ La Finca y happy factoring


El Bruno


Crossposting from ElBruno.com

[VS2008] Code Metrics

Microsoft Visual Studio 2008 Beta 2

Buenas

después de unas semanas complicadas jugando con el Nanocóptero y cuando comienzo a cerrar los pendientes con las Domain Specific Language Tools, me queda tiempo para probar un par de cervezas con los amigos algunas de las novedades de Microsoft Visual Studio 2008. En este caso uno de los 4 pilares fundamentales del desarrollo que posee Microsoft Visual Studio 2008: Code Metrics.

Esta nueva herramienta permite a los desarrolladores generar métricas para sobre proyectos y soluciones de Visual Studio para analizar la “complejidad” de los mismos. Los resultados se realiza sobre 5 tipos diferentes de análisis: Maintainability Index, Cyclomatic Complexity, Depth of Inheritance, Class Coupling, and Lines of Code (donde los datos del primer análisis surgen de una fórmula sobre los resultados de los 4 restantes).

Pues bien, si te gusta la informática seguramente conocerás los conceptos sobre los que se basan las métricas de código, pero lo interesante es ver como está integrado dentro de Microsoft Visual Studio 2008. Para esto, pensé en escribir un poco de código para una mini demo, pero después me decanté por utilizar un poco de código ya escrito, y tal vez uno de los más populares para los desarrolladores .Net: Enterprise Library 3.1.

 

El proceso de análisis tarda un poco, teniendo en cuenta la cantidad de código que posee EntLib, no es de extrañar. Y tampoco es de extrañar los excelentes resultados que da el mismo; todos los assemblies con un nivel de mantenibilidad muy alto (all greens) y salvo excepciones detalles como el Core.Design la complejidad ciclomática es muy buena:

 

Sobre el panel Code Metrics, sobre los resultados obtenidos, es posible realizar algunos filtros por algunos de los análisis realizados para analizar más en detalle esta información:

 

Finalmente, si queremos realizar un análisis más detallado, es posible exportar los resultados a la herramienta de BI más popular para el desktop: Microsoft Excel.

 

 

Por ejemplo, el siguiente gráfico muestra los diferentes resultados del análisis realizado sobre cada uno de los assemblies de Enterprise Library 3.1 y si alguien está interesado en ver todo el detalle puede descargar el archivo excel desde aquí.

 

Nota: llama la atención la cantidad de código que tiene el Logging AppBlock, versus el Exception Handling AppBlog, entre otras cosas.

 

Pues bien, una gran incorporación para Microsoft Visual Studio 2008 y una nueva gran herramienta para nosotros los desarrolladores, que nos permitirá perfeccionar un poco más el resultado de nuestro trabajo diario.

 

Saludos @ Home

El Bruno

Crossposting from ElBruno.com

OpenXml Writer … (no usa el chapuzon del OpenXml SDK)

Buenas

se están por cumplir 2 años de mis primeros acercamientos a OpenXml y todavía no hay un SDK decente en el mercado para el procesamiento de los documentos del nuevo Microsoft Office 2007.

Ojo, esto tiene su lado bueno. Si tienes algún enemigo al que le desees lo peor, le puedes aconsejar que trabaje con el Microsoft SDK for OpenXml; pero ten cuidado porque asi empiezan las vendettas y después de esto solo queda comenzar una guerra de familias que no acabará hasta que una de las dos se extermine o hasta que se apruebe como estandar el OpenXml.

 

Por suerte existe una web para desarrolladores con mucha información: http://openxmldeveloper.org/. Gracias a la misma me he encontrado con un WordPad editor de archivos docx, con su código fuente incluido que, como un primer acercamiento a una aplicacion OpenXml viene muy bien. Se trata de OpenXml Writer:

 

Si están interesados en comenzar a trabajar con documentos OpenXml, esta aplicacíon demuestra con un código muy simple como realizar las tareas más comunes para trabajar con docs docx.

Si desoués de esto, siguen interesados en trabajar con OpenXml, esperen a la 2da versión del Microsoft SDK for OpenXml; … 😉

 

Saludos @ La Finca

El Bruno

Crossposting from ElBruno.com

[VS2008][DSL] Lo que vendrá … (las 2das partes mejoran con el tiempo !!!)

Microsoft Visual Studio 2008 Beta 2


Buenas,


lamentablemente no puedo escribir mucho acerca de lo que estoy haciendo con Domain Specific Language Tools, pero cada tanto trato de dejar algún pequeño tip o tutorial sobre las mismas para que un problema o una tarea que suele tardar un día o mas en solucionarse, se pueda realizarse en minutos. No me considero un usuario experto, pero si admito que las estoy utilizando/presionando bastante hasta ver adonde llega el SDK de Visual Studio 2005 y las propias Domain Specific Language Tools. Como cualquier herramienta en su primera versión, en este momento el concepto al que tratan de acercarnos es muy interesante; pero lamentablemente la implementación es un poco pobre en algunos aspectos, la distribución por ejemplo.


Es por eso que el equipo encargado de Domain Specific Language Tools se ha movido del grupo Team Architect al equipo de Visual Studio (donde por naturaleza deberían pertenecer). Además al ser parte nativa del shell de Visual Studio, no será necesario el SDK de Visual Studio para el desarrollo de DSLs, estarán mucho más integradas dentro de Visual Studio.


Sin embargo la nueva versión de VS, Microsoft Visual Studio 2008 no implementará grandes cambios con respecto a las DSL Tools actuales, solo la inclusión dentro del IDE, algunos fixs importantes del SDK y por fin un improvement para la gestion de los path entre elementos del modelo.


Para los cambios importantes, en cuanto a diseño, implementacion y maduración del modelo de creación de DSLs deberemos esperar hasta Rosario, o ¿porque no? utilizar las propias Domain Specific Language Tools para crear una nueva versión de las Domain Specific Language Tools.


 


Saludos @ Home


El Bruno


PD: se que crear código que se cree a si mismo da un poco de miedo porque es un step close a los robots que aprenden a aprender, y a partir de allí queda muy poco para un futuro apocalíptico donde los robots se muevan como en este video.



Crossposting from ElBruno.com

[DSL] Como agregar un menu personalizado


Buenas,


siguiendo con la lista de las tareas más comunes que realizamos o aunque sea tratamos cuando trabajamos con las Domain Specific Language Tools es agregar un menú personalizado dentro del IDE de Visual Studio 2005.


Como siempre el mejor lugar para poder encontrar una referencia es MSDN, pero sin embargo no existe un ejemplo end-to-end para poder completar esta tarea. Es por esto que el siguiente tutorial, partirá desde el último ejemplo de un proyecto DSL para la gestión de Proyectos y Usuarios, y sobre el diseñador agregaremos un menú contextual que muestre información sobre el o los elementos seleccionados.


 


Tutorial



  1. Trabajaremos sobre el proyecto DslPackage.
  2. Editar el archivo DslPackage \ CtcComponents \ Commands.ctc
    (es conveniente refrescar algunos conociemientos de hace algun tiempo para comprender la sintaxís de este archivo, pero siempre es bueno volver a la fuente)
  3. Después de la sección de los includes, agregamos 2 #defines para referenciar nuestro nuevo elemento del menú.
  4. El primer elemento definirá un id unívoco para el menú y el segundo elemento identificará al ícono que se le asignará al menú.

    #define displaySelectedItemInformation 0x801
    #define IconDslMenu guidOfficeIcon:msotcidMergeToDocument

  5. Para la imagen del menú he utilizado uno de los 7000 iconos disponibles que trae Office y que podemos encontrar en el archivo “..Program FilesVisual Studio 2005 SDK2007.02VisualStudioIntegrationCommonIncoffice10msobtnid.h“, incluido dentro de la definición del archivo Commands.ctc. De este archivo he seleccionado la entrada 159 que representa al Label: “&Merge to Document

  6. Dentro de la sección BUTTONS_BEGIN agregamos la definición para la creación de nuestro menú.

    BUTTONS_BEGIN
    GENERATED_BUTTONS
    // Add additional button definitions here.
    // Command, Parent Group, Priority, Image, Type, Visibility, Text;
    //guidCmdSet:displaySelectedItemInformation, guidCmdSet:grpidContextMain, 0x0100, OI_NOID, BUTTON, DIS_DEF, “&Display Selected Item Information”;
    guidCmdSet:displaySelectedItemInformation, // Command ID
    guidCmdSet:grpidContextMain, // Group ID
    0x0100, // Priority
    IconDslMenu, // Icon ID
    BUTTON, // Button Type
    0, // Flags
    &Display Information, // Command Text
    &Display Information, // Menu Text
    Display Selected Item Information, // ToolTip Text
    Display Selected Item Information, // Command Well Text
    DisplayImformation, // English Command Name
    DisplayImformation; // Localized Command Name

    BUTTONS_END

    la definición de cada nuevo elemento que querramos agregar se comprende de una serie de valores que identifican el elemento, el elemento superior, la prioridad, el icono del mismo, el tipo de elemento, la visibilidad, y el texto. La definición completa de los elemento en esta sección se explica en el MSDN en este link.
  7. A continuación editamos el archivo DslPackage \ GeneratedCode \ Package.tt; y modificamos la definición de los menues que agregaremos incrementando el parametro contador como la cantidad de menúes que queremos agregar. En este caso es igual a 1:

    [VSShell::ProvideMenuResource(1000, 1)]

  8. Transformamos todos los templates desde el Solution Explorer (o alguna ruta alternativa)
  9. Agregamos una nueva clase al proyecto llamada Dsl15CommandSet.partial.cs. Este archivo implementará una clase parcial para la clase Dsl15CommandSet.
  10. Dentro de esta clase agregaremos una constante que represente nuestro menú y que coincida con el valor del menu que creamos en el Commands.ctc. Por ejemplo:

    #region Command ID constants

    // Must be unique within this DSL.
    // Must equal the values defined in Commands.ctc
    private const int displaySelectedItemInformation = 0x801;

    #endregion


  11. Sobreescribiremos la función GetMenuCommands(), donde agregaremos un nuevo menu referenciado al id que creamos en el paso anterior. Para la creación del CommandId utilizo un helper llamado CustomCommandId():

    /// <summary>
    /// Register event handlers for menu commands. Called once when the DSL designer starts.
    /// </summary>
    /// <returns></returns>
    protected override IList<System.ComponentModel.Design.MenuCommand> GetMenuCommands()
    {
    // Get the commands defined in the generated code.
    global::System.Collections.Generic.IList<global::System.ComponentModel.Design.MenuCommand> commands = base.GetMenuCommands();

    CommandID cmdId = CustomCommandId(displaySelectedItemInformation); // Unique Id for this command

    // Add command handlers for menu items to change an Association’s sort.
    // Each command has two handlers:
    // OnStatus… which determines whether the command should appear on the menu
    // OnMenu… which performs the command
    DynamicStatusMenuCommand displaySelectedItemMenu =
    new DynamicStatusMenuCommand(
    new EventHandler(OnPopUpMenuDisplayAction),
    new EventHandler(OnPopUpMenuClick), cmdId);

    displaySelectedItemMenu.Text = &Display Selected Item Information;

    // add new PopUpMenu
    commands.Add(displaySelectedItemMenu);

    // Registration of more command handlers if required go here…
    return commands;
    }

    /// <summary>
    /// Helper to create local CommandIDs.
    /// The integer ID is qualified with a Guid for this DSL, so as to ensure
    /// the ID is unique in the system.
    /// </summary>
    /// <param name=”command”>Command number within this language</param>
    /// <returns></returns>
    private CommandID CustomCommandId(int command)
    {
    return new CommandID(new Guid(Constants.Dsl15CommandSetId), command);
    }


  12. Finalmente debemos agregar 2 EventHandlers para gestionar la visibilidad del elemento en tiempo de ejecución (OnPopUpMenuDisplayAction) y para gestionar el evento Click del mismo (OnPopUpMenuClick). En el evento Click recorreremos la lista de elementos seleccionados y crearemos un string con el contenido de los mismos para mostrarlo en un MessageBox.

    #region Handlers for New PopUpMenu

    internal void OnPopUpMenuDisplayAction(object sender, EventArgs e)
    {
    MenuCommand command
    = sender as MenuCommand;

    // The popmenu command is always visible
    command.Visible = true;
    command.Enabled
    = true;
    }

    internal void OnPopUpMenuClick(object sender, EventArgs e)
    {
    MenuCommand command
    = sender as MenuCommand;
    StringBuilder sb
    = new StringBuilder();
    foreach (object selectedObject in this.CurrentSelection)
    {
    sb.AppendLine(
    Selected Object: + selectedObject.ToString());
    }
    System.Windows.Forms.MessageBox.Show(sb.ToString());
    }

    #endregion


  13. Compilamos la solución y cuando ejecutamos la misma podremos ver, si desplegamos el menu contextual sobre el diseñador la nueva opción:



  14. Si seleccionamos los 3 elementos de usuario y presionamos el menú que recién hemos creado veremos el mensaje con la información de los elementos seleccionados:



Proyecto de ejemplo


El proyecto de ejemplo se puede descargar desde aquí y un pequeño video para mostrar el resultado final del proyecto.


 



Video: DSL – Add new menu item


 


Update: como validar la visualización del elemento http://elbruno.com/blogs/elbruno/archive/2007/12/12/dsl-como-agregar-un-menu-personalizado-2da-parte.aspx


 


Saludos @ Home


El Bruno

Crossposting from ElBruno.com

[VS2005] Nanocoptero + VB.Net + InfraRed + Mobile = Enfermeras poco contentas

Buenas,

las enfermeras siguen poco contentas conmigo; un hospital es un lugar donde no se puede hacer mucho ruido (casi nada creo); y eso crea un ambiente bastante aburrido. Para matar este aburrimiento decidí traer uno de los últimos juguetes que me regalo mi chica: el Nanocóptero (además me han prohibido publicar los videos del nanocóptero en una persecución cuerpo a cuerpo con uno de mis gatos)

Pero bueno, unas fotos en la pieza del hospital puedo mostrar:

   

 

Bases de un juguete complejo

Para aquellas personas como yo que no tenemos mucho mundo arriba, los secretos de la aerodinámica son algo complejos. Gracias a mi padre que es físico me entero que en realidad la base es que:

La fuerza vertical que eleve un avión o helicóptero tendrá que ser igual o mayor que la fuerza de su peso.

En el Nanocóptero el paso del aire para crear sustentación se consigue impulsando las alas circularmente, es decir creando un fuerza vertical para abajo. Además se utiliza el rotor de cola para dar estabilidad horizontal al mismo. Con esta base y después de jugar un rato, pude controlar muy precariamente los movimientos del nanocóptero.

 

Introducing Mobile

Y aquí comenzó el desafío, aquellos que sean detallistas habrán notado que además del nanocóptero, mi Dell Latitude D620 me hacía compania; eso significa Visual Studio, acceso a internet y ganas de probar algo nuevo.

Como el control del nanocóptero se comunica con el mismo a través de infrarrojos, y mi PDA tiene un control de infrarrojos, supuse que tal vez el .Net Compact Framework me podía ayudar a realizar algo tan simple como un pequeño soft para controlar el nanocoptero desde la PDA.

Dentro de MSDN podemos encontrar mucha información al respecto, por ejemplo la librería de referencia central: Infrared Connections.

Sin embargo después de tirar algunas líneas las enfermeras me quitaron el nanocóptero descubrí que la librería incluida en el .Net Compact Framework solo soporta el estandar IrDA (a seguir leyendo, ahora cambiamos desde MSDN a http://www.irda.org/), y parece que el nanocóptero como viene de China tiene su propia idiosincracia.

Sin embargo he dejado preparados las siguientes líneas para completar cuando me respondan los fabricantes del nanocóptero con las especificaciones técnicas del mismo:

1 Imports System.Net 2 Imports System.Net.IrDAEndPoint 3 Imports System.Net.Sockets 4 Imports System.IO 5 6 Public Class Form1 7 Dim irClient As IrDAClient 8 Dim irServiceName As String = "IrDANanocopteroTest" 9 Dim irDevices() As IrDADeviceInfo 10 Dim buffersize As Integer = 256 11 12 ''' <summary> 13 ''' Moves the nanocopter. 14 ''' </summary> 15 Public Sub MoveNanocopter() 16 irClient = New IrDAClient() 17 18 ' coneccion al IrDA 19 If Not GetInfraredDevice() Then Exit Sub 20 21 irClient.GetStream() 22 23 ' stream para enviar datos 24 Dim fs As Stream 25 fs = New MemoryStream(1024) 26 27 ' obtener un stream para la comunicacion ... 28 Dim baseStream As Stream = irClient.GetStream() 29 30 ' COMPLETE ... 31 32 ' dispose 33 fs.Close() 34 baseStream.Close() 35 irClient.Close() 36 37 End Sub 38 39 ''' <summary> 40 ''' Gets the infrared device. 41 ''' </summary> 42 ''' <returns>True if the connection was successful</returns> 43 Private Function GetInfraredDevice() As Boolean 44 Dim connected As Boolean = True 45 46 ' obtiene el dispositivo infrarrojo 47 irDevices = irClient.DiscoverDevices(1) 48 49 ' valida si se pudo conectar al dispositivo de infrarojos 50 If irDevices.Length = 0 Then 51 MsgBox("No remote infrared devices found.") 52 connected = False 53 End If 54 Try 55 Dim irEndP As New IrDAEndPoint(irDevices(0).DeviceID, irServiceName) 56 Dim irListen As New IrDAListener(irEndP) 57 irListen.Start() 58 irClient = irListen.AcceptIrDAClient() 59 MsgBox("Nanocoptero conectado !!!") 60 61 Catch ex As Exception 62 Dim msg As String = String.Format("No se pudo conectar al dispositivo: {0}", ex.ToString()) 63 MsgBox(msg) 64 connected = False 65 End Try 66 67 ' retorna el estado de la conexion 68 Return connected 69 End Function 70 71 End Class

Pues bien, la persona que dijo la frase: “nunca subestimes el poder del aburrimiento” … tenia mucha pero mucha razón.

(creo que fueron Ricardo Varela y Chema Alonso en el CodeCamp del 2006)

 

Saludos @ Hospital

El Bruno

Crossposting from ElBruno.com

[DSL] Como agregar una imagen de fondo en el editor

Buenas

Buenas

existen pocas cosas más aburridas que un hospital, tal vez las espesas reuniones de gerentes alrededor de las 19:00; pero bueno este tiempo sirve para empezar a sacar post del folder Draft y no seguir jugando con la Wii porque a las enfermeras no les cae bien.

Antes de comenzar con la generación de artefactos utilizando las Domain Specific Language Tools, me gustaría dejar un pequeño tip que permite agregar una imagen de fondo a un modelo creado con las Domain Specific Language Tools (otra de las features que pienso que falta en el SDK, pero que ya ha sido solicitado para la nueva versión)

Para comenzar parto del ejemplo que dejé en mi último post sobre DSLs, y después de completar un poco el mismo con algunos elementos nuevos quiero cambiar el siguiente editor por uno con este background.

 

Tutorial

  1. Agregamos una imagen como un recurso a nuestro proyecto. (para simplificar un poco el código he agregado la imagen como un recurso, pero se puede implementar de varias formas diferentes)
  2. Seleccionar el elemento que representa al diagrama, Dsl15Diagram y cambiar la propiedad Generate Double Derived: True.
  3. Generamos el código para reflejar nuestros cambios en el modelo.
  4. Agregamos una nueva clase al proyecto Dsl llamada Dsl15Diagram.partial.cs y agregamos el siguiente código a la misma. Dentro del método InitializeShapeFields() agregamos un nuevo Shape del tipo ImageField y configuramos al mismo definiendo que no pueda tomar foco ni ser seleccionado, y sus márgenes:
    using System; using System.Collections.Generic; using System.Text; using Microsoft.VisualStudio.Modeling.Diagrams; using ElBruno.Dsl15.Properties; namespace ElBruno.Dsl15 { public partial class Dsl15Diagram { /// <summary> /// Initialize shape decorator mappings. This is done here rather than in individual shapes because decorator maps /// are defined per diagram type rather than per shape type. /// </summary> /// <param name="shapeFields"></param> protected override void InitializeShapeFields(IList<Microsoft.VisualStudio.Modeling.Diagrams.ShapeField> shapeFields) { base.InitializeShapeFields(shapeFields); // add backgroung image to the designer ImageField backgroundImage = new ImageField("background", Properties.Resources.fondo); backgroundImage.DefaultFocusable = false; backgroundImage.DefaultSelectable = false; backgroundImage.DefaultVisibility = true; shapeFields.Add(backgroundImage); // define Background Image margins backgroundImage.AnchoringBehavior.Clear(); backgroundImage.AnchoringBehavior.SetTopAnchor(AnchoringBehavior.Edge.Top, -1.5); backgroundImage.AnchoringBehavior.SetLeftAnchor(AnchoringBehavior.Edge.Left, 0); } } }
  5. Compilamos la solución y ejecutamos nuevamente. Podremos ver el editor como lo muestra la siguiente imagen:

 

Tip simple pero efectivo. El código de ejemplo se puede descargar desde aquí.

 

Saludos @ Hospital

El Bruno

Crossposting from ElBruno.com

[VS2005] Strings vs StringBuilders

Buenas

después del minipost de hace unos días sobre la utilización de String.IsNullOrEmpty en el desarrollo de aplicaciones; alguien me preguntó porque String vs StringBuilders. Ya se que este no es un tema nuevo y que seguramente mucha gente lo conoce, pero para los que no estén al tanto, un consejo: “ojo con el enfoque que le dan a sus aplicaciones si tienes un proceso de cadenas string muy intensivo“.

¿Porqué digo esto? porque en .Net los string son objetos rígidos, es decir, no es posible concatenar strings dentro del objeto strings. Si bien podemos utilizar la función Concat(), para cada nuevo String que procesamos, el string original se destruye y uno nuevo se crea en su lugar.

Como siempre la mejor forma de demostrarlo en con código, y para esto rescato una clase que hace muchísimo escribí para una demo:

1 class Program 2 { 3 /// <summary> 4 /// Mains the specified args. 5 /// </summary> 6 /// <param name="args">The args.</param> 7 static void Main(string[] args) 8 { 9 // 1000 operations 10 TestString(1000); 11 TestStringBuilder(1000); 12 13 // 5000 operations 14 TestString(5000); 15 TestStringBuilder(5000); 16 17 // 10000 operations 18 TestString(10000); 19 TestStringBuilder(10000); 20 21 // 50000 operations 22 TestString(50000); 23 TestStringBuilder(50000); 24 25 // 100000 operations 26 TestString(100000); 27 TestStringBuilder(100000); 28 29 Console.WriteLine("Finish process test ..."); 30 Console.ReadKey(); 31 } 32 33 /// <summary> 34 /// Tests the string. 35 /// </summary> 36 /// <param name="count">The count.</param> 37 public static void TestString(int count) 38 { 39 DateTime dtStart = DateTime.Now; 40 string ret = string.Empty; 41 for (int i = 0; i < count; i++) 42 { 43 ret += i.ToString(); 44 } 45 DateTime dtEnd = DateTime.Now; 46 TimeSpan tsDif = dtEnd - dtStart; 47 Console.WriteLine(string.Format("For {0} operations Using Strings: {1} seconds", count, tsDif.Seconds.ToString())); 48 } 49 50 /// <summary> 51 /// Tests the string builder. 52 /// </summary> 53 /// <param name="count">The count.</param> 54 public static void TestStringBuilder(int count) 55 { 56 DateTime dtStart = DateTime.Now; 57 StringBuilder sb = new StringBuilder(); 58 for (int i = 0; i < count; i++) 59 { 60 sb.Append( i.ToString() ); 61 } 62 DateTime dtEnd = DateTime.Now; 63 TimeSpan tsDif = dtEnd - dtStart; 64 Console.WriteLine(string.Format("For {0} operations Using StringBuilder: {1} seconds", count, tsDif.Seconds.ToString())); 65 } 66 } 67

 

Como pueden ver, esta aplicación de Consola crea y concatena strings en un determinado numero de ocasiones y durante el proceso, toma los tiempos de inicio y fin para poder tener la diferencia de los mismos. El output de la consola es bastante explícito en cuando a las relaciones

 

For 1000 operations Using Strings: 0 seconds

For 1000 operations Using StringBuilder: 0 seconds

For 5000 operations Using Strings: 0 seconds

For 5000 operations Using StringBuilder: 0 seconds

For 10000 operations Using Strings: 0 seconds

For 10000 operations Using StringBuilder: 0 seconds

For 50000 operations Using Strings: 10 seconds

For 50000 operations Using StringBuilder: 0 seconds

For 100000 operations Using Strings: 55 seconds

For 100000 operations Using StringBuilder: 0 seconds

Finish process test …

 

Saludos @ Madrid

El Bruno

Crossposting from ElBruno.com

[VSTE4DB] Incluyendo scripts para inicializar tablas con datos

Buenas

si trabajar con proyectos de bases de datos con Visual Studio Team Edition for Database Professionals, y has probado las opciones de deploy de este tipo de proyectos, seguramente habrás tenido la necesidad de inicializar algunas tablas con datos, luego de crear la base de datos en el Deploy. Pues bien, una de las formas de realizar esta acción es uitilizar los Data Generation Plans incluidos en cada proyecto, pero tal vez si ya tienes tu base de datos con datos de ejemplo, te interese replicar los mismos.

El siguiente tutorial demuestra como crear un proyecto de BD utilizando AdventureWorks y como generar un deploy del mismo con parte de los datos de ejemplo.

 

Tutorial

 

1. Crear un nuevo proyecto de base de datos para Microsoft SQL Server 2005 llamado AdventureWorksDeploy.

2. Importar el Schema de AdventureWorks, deplegando el menu contextual sobre el proyecto y seleccionado Import Database Schema.

3. Crear una nueva conexión hacia AdventureWorks e importar el Schema.

4. Desde las propiedades del proyecto, configurar la base de datos de destino para el Deploy. En este caso lo haré sobre mi servidor local y sobre una nueva base de datos llamada AdventureWorksDeploy. Además debemos marcar la opción Always re-create database.

 

5. Una vez configurada la base de datos de deploy realizamos un deploy para que la misma se cree con las tablas vacías, desplegando el menú contextual sobre el proyecto y seleccionando la opción Deploy. Verificamos que en el servidor de datos se haya creado una nueva base datos: AdventureWorksDeploy.

6. Lanzamos el comparador de datos desde el menu Data // Data Compare // New Data Comparison, seleccionando AdventureWorks y AdventureWorksDeploy como bases de datos para comparar.

7. Sunpogamos que solo queremos insertar los datos de la tabla Production.ProductModel, seleccionamos la misma y seleccionamos la opcion Export to Editor.

 

 

8. La comparación de datos ha creado un script para la generación de datos, que entre otras cosas deshabilita las claves y relaciones de las tablas, deshabilita los Identity para la insercion de datos, serializa los campos binarios a base64, etc.

9. Dentro del proyecto crearemos una nueva carpeta llamada SampleData.

10 . Dentro de esta carpeta agregamos un nuevo sql script llamado Production.sql. Copiamos el contenido del script para la generación de datos dentro de este archivo y lo grabamos.

11. Editamos el archivo ScriptsPost-DeploymentScript.PostDeployment.sql y agregamos la siguiente instrucción al final del mismo:

:r ….SampleDataProduction.sql

esta instrucción incluye el archivo Production.sql en la ejecución del PostDeploy script.

13. Nuestro archivo debe quedar con el siguiente contenido o similar:

/* Post-Deployment Script Template -------------------------------------------------------------------------------------- This file contains SQL statements that will be appended to the build script Use SQLCMD syntax to include a file into the post-deployment script Example: :r .filename.sql Use SQLCMD syntax to reference a variable in the post-deployment script Example: :setvar TableName MyTable SELECT * FROM [$(TableName)] -------------------------------------------------------------------------------------- */ :r .Permissions.sql :r .RoleMemberships.sql :r .RulesAndDefaults.sql :r .DatabaseObjectOptions.sql :r .Signatures.sql -- ================================= -- ADD SAMPLE DATA -- ================================= :r ....SampleDataProduction.sql

14. A continuación realizamos un nuevo deploy de la base de datos y veremos que en la base de datos creada AdventureWorksDeploy en la tabla Production.ProductModel están los datos de ejemplo.

 

Conclusión

Las herramientas que posee Visual Studio Team Edition for Database Professionals nos permiten crear y desplegar muy fácilmente bases de datos SQL Server. Siguiendo los pasos del tutorial podemos agregar más tablas en la comparación y generar un script para la inserción de datos, o tal vez generar varios scripts para la inserción de datos separando los mismos por algún criterio en particular. Por ejemplo:

 

Descarga del proyecto de ejemplo (gracias geeks.ms)

SkyDrive

 

Saludos @ Home &  happy db deploying

El Bruno

Crossposting from ElBruno.com