How to pass an array (Range.Value) to a native .NET type without looping?

Question 1

   list.AddRange Range("A1:A5").Value

The range's Value gets marshaled as an array. That's about the most basic .NET type you can imagine of course. This one however has bells on, it is not a "normal" .NET array. VBA is a runtime environment that likes to create arrays whose first element starts at index 1. That's a non-conformant array type in .NET, the CLR likes arrays whose first element starts at index 0. The only .NET type you can use for those is the System.Array class.

An extra complication is that the array is a two-dimensional array. That puts the kibosh on your attempts to get them converted to an ArrayList, multi-dimensional arrays don't have an enumerator.

So this code works just fine:

    public void AddRange(object arg) {
        var arr = (Array)arg;
        for (int ix = ar.GetLowerBound(0); ix <= arr2.GetUpperBound(0); ++ix) {
            Debug.Print(arr.GetValue(ix, 1).ToString());
        } 
    }

You probably don't care for that too much. You could use a little accessor class that wraps the awkward Array and acts like a vector:

class Vba1DRange : IEnumerable<double> {
    private Array arr;
    public Vba1DRange(object vba) {
        arr = (Array)vba;
    }
    public double this[int index] {
        get { return Convert.ToDouble(arr.GetValue(index + 1, 1)); }
        set { arr.SetValue(value, index + 1, 1); }
    }
    public int Length { get { return arr.GetUpperBound(0); } }
    public IEnumerator<double> GetEnumerator() {
        int upper = Length;
        for (int index = 0; index < upper; ++index)
            yield return this[index];
    }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }

Now you can write it the "natural" way:

    public void AddRange(object arg) {
        var arr = new Vba1DRange(arg);
        foreach (double elem in arr) {
            Debug.Print(elem.ToString());
        }
        // or:
        for (int ix = 0; ix < arr.Length; ++ix) {
            Debug.Print(arr[ix].ToString());
        }
        // or:
        var list = new List<double>(arr);
    }

Question 2

Here's a proof of concept as an expansion of @phoog's comment. As he points out, the AddRange method takes an ICollection.

Implementing ICollection

In the VBA IDE, add a reference to mscorlib.tlb: Tools--->References, then browse to find your .NET Framework mscorlib.tlb. Mine was at "C:\Windows\Microsoft.NET\Framework\vX.X.XXXXX\mscorlib.tlb".

Create a new class called "clsWrapLongArray" as follows:

Option Compare Database
Option Explicit

Implements ICollection
Dim m_lngArr() As Long

Public Sub LoadArray(lngArr() As Long)
    m_lngArr = lngArr
End Sub

Private Sub ICollection_CopyTo(ByVal arr As mscorlib.Array, ByVal index As Long)
    Dim i As Long
    Dim j As Long
    j = LBound(m_lngArr)
    For i = index To index + (ICollection_Count - 1)
        arr.SetValue m_lngArr(j), i
        j = j + 1
    Next
End Sub

Private Property Get ICollection_Count() As Long
    ICollection_Count = UBound(m_lngArr) - LBound(m_lngArr) + 1
End Property

Private Property Get ICollection_IsSynchronized() As Boolean
    'Never called for this example, so I'm leaving it blank
End Property

Private Property Get ICollection_SyncRoot() As Variant
    'Never called for this example, so I'm leaving it blank
End Property

Here is the Array.SetValue method used.

Create a new module called "mdlMain" to run the example:

Option Compare Database
Option Explicit

Public Sub Main()

    Dim arr(0 To 3) As Long

    arr(0) = 1
    arr(1) = 2
    arr(2) = 3
    arr(3) = 4

    Dim ArrList As ArrayList
    Set ArrList = New ArrayList

    Dim wrap As clsWrapLongArray
    Set wrap = New clsWrapLongArray
    wrap.LoadArray arr
    ArrList.AddRange wrap
End Sub

If you put a breakpoint on the End Sub and run Main(), you can see by inspecting ArrList in the immediate window that it contains the 4 values added from the Long array. You can also step through the code to see that ArrayList actually calls the ICollection interface members Count and CopyTo to make it happen.

I could see that it might be possible to expand on this idea to create Factory functions to wrap types like Excel Ranges, VBA Arrays, Collections, etc.

This same method works with String arrays! :D

I found some very close answers by Googling "System.ArrayList" "SAFEARRAY" and "System.Array" "SAFEARRAY" and refining with "COM Marshaling", since VBA arrays are COM SAFEARRAYs, but nothing quite explained how one might convert them for use in .NET calls.

Question 3

It's inefficient because .Value2 is a COM call. Calling it thousands of times adds a lot of interop overhead. Adding items to an array in a loop should be MUCH faster:

Dim list as Object
Set list = CreateObject("System.Collections.ArrayList")

Dim i As Long
Dim a as Variant
a = Range("A1:A5").Value2
For i = 1 To 5
    list.Add a(i,1)
Next

How do I pass a native VBA array as a parameter to an ArrayList?

I don't think you can - a native VBA array is not an ICollection, so the only way to create one would be to copy the values in a loop.

The reason it works in a C# console application is because arrays in C# are ICollections, so the AddRange method accepts them just fine.

How to pass an array (Range.Value) to a native .NET type without looping?

Update