Индексация массивов с 1 (единицы)

static class a
{
    public static int s(int indexE)
    {
        return indexE - 1;
    }
}

array[a.s(1)]; // Обращаемся к первому элементу массива.

Random rnd = new Random();
int[] array = new int[10]; // Создаём массив из 10 элементов.
 
for (int i = 1; i <= array.Length; i++) // Заполняем массив случайными числами.
    array[a.s(i)] = rnd.Next(0, 100);
for (int i = 1; i <= array.Length; i++) // Выводим сгенерированные значения.
    Console.WriteLine("{0} ячейка = {1}", i, array[a.s(i)]);
Console.ReadLine();

        public static void Main(string[] args)
        {
            MyArray<int> arr = new MyArray<int>(10);
 
            for (int i = 1; i <= 10; i++)
            {
                arr[i] = i;
            }
 
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine("index {0}: value {1}", i, arr[i]);
            }
        }
 
 
        public class MyArray<T>
        {
            private T[] array;
 
            public MyArray(int size)
            {
                array = new T[size];
            }
 
            public T this[int index]
            {
                get { return array[index - 1]; }
                set { array[index - 1] = value; }
            }
        }

class MyArray<T> : IReadOnlyList<T>
{
    private T[] _data;
 
    public MyArray(int length)
    {
        _data = new T[length];
    }
 
    public MyArray(IEnumerable<T> seq)
    {
        _data = seq.ToArray();
    }
 
    public T this[int index]
    {
        get { return _data[index - 1]; }
        set { _data[index - 1] = value; }
    }
 
    public int Count
    {
        get { return _data.Length; }
    }
 
    public IEnumerator<T> GetEnumerator()
    {
        foreach (T e in _data)
            yield return e;
    }
 
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
 
    public static implicit operator T[](MyArray<T> array)
    {
        return array._data;
    }
    public static implicit operator MyArray<T>(T[] array)
    {
        return new MyArray<T>(array);
    }
}
 
 
class Program
{
    private static void Main(string[] args)
    {
        MyArray<int> a = new[] {1, 2, 3, 4, 5, 6};
        Console.WriteLine(a[1]);
        Console.ReadKey();
    }
}

Array array = Array.CreateInstance(typeof(string), new[] { 3 }, new[] { 1 });
array.SetValue("one", 1);
array.SetValue("two", 2);
array.SetValue("three", 3);
for (int i = array.GetLowerBound(0); i <= array.GetUpperBound(0); i++)
{
    Console.WriteLine("array[{0}] = {1}", i, array.GetValue(i));
}