优雅传递列表和对象PARAMS

Question

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

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

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

如果你已经有对象的列表，你可以打开它进入一个数组传递给此方法：

DoStuff(fooList.ToArray()); 

但是，有没有什么优雅的方式混合n匹配？也就是说，要传递多个对象和对象列表，并将结果展平成一个列表或数组给你？理想情况下，我想能够调用我的方法是这样的：

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

使用重载：

public void DoStuff(Foo foo) 
    { 
     //Do some stuff here with foo 
    } 

    public void DoStuff(params Foo[] foos) 
    { 
     foreach (var foo in foos) 
     { 
      DoStuff(foo); 
     } 
    } 

    public void DoStuff(params IEnumerable<Foo>[] foos) 
    { 
     foreach (var items in foos) 
     { 
      DoStuff(items); 
     } 
    } 

    public void OtherStuff() 
    { 
     DoStuff(new Foo()); 
     DoStuff(new Foo(), new Foo()); 
     DoStuff(new Foo[] { }); 
     DoStuff(new Foo[] { }, new Foo[] { }); 
    } 

Answer 4

你不能完全做你想做的事情，但用扩展方法，你可以得到相当接近：

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 5

你可以把不同的方法将对象加载到同一个集合，而不是优雅，但它会工作，而逻辑是很容易跟随，而不是非常难实现。

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