IndexOutOfRangeException for an IList<T>

Question

I am implementing a list, and I am wondering about the definition of the IndexOutOfRange. Which one of the following do you think is better?

/// <exception cref="IndexOutOfRangeException">if index is less than 0
/// or greater than <see cref="Count"/>
public T this[int index] { get { return myArray[index]; } }

Or

/// <exception cref="IndexOutOfRangeException">if index outside the valid range
/// for an array of length equal to <see cref="Count"/></exception>
public T this[int index] { get { return myArray[index]; } }

I am thinking about the case when this class would be used from a .NET language that indexes arrays starting from 1. I don't know much about the topic, but is the second version better than the first by any means?

Answer 1

Is it possible you could also have a "Base" property, then you could say:

/// <exception cref="IndexOutOfRangeException">if index is less than <see cref="Base" />

If you can't have a Base property, then the second version is better, if you have to be careful about 1-based arrays.

Answer 2

Slightly OT: can you encapsulate a list rather than an array, and then everything falls out in the wash since the encapsulated list will generate appropriate exceptions?

Edit: if you really need the array internally, how about wrapping it in a list inside the accessor first, and then selecting by index. This way the translation from list index to array index occurs inside the language of your component rather than the caller's.

Presumably the semantics of list indexing doesn't change across .Net languages? This is what your component should follow since it implements the list interface.

Edit again: actually, is this a problem at all??

People access your array through the accessor, which is written in a language that you control and so know where array indexing starts from. Even if you call your (say) C# class from a VB.Net caller, the accessor will still use C#'s idea of array indexes, won't it?

Answer 3

IList<T> already documents the exception (ArgumentOutOfRangeException, not IndexOutOfRangeException). If you are implementing the interface and not changing the documented behavior, why do you need to document it? If you're going to document it at all, it ought to agree with the interface.

EDIT: Just noticed your implementation (or at least the implication by naming of your implementation). I agree with @Dan, you really ought to base it on List<T> instead of an array so that the implementation agrees with the interface. Under that condition, there is no need to re-document the exception. If you don't change the underlying implementation then you ought to catch the IndexOutOfRangeException and map it to the ArgumentOutOfRangeException documented by the interface.

Answer 4

As an aside - you can always simply inherit from Collection<T> as a starting point... this provides the raw code, while letting you customize things. You can inherit from List<T>, but unlike Collection<T> there are no useful virtual methods on List<T>.