Non-0 based arrays in C# with traditional [ ] array syntax?

You could create a class that implements the decorator pattern: just implement the IList interface (wich is also implemented by Array) and do whatever shifting you want on the this [int index] property.

The decorator pattern is described here: http://www.codeproject.com/Articles/479635/UnderstandingplusandplusImplementingplusDecoratorp

The Array class does not support this, but you can write your own array class with one-based indices:

public class OneBasedArray<T>
{
    public T[] InnerArray;
    public T this[int i]
    {
        get { return InnerArray[i-1]; }
        set { InnerArray[i-1] = value; }
    }
}

And then use it like this:

var myArray = new OneBasedArray<int> { InnerArray = new int[]{ 1, 2, 3, 4, 5 } };
for(int i = 1; i <=5; i++)
{
    Console.WriteLine(myArray[i]);
}

This code is only to get the idea, such a class would of course need a nicer interface.

You can only use an array's indexer when it's a 0-indexed array.

You can use an indexer for a custom, non-array, type, and use whatever logic you want for it, such as making it non-zero-indexed, but that's not an option for arrays.

I think Lukas' answer is probably the easiest way to handle this, but if, for some reason, you really wanted to use Array.CreateInstance (not sure why you would - maybe some external library might insist on it?), you could wrap it in a class like this:

public class NonZeroArray<T>
{
    private readonly Array array;

    public T this[int i]
    {
        get { return (T)array.GetValue(i); }
        set { array.SetValue(value, i); }
    }

    public NonZeroArray(int length, int lowerBounds = 0)
    {
        array = Array.CreateInstance(typeof(T), new int[] { length}, new int[] { lowerBounds } );
    }
}

You could obviously make this a lot prettier (and easier to work with) by having it implement the rest of IList<T>. And if you really need the native array, you could implement a property with a getter to expose it when needed.

Using it would be simply:

var myNonZeroArray = new NonZeroArray<string>(16,100);
myNonZeroArray[100] = "foo";
Console.WriteLine(myNonZeroArray[100]);   // prints "foo"

Here's a custom class that extends IList<T> to provide functionality for starting at a non-zero index:

public class NonZeroList<T> : IList<T>
{
    private int startIndex;
    private List<T> inner;

    public NonZeroList(int startIndex, IEnumerable<T> content)
    {
        this.startIndex = startIndex;
        inner = content.ToList();
    }
    public NonZeroList(int startIndex)
    {
        this.startIndex = startIndex;
        inner = new List<T>();
    }

    public T this[int i]
    {
        get
        {
            return inner[i - startIndex];
        }
        set
        {
            inner[i - startIndex] = value;
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        foreach (T i in inner)
            yield return i;
        yield break;
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return inner.GetEnumerator();
    }

    public int IndexOf(T item)
    {
        return inner.IndexOf(item) + startIndex;
    }

    public void Insert(int index, T item)
    {
        inner.Insert(index - startIndex, item);
    }

    public void RemoveAt(int index)
    {
        inner.RemoveAt(index - startIndex);
    }

    public void Add(T item)
    {
        inner.Add(item);
    }

    public void Clear()
    {
        inner.Clear();
    }

    public bool Contains(T item)
    {
        return inner.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        inner.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return inner.Count; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(T item)
    {
        return inner.Remove(item);
    }
}

To use it, you initialize it just as you would a normal List<T>, but with the start index specified (e.g. NonZeroList<int> myList = new NonZeroList<int>(20) { 0, 1, 2, 3 };). You can then use it just as you would a normal List<T> or T[].

If you want to use it as an array instead of a list, then you can simply add bounds checking or implement IEnumerable<T> instead of IList<T>, and create utility functions yourself.