Home - About me - Browse by categories

MishraReader Beta 1 dans les bacs !

MishraReader est un client GoogleReader écrit en WPF 4.0, respectant le design Metro et disponible sur CodePlex (sources et exécutable) : http://mishrareader.codeplex.com

image

A l’initiative de David Catuhe ce projet regroupe une dizaine de développeurs français. J’y ai d’ailleurs moi-même écrit quelques modestes lignes de codes image

De nombreuses fonctionnalités ont été inclues dans cette première béta, pour une liste complète de celles-ci je vous invite à lire le billet de David sur son blog.

Pour tester l’application, rendez-vous sur CodePlex !

N’hésitez pas à faire des retours d’utilisation / propositions de fonctionnalités.

Bonne lecture et à bientôt image

read more

[Visual Studio] Développement de règles d'archivage personnalisées pour TFS

Visual Studio permet d’exécuter du code avant chaque opération d’archivage afin de valider qu’un certain nombre de conditions soit réunies pour autoriser (ou non) le développeur à archiver son code : c’est ce qu’on appel des règles d’archivage (ou checkin policies).

Il existe déjà des règles out of the box qu’il est possible d’activer en faisant un clic droit sur le projet d’équipe pour lequel vous souhaitez activer une règle dans le Team Explorer, en sélectionnant l’entrée de menu Team Project Settings puis Source Control…

image

Il est également possible de développer ses propres règles d’archivage. Pour cela, il vous faut installer le SDK Visual Studio (disponible via l’extension manager), si ce n’est pas déjà fait :

image

Créez une projet de type Class Library et ajoutez-y les références suivantes :

  • Microsoft.TeamFoundation.VersionControl.Client
  • Microsoft.TeamFoundation.WorkItemTracking.Client

Une checkin policy est en fait une classe qui dérive de **PolicyBase **et qui soit sérialisable. Pour l’exemple, nous allons créer une règle vérifiant qu’un work item ait bien été associé au changeset (déjà existante) mais en plus que l’état du work item n’est pas Closed :

[Serializable]
public class SampleCheckinPolicy : PolicyBase
{
public override string Description
{
get { return "Cette règle d'archivage vérifie qu'aucun work item associé au changeset n'est en état Closed."; }
}

public override bool Edit(IPolicyEditArgs policyEditArgs)
{
return true;
}

public override PolicyFailure[] Evaluate()
{
throw new NotImplementedException();
}

public override string Type
{
get { return "SampleCheckinPolicy"; }
}

public override string TypeDescription
{
get { return "Cette règle d'archivage vérifie qu'aucun work item associé au changeset n'est en état Closed."; }
}
}

PolicyBase est une classe abstraite, voilà les méthodes / propriété à redéfinir :

  • Description / Type Description : information à propos de la règle (pour affichage dans les interfaces de VS)

  • Type : nom de la règle (pour affichage également)

  • Edit : permet d’afficher une fenêtre dans le cas où l’on souhaite que la règle soit configurable

  • Evaluate : vérifie les conditions de la règles et retourne une liste d’erreur, si la règle n’est pas validée

La classe PolicyBase expose une propriété PendingChecking sur laquelle il est possible de récupérer les work items associées, les notes d’archivage… Il est donc possible de vérifier que des work items sont associés et qu’aucun n’est en état Closed :

public override PolicyFailure[] Evaluate()
{
var failures = new List<PolicyFailure>();

if (PendingCheckin.WorkItems.CheckedWorkItems.Any())
{
foreach (var workItemCheckinInfo in PendingCheckin.WorkItems.CheckedWorkItems)
{
if(workItemCheckinInfo.WorkItem.State == "Closed")
{
string message = String.Format("Le workitem #{0} est en état Closed. Archivage impossible",
workItemCheckinInfo.WorkItem.Id);

failures.Add(new PolicyFailure(message,this));
}
}
}
else
{
failures.Add(new PolicyFailure("Aucun work item n'est associé au changeset !", this));
}

return failures.ToArray();
}

Tant que la méthode Evaluate retourne des erreurs, Visual Studio empêchera l’opération d’archivage (sauf si l’utilisateur contourne explicitement la règle).

La règle est prête, il ne reste plus qu’à la packager !

Pour cela ajoutez un projet d’extensibilité VSIX à la solution :

image

Ajoutez une référence vers la librairie contenant la règle à ce projet et vérifiez bien que la valeur Copy Local de cette référence est à vrai.

Il faut maintenant ajouter une fichier pkgdef au projet VSIX dans lequel sera renseigné l’enregistrement de la checkin policy dans le registre Windows. Ce fichier doit porter le nom du projet VSIX (SampleCheckinPolicyPackage.pkgdef, dans mon cas). Placez la propriété Include in VSIX à vrai dans les propriétés du fichier.

[$RootKey$\TeamFoundation\SourceControl\Checkin Policies]
"SampleCheckinPolicy"="$PackageFolder$\SampleCheckinPolicy.dll"

Attention : Le nom de la clé doit correspondre à celui de la dll !

Il ne reste plus qu’à lancer le projet VSIX en debug dans l’instance expérimentale de Visual Studio ou d’installer le VSIX produit lors de la génération du projet.

Rendez-vous alors dans les paramètres du source contrôles pour le projet d’équipe désiré : vous devriez pouvoir ajouter la règle :

image

Tentez un archivage sans associer de Work Item ou en associant un Work Item en état Closed sur ce projet. Vous devriez voir apparaître les messages d’erreur de la règle dans la fenêtre Pending Changes :

image   image

Téléchargez le code d’exemple : SampleCheckinPolicy.zip

A bientôt image

read more

[ASP.NET MVC] Validation de formulaire avec jQuery

ASP.NET MVC 3 supporte de nouvelle fonctionnalités en terme de validation de formulaire côté client, à l’aide de la bibliothèque de jQuery et de son plugin dédié à la validation.

Dans ce post, nous verrons comment valider un formulaire côté client. Il faut garder à l’esprit que la validation côté client n’est là que pour rendre le formulaire plus ergonomique (il s’agit plutôt d’aide à la saisie) : il est impératif de toujours valider un modèle côté serveur !

Dans le fichier de configuration de votre application ASP.NET MVC 3, vous devriez voir les deux clés suivantes dans la section :

<add key="ClientValidationEnabled" value="true" />
<add key="UnobtrusiveJavaScriptEnabled" value="true" />

La première, ClientValidationEnabled, permet de préciser que vous souhaitez que la validation des formulaires côté client (en Javascript donc) soit activée.

La seconde, UnobtrusiveJavaScriptEnabled, permet de préciser que vous souhaitez que du javascript non intrusif soit utilisé pour la validation. Le monteur ASP.NET MVC 3 rajoutera alors des attributs supplémentaires lors de la génération des champs d’un formulaire par l’intermédiaire d’un HtmlHelper (TextBox, TextBoxFor, CheckBox, CheckBoxFor…).

Ces attributs pourront ensuite être interprétés par un framework de validation JQuery : jQuery Validate (et jQuery Validate Unobtrusive).

Lorsque vous ajoutez une nouvelle vue à votre projet via l’interface Visual Studio prévue à cet effet, il est possible de cocher une case Reference script libraries afin que les scripts nécessaires à la mise en place de la validation soit ajoutés à la page :

image

Cela aura pour effet d’ajouter les lignes suivantes à la vue :

<script src="@Url.Content("~/Scripts/jquery.validate.min.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")" type="text/javascript"></script>

Il s’agit des scripts nécessaires pour faire fonctionner l’API jQuery Validate. L’ajout de ces deux références de scripts ainsi que les deux clés du fichier Web.config suffise à permettre la validation côté client :

image

NB : pour que cela fonctionne, le modèle doit porter des attributs de validation ! (cf. exemple en bas de page)

Le markup HTML généré lors de l’appel du formulaire est le suivant :

<div class="editor-label">
<label for="Title">Title</label>

<div class="editor-field">
<input class="text-box single-line" data-val="true" data-val-required="Le champ titre est obligatoire" id="Title" name="Title" type="text" value="" />
<span class="field-validation-valid" data-valmsg-for="Title" data-valmsg-replace="true"></span>

<div class="editor-label">
<label for="Description">Description</label>

<div class="editor-field">
<input class="text-box single-line" data-val="true" data-val-required="Le champ description est obligatoire" id="Description" name="Description" type="text" value="" />
<span class="field-validation-valid" data-valmsg-for="Description" data-valmsg-replace="true"></span>

Comme il est possible de le constater, un certain nombre d’attribut / class ont été rajoutés sur les input afin de permettre la valdidation non intrusive :

  • data-val : indique que la validation doit avoir lieu sur cet élément

  • data-val-required : indique que le champ est requis et fournit le message d’erreur à afficher

  • data-val-message-for : indique que la balise span affiche le message d’erreur du champ description

Du coup, si JavaScript est activé sur la machine de l’utilisateur, les champs doivent être saisis convenablement avant le post du formulaire.

Il faut cependant valider le modèle côté serveur, dans le contrôleur :

if (ModelState.IsValid)
{
using (var repo = new BlogRepository())
{
repo.AddBlog(blog);
return RedirectToAction("Index", "Home");
}
}

Si vous désactivez la validation non intrusive (via la clé de configuration UnobtrusiveJavaScriptEnabled vue précédemment) vous obtiendrez alors le markup suivant à la suite du formulaire :

<script type="text/javascript">
//<![CDATA[
if (!window.mvcClientValidationMetadata) { window.mvcClientValidationMetadata = []; }
window.mvcClientValidationMetadata.push({"Fields":[{"FieldName":"Title","ReplaceValidationMessageContents":true,"ValidationMessageId":"Title_validationMessage","ValidationRules":[{"ErrorMessage":"Le champ titre est obligatoire","ValidationParameters":{},"ValidationType":"required"}]},{"FieldName":"Description","ReplaceValidationMessageContents":true,"ValidationMessageId":"Description_validationMessage","ValidationRules":[{"ErrorMessage":"Le champ description est obligatoire","ValidationParameters":{},"ValidationType":"required"}]},{"FieldName":"IsPublished","ReplaceValidationMessageContents":true,"ValidationMessageId":"IsPublished_validationMessage","ValidationRules":[{"ErrorMessage":"The IsPublished field is required.","ValidationParameters":{},"ValidationType":"required"}]},{"FieldName":"PublishDate","ReplaceValidationMessageContents":true,"ValidationMessageId":"PublishDate_validationMessage","ValidationRules":[{"ErrorMessage":"The PublishDate field is required.","ValidationParameters":{},"ValidationType":"required"}]}],"FormId":"form0","ReplaceValidationSummary":false,"ValidationSummaryId":"validationSummary"});
//]]>
</script>

Projet web d’exemple : BlogSample.Mvc.zip

A bientôt image

read more

[ASP.NET MVC] Repository Entity Framework dans un contexte stateless

Les mappeurs objets relationnels comme Entity Framework apportent de nombreux avantages lors du développement d’application utilisant des bases de données comme système de stockage. Au delà d’effectuer un mapping entre le monde objet et le monde relationnel, permettre la génération de requête SQL à partir du langage .NET LINQ, Entity Framework fournit également un système de détection de changement sur les entités afin de générer uniquement le nécessaire lorsque l’on demande un commit sur la base de données.

L’idée est assez simple au final : toute entité chargée depuis un contexte Entity Framework possède un état :

  • Unchanged : l’entité n’est pas modifiée, aucune requête SQL ne sera générée pour celle-ci lors du commit
  • Added : l’entité a été ajoutée au contexte, un ordre INSERT sera généré lors du commit
  • Modified : l’entité a été modifiée depuis qu’elle a été chargée via le contexte, un ordre UPDATE sera généré lors du commit
  • Deleted : l’entité a été supprimée du contexte, un ordre DELETE sera généré lors du commit

Il existe un dernier état que peut prendre une entité : Detached, c’est à dire qu’elle n’a pas été récupérée via le contexte Entity Framework.

L’état d’une entité est maintenue au sein du contexte par l’ObjectStateManager. Dès lors que le contexte Entity Framework est disposé, toutes les informations relatives au suivi des changements sont perdues.

ASP.NET MVC de part sa nature stateless force une très courte durée de vie pour un contexte Entity Framework : j’envoie une requête HTTP au serveur, le contexte Entity Framework est créé, la récupération de données est effectuée, le contexte est libéré et la connection à la base de données fermée, impliquant que le suivi des changements soit impossible dans ce cas : comment replacer mon objet dans le contexte lors que je post un formulaire HTML ?

Pour l’exemple, nous allons travailler avec l’entity data model suivant :

image

Créeons à présent la classe repository qui va permettre d’effectuer les opérations de CRUD sur un item de type Blog :

public class BlogRepository : IDisposable
{
private readonly BlogsContainer _blogsContainer = new BlogsContainer();

public void AddBlog(Blog blog)
{
_blogsContainer.Blogs.AddObject(blog);
_blogsContainer.SaveChanges();
}

public Blog GetBlog(int blogId)
{
return _blogsContainer.Blogs.SingleOrDefault(b => b.Id == blogId);
}

public IEnumerable<Blog> GetBlogs()
{
return _blogsContainer.Blogs.ToList();
}

public void DeleteBlog(Blog blog)
{

}

public void UpdateBlog(Blog blog)
{

}

public void Dispose()
{
_blogsContainer.Dispose();
}
}

Comme il est possible de le constater dans l’extrait de code ci-dessus, les opérations Add/Get sont réalisées de manière tout à fait classique sur l’object context Entity Framework. Cela va en revanche différer pour les méthodes Delete et Update, volontairement laissées vides pour le moment.

En effet, dans un contexte stateless, il n’est pas possible de bénéficier directement du mécanisme de change tracking proposé par Entity Framework : il faut auparavant attacher l’objet au contexte s’il ne l’est pas déjà.

Pour cela, l’object context expose une propriété ObjectStateManager qui va permettre de récupérer une ObjectStateEntry associée a une entité : si celle-ci existe, l’élément est connu du contexte, sinon il est inconnu :

ObjectStateEntry stateEntry;
if (_blogsContainer.ObjectStateManager.TryGetObjectStateEntry(blog, out stateEntry))
{
//l'objet Blog est connu du change tracker
}
else
{
//l'objet blog est inconnu du change tracker
}

Du coup, dans le cas d’un delete, on vérifie si l’objet est connu du change tracker : si oui, pas de souci, sinon on attache l’objet au contexte avant de demander sa suppression :

public void DeleteBlog(Blog blog)
{
ObjectStateEntry stateEntry;
if (!_blogsContainer.ObjectStateManager.TryGetObjectStateEntry(blog, out stateEntry))
{
_blogsContainer.Blogs.Attach(blog);
}

_blogsContainer.Blogs.DeleteObject(blog);
_blogsContainer.SaveChanges();
}

De la même manière, pour la mise à jour il faut vérifier si l’objet est connu du change tracker. Si oui, on va pouvoir utiliser la méthode ApplyCurrentValues de l’object set Blogs pour appliquer les changements et forcer le passage de l’entité dans l’état Modified. Sinon, il faut forcer le changement d’état via l’object state manager, après avoir attacher l’entité blog :

public void UpdateBlog(Blog blog)
{
ObjectStateEntry stateEntry;
if (!_blogsContainer.ObjectStateManager.TryGetObjectStateEntry(blog, out stateEntry))
{
_blogsContainer.Blogs.Attach(blog);
_blogsContainer.ObjectStateManager.ChangeObjectState(blog, System.Data.EntityState.Modified);
}
else
{
_blogsContainer.Blogs.ApplyCurrentValues(blog);
}

_blogsContainer.SaveChanges();
}

Et voilà un repository ultra simple, fonctionnel et adapté au développement d’applications stateless avec ASP.NET MVC.

A bientôt image

read more

Nouveau blog : aspnet mvc 3, windows azure, entity framework…

J’ai décidé d’externaliser mon blog et de quitter la plateforme Dotnet-France, sur laquelle mon ancien blog est toujours hébergé.

Pourquoi ce choix ? Tout simplement parce que je voulais écrire moi-même mon blog afin qu’il corresponde exactement à mes besoins et au passage cela m’a permis de prendre en main un certain nombre de technologies auxquelles je voulais me consacrer depuis un petit moment : ASP.NET MVC 3 et Windows Azure.

Vous l’aurez compris, ce blog a donc été développé avec ASP.NET MVC 3, et utilise le View Engine Razor (qui envoie franchement du paté!) et est hébergé sur Windows Azure pour la partie compute et Windows Azure Storage (Table) pour la partie Data.

Afin de mettre en place certains conceptes (injection de dépendances, scénario d’hébergement in cloud / on premises…), j’ai également développé un provider Entity Framework code first me permettant d’attaquer une base de données Sql Azure à la place du table storage.

J’ai identifié certains point assez intéressants lors du développement de ce blog, aussi je vais tâcher de publier des posts sur le développement d’applications web ASP.NET MVC 3 hébergées dans Windows Azure ou utilisant Entity Framework, l’injection de dépendance…

Mon ancien blog restera en ligne, mais ne sera plus alimenté, donc pensez à mettre à jour vos flux RSS si vous voulez continuer à suivre mes posts image

Comme avant, je n’ai pas véritablement de sujet de prédilection (bon ok, Silverlight / Windows Phone, si je dois choisir) mais j’aime toucher à tout, donc je continuerai à parler des technologies .NET en général sur ce blog, au fur et à mesure de mes découvertes / projets image

N’hésitez pas à me faire part de vos commentaires / remarques / suggestions quant à ce nouveau blog !

A bientôt pour de nouvelles aventures…

Julien

read more