How to map and marshal a C array into a C# code

I am writing C# code that call a C library and something it is not quite clear in my mind.

The C function has this signature:

double* DoSomeStuff(double* input,int numberOfElements);

I have mapped the function as:

[System.Runtime.InteropServices.DllImportAttribute("myDll.dll", EntryPoint="DoSomeStuff")]
public static extern  System.IntPtr DoSomeStuff(ref double input, int numberOfElements) ;

The input value is an array, so the C function will expect a contiguous memory layout. I am more familiar with C++ than C#. In C++ I'd used a std::vector to store the data and then I would use the data() method to get the pointer and exchange the information with C code. std::vector guarantees a con开发者_StackOverflowtiguous layout memory.

Which data structure can I used in C#? Is there anything like std::vector in C#?

I have faced before the same problem for a string (In C++ std::string is just a std::vector with some make up). And I have solve the problem using:

System.IntPtr stringExample = Marshal.StringToHGlobalAnsi("StringExample"); 

The static function does the job for me. There is anything like this function for other types?

I have asked already too many questions, I think the most important one is: what is the best practise to solve this kind of problem?

Thanks

1)

Define the input as IntPtr:

[System.Runtime.InteropServices.DllImportAttribute("myDll.dll", EntryPoint="DoSomeStuff")]
public static extern  System.IntPtr DoSomeStuff(IntPtr input, int numberOfElements) ;

2)

Create an array in a fixed block, then create an IntPtr from the Pointer and then pass it to DoSomeStuff.

double[] input = new double[20];
IntPtr result = IntPtr.Zero;
fixed(double* d = &input[0])
{
    result = DoSomeStuff(new InptPtr(d), 20);
}

...

Reason for the fixed block is so that GC does not move the array while unmanaged code is populating it.

To make your example work you should define the siganture of the extern function as follows:

[System.Runtime.InteropServices.DllImportAttribute("myDll.dll", EntryPoint="DoSomeStuff")]
public static extern  System.IntPtr DoSomeStuff([MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)], int numberOfElements);

The second (named) parameter of MarshalAs attaribute tells to the marshaller where the size of the array stored.

Regarding the second question, C# has List<Type> class that behaves similary to std:vector<Type>. However, I don't think you can directly provide it to the marshaller. What you can do is to use ToArray() methor of the List class, to get an array.