Discussion :

[tomlev]

La version 0.2 de la librairie Dvp.NET est disponible !



Au programme, de nombreuses fonctionnalités supplémentaires, ainsi que des améliorations et corrections des fonctionnalités existantes :

• Assembly Developpez.Dotnet
  
  • Classe DataExtensions
    
    • Méthode GetStream : pour faciliter la lecture de données binaires à partir d'un champ BLOB. Permet de lire les données comme un flux, plutôt que par appels successifs à GetBytes (exemple)
    • Méthodes Get[Type]OrDefault : équivalent aux méthodes Get[Type], mais permet de spécifier une valeur à renvoyer si la valeur du champ est DBNull (exemple)
  • Classe EnumExtensions : améliorations diverses et correction d'un bug
  • Classe DefaultDictionary : ajout d'une option pour spécifier si les clés manquantes sont ajoutées ou non, via un paramètre du constructeur (exemples)
  • Classe EnumerableExtensions : nombreuses méthodes d'extension supplémentaires
    
    • Méthode None : le contraire de Any
    • Méthode GetSegment et méthodes associées : pour travailler sur des segments de tableaux
    • Méthodes IndexOf, LastIndexOf : cherchent la position d'un élément dans un séquence
    • Méthodes SkipFirst, SkipLast, SkipAt : sautent un élément dans une séquence
    • Méthode ReplaceAt : remplace à la volée un élément dans une séquence
    • Méthode InsertAt : insère à la volée un élément dans une séquence
    • Méthodes ShiftLeft, ShiftRight : effectuent un décalage à gauche ou à droite des éléments d'un tableau
    • Méthodes RotateLeft, RotateRight : effectuent une rotation à gauche ou à droite des éléments d'un tableau
    • Méthode CopyTo : copie les éléments d'une séquence vers un tableau
    • Méthode AddRange : insère plusieurs éléments dans une collection (équivalent à List<T>.AddRange, mais pour tous les types implémentant ICollection<T>)
    • Méthode ContainsAny : vérifie si une séquence contient au moins un des éléments spécifiés
    • Méthode Apply : applique une action à la volée sur chaque élément d'une séquence
  • Classe DictionaryExtensions :
    
    • Méthode ToDictionary : reconstruit un dictionnaire à partir d'une séquence de paires clés/valeurs (utile pour concaténer ou fusionner 2 dictionnaires). (exemple)
  • Classe CollectionFactory : permet de créer des collections génériques avec des types anonymes, grâce à l'inférence de type (exemple)
  • Classe StringExtensions
    
    • Méthode Take : indique le nombre de caractères à prendre (s'utilise en conjonction avec From). (exemples)
  • Classe LinqHelper : des méthodes pour faciliter l'utilisation de Linq (expressions lambdas, arbres syntaxiques...)
    
    • Méthode GetPropertyName : obtenir le nom d'une propriété à partir d'une expression lambda. Cela permet notamment d'éviter les "magic strings" que le compilateur ne peut pas vérifier (exemple)
    • Méthode GetMethodName : idem, pour une méthode (exemple)
    • Méthode Expr : permet de déclarer une expression Linq en tirant parti de l'inférence de type (utile pour les types anonymes) (exemple)
    • Méthode Func : permet de déclarer un delegate en tirant parti de l'inférence de type (utile pour les types anonymes)
  • Classe FuncExtensions : de nouvelles méthodes pour la programmation fonctionnelle
    
    • Méthodes ApplyFirst, ApplySecond, etc : obtient une nouvelle fonction en fixant la valeur d'un de ses paramètres (application partielle)
  • Classe CoreExtensions :
    
    • Méthode Switch : permet d'évaluer une valeur de façon similaire à une instruction switch, mais beaucoup plus souple (similaire au "pattern matching" des langages fonctionnels). (exemple)
    • Méthode GetService<T> : facilite l'utilisation de l'interface IServiceProvider, en évitant de faire des conversions et de répéter 3 fois le type...
    • Méthode CheckArgumentOutOfRange : vérifie qu'un argument est bien dans la plage attendue, et lève une exception ArgumentOutOfRange si ce n'est pas le cas
    • Méthode MakeHashCode : permet de générer facilement un hashcode pour un objet à l'aide d'un algorithme fiable
  • Classe WeakEvent<TEventHandler> : un wrapper d'évènement qui maintient des références faibles sur ses handlers, pour éviter les fuites mémoires dues à des handlers non retirés (exemple)
  • ImmutableList<T> : une liste générique immuable. Les méthodes Add, Remove, etc renvoient une nouvelle liste qui comporte les modifications. Utile pour la programmation fonctionnelle
  • Classe ReflectionExtensions :
    
    • Méthode GetDefaultValue : renvoie la valeur par défaut d'un type
  • Classe ReadOnlyDictionary :
    
    • Méthode FromNonGenericDictionary : pour créer un dictionnaire en lecture seule à partir d'un dictionnaire non générique
  • Classe AutoStopwatch : pour mesurer précisément le temps écoulé pour effectuer une action. Equivalent à la classe Stopwatch, mais plus simple d'utilisation (exemple)
  • Classe NotifyPropertyChangedExtensions : méthodes d'extension pour gérer les notifications PropertyChanged, et les dépendences entre diverses propriétés d'un objet. (exemples)
  • Classe MethodCallMonitor : 2 bugs critiques corrigés
• Assembly Developpez.Dotnet.Windows (pour WPF)
  
  • Propriété attachée DragMove.Enabled : pour activer déclarativement en XAML le déplacement automatique d'une fenêtre sans bordure
  • Classe DependencyObjectExtensions : correction d'un bug critique dans la méthode FindAncestor
  • Classe GridViewColumns : des propriétés attachées pour définir par binding la liste des colonnes d'une GridView (exemple à venir sur le wiki)
  • Classe UpdatableMarkupExtension : classe de base pour des markup extensions qui mettent à jour leur cible (exemple à venir sur le wiki)
  • Classe ObservableCollectionExtensions : une méthode d'extension AsObservable pour faciliter la créations de collections observables
  • Classe RangeObservableCollection :
    
    • Méthode ReplaceRange : remplace plusieurs valeurs consécutives dans la collection, avec une seule notification de changement
• L'assembly Developpez.Dotnet.SystemUtils a été renommé en Developpez.Dotnet.System
• Ajout d'une nouvelle version des binaires, spécifique pour l'utilisation avec .NET 4 : certaines méthodes en sont exclues, afin d'éviter les conflits avec des méthodes introduites dans .NET 4 (par exemple Enumerable.Zip)
• Quelques améliorations de la documentation
• Ajout d'un package comprenant les binaires, les sources et la doc, plus pratique que de tout télécharger séparément...

N'hésitez pas à tester tout ça et à nous faire part de vos retours

[stailer]

Bonjour,

A priori les helpers pour Linq m'intéressent... Mais où puis-je trouver des exemples d'utilisation de cette librairie ?

[tomlev]

A priori les helpers pour Linq m'intéressent... Mais où puis-je trouver des exemples d'utilisation de cette librairie ?

Sur le wiki... dès que j'aurais trouvé le temps de les écrire

En attendant, voilà des exemples pour les principales fonctionnalités de LinqHelper.

- GetPropertyName

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
private string _name;
public string Name
{
    get { return _name; }
    set
    {
        _name = value;
        OnPropertyChanged(LinqHelper.GetPropertyName(() => Name));
    }
}

L'intérêt est d'éviter d'écrire OnPropertyChanged("Name"), avec une chaine qui n'est pas vérifiée par le compilateur et n'est pas prise en compte par la refactorisation (si tu renommes la propriété). Moyennant une dégradation acceptable des performances, tu profites de la vérification à la compilation et de la refactorisation.

Comme ça me sert souvent, je me fais souvent une surcharge de OnPropertyChanged qui prend directement une expression en paramètre :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
protected void OnPropertyChanged<TProperty>(Expression<Func<TProperty>> propertySelector)
{
    OnPropertyChanged(LinqHelper.GetPropertyName(propertySelector));
}

- Expr et Func

Supposons que tu crées un objet de type anonyme :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

var toto = new { Foo = "hello", Bar = 42 };

Maintenant, tu veux déclarer une fonction qui prend en paramètre un objet de ce type et renvoie un bool :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Func<???, bool> barIsEven = x => x.Bar % 2 == 0;

Tu mets quoi à la place de "???" ? Evidemment comme le type est anonyme, tu ne peux pas l'utiliser dans la déclaration du delegate... C'est là que LinqHelper intervient :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

var barIsEven = LinqHelper.Func(toto, x => x.Bar % 2 == 0);

Le 1er paramètre (toto) n'est pas utilisé dans l'implémentation de la méthode, il sert seulement à ce que le compilateur puisse déterminer le type du delegate. Si tu n'as pas déjà sous la main une instance du type anonyme, tu peux faire comme ça :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
var barIsEven = LinqHelper.Func(
                new { Foo = default(string), Bar = default(int) },
                x => x.Bar % 2 == 0);

Note l'utilisation de default(string) plutôt que null, pour bien montrer qu'il s'agit d'une string.

Le principe est le même pour Expr, si tu veux une expression plutôt qu'une fonction.

[anthyme]

Sympa le coup du func !

Par contre pour les propertychanged je trouve pas le gain assez intéressant, pour le moment rien ne vaut un bon petit aspect postsharp

[tomlev]

Par contre pour les propertychanged je trouve pas le gain assez intéressant, pour le moment rien ne vaut un bon petit aspect postsharp

C'est vrai que PostSharp est sympa pour ce genre de choses... par contre j'aime pas trop le fait que ce soit une post-compilation, je préfère une solution 100% code

[stailer]

Very intéressant... Merci pour les exemples et vivement le Wiki

[anthyme]

C'est vrai que PostSharp est sympa pour ce genre de choses... par contre j'aime pas trop le fait que ce soit une post-compilation, je préfère une solution 100% code

Qu'est ce qui te dérange ? Qu'il y est une étape de plus dans la compilation ?

[tomlev]

Qu'est ce qui te dérange ? Qu'il y est une étape de plus dans la compilation ?

Principalement, oui. Mais bon, c'est vrai que c'est pas non plus très gênant... de ce que je me souviens quand j'avais testé, c'est géré automatiquement du moment que tu références l'assembly Postsharp (d'ailleurs je me demande bien comment ils ont fait ça )

[lukeni2]

bonne initaitive de créer cette librarie .net open source. Je vais télécharger et puis essayer.

[tomlev]

Pour ceux qui attendaient les exemples, j'en ai ajouté un certain nombre dans le wiki. Suivez les liens dans le premier post