What is the most efficient way to convert a std::vector<T> to a .NET List<U>?

Question

What is the most efficient way to convert a std::vector to a .NET List?

To give some context, I am wrapping an unmanaged C++ class with C++/CLI. The C++/CLI class holds a pointer to the C++ class and I have a wrapper for each public method.

One method returns a std::vector, so in my wrapper I was going to return the .NET class List. I.e.

// unmanaged class
class A
{
    public:
        std::vector<int> runList();
}

// managed class
public ref class A
{
    public:
        // the below is obviously extremely inefficient
        List<UInt32> MethodA()
        {
            std::vector<unsigned int> runList = mpChannelNode->runList();
            std::vector<unsigned int>::iterator itr;

            List<UInt32> list = gcnew List<UInt32>();

            for (itr = runList.begin(); itr != runList.end(); itr++)
            {
                list.Add(*itr);
            }

            return list;
        }

    private:
        A* mpChannelNode;
}

How can I make this more efficient? Feel free to recommend a different return type for the .NET class. Lets assume I just need to get that vector into managed world efficiently in any shape or form.

Answer 1

If you're really that concerned about it, use unverifiable code instead:

List<unsigned>^ MethodA()
{
    std::vector<unsigned> const& runList = mpChannelNode->runList();
    array<unsigned>^ ret = gcnew array<unsigned>(runList.size());
    if (runList.size())
    {
        pin_ptr<unsigned> dest = &ret[0];
        std::memcpy(dest, &runList[0], runList.size() * sizeof(unsigned));
    }
    return gcnew List<unsigned>(ret);
}

That said, I'd be surprised if there was a noticeable difference either way...

Answer 2

I am not familiar with C++-CLI but one small improvement you can make is to create your list with the right capacity from the beginning.

List<UInt32> list = gcnew List<UInt32>(runList.size());

Another improvement would be to pre-increment your C++ iterator instead of post-incrementing it because currently you create an extra object for every element that is discarded immediately.

Answer 3

Consider turning into the vector directly into an array .. the below will work and be valid, until you resize the vector.

vector<int> vec(10);
int *array = &vec[0]; 

Then, you should be able to treat that (I think -- VS not on machine) as a passed array to populate your list.

You should also create your list with a size that you expect to need -- adding one by one will be slow.