Question

I tried the solution below but I don’t like it. I am looking for extending the class, not encapsulating a double[].

Thanks.

EDIT: We need to work with .NET 2.0

public class DoubleArray : IList, ICloneable
{

    protected double[] items;

    /// <summary>
    /// Gets the last item in the array.
    /// </summary>
    public double Last { get { return items[items.Length-1]; } }

    /// <summary>
    /// Gets the number of items in the array.
    /// </summary>
    public int Length { get { return items.Length; } }

    /// <summary>
    /// Number of items constructor.
    /// </summary>
    /// <param name="len">Number of items</param>
    public DoubleArray(int len)
    {
        items = new double[len];
    }      

    public double this[int index]
    {
        get { return items[index]; }
        set { items[index] = value; }
    }

    public bool IsReadOnly
    {
        get { return items.IsReadOnly; }
    }

    public bool IsFixedSize
    {
        get { return items.IsFixedSize; }
    }

    public void CopyTo(Array array, int index)
    {
        items.CopyTo(array, index);
    }

    public IEnumerator GetEnumerator()
    {
        return items.GetEnumerator();
    }

    public object SyncRoot
    {
        get { return items.SyncRoot; }
    }

    public bool IsSynchronized
    {
        get { return items.IsSynchronized; }
    }

    object ICloneable.Clone()
    {
        return items.Clone();
    }

    #region ICollection and IList members implementation

    // hides this members from intellisense, see: http://stackoverflow.com/questions/10110205/how-does-selectedlistviewitemcollection-implement-ilist-but-not-have-add

    int ICollection.Count
    {
        get { return items.Length; }
    }

    int IList.Add(object value)
    {
        throw new NotImplementedException();
    }

    bool IList.Contains(object value)
    {
        throw new NotImplementedException();
    }

    void IList.Clear()
    {
        throw new NotImplementedException();
    }

    int IList.IndexOf(object value)
    {
        throw new NotImplementedException();
    }

    void IList.Insert(int index, object value)
    {
        throw new NotImplementedException();
    }

    void IList.Remove(object value)
    {
        throw new NotImplementedException();
    }

    void IList.RemoveAt(int index)
    {
        throw new NotImplementedException();
    }

    object IList.this[int index]
    {
        get { throw new NotImplementedException(); }
        set { throw new NotImplementedException(); }
    } 

    #endregion

}

Answer 1

Here is a solution that satisfies me. C# 3.0 Extensions can be used in .NET 2.0 simply adding this code:

#if NET20
namespace System.Runtime.CompilerServices
{
    [AttributeUsageAttribute(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
     public class ExtensionAttribute : Attribute
    {
    }
}
#endif

Afterwards you can use the following extension method (and many others):

public static class DoubleArrayExtension
{
    // This is the extension method.
    // The first parameter takes the "this" modifier
    // and specifies the type for which the method is defined.       
    public static double Last(this double[] items)
    {
        return items[items.Length - 1];
    }

}

Thanks for all your hints and suggestions guys!