For what you need, List<string> is probably the most versatile. StringCollection was handy in 1.1, when (without generics) you needed specific classes for typed collections. Collection<string> is handy if you want to subclass it to provide validation etc. Either way, in 3.5, LINQ will provide lots of additional methods for them – but without LINQ, … Read more
Basically the nongeneric interfaces came first, in .NET 1.0 and 1.1. Then when .NET 2.0 came out, the generic equivalents came out. Life would have been a lot simpler if generics had made it into .NET 1.0 🙂 In terms of implementing “only” IEnumerable<T> instead of both – you basically have to implement both, and … Read more
Generally speaking, you should try and use the least specific type that suits your purpose. IEnumerable is less specific than IList (IList implements IEnumerable) so unless you want something specific from IList (such as Count as you suggest, or perhaps Add, Delete, etc), I’d use IEnumerable. One benefit of remaining with IEnumerable is that you … Read more
Noticed a lot of answer were quite old. This will also work: using System.Linq; dict.Values.ToList();
Try List<SubProduct> subProducts = new List<SubProduct>(Model.subproduct); or List<SubProduct> subProducts = Model.subproducts as List<SubProduct>;
You can use LINQ: using System.Linq; IList<Foo> list = new List<Foo>(); IEnumerable<Foo> sortedEnum = list.OrderBy(f=>f.Bar); IList<Foo> sortedList = sortedEnum.ToList();
Because an interface shoud be easy to implement and not contain “everything but the kitchen”. If you add AddRange you should then add InsertRange and RemoveRange (for symmetry). A better question would be why there aren’t extension methods for the IList<T> interface similar to the IEnumerable<T> interface. (extension methods for in-place Sort, BinarySearch, … would … Read more
The problem is that you’re calling List<T>.Reverse() which returns void. You could either do: List<string> names = “Tom,Scott,Bob”.Split(‘,’).ToList<string>(); names.Reverse(); or: IList<string> names = “Tom,Scott,Bob”.Split(‘,’).Reverse().ToList<string>(); The latter is more expensive, as reversing an arbitrary IEnumerable<T> involves buffering all of the data and then yielding it all – whereas List<T> can do all the reversing “in-place”. (The … Read more
IEnumerable<T> represents a series of items that you can iterate over (using foreach, for example), whereas IList<T> is a collection that you can add to or remove from. Typically you’ll want to be able to modify an Order by adding or removing OrderLines to it, so you probably want Order.Lines to be an IList<OrderLine>. Having … Read more
Because an array allows fast access by index, and IList/IList<T> are the only collection interfaces that support this. So perhaps your real question is “Why is there no interface for constant collections with indexers?” And to that I have no answer. There are no readonly interfaces for collections either. And I’m missing those even more … Read more