Quel est le meilleur ou le plus intéressant l’utilisation de méthodes d’Extension vous ' ai vu ?

Question

Je commence à vraiment aimer les méthodes d’extension... Je me demandais si quelqu'un que lui a trébuché sur un qui a vraiment soufflé leur esprit, ou juste trouvé intelligent.

Un exemple que j’ai écrit aujourd'hui :

Édité en raison de commentaires d’autres utilisateurs :

Cela permet une boucle for pour être écrite comme une boucle foreach :

J’ai hâte de voir d’autres exemples ! Profitez !

Answer 1

C’est celui qui a été faire certain jeu de moi ces derniers temps :

Utilisé comme :

Memento est une classe très pratique :

Et pour terminer les dépendances :

Answer 2

La solution complète est trop grande à mettre ici, mais j’ai écrit une série de méthodes d’extension qui vous permet de convertir facilement un DataTable dans un fichier CSV.

À la fin de la journée, vous pourriez l’appeler comme ceci :

Answer 3

Je ne suis pas un fan de l' INotifyPropertyChanged interface exigeant que les noms de propriétés sont passés comme des chaînes de caractères. Je veux un fortement typé moyen de vérifier au moment de la compilation que je ne fais que soulever et la manipulation des modifications de la propriété pour les propriétés qui existent. J'utilise ce code pour faire ça:

public static class INotifyPropertyChangedExtensions
{
    public static string ToPropertyName<T>(this Expression<Func<T>> @this)
    {
        var @return = string.Empty;
        if (@this != null)
        {
            var memberExpression = @this.Body as MemberExpression;
            if (memberExpression != null)
            {
                @return = memberExpression.Member.Name;
            }
        }
        return @return;
    }
}

Dans les classes qui implémentent INotifyPropertyChanged - je inclure cette méthode d'assistance:

protected void NotifySetProperty<T>(ref T field, T value,
    Expression<Func<T>> propertyExpression)
{
    if (field == null ? value != null : !field.Equals(value))
    {
        field = value;
        this.NotifyPropertyChanged(propertyExpression.ToPropertyName());
    }
}

De sorte que, finalement, je peux faire ce genre de chose:

private string _name;
public string Name
{
    get { return _name; }
    set { this.NotifySetProperty(ref _name, value, () => this.Name); }
}

Il est fortement typé et je ne déclencher des événements pour les propriétés qui en fait le changement de leur valeur.

Answer 4

Eh bien, ce n'est pas vraiment intelligent, mais j'ai modifié les méthodes ---- OrDefault afin que vous puissiez spécifier un élément par défaut en ligne au lieu de rechercher la valeur null ultérieurement dans votre code:

     public static T SingleOrDefault<T> ( this IEnumerable<T> source, 
                                    Func<T, bool> action, T theDefault )
    {
        T item = source.SingleOrDefault<T>(action);

        if (item != null)
            return item;

        return theDefault;
    }
 

C'est incroyablement simple mais cela aide vraiment à nettoyer ces contrôles nuls. Il est préférable de l'utiliser lorsque votre interface utilisateur attend une liste d'éléments X, comme un système de tournoi ou des machines à sous et que vous souhaitez afficher les "sièges vides".

Usage:

     return jediList.SingleOrDefault( 
                 j => j.LightsaberColor == "Orange", 
               new Jedi() { LightsaberColor = "Orange", Name = "DarthNobody");
 

Answer 5

En voici un que j'ai bidouillé, alors n'hésitez pas à choisir des trous. Il faut un (ordonnée) de la liste d'entiers et qui renvoie une liste de chaînes de contiguë plages. par exemple:

1,2,3,7,10,11,12  -->  "1-3","7","10-12"

La fonction (dans une classe statique):

public static IEnumerable<string> IntRanges(this IEnumerable<int> numbers)
{
    int rangeStart = 0;
    int previous = 0;

    if (!numbers.Any())
        yield break;

    rangeStart = previous = numbers.FirstOrDefault();

    foreach (int n in numbers.Skip(1))
    {
        if (n - previous > 1) // sequence break - yield a sequence
        {
            if (previous > rangeStart)
            {
                yield return string.Format("{0}-{1}", rangeStart, previous);
            }
            else
            {
                yield return rangeStart.ToString();
            }
            rangeStart = n;
        }
        previous = n;
    }

    if (previous > rangeStart)
    {
        yield return string.Format("{0}-{1}", rangeStart, previous);
    }
    else
    {
        yield return rangeStart.ToString();
    }
}

Exemple d'utilisation:

this.WeekDescription = string.Join(",", from.WeekPattern.WeekPatternToInts().IntRanges().ToArray());

Ce code est utilisé pour convertir les données à partir d'un DailyWTF digne de calendrier d'application. WeekPattern est un masque de bits stockés dans une chaîne de caractères "0011011100...". WeekPatternToInts() qui convertit un IEnumerable<int>, dans ce cas [3,4,6,7,8], qui devient "3-4,6-8". Il fournit à l'utilisateur une description compacte de la scolaires semaine de plages qu'une conférence se produit sur.