Question

在C＃中，可以使用params关键字为方法指定任意数量的类型化参数：

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

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

如果您已有对象列表，可以将其转换为数组以传递给此方法：

DoStuff(fooList.ToArray());

但是，有没有任何优雅的混合方式？也就是说，传入多个对象和对象列表，并将结果展平为一个列表或数组？理想情况下，我希望能够像这样调用我的方法：

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

截至目前，我知道如何执行此操作的唯一方法是将所有内容预处理到一个列表中，我不知道有任何方法可以执行此操作。

编辑：要明确，我没有与params关键字结婚，这只是一个帮助我解释我想做的相关机制。我很满意任何看起来干净的解决方案，并将所有内容压缩成一个列表。

Answer 1

您可以创建一个具有隐式转换的类来包装单个元素和列表：

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();
    }
}

然后您可以将DoStuff方法更改为：

private static void DoStuff(params ParamsWrapper<Foo>[] foos)
{
    Foo[] all = foos.SelectMany(f => f).ToArray();
    //
}

Answer 2

您可以使用Enumerable.Concat加入多个列表和项目，例如：

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

注意：可能有更多可读方式来实现您想要做的任何事情。即使传递IEnumerable<Foo>也更具可读性。

Answer 3

你不能完全按照自己的意愿去做，但是使用扩展方法，你可以非常接近：

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;
    }
}

Answer 4

你可以制作单独的方法来将对象加载到同一个集合中，不是那么优雅但它会起作用，而且逻辑很容易理解，而且实现起来也不是很难。

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);

优雅地将列表和对象作为参数传递

4 个答案: