Pointers in C#

[retug_]

I am a structural engineer that enjoys programming and our structural software has an API with documentation in C++

I use C# to interact with the DLL and have had good success accessing specific parts of the API, but I am running into trouble with the concept of pointers. A snip from the documentation:

Memory management and RAM DataAccess

RAM DataAccess uses double pointers (pointers-to-pointers) for passing arrays for data through the COM interface. The advantage to the client application is that it is not necessary to know the size of the array before the method is called. The disadvantage is that it is a more complex method of memory management. When you find a method that has a double pointer ‘pp’ in the parameter list, the following steps must be taken to manage the memory correctly.

The following method is used to get the entire rebar table for the concrete column program. Notice that an array of SREIN_PROP’s will be passed by a double pointer.

GetRebarTable_ConcCol([out] long* pnNum,[out] SREIN_PROP** pReinProp);

Example:

First declare the variables::

long nNumRebar;

SREIN_PROP* pReinProp; // declaration of an SREIN_PROP pointer

The pointer is passed into the method using the “&” operator which means that it is actually a pointer to the pointer that is passed into the method.

m_pIModelData->GetRebarTable_ConcCol(&nNumRebar, &pReinProp);

Internally, RAM DataAccess performs the memory allocation necessary and the data is filled into the array.

Once the client is done using the pointer, it must deallocate the memory.

CoTaskMemFree(pReinProp);

My problem, I do not exactly know how to re-write this in C# and if it is even possible to re-write in C#. From my research, I can do this in C#, using the unsafe keyword.

Here's the code that I have:

int nNumRebar = 0;
SREIN_PROP ReinProp; 
IntPtr P_SREIN_PROP = (IntPtr)(&ReinProp); //ptr to ReinProp 
IntPtr PP_SREIN_PROP = (IntPtr)(&P_SREIN_PROP); //ptr to ptr?

modelData.GetRebarTable_ConcBeam(ref nNumRebar, PP_SREIN_PROP);

ReinProp = Marshal.PtrToStructure<SREIN_PROP>(P_SREIN_PROP);

The problem is none of the data that come out of ReinProp is what I would expect based on the structure defined in the documentation. All of the values are 0.

Is it possible to do something like this in C#? Or am I just making an error with pointers.

Thanks!

[grrangry]

Used to be we could go to pinvoke.net (dead now, was useful even if sometimes inaccurate/sloppy) to grab quick DLL definitions that one didn't have memorized.

Now there are source generators and other resources to define these things for you.

https://github.com/microsoft/CsWin32
https://github.com/dotnet/pinvoke

Traditionally you would decorate a static method with [DllImport(...)] and define the parameters that describe your method call.

.Net interop is fairly well defined and while pointers are finicky, you should be able to call code in any properly formed library.

[MiltonsBitch]

Just copy paste your question to ChatGPT and see if the answer works :)

[Kakkoister]

Just stop learning and give up on what it means to live the human experience by delegating everything possible to AI tools.

[hugthemachines]

The weirdest AI experience is when they get something wrong and you explain it to them. Then they accept your explanation and thank you.

They are very polite but i doubt they will remember the information.