Depuis hier je joue un peu :D avec VS 2010.
Entre 2 plantages, j'ai pratiqué quelques exemples de requêtes parallèlisées via PLINQ.
Dans ma machine virtuelle, il est pour l'instant très difficile de mesurer le gain (quelques millisecondes dans mes premiers tests).
En lisant un peu le blog de la team parallel extensions, il serait possible de simuler dans la machine virtuelle le multi coeur grâce à hyperV.

Donc wait and see, j'essaierai de mettre cela en place dans un futur proche avec l'aide d'un ingénieur IT.

En attendant, c'est assez bluffant, quasi-indolore au niveau du code.
Par contre les objets de requêtage PLINQ sont complètement différents de ceux de Linq (objectquery dans mon cas).
Linq

PLinq

Alexandre Equoy

Juste un petit billet pour vous signaler que le Technet Tour 2008 passera sur Lille les 13 et 14 octobre 2008.

Inscrivez vous.

Alexandre Equoy

Il y a quelques temps (avant l'arrivée de Linq) j'avais implémenté pour un client un GenericSorter, classe héritant de List<T> et IComparer<T> afin de gérer les problématiques de tri dans des collections.

En utilisant Linq chez un client hier, voici une possibilité d'implémenter un tri générique sur n'importe quelle colonne d'un objet. 

1) Cas simple : J'ai une collection de Client que je veux pouvoir trier sur n'importe quelle colonne passée en paramètre en tant que chaîne :

public List<Client> OrdonneClient(List<Client> lesAdherents, string colonneOrder, bool ascendant)
        {

            IEnumerable<Client> lesClients;
            if (ascendant)
            {
                lesClients = from c in lesAdherents
                             orderby c.GetType().GetProperty(colonneOrder).GetValue(c, null) ascending
                             select c;
            }
            else
            {
                lesClients = from c in lesAdherents
                             orderby c.GetType().GetProperty(colonneOrder).GetValue(c, null) descending
                             select c;
            }

return lesObjetsEnumerables.ToList(); 

     }

  2) Poussons le bouchon un peu plus loin pour atteindre une généricité au niveau de la collection d'objet:

public List<T> OrdonneCollection<T>(List<T> lesObjets, string colonneOrder, bool ascendant)
        {
            try
            {
                IEnumerable<T> lesObjetsEnumerables;
                if (ascendant)
                {
                    lesObjetsEnumerables = from c in lesObjets
                                           orderby c.GetType().GetProperty(colonneOrder).GetValue(c, null) ascending
                                           select c;
                }
                else
                {
                    lesObjetsEnumerables = from c in lesObjets
                                           orderby c.GetType().GetProperty(colonneOrder).GetValue(c, null) descending
                                           select c;
                }
                return lesObjetsEnumerables.ToList();
            }
            catch { throw new NotImplementedException("Colonne non implémentée");}
        }

Tout ceci n'a de sens que dans le cas où l'on vous passe une colonne en chaîne de caractère comme les SortExpression des gridView d'ASP.NET.

Si vous connaissez la colonne sur laquelle trier, il suffit de faire :

maCollection.OrderBy(element=>element.Property);

3) Tiens puisqu'on parle de lambda, simplifions la dernière méthode :

public static List<T> OrdonneCollectionLambda<T>(List<T> lesObjets, string colonneOrder, bool ascendant)
        {           
            try
            {
                if (ascendant)
                    return lesObjets.OrderBy(element => element.GetType().GetProperty(colonneOrder).GetValue(element, null)).ToList();
                else
                    return lesObjets.OrderByDescending(element => element.GetType().GetProperty(colonneOrder).GetValue(element, null)).ToList();
            }
            catch { throw new NotImplementedException("Colonne non implémentée"); }
        }

Alexandre Equoy