Passer un seul élément comme IEnumerable <T>

Existe-t-il un moyen courant de passer un seul élément de type Tà une méthode qui attend un IEnumerable<T> paramètre? Le langage est C #, framework version 2.0.

Actuellement, j'utilise une méthode d'assistance (c'est .Net 2.0, j'ai donc tout un tas de méthodes d'aide à la coulée / projection similaires à LINQ), mais cela semble juste idiot:

public static class IEnumerableExt
{
    // usage: IEnumerableExt.FromSingleItem(someObject);
    public static IEnumerable<T> FromSingleItem<T>(T item)
    {
        yield return item; 
    }
}

Une autre façon serait bien sûr de créer et de remplir un List<T>ou un Arrayet de le passer à la place de IEnumerable<T>.

[Modifier] En tant que méthode d'extension, elle pourrait être nommée:

public static class IEnumerableExt
{
    // usage: someObject.SingleItemAsEnumerable();
    public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
    {
        yield return item; 
    }
}

Est-ce que j'ai râté quelque chose?

[Edit2] Nous avons trouvé someObject.Yield()(comme @Peter l'a suggéré dans les commentaires ci-dessous) comme étant le meilleur nom pour cette méthode d'extension, principalement pour la brièveté, alors voici avec le commentaire XML si quelqu'un veut l'attraper:

public static class IEnumerableExt
{
    /// <summary>
    /// Wraps this object instance into an IEnumerable&lt;T&gt;
    /// consisting of a single item.
    /// </summary>
    /// <typeparam name="T"> Type of the object. </typeparam>
    /// <param name="item"> The instance that will be wrapped. </param>
    /// <returns> An IEnumerable&lt;T&gt; consisting of a single item. </returns>
    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }
}

Votre méthode d'aide est la façon la plus propre de le faire, OMI. Si vous passez une liste ou un tableau, un morceau de code sans scrupules pourrait le transtyper et modifier le contenu, ce qui entraînerait un comportement étrange dans certaines situations. Vous pouvez utiliser une collection en lecture seule, mais cela impliquera probablement encore plus d'habillage. Je pense que votre solution est aussi nette que possible.

Eh bien, si la méthode attend un, IEnumerablevous devez passer quelque chose qui est une liste, même si elle ne contient qu'un seul élément.

qui passe

new[] { item }

comme l'argument devrait suffire je pense

En C # 3.0, vous pouvez utiliser la classe System.Linq.Enumerable:

// using System.Linq

Enumerable.Repeat(item, 1);

Cela va créer un nouvel IEnumerable qui ne contient que votre article.

En C # 3 (je sais que vous avez dit 2), vous pouvez écrire une méthode d'extension générique qui pourrait rendre la syntaxe un peu plus acceptable:

static class IEnumerableExtensions
{
    public static IEnumerable<T> ToEnumerable<T>(this T item)
    {
        yield return item;
    }
}

le code client est alors item.ToEnumerable().

Cette méthode d'assistance fonctionne pour un élément ou plusieurs.

public static IEnumerable<T> ToEnumerable<T>(params T[] items)
{
    return items;
}    

Je suis un peu surpris que personne n'ait suggéré une nouvelle surcharge de la méthode avec un argument de type T pour simplifier l'API client.

public void DoSomething<T>(IEnumerable<T> list)
{
    // Do Something
}

public void DoSomething<T>(T item)
{
    DoSomething(new T[] { item });
}

Maintenant, votre code client peut simplement faire ceci:

MyItem item = new MyItem();
Obj.DoSomething(item);

ou avec une liste:

List<MyItem> itemList = new List<MyItem>();
Obj.DoSomething(itemList);

Soit (comme cela a été dit précédemment)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

ou

MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject, 1));

En remarque, la dernière version peut aussi être sympa si vous voulez une liste vide d'un objet anonyme, par exemple

var x = MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new { a = 0, b = "x" }, 0));

Comme je viens de le découvrir et de voir que l'utilisateur LukeH l'a également suggéré, une belle façon simple de le faire est la suivante:

public static void PerformAction(params YourType[] items)
{
    // Forward call to IEnumerable overload
    PerformAction(items.AsEnumerable());
}

public static void PerformAction(IEnumerable<YourType> items)
{
    foreach (YourType item in items)
    {
        // Do stuff
    }
}

Ce modèle vous permettra d'appeler la même fonctionnalité de multiples façons: un seul élément; plusieurs éléments (séparés par des virgules); un tableau; une liste; une énumération, etc.

Je ne suis pas sûr à 100% de l'efficacité de l'utilisation de la méthode AsEnumerable, mais cela fonctionne vraiment.

Mise à jour: la fonction AsEnumerable semble assez efficace! ( référence )

Bien que ce soit exagéré pour une méthode, je pense que certaines personnes peuvent trouver les extensions interactives utiles.

Les extensions interactives (Ix) de Microsoft incluent la méthode suivante.

public static IEnumerable<TResult> Return<TResult>(TResult value)
{
    yield return value;
}

Qui peut être utilisé comme ceci:

var result = EnumerableEx.Return(0);

Ix ajoute de nouvelles fonctionnalités que l'on ne trouve pas dans les méthodes d'extension Linq d'origine et est le résultat direct de la création des extensions réactives (Rx).

Pensez, Linq Extension Methods+ Ix= Rxpour IEnumerable.

Vous pouvez trouver à la fois Rx et Ix sur CodePlex .

Ceci est 30% plus rapide que yieldou Enumerable.Repeatlorsqu'il est utilisé en foreachraison de cette optimisation du compilateur C # , et des mêmes performances dans d'autres cas.

public struct SingleSequence<T> : IEnumerable<T> {
    public struct SingleEnumerator : IEnumerator<T> {
        private readonly SingleSequence<T> _parent;
        private bool _couldMove;
        public SingleEnumerator(ref SingleSequence<T> parent) {
            _parent = parent;
            _couldMove = true;
        }
        public T Current => _parent._value;
        object IEnumerator.Current => Current;
        public void Dispose() { }

        public bool MoveNext() {
            if (!_couldMove) return false;
            _couldMove = false;
            return true;
        }
        public void Reset() {
            _couldMove = true;
        }
    }
    private readonly T _value;
    public SingleSequence(T value) {
        _value = value;
    }
    public IEnumerator<T> GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
    IEnumerator IEnumerable.GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
}

dans ce test:

    // Fastest among seqs, but still 30x times slower than direct sum
    // 49 mops vs 37 mops for yield, or c.30% faster
    [Test]
    public void SingleSequenceStructForEach() {
        var sw = new Stopwatch();
        sw.Start();
        long sum = 0;
        for (var i = 0; i < 100000000; i++) {
            foreach (var single in new SingleSequence<int>(i)) {
                sum += single;
            }
        }
        sw.Stop();
        Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}");
        Console.WriteLine($"Mops {100000.0 / sw.ElapsedMilliseconds * 1.0}");
    }

IanG a un bon article sur le sujet , suggérant EnumerableFrom()comme nom (et mentionne que Haskell et Rx l'appellent Return). L'IIF de F # l'appelle aussi Return . F # Seqappelle l'opérateursingleton<'T> .

Tentant si vous êtes prêt à être centré sur C # est de l'appeler Yield[faisant allusion à la personne yield returnimpliquée dans sa réalisation].

Si vous êtes intéressé par les aspects de la performance, James Michael Hare a également un article de retour zéro ou un article qui vaut bien une analyse.

Ce n'est peut-être pas mieux mais c'est plutôt cool:

Enumerable.Range(0, 1).Select(i => item);

Je suis d'accord avec les commentaires de @ EarthEngine sur le message d'origine, qui est que "AsSingleton" est un meilleur nom. Voir cette entrée wikipedia . Ensuite, il résulte de la définition de singleton que si une valeur nulle est passée comme argument, 'AsSingleton' devrait retourner un IEnumerable avec une seule valeur null au lieu d'un IEnumerable vide qui réglerait le if (item == null) yield break;débat. Je pense que la meilleure solution est d'avoir deux méthodes: 'AsSingleton' et 'AsSingletonOrEmpty'; où, dans le cas où un NULL est passé en argument, 'AsSingleton' renverra une seule valeur Null et 'AsSingletonOrEmpty' renverra un IEnumerable vide. Comme ça:

public static IEnumerable<T> AsSingletonOrEmpty<T>(this T source)
{
    if (source == null)
    {
        yield break;
    }
    else
    {
        yield return source;
    }
}

public static IEnumerable<T> AsSingleton<T>(this T source)
{
    yield return source;
}

Ensuite, celles-ci seraient plus ou moins analogues aux méthodes d'extension «First» et «FirstOrDefault» sur IEnumerable, ce qui semble juste.

La façon la plus simple que je dirais serait new T[]{item};; il n'y a pas de syntaxe pour ce faire. L'équivalent le plus proche auquel je peux penser est le paramsmot - clé, mais bien sûr, cela vous oblige à avoir accès à la définition de la méthode et n'est utilisable qu'avec des tableaux.

Enumerable.Range(1,1).Select(_ => {
    //Do some stuff... side effects...
    return item;
});

Le code ci-dessus est utile lors de l'utilisation comme

var existingOrNewObject = MyData.Where(myCondition)
       .Concat(Enumerable.Range(1,1).Select(_ => {
           //Create my object...
           return item;
       })).Take(1).First();

Dans l'extrait de code ci-dessus, il n'y a pas de vérification vide / nulle et il est garanti qu'un seul objet est renvoyé sans avoir peur des exceptions. De plus, étant donné qu'il est paresseux, la fermeture ne sera pas exécutée tant qu'il n'aura pas été prouvé qu'aucune donnée existante ne correspond aux critères.

Je suis un peu en retard à la fête mais je vais quand même partager mon chemin. Mon problème était que je voulais lier ItemSource ou WPF TreeView à un seul objet. La hiérarchie ressemble à ceci:

Projet> Parcelle (s)> Salle (s)

Il n'y aura toujours qu'un seul projet, mais je voulais toujours montrer le projet dans l'arborescence, sans avoir à passer une collection avec seulement un seul objet comme certains l'ont suggéré.
Comme vous ne pouvez transmettre que des objets IEnumerable en tant que ItemSource, j'ai décidé de rendre ma classe IEnumerable:

public class ProjectClass : IEnumerable<ProjectClass>
{
    private readonly SingleItemEnumerator<AufmassProjekt> enumerator;

    ... 

    public IEnumerator<ProjectClass > GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Et créez mon propre énumérateur en conséquence:

public class SingleItemEnumerator : IEnumerator
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(object current)
    {
        this.Current = current;
    }

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public object Current { get; }
}

public class SingleItemEnumerator<T> : IEnumerator<T>
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(T current)
    {
        this.Current = current;
    }

    public void Dispose() => (this.Current as IDisposable).Dispose();

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public T Current { get; }

    object IEnumerator.Current => this.Current;
}

Ce n'est probablement pas la solution "la plus propre" mais cela a fonctionné pour moi.

EDIT
Pour maintenir le principe de responsabilité unique comme l'a souligné @Groo, j'ai créé une nouvelle classe wrapper:

public class SingleItemWrapper : IEnumerable
{
    private readonly SingleItemEnumerator enumerator;

    public SingleItemWrapper(object item)
    {
        this.enumerator = new SingleItemEnumerator(item);
    }

    public object Item => this.enumerator.Current;

    public IEnumerator GetEnumerator() => this.enumerator;
}

public class SingleItemWrapper<T> : IEnumerable<T>
{
    private readonly SingleItemEnumerator<T> enumerator;

    public SingleItemWrapper(T item)
    {
        this.enumerator = new SingleItemEnumerator<T>(item);
    }

    public T Item => this.enumerator.Current;

    public IEnumerator<T> GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Que j'ai utilisé comme ça

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

EDIT 2
J'ai corrigé une erreur de MoveNext()méthode.

A classer sous "Pas forcément une bonne solution, mais quand même ... une solution" ou "Stupid LINQ tricks", vous pouvez combiner Enumerable.Empty<>()avec Enumerable.Append<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Append("Hello, World!");

... ou Enumerable.Prepend<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Prepend("Hello, World!");

Les deux dernières méthodes sont disponibles depuis .NET Framework 4.7.1 et .NET Core 1.0.

Il s'agit d'une solution réalisable si l'on avait vraiment l' intention d'utiliser des méthodes existantes au lieu d'écrire les leurs, bien que je ne sois pas sûr que ce soit plus ou moins clair que la Enumerable.Repeat<>()solution . Il s'agit certainement d'un code plus long (en partie parce que l'inférence de paramètres de type n'est pas possible Empty<>()) et crée cependant deux fois plus d'objets énumérateurs.

Pour compléter ce "Saviez-vous que ces méthodes existent?" réponse, Array.Empty<>()pourrait être substitué Enumerable.Empty<>(), mais il est difficile de prétendre que cela rend la situation ... meilleure.

J'ai récemment posé la même question sur un autre post ( Existe-t-il un moyen d'appeler une méthode C # nécessitant un IEnumerable <T> avec une seule valeur? ... avec benchmarking ).

Je voulais que les gens s'arrêtent ici pour voir la brève comparaison de référence montrée à ce poste plus récent pour 4 des approches présentées dans ces réponses.

Il semble que le simple fait d'écrire new[] { x }les arguments de la méthode soit la solution la plus courte et la plus rapide.