Élégamment passant des listes et des objets comme paramètres

En C#, on peut utiliser la params mot-clé pour spécifier un nombre arbitraire de paramètres typés à une méthode:

public void DoStuff(params Foo[] foos) {...}

public void OtherStuff {
    DoStuff(foo1);
    DoStuff(foo2, foo3);
}

Si vous avez déjà une liste d'objets, vous pouvez le transformer en un tableau de passer à cette méthode:

DoStuff(fooList.ToArray());

Cependant, est-il une manière élégante de mix-n-match? C'est, pour passer dans de multiples objets et des listes d'objets et les résultats sont aplaties dans une liste ou un tableau pour vous? Idéalement, je voudrais être en mesure de téléphoner à ma méthode comme ceci:

DoStuff(fooList, foo1, foo2, anotherFooList, ...);

De plein droit maintenant, la seule façon que je sais comment faire c'est pour pré-traiter le tout dans une seule liste, et je ne sais pas de toute façon de le faire d'une manière générique.

Edit: Pour être clair, je ne suis pas marié à la params mot-clé, c'est juste un mécanisme qui m'a aidé à expliquer ce que je voulais faire. Je suis très heureux avec n'importe quelle solution qui a l'air propre et aplatit le tout dans une seule liste.

n'utilisez pas de params sauf si vraiment nécessaire.
J' j'espère il n'y a aucun moyen de mélanger et assortir. Comment le compilateur de savoir si vous vouliez aplatir un objet qui est un tableau d'objets? Faut-il aplatir un tableau de tableaux d'objets? Comment pourrait-il éventuellement décider du moment d'aplatir et quand ne pas le faire?
Je ne suis pas tout à fait clair sur ce que votre objectif ou de motivation, mais, la documentation de params msdn.microsoft.com/en-us/library/w5zay9db.aspx montre l'utilisation d'un tableau de type comme dans public static void UseParams2(params object[] list)

OriginalL'auteur ean5533 | 2013-08-05

  1. 12

    Vous pouvez créer une classe avec implict conversions pour envelopper un seul élément et une liste:

    public class ParamsWrapper<T> : IEnumerable<T>
{
    private readonly IEnumerable<T> seq;

    public ParamsWrapper(IEnumerable<T> seq)
    {
        this.seq = seq;
    }

    public static implicit operator ParamsWrapper<T>(T instance)
    {
        return new ParamsWrapper<T>(new[] { instance });
    }

    public static implicit operator ParamsWrapper<T>(List<T> seq)
    {
        return new ParamsWrapper<T>(seq);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return this.seq.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

    ensuite, vous pouvez changer votre DoStuff méthode:

    private static void DoStuff(params ParamsWrapper<Foo>[] foos)
{
    Foo[] all = foos.SelectMany(f => f).ToArray();
    //
}
    +1. C'est intelligent, comme une réponse à l'énigme de l'OP présenté 🙂 Même si je suis sûr que c'est aussi "mal" 🙂 (dans le sens que Jon Skeet signifie, par exemple. dans cet exposé: youtu.être/lGbQiguuUGc). Je ne pense pas qu'il devrait aller dans le code de production, mais c'est sympa
    Ah, C'est le genre de réponse que je cherchais. Non pas parce que je veux l'utiliser dans la production, mais parce que je savais que intelligent réponses à ce problème pourrait m'enseigner quelque chose de nouveau. Excellent, merci.
    Pourquoi ne pas aller dans le code de production?

    OriginalL'auteur

  2. 4

    Vous pouvez utiliser Énumérable.Concat de rejoindre plusieurs listes et les éléments, comme:

     DoStuff(fooList
       .Concat(Enumerable.Repeat(foo1,1))
       .Concat(Enumerable.Repeat(foo2,1))
       .Concat(Enumerable.Repeat(anotherFooList))
       .ToArray();

    Remarque: il y a probablement beaucoup plus lisible des moyens pour réaliser tout ce que vous essayez de faire. Même en passant IEnumerable<Foo> est plus lisible.

    OriginalL'auteur

  3. 1

    Vous ne pouvez pas vraiment faire ce que vous essayez de faire, mais avec une méthode d'extension, vous pouvez obtenir à peu près:

    void Main()
{
    var singleFoo = new Foo();
    var multipleFoos = new[] { new Foo(), new Foo(), new Foo() };
    var count = DoStuffWithFoos(singleFoo.Listify(), multipleFoos).Count();
    Console.WriteLine("Total Foos: " + count.ToString());
}

public IEnumerable<Foo> DoStuffWithFoos(params IEnumerable<Foo>[] fooLists)
{
    return fooLists.SelectMany(fl => fl); //this flattens all your fooLists into
                                          //a single list of Foos
}

public class Foo { }

public static class ExtensionMethods
{
    public static IEnumerable<Foo> Listify(this Foo foo)
    {
        yield return foo;
    }
}
    Pas une mauvaise solution. Ajoute un tout petit peu de charge de l'appelant (appel Listify), mais pas trop.

    OriginalL'auteur

  4. 0

    vous pourriez faire de méthodes distinctes pour charger les objets dans la même collection, non pas qu'élégant, mais il va travailler, et la logique est vraiment facile à suivre, et pas très difficile à mettre en œuvre.

    public class Flattener<T> : IEnumerable<T>
{
    private List<T> _collection = new List<T> ( );
    public void Add ( params T [ ] list )
    {
        _collection.AddRange ( list );
    }

    public void Add ( params IEnumerable<T> [ ] lists )
    {
        foreach ( var list in lists )
            _collection.AddRange ( list );
    }

    public T Result
    {
        get
        {
            return _collection.ToArray();
        }
    }

    public IEnumerator<T> GetEnumerator ( )
    {
        return _collection.GetEnumerator ( );
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator ( )
    {
        return GetEnumerator ( );
    }
}


Flattener<Foo> foos = new Flattener();
foos.Add(fooList, fooList2, fooList3,...);
foos.Add(foo1,foo2,foo3,...);
DoStuff(foos.Result);
    Ce n'est pas beaucoup plus propre que la simple création d'un List<Foo> et à l'aide de Add et AddRange.

    OriginalL'auteur