First off “Better” includes a combination of performance (memory and speed) In general you can’t have both, the rule of thumb is, if you optimise for speed, it’ll cost memory, if you optimise for memory, it’ll cost you speed. There is a better option, that performs well on both memory and speed fronts, and can … Read more
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.
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
I don’t see how the first version would compile, and the second version won’t do anything unless you use the result. It doesn’t remove anything from the existing collection – indeed, there may not even be an in-memory collection backing it. It just returns a sequence which, when iterated over, will return the appropriate values. … Read more