My problem is that I have a method that can take a collection as parameter that,
Has a Count property
Has an integer indexer (get-only)
And I don't know what type should this parameter be. I would choose IList<T> before .NET 4.5 since there is no other indexable collection interface for this and arrays implement it, which is a big plus.
But .NET 4.5 introduces the new IReadOnlyList<T> interface and I want my method to support that, too. How can I write this method to support both IList<T> and IReadOnlyList<T> without violating the basic principles like DRY?
Can I convert IList<T> to IReadOnlyList<T> somehow in an overload?
What is the way to go here?
Edit: Daniel's answer gave me some pretty ideas, I guess I'll go with this:
public void Do<T>(IList<T> collection)
{
DoInternal(collection, collection.Count, i => collection[i]);
}
public void Do<T>(IReadOnlyList<T> collection)
{
DoInternal(collection, collection.Count, i => collection[i]);
}
private void DoInternal<T>(IEnumerable<T> collection,
int count, Func<int, T> indexer)
{
// Stuff
}
Or I could just accept a ReadOnlyList<T> and provide an helper like this:
public static class CollectionEx
{
public static IReadOnlyList<T> AsReadOnly<T>(this IList<T> collection)
{
if (collection == null)
throw new ArgumentNullException("collection");
return new ReadOnlyWrapper<T>(collection);
}
private sealed class ReadOnlyWrapper<T> : IReadOnlyList<T>
{
private readonly IList<T> _Source;
public int Count { get { return _Source.Count; } }
public T this[int index] { get { return _Source[index]; } }
public ReadOnlyWrapper(IList<T> source) { _Source = source; }
public IEnumerator<T> GetEnumerator() { return _Source.GetEnumerator(); }
IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
}
}
Then I could call Do(array.AsReadOnly())
