Le nouveau blog de mon équipe est disponible à l’adresse:

• http://blogs.msdn.com/b/frmcs-dev

Vous retrouverez des articles sur les sujets de développement suivants:

- Windows 8 Metro Application, Windows Phone 7, ASP.NET, WPF, SOA, ALM, TFS, …

Voici les autres blogs des équipes MCS France :

• Microsoft Services
• Equipe Poste de Travail
• Equipe IW
• Equipe Unified Communication
• Equipe CRM
• Equipe DataCenter
• Equipe Sécurité

Bonne lecture,

Benoît

Je travaille depuis quelque temps sur un projet WPF. Mon client nous met à disposition un automate d’intégration continu sur lequel nous n’avons pas la main en terme de customisation.

Ce dernier permet d’effectuer des étapes importantes telle que l’exécution de tests unitaires, couverture de code, vérification de la qualité de code, … cependant certaines étapes à mon sens sont manquantes.

Dans cet article je vais vous présenter un exemple de processus automatisé que j’utilise en complément qui me permet de sécuriser la livraison de l’application en environnement de test.

Je pars du postulat que sur mon poste de développement, seulement le framework.net et Visual Studio 2010 sont installés.

L’idée est de créer ce script le plus vite possible avec les outils en ma possession

=>Je vais donc créer un script MSBuild

Définition des étapes de processus de livraison

Le script est structuré en sept étapes:

1. GetLatestVersion;
2. IncrementVersion;
3. Clean;
4. Compil;
5. Deploy;
6. Check;
7. CheckinCode;

GetLatestVersion / CheckInCode

Ces targets permettent de réccupérer la dernière version du code et de faire un check-in du code modifié par ce processus. A ce niveau là tout dépend de votre gestionnaire de configuration.

Si vous utilisez Microsoft Team Foundation Server les Tasks sont disponibleq dans Microsoft.TeamFoundation.Build.targets (C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\TeamBuild pour une machine x64).

Sinon, pour les autres gestionnaires de configuration, il suffit d’obtenir des tasks tier:

• MSBuild Community Tasks : http://msbuildtasks.tigris.org/
• MSBuid Extension Pack : http://msbuildextensionpack.codeplex.com/

IncrementVersion

Incrémente automatiquement le numéro de version des composants de la solution;

Soit une Custom Task peut être créée, soit les MSBuild Community Tasks offrent une tâche qui permet de modifier le fichier Assemblyinfo.

Clean

Nettoyage du bin des projets de la solutions.  Tous les répertoires bin/debug et bin/release sont nettoyés avec la task suivante:

Compil

Cette simple target compile la solution dans la configuration définie:

Deploy

La target Deploy copie les fichiers, présents dans le projet de démarrage de la solution, dans le répertoire de destination. Si le répertoire n’existe pas il est créé.

Check

A ce niveau là, j’ai créé une custom task qui, à partir d’un fichier Xml, vérifie les fichiers déposés dans le répertoire de livraison.

Cette custom task vérifie:

• le nombre de binaires présents;
• la version de ces binaires;

Dans la artie suivante de ce post, je vais rentrer en détail sur la façon de faire une Custom Task MSBuild.

Voici les grandes lignes du script MSBuild =>MyBuild.proj

Dans ce script, deux patterns MSBuild sont vraiment intéressants:

• l’utilisation de DependsOnTarget pour permettre une meilleure granularité de target. Comme pour du code .net, je met le minimum de logique dans une target => 1 target = 1 rôle;
• la pré-initialisation des properties au début du script afin d’avoir lors de l’exécution du script MSBuild un minimum de paramettres à saisir.

Execution du script

Pour démarrer ce script, ouvrez le Visual Studio Command Prompt (2010) pour avoir MSBuild dans le path.

Naviguez jusqu’à votre fichier proj MyBuild.proj, lancez la ligne de commande suivante:

msbuild MyBuild.proj /p:Version=1.0.0.24

Cette ligne de commande lance le processus pour la version 1.0.0.24, la compilation est faite en release.

Exemple de Custom Task MSBuild

Créez un projet de classe de librairie nommé par exemple MyCustomTaskMSBuild.

Ajouter les références aux dlls Microsoft.Build.Framework.dll:

Renommez la classe Class1.cs en MyCustomTask.cs et faites la hériter de l’interface ITask.

Ensuite, à vous de jouer, après avoir surchargé les méthodes/propriétés de ITask, vous pouvez créer un code celui-ci:

Pour tout ce qui est logging de messages, utilisez la méthode Trace.

J’ai rajouté un MyInputParam, avec l’attribut Required il devient obligatoire lors de l’exécution du script MSBuild.

Comment insérer cette nouvelle Task dans mon fichier proj

En entête du fichier proj, rajoutez la ligne suivante:

Cette ligne défini le lien avec la Custom Task, il suffit ensuite d’appeller cette Task dans une target comme suit:

Et maintenant, testez:

Ensuite, en vie réelle, vérifiez que le ficher proj est dans le même répertoire que la dll de la Custom Task.

Comment debugger cette Custom Task

Pour debugger cetteTask, forcez le projet MyCustomTaskMSBuild à Startup Project.

Etre sûr que le fichier proj est bien dans le répertoire bin\debug du projet MyCustomTaskMSBuild.

Dans l’onglet Debug des propriétés de ce projet. Sélectionner Start exsternal program et pointez vers l’exécutable MSBuild, dans mon cas C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe

Dans les Command Line Arguments, il suffit de mettre le nom du fichier MSBuild avec les bons paramètres.

F5 et le debug peut commencer.

Quelques liens

Documentation MSBuild sur MSDN :

• http://msdn.microsoft.com/en-us/library/dd393574(VS.110).aspx
• http://msdn.microsoft.com/en-us/library/dd393574.aspx
  

Blog de l’équipe MSBuild

• http://blogs.msdn.com/b/msbuild/

Benoît

Tools that you can add around TFS 2010

Check-in policy

• TFS 2010 Time Tracking Checkin Policy
  http://visualstudiogallery.msdn.microsoft.com/58ec8802-bd48-4673-a465-4ba099cfbce1

As Project Manager, you need to track the time spent on a specific task, this check-in policy is for you.

Build

• Inmeta.VisualSt​udio.TeamExplor​er.BuildExplore​r
  http://visualstudiogallery.msdn.microsoft.com/35daa606-4917-43c4-98ab-38632d9dbd45

Your TFS project contains so many builds, this tool enable you to create folders in the Build Explorer.

• Team Foundation Server Build Extensions Power Tool March 2011
  http://visualstudiogallery.msdn.microsoft.com/2d7c8577-54b8-47ce-82a5-8649f579dcb6

You need to execute Maven 2 and Ant builds on your build server. Takes advantage of JUnit tests results.

Templates

• Microsoft Visual Studio Scrum 1.0
  http://visualstudiogallery.msdn.microsoft.com/59ac03e3-df99-4776-be39-1917cbfc5d8e

New process template : Scrum.

Specs & Modeling

• Spec Explorer 2010 Visual Studio Power Tool
  http://visualstudiogallery.msdn.microsoft.com/271d0904-f178-4ce9-956b-d9bfa4902745?SRC=Featured

Spec Explorer is a visual tool for modeling software behavior and generating test suites from those models

• UML Extension For Spec Explorer 2010
  http://visualstudiogallery.msdn.microsoft.com/ce73da2a-072f-44d0-ae18-600213b56520

Extension of the Spec Explorer, adding sequence diagram.

• Visualization and Modeling Feature Pack Runtime
  http://visualstudiogallery.msdn.microsoft.com/93ba7cc9-e145-453f-a269-d98e0576b961

Tests

• Visual Studio 2010 Lab Management Feature Pack
  http://msdn.microsoft.com/en-us/vstudio/ee712698
  
• Microsoft Visual Studio 2010 Load Test Feature Pack
  http://msdn.microsoft.com/en-us/library/gg701769.aspx

Integration

• Microsoft Team Foundation Server 2010 and Microsoft Project Server Integration Feature Pack
  http://msdn.microsoft.com/en-us/library/gg455680.aspx

Installation & connection

• Microsoft Team Foundation Server 2010 MOSS Configuration Tool
  http://visualstudiogallery.msdn.microsoft.com/db469790-5e3e-42f3-906e-411a73795a1b
• Team Foundation Server Integration Tools (March 2011 Release)
  http://visualstudiogallery.msdn.microsoft.com/f854dd59-8eeb-4673-8d9a-ae012989bfa2
• Team Foundation Server MSSCCI Provider 2010
  http://visualstudiogallery.msdn.microsoft.com/bce06506-be38-47a1-9f29-d3937d3d88d6
• Team Foundation Server Power Tools March 2011
  http://visualstudiogallery.msdn.microsoft.com/c255a1e4-04ba-4f68-8f4e-cd473d6b971f

Articles & Guides

• Visual Studio TFS Branching and Merging Guidance
  http://msdn.microsoft.com/en-us/magazine/gg598921.aspx
• Visual Studio TFS Team Project and Collection Guidance
  http://msdn.microsoft.com/en-us/magazine/gg983486.aspx
• Visual Studio TFS Branching Guide 2010
  http://tfsbranchingguideiii.codeplex.com/
• Visual Studio TFS Upgrade Guide
  http://vs2010upgradeguide.codeplex.com/

Blogs

Some interesting blogs:

• http://blogs.msdn.com/b/team_foundation/
• http://blogs.msdn.com/b/briankel/
• http://blogs.msdn.com/b/bharry/
• http://blogs.msdn.com/b/willy-peter_schaub/
• http://blogs.msdn.com/b/sunder/

Since few months, I work on developing a WPF UI that directly connects to MS Dynamics CRM 4.0. In this post I will present you some of the practices I use in this project.

Restriction of the result

Reduce the attributes to return

Specify all desired attributes and not all-attributes element. all-attributes will return all fields of the desired entities:

<attribute name=”…” />

<attribute name=”…” />

instead of:

<all-attributes />

I really recommend you to manually set all the attributes you need. This will reduce the size of the response and in a same time, this reduce the SQL request generated by CRM.

Pagination with Paging cookie

Take few minutes to create your own paging mechanism.

Step 1 :

• Create a context object for the server calls:

• Encapsulate the query encapsulation and parse the return of the FetchXML query:

• Test the code:

Joining entities

FetchXML offers the ability to return fields from parent entity, linq queries not.

Using aliases

Using aliases for you linked entities will facilitate the execution and your deserialization. If you do not set an alias, you will not be able to return fields with same names from different entities.

Here is the result of previous FetchXML queyry:

In the example, you can now returns createdby (createdon, modifiedby, modifiedon) on two different entities. After in your project, you can easily create you own deserialization mechanism having the alias as parameter.

Left Join

You cannot use left join using Linq. Fetch queries enable left join. This helps you a lot, if you need to return in each contact query specific fields of parent entity, this reduces the number of request to server.

Quick generation of fetch XML query

Here is in 5 points a quick way to generate your FetchXML query:

• Use the advance find of MS CRM;
• Use the graphical user interface to define your query;
• Run the query (click on Find button) ;
• Press CTRL+N, this will create a new IE window but will keep the context;
• Replace the url in the address bar
  • javascript:alert(resultRender.FetchXml.value);

This will open a pop-up with the expected FetchXml

I really recommand you to read it ;-).

It is available at http://www.amazon.fr/Windows-7-avanc%C3%A9-Thomas-Garcia/dp/2212129955/ref=sr_1_2?ie=UTF8&s=books&qid=1299059442&sr=8-2

You can also follow him at on his blog http://blogs.msdn.com/b/lgmorand/

I will talk about four main points:

• Debugging bindings;
• Checking your visual tree;
• Profiling your WPF application;
• Optimizing your WPF application;

Data bindings

Here are two very important posts that explicit different solutions for debugging bindings:

- This post from Bea Stollnitz;

- This post from Karl Shifflet;

After reading those post, in WPF projects I use all those techniques in this order:

1. I read the Visual Studio Output Window to show. In most cases, the message is enough explicit.
2. Usage of the DebugConverter: here is the implementation of the DebugConverter I use in projects.

I define it in the resources of the application, and it’s done. I just have to call this converter on the binding where I encounter an issue. Automatically the debugger breaks in my converter. After solving the binding issue, I suppress the converter and that’s all.

I don’t really use the trace sources because most of times, I already found the issue before using it

Visual Tree debugging

In a previous post, I explained you my favorite tools, the two I use quickly to debug the visual tree of my application are Mole and Snoop.

Mole is useful when you set a breakpoint in Visual Studio and you want to debug the visual/logical tree of your application. It’s integrated into Visual Studio, when in your code you set a breakpoint, you can easily open Mole to understand what is happening in the visual or in the logical tree. I use Mole in Visual Studio, when debugging. I’m able to quickly find what’s happening –> incorrect owner, style not applied correctly, …

Snoop is different tool, also displays the visual tree of a WPF application, it is not working within Visual Studio. It takes the applications at a specific moment. It also displays in a tree control the visual tree to easily navigate into the elements but also allows to split the application in a 3D representation of all visual elements to better understand the graphical composition of the application. This allows to to better understand why part of your application is not docked correctly or stretched correctly.

Profiling tools

Performance Profiling Tools for Windows Presentation Foundation (also know as WPFPerf) is available in the Microsoft Windows SDK for Windows 7 and the .NET Framework 4.

WPFPerf contains 2 tools :

• Perforator : analyze rendering behavior, this is used to look for rendering issues;
• Visual Profiler : analyze the use of WPF services to determine which visual element if causing a performance bottleneck.

I really use them when I really want to understand what is happening on a UI point of view, how the visual tree is build, how all the events/animations are

If you need more documentation on those tools, I redirect you to  WPF Performance Suite on MSDN .

Optimization reference

Here are my two main resources for optimization

• MSDN Article : Optimizing WPF Application Performance.
• WPF Performance and .NET Framework Client Profile blog : this blog gives a lot of tips for WPF optimizations.

Do not forget that WPF is also a part of .NET, so also use the Improving .NET Application Performance and Scalability form Pattern & Practice.

Conclusion

In this post I summarized some actions to do during a development life cycle on a WPF project.

And of course, you can follow a TechDays 2011 Session, from one of my colleague Luc Vo Van on WPF/Silverlight performance tips & tricks.

Project configuration

Before starting your application, on the project properties> Debug tab, make sure that “Enable unmanaged code debugging” is enabled.

Starting analyzing

Start your debugging your application, execute the scenario where you found that there is a memory leak, break at the end of this execution (Break All or CTRL+ALT+DEL).

In Visual Studio, Open the immediate windows and load sos.dll.

For .net 4.0 application:

.load C:\windows\Microsoft.NET\Framework\v4.0.30319\sos.dll

or

.load sos

For .net 2.0, 3.0 or 3.5 application:

.load C:\windows\Microsoft.NET\Framework\v2.0.50727\sos.dll

Enter the following command line to get the summary of object types that are still in memory:

!dumpheap –stat

If one of the type should not be in memory, you can filter for a specific type:

!dump –type MyNamespace.MyType

This lists all objects of this specific type in the heap. Once you have the address of one specific object you can get a dump of a specific object:

!gcroot 02369d30

This dump lists all the objects that references, and that forces the object to be kept in the heap. After you should investigate deeper

Main commands to use

Interesting links

MSDN reference : http://msdn.microsoft.com/fr-fr/library/bb190764.aspx

Tess Ferrandez blog: http://blogs.msdn.com/b/tess/ (very interesting blog). She wrote several good post but also one dedicated on “Debugging Silverlight applications with windbg and sos.dll”

.net development

Visual Studio Gallery lists many interesting tools:

• Productivity Power Tools
• Power Commands for Visual studio
• Team Foundation
• Regex Editor
• tangible T4 Editor plus modeling tools for VS2010
• …

Reflector is the tool used, as written on the red-gate site, “Explore and analyze .NET assemblies”.

A lot of add-ins exists –>Reflector Add-Ins. One I always use is Baml Viewer. It loads and render the BAML in XAML.

PInvoke.Net is in a same time a reference web site but also tool helping into interaction with com dll.

LinqPad helps you to create Linq queries (Linq to Objects, Linq to XML, Entity Framework, …) but also you can also write code and it’s instantly executed.

WPF development

Snoop helps you in your WPF developments, it displays the visual tree of your application (you also can see it in 3D). I use it to understand why a specific WPF control is not displayed correctly.

Mole (available for Visual Studio 2008) is a WPF visualizer, very useful when debugging your application and more precisely WPF visual tree or logical tree.

Http debugger

Fiddler is a web debugging proxy.

File and Disk utilities

When do not know why a file is already used by another process or what’s happening on your system Process Monitor is the tool. It traces in real time file, registry and process activity.

Memory debugger

WinDBG is available in the Microsoft Windows SDK ( Seven version, for other version of OS ). It helps you into finding memory leaks.

Visual Studio + sos.dll (sos.dll is i) is also an other way to find memory leaks.

In my previous post, I explained how to configure Unity at runtime. This one will describe how to use the configuration file.

First of all add the following references to your project:

• System.Configuration.dll
• Microsoft.Practices.Unity.Configuration.dll

Simple scenario

Add a using directive to get easy access to the container initializer:

Update the Program class as follows:

Add a configuration file (which is a simple XML file):

Run the example and the result is the same as in my previous post.

Singleton scenario

To use the injected object as a singleton, just define a ControledContainerLifetimeManager, which manages the lifetime of your object as a unique instance:

Alias scenario

For the alias scenario, remove the previous configuration file, and change the code as follows :

Then use the following configuration file instead, which defines the aliases with the name attribute:

In the upcoming posts, I will explain you how to :

• Configure in Runtime or in Design time;
• Make the best use of it

In this post I will assume that you already know about ALL the advantages of using the IoC pattern. You can download Unity here.

Simple scenario

First of all, we will create the project that will help us for all the samples. I will name it UnityTest.

First and foremost, let’s add a reference to Microsoft.Practices.Unity.

Then create an interface named IMyComponent:

Implement that interface in the MyComponent class:

Finally, implement Program as follows (register, then resolve the types):

What was actually done, was to instantiate the Unity container, and then register a new couple inside it. From then on, every time I will need an implementation of IMyComponent, Unity will instantiate MyComponent through a call to Resolve.

Singleton scenario

If I want to have MyComponent as a singleton, I will have to register it as an instance:

Then, each time I will need an instance of IMyComponent, Unity will return me the registered singleton.

Aliases scenario

I will create a new class MyComponentFr that will also implement the IMyComponent interface.

This is exactly the same code as the initial MyComponent except that the text is in French. The following code demonstrates how to use aliases to return different implementations of IMyComponent, depending on an alias :

As you can see, I just have to register the implementation with an alias.