There is a hierarchy here: interface IList<T> : ICollection<T> { } interface ICollection<T> : IEnumerable<T> { } You want to aim for the least possible coupling, so return an IEnumerable<T> if that is enough. It probably will be. Return an IList<T> if the situation requires that the caller gets a List that it can use … Read more
Straight from the horse’s mouth (Hejlsberg): Ideally all of the generic collection interfaces (e.g. ICollection<T>, IList<T>) would inherit from their non-generic counterparts such that generic interface instances could be used both with generic and non-generic code. For example, it would be convenient if an IList<T> could be passed to code that expects an IList. As … Read more
You can get a reference to the Enumerator, using the GetEnumerator method, then you can use the MoveNext() method to move on, and use the Current property to access your elements: var enumerator = getInt().GetEnumerator(); while(enumerator.MoveNext()) { int n = enumerator.Current; Console.WriteLine(n); }
It turns out that this is actually awfully simple to do: container.RegisterType<IEnumerable<IParserBuilder>, IParserBuilder[]>(); Unity natively understands arrays, so we just need to map the enumerable to an array of the same type.
First of all, are you sure it’s really IEnumerator and not IEnumerable? I strongly suspect it’s actually the latter. Furthermore, the question is not entirely clear. Do you have an index, and you want to get an object at that index? If so, and if indeed you have an IEnumerable (not IEnumerator), you can do … Read more
There’s an inherent problem in doing so, because IEnumerator<T> has both MoveNext() and Current. You really want a single call such as: bool TryMoveNext(out T value) at that point you can atomically move to the next element and get a value. Implementing that and still being able to use yield could be tricky… I’ll have … Read more
Well, you have incorrect expectations of Cast, that’s all – it’s meant to deal with boxing/unboxing, reference and identity conversions, and that’s all. It’s unfortunate that the documentation isn’t as clear as it might be 🙁 The solution is to use Select: doubleNumbers2 = intNumbers.Select(x => (double) x).ToArray();
Marc’s and CodeInChaos’s answers are pretty good, but just to add a few more details: First off, it sounds like you are interested in learning about the design process we went through to make this feature. If so, then I encourage you to read my lengthy series of articles that I wrote while designing and … Read more
First, you don’t need Flatten(); that method already exists, and is called SelectMany(). You can use it like this: IEnumerable<IEnumerable<int>> foo = new [] { new[] {1, 2}, new[] {3, 4} }; var bar = foo.SelectMany(x => x); // bar is {1, 2, 3, 4} Second, your first attempt doesn’t work because generic type inference … Read more
IEnumerable/IEnumerable<T> makes no guarantees about ordering, but the implementations that use IEnumerable/IEnumerable<T>may or may not guarantee ordering. For instance, if you enumerate List<T>, order is guaranteed, but if you enumerate HashSet<T> no such guarantee is provided, yet both will be enumerated using the IEnumerable<T> interface.