.net is good... C# is better ;)

Lorsque l'on travaille avec les Types, il existe tout un tas de méthodes et propriétés pour savoir si par exemple on est en présence d'un Generic, d'un tableau, d'une classe... Il existe aussi une méthode pour savoir si notre Type hérite d'un autre Type.

Cependant, il n'existe aucun méthode permettant de savoir si celui-ci implémente une interface. Je vous propose donc une petite méthode d'extension faisant le travail.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 

public static class TypesExtensions
{
  /// <summary>
  /// Test si un type implémente une interface 
  /// </summary>
  /// <param name="type"></param>
  /// <param name="interface"></param>
  /// <returns></returns>
  public static bool IsImplementInterface(this Type type, Type @interface) {
    return type.FindInterfaces((t, c) => {
      var tc = c as Type;
      var tt = t as Type;

      if (tc.IsGenericType && tc.ContainsGenericParameters && tt.IsGenericType)
      {
        return tc.GetGenericTypeDefinition() == tt.GetGenericTypeDefinition();
      }
      return tc == tt;
    }, @interface).Length > 0;
  }

}

Voici un exemple d'utilisation :

1
2
3
4
5
6
 

var iInterface = typeof(ICollection);
var type1 = typeof(object);
var type2 = typeof(List<string>);

var tTest1 = type1.IsImplementInterface(iInterface);
var tTest2 = type2.IsImplementInterface(iInterface);

En exécutant le code ci-dessus, on constate que tTest1 est égal à false tandis que tTest2 est true.

Update 22/09

Réponse à une question intéressante venue par email : Ne serait-il pas plus simple d'utiliser IsAssignableFrom ?

En fait, la méthode Type.IsAssignableFrom(type) permet de déterminer si l'instance du Type en cours peut être assignée à une instance du type spécifié. Hors dans notre cas, le type spécifié est une interface, ce n'est donc pas un type que l'on peut instancié.

Voici par exemple le résultat des différents appels :

1
2
3
4
5
6
7
8
9
 

var t = typeof(List<string>);
var i = typeof(ICollection<string>);
var i2 = typeof(ICollection<>);

var test1 = t.IsAssignableFrom(i); // ==> false
var test2 = t.IsAssignableFrom(i2); // ==> false

var test3 = t.IsImplementInterface(i); // ==> true
var test4 = t.IsImplementInterface(i2); // ==> true

NDepend est un produit bien connu des développeurs soucieux de produire des applications robustes puisqu'il analyse de façon statique votre code source grâce à des outils très puissants.

Cette version 4.0 apporte son lot de nouveautés :

• Complète intégration à Visual Studio 11 (futur VS2012),
• Création de requêtes et de règles en LINQ grâce à CQLinq,
• CQLinq est basé sur la nouvelle API de NDepend.

Au programme, vous pourrez retrouver plus de 60 nouvelles règles (personnalisables) écrites avec CQLinq mais aussi la mise à jour et l'optimisation des règles précédemment présentent. Mieux encore, un outil permet de convertir vos requêtes CQL en CQLinq automatiquement !
Vous trouverez aussi 14 Power Tools open-sources basés sur NDepend.API que vous pourrez adapter facilement pour vos besoins !

Un petit exemple de la puissance de NDepend, le code suivant permet de rechercher toutes les instances d'objet Disposable qui n'appellent pas la méthode Dispose() :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 

            
              // <Name>Types with disposable instance fields must be disposable</Name>
              
warnif count > 0

let iDisposable = ThirdParty.Types.WithFullName("System.IDisposable").FirstOrDefault() 
where iDisposable != null // iDisposable can be null if the code base doesn't use at all System.IDisposable

from t in Application.Types where 
   !t.Implement(iDisposable) && 
   !t.IsGeneratedByCompiler 

let instanceFieldsDisposable = 
    t.InstanceFields.Where(f => f.FieldType != null &&
                                f.FieldType.Implement(iDisposable))

where instanceFieldsDisposable.Count() > 0
select new { t, instanceFieldsDisposable }
          

Pour en savoir plus, je vous conseille vivement d'aller voir la page consacrée à NDepend v4.

L’implémentation de l’interface INotifyPropertyChanged est très pratique lorsque l’on veut, dans un context de DataBinding, que notre Vue soit informée des changements des propriétés de notre Modèle. Cependant, il est long et rébarbatif d’écrire le setter pour chaque propriété.

Voici donc une idée d’implémentation automatisant tout cela…

Je vous invite à lire la suite de cet article sur mon blog pro : Simplifier l’écriture de INotifyPropertyChanged en C#.
N'hésitez pas à jeter un oeil sur le project Codeplex dans lequel est implémentée cette solution.

Ceux qui me connaissent depuis longtemps savent à quel point j'aime Windows Forms. Mais depuis l'arrivée de Silverlight et WPF, je boude régulièrement cette API car il n'est pas toujours facile de faire les choses proprement. Je me suis donc lancé dans la création d'une implémentation de MVVM pour Windows Forms.

Je vous invite donc à lire mon article et à découvrir mon projet sur CodePlex.

Le métier de développeur est rempli de tâches répétitives et rébarbatives, avec notamment la création de formulaires pour la création, la lecteur, la mise à jour et la suppression, communément appelé CRUD (Create, Read, Update et Delete).

Ainsi, au démarrage d'un projet ASP.net MVC3, il faut créer tous les modèles, les controleurs, les vues et le DbContext Entity Framework permettant de lire les données.

Dans la lignée de mon dernier post et de ma dernière source sur CSharpFR, j'ai donc, créé un template de projet pour Microsoft Visual Studio 2010 se connectant à une base de données (SQL Server) et générant automatiquement tous les controleurs, modèles (avec Primary et Foreign Keys), vues en quelques secondes ! En prime, les vues Index sont triables et paginées en jQuery !

Je vous invite donc à télécharger et à tester ce template sur Codeplex : http://somvc.codeplex.com.
Prochainement ce template évoluera et incluera les tests unitaires.

Cet utilitaire permet de créer toutes les classes métiers d'une application ASP.net MVC 3 à partir d'une connection à une base de données (testé avec SQL Server, SQL Server Express et SQL Server CE).

En quelques secondes vous pourrez créer tous les modèles de votre application ASP.net MVC 3 : toutes les propriétés possédant déjà les attributs nécessaires à MVC et à Entity Framework !

Les classes sont crées via un Template T4 et donc, il est très facile de créer d'autres templates pour d'autres types de projets.

Rendez-vous sur CSharpFR : Création de classes métiers à partir d'une base de données.

A travers ce court article, je vous propose de mettre en œuvre une technique que je considère comme simple et rapide : simple car elle s’appuie sur l’implémentation du modèle MVC d’ASP.net et rapide car elle ne nécessite pas la refonte complète de votre application.

Lire la suite...

Windows Forms est une technologie « ancienne » basée sur win32 et inspirée de Visual Basic. Elle a l’avantage d’être facile à apprendre et rapidement performante. Malheureusement, il arrive souvent lorsque l’on cherche à construire des formulaires complexes d’être « limité ».

Microsoft a introduit Windows Presentation Foundation (WPF) avec la version 3.0 du Framework .net, cette spécification graphique permet à l’aide du langage XAML, un langage basé sur XML, de spécifier vos formulaires à la manière d’ASP.net : c’est à la fois très facile… et déroutant !

WPF abandonne GDI+ et s’appuie désormais sur DirectX qui lui permet d’offrir en plus un support de la 3D et surtout un rendu vectoriel, il est donc possible très facilement d’effectuer des zooms, des rotations, des flips…

Si comme moi vous avez fait beaucoup de Windows Forms, la transition vers WPF peut vous faire peur car tout semble différent… voire étrange ! Nous allons donc découvrir comment, à partir de notre expérience Windows Forms, il est possible (je n’ai pas dit simple) de se mettre à WPF. Commençons donc par quelques banalités et voyons les containers.

Lire la suite

So@t contribue à l’aventure de la Communauté Silverlight France par deux de ses consultants Cyril Cathala et Nathanael Marchand. Ils seront présents sur scène lors du lancement dans les locaux de Microsoft. Mais quelle est cette communauté ?

Je vous invite à lire la suite sur le blog de Nathanael

Le DataBinding est un moyen de lier une structure de données à des contrôles d’un formulaire sans avoir à se soucier des mises à jour effectuées par les 2 parties. Toutes les propriétés des contrôles peuvent être liées, mais traditionnellement on associe les propriétés Text ou Value.
Nous allons voir dans cet article les différents types de liaisons et les sources de données supportées par Windows Forms, puis nous continuerons avec un rapide aperçu des interfaces qui permettent au DataBinding de fonctionner. Pour finir, nous étudierons un cas pratique et mettrons en place un formulaire consommant une source de données personnalisée.

Lire la suite...

Voilà, après trop de temps passé dans l'ombre... je reviens avec l'obtention de la certification TS 75-515... c'est un début, je compte passer les autres rapidement !

En attendant, j'ai l'intention d'écrire une série d'articles dont le premier devrait être publié à la fin du mois de juillet !

Stay tuned !

Je suis heureux de vous annoncer la publication de mon application sur le MarketPlace de Windows Phone 7 :).

"Mon Coffre Fort" est une application permettant de stocker en toute sécurité vos informations confidentielle tels que vos numéros de cartes bancaires, vos mots de passe, vos codes PIN (code de portes...). Pour cela, les informations sont stockés sur votre téléphone au moyen d'un mot de passe que vous aurez défini et de l'identifiant unique qui identifie votre WP7. Ainsi, toute personne mal intensionnée voulant récupérer vos informations sera déboutée.

L'application est disponible en français et en anglais, mais sera prochainement mise à jour pour intégrer l'espagnol, l'allemand et peut-être l'italien. Plus quelques petites améliorations.

Pour l'acheter (0,99€) vous pouvez suivre le lien suivant : http://social.zune.net/redirect?type=phoneApp&id=89ac82f4-641d-e011-9264-00237de2db9e

Visual NDepend est un outil développé par Patrick Smacchia, MVP Visual C# français reconnu pour la qualité de ses ouvrages sur .net et C#.

A partir de l’analyse statique d’une assembly, NDepend permet d’établir un ensemble de statistiques facilitant l’évaluation de la qualité d’une bibliothèque, d’une application ou tout autre résultat d’une compilation en .net. Nous verrons un peu plus loin les différentes formes de statistiques et de leurs représentations.

Vous trouverez attaché à cet article le fichier PDF

Patrick Smacchia a publié ces derniers jours une nouvelle version de NDepend incluant une nouvelle fonctionnalité : une aide contextuelle.

Cette aide survient uniquement lorsque l'utilisateur survolera un panel avec sa souris et fournit une information claire sur l'élément pointé.

Cette fonctionnalité aidera surement les personnes qui débutent avec NDepend.

Référence : Software learnability increased with Context-Sensitive Help (Patrick Smacchia)

Télécharger NDepend

Bonjour à tous,

Après quelques semaines de silence, je vais reprendre petit à petit les mises à jour de ce blog.

Je vous prépare actuellement un article sur la nouvelle version de NDepend.

En attendant, je vous invite à venir voir mes photos sur Flickr.

Et oui, tout comme Richard, je ne suis pas renouvelé au titre de MVP C#.

Bien sûr à la vue de la qualité et de la quantité de mes participations communautaires de cette année, j'avoue que je m'y attendais ! Je remercie Martine de m'avoir averti par téléphone avant la missive officielle !

Une page se tourne... peut-être un nouveau départ ? non ?

En attendant un éventuel retour au premier plan sur les technologies Microsoft, j'ai décidé de me consacrer un peu à la photo et la musique.

Merci pour tout.

Voila... ça faisait un moment que j'hésitais à poster cette source... je l'ai développé suite à une overdose de création de contrôles !

Parmis les choses qui me rebutent, celle qui consiste à recopier 10 fois le même bloc de code me donne envie de tout plaquer... tout arrêter !
Alors, j'ai eu l'idée d'une classe qui permettrait de décorer mes propriétés avec des attributs de manières à éviter la longue et fastidieuse tâche de déclaration des DependencyProperties.

Je vous propose donc ce bout de code déposer sur www.csharpfr.com (chapeau pour la V11 !).

Source mise à jour en tenant compte des remarques de Romain.

Il y a des jours où l'on passe trop de temps à s'arracher les cheveux !

Depuis quelques temps l'application sur laquelle je travaille remonte de manière aléatoire l'erreur suivante :

Validation of viewstate MAC failed. If this application is hosted by a Web Farm or cluster, ensure that <machineKey> configuration specifies the same validationKey and validation algorithm. AutoGenerate cannot be used in a cluster.

Problème : cette application ne tourne pas sur un cluster !

Après quelques recherches sur l'Internet, il s'agirait d'un problème connu et il existerait un patch dans le SP1 du Framework 3.5. (Nous utilisons le Framework 2.0 pour notre application... oui, oui... je sais c'est vieux, mais l'immobilisme des grands groupes n'est pas une légende !)

J'ai aussi trouvé le pansement suivant qui consiste à surcharger la méthode Render des pages :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 

protected override void Render(HtmlTextWriter writer)
{
    StringWriter stringWriter = new StringWriter();
    HtmlTextWriter htmlWriter = new HtmlTextWriter(stringWriter);

    base.Render(htmlWriter);

    string html = stringWriter.ToString();
    string[] aspnetFormelems = new string[5];
    aspnetFormelems[0] = "__EVENTTARGET";
    aspnetFormelems[1] = "__EVENTARGUMENT";
    aspnetFormelems[2] = "__VIEWSTATE";
    aspnetFormelems[3] = "__EVENTVALIDATION";
    aspnetFormelems[4] = "__VIEWSTATEENCRYPTED";
    foreach (string elem in aspnetFormelems)
    {
        //Response.Write("input type=""hidden"" name=""" & abc.ToString & """")
        int startPoint = html.IndexOf(string.Format(@"<input type=""hidden"" name=""{0}""", elem));
        if (startPoint < 0)
        {
            continue;
        }
        //does __VIEWSTATE exist?
        int endPoint = html.IndexOf("/>", startPoint) + 2;
        string viewStateInput = html.Substring(startPoint,
                                               endPoint - startPoint);
        html = html.Remove(startPoint, endPoint - startPoint);
        int formStart = html.IndexOf("<form");
        int endForm = html.IndexOf(">", formStart) + 1;
        if (endForm >= 0)
        {
            html = html.Insert(endForm, viewStateInput);
        }
    }

    writer.Write(html);
}

Pour le moment, je n'ai pas eu le temps de tester la mise à jour du Framework... Par contre, le pansement ci-dessus donne des résultats satisfaisant : le bug surgit beaucoup moins souvent... mais il est toujours là !

Question : Rencontrez-vous ce problème ? Avez-vous des pistes ?

Parmi elles se trouvent une fonctionnalité bien connue de tout le monde : le double clic sur la barre de titre des applications pour les agrandir/restaurer.

• lorsque vous glissez votre fenêtre vers la bordure supérieur de votre écran, celle-ci se maximise ;
• lorsque vous glissez votre fenêtre vers l'une des bordures droite ou gauche de votre écran, celle-ci se maximise en hauteur ;
• lorsque vous pointez votre fenêtre et faites apparaitre le curseur de redimensionnement vertical (la double flèche verticale) et que vous double-cliquez, votre fenêtre se maximisera en hauteur ;
• si vous secouer votre fenêtre en l'attrapant par la barre de titre, toutes les autres fenêtres se replient (et inversement) ;
• lorsque que votre fenêtre est maximisée, si vous essayez de la déplacer en l'attrapant par la barre de titre, elle retrouve la taille qu'elle avait avant d'être maximisée.

J'espère que tout est clair !

Bon test !