We Keep Coding

Marshaling a SAFEARRAY of Managed Structures by COM Interop

i am trying to pass an array of struct exported from a c# library to c++ code. the objective is to pass SAFEARRAY of struct from c++ to c#.
I have followed instructions from
http://limbioliong.wordpress.com/2011/07/16/marshaling-a-safearray-of-managed-structures-by-com-interop-part-2/
but getting this error with the call GetRecordInfoFromTypeInfo
0x80028019 Old format or invalid type library.

If you don't need to have a dispinterface, following should work:
void MyMethod([MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] MyStruct[] data, long size);
If you need to use SAFEARRAY, I would expect following to work (but I am not 100% sure, as I don't have Windows machine available at the moment):
void MyMethod([MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_USERDEFINED)] MyStruct[] data);
If you can afford to change your struct to class then this will also work, and save you from UDT hassle:
void MyMethod([MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_UNKNOWN)] MyStruct[] data);

Does the struct contains strings? If so, make sure to tag them [MarshalAs(UnmanagedType.BStr)]. There is a limitation in COM: strings in arrays of structs must be BSTRs. TLBExp defaults to LPWSTR and then the call dies. See here: http://msdn.microsoft.com/en-us/library/z6cfh6e6(v=vs.100).aspx

Parsing a C# object into a C++ object

I need to use a DLL coded in C++ in a C# application, there is a method in the DLL with receives a object declared in the C++ and I don't know how to parse a equivalent object maded in C# to the function of the DLL
Can someone help me?

You will need to use the System.Runtime.InteropServices namespace with Platform Invoke if the c++ code is not managed or COM. You will need to define the structure in your C# application and pass an object of whatever type your structure is to the method you are using Platform Invoke on. To tell you anymore, I need to see some header files.
Here is a sample :
c++ header:
struct MyStruct
{
int size;
char* data;
}
bool MethodToInvoke(MyStruct* obj);
c# declarations:
struct MyStruct
{
int size;
string data;
}
[DllImport("YourDllHere.dll")]
static extern bool MethodToInvoke(ref MyStruct obj);
Of course, it could get much more complicated but that is the general idea.
It can and may get really nasty when you have to worry about calling conventions and marshaling arrays. Regardless the world needs to see some code from you.

need help converting c++ definitions to c# equivalent

I'm using an API (written in c++) to connect to a DVR machine, actually I only have the .dll and the .lib files, and I want to do the job in .NET (C#).
So, the API doc contains definitions to all functions inside the dll, and I'm having a hard time trying to figure out how to translate those functions to equivalente C# definitions. Some of them are straightforward, but some I cannot make it work.
For example, there is this function:
bool searchEvent(int channel, const LONG* condition, bool next)
In my c# class I put the following:
[DllImport("search.dll")]
protected static extern bool searchEvent(int channel,
[MarshalAs(UnmanagedType.I8)]long condition, bool next);
but when I call the searchEvent function, it raises an error (memory error), I guess because of that long var. So my question is how can I translate "const LONG* condition" to c#?
Also, that searchEvent function triggers a callback that returns a struct. I am unable to translate some vars of that struct, like:
char _version[2]
time_t _time
BYTE* _minute
unsigned short int _dwell[MAX]
Can someone help me with this, please? I´m no expert in c++, so any tips are greatly appreciated. Thanks!

[DllImport("search.dll")]
[return: MarshalAs(UnmanagedType.U1)]
private static extern bool searchEvent(
int channel,
ref int condition,
[MarshalAs(UnmanagedType.U1)] bool next
);
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
private struct Mumble {
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 2)]
public string version;
public long time;
public IntPtr minute;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX)]
public ushort _dwell[];
}
You will have to marshal the Mumble.Minute value yourself with Marshal.ReadXxxx(). These declarations are not great for interop, writing a wrapper in the C++/CLI language is advisable.

Without getting into the specifics, you need to overcome two hurdles:
1) Since you don't have the original .h (header) file, you're guessing as to what it could be, based on the API documentation. Hopefully you'll get it right, but there may be some subtle things in the header file that won't be in the documentation, such as structure packing, calling convention, name mangling, etc. You can start by assuming the defaults for this stuff. Bottom line you have to experiment.
2) You are attempting to create P/Invoke calls into a C DLL when you don't have the original header file. You don't know even know if you know how to make these calls from C, much less C#.
By doing this straight from C#, you're trying to attack these two issues at the same time. when something doesn't work, you're not sure if it's because you go the P/Invoke syntax wrong, or it's an issue related to your interpretation of what the header file content looks like. I'd try to attack these problems one at a time. First, try to make the DLL calls from a simple C console app. This shouldn't be difficult to create, then hand build a .H file, and very that you can make all the calls.
After you're done with that, you now have to get those calls to work from C#.
Frankly, I avoid P/Invoke unless I can just reuse one that someone else created (from http://PInvoke.net) for the Windows API. If I were you, and I already new how to make the calls from C, I'd just create a C++/CLI wrapper DLL for it. The advantage is that, you make the calls exactly as you do in the console app -- no P/Invoke necessary. And then expose those calls from the C++/CLI DLL as .NET. Your C# code will call the C++/CLI DLL, which looks just like (and is) a .NET component, with no weird P/Invoke stuff in the C# code.
Good luck.

Calling unmanaged c++ code in C# Mixed with STL

Hey, I want to call unmanaged c++ code in C#
The function interface is like following(I simplified it to make it easy to understand)
Face genMesh(int param1, int param2);
Face is a struct defined as:
struct Face{
vector<float> nodes;
vector<int> indexs;
}
I googled and read the MSDN docs found ways to call simple c/c++ unmanged code in C#, also know how to hand the struct as return value. And My question is how to handle "vector". I did not find rules about mapping between vector and some types in C#
Thanks!

You want, if possible, to avoid using STL in anything but pure UNmanaged code. When you mix it with C++/CLI (or Managed C++), you will likely end up with the STL code running as managed and the client code running as unmanaged. What happens is that when you, say, iterate over a vector, every call to a vector method will transition into managed code and back again.
See here for a similar question.

You're probably going to need to pass the raw arrays unless you really want to jump through some hoops with the interop as the rules specify the types have to either be marhallable by the framework, or you've given the framework a specific structure it can marshall. This probably is not possible for vector. So, you can define you C++ struct as
#pragma pack(push, 8)
struct ReflSettings
{
double* Q;
double* DisplayQ;
}
#pragma pack(pop)
then you C# struct would be
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 8)]
public class ModelSettings:IDisposable
{
[XmlIgnore] internal IntPtr Q;
[XmlIgnore] internal IntPtr DisplayQ;
}
Hope this helps.

Probably the simplest thing to do is to create a managed class in C++ to represent the 'Face' structand copy the it's contents into the new managed class. Your c# code should then be able to understand the data.
You could use an ArrayList in place of the vectors.

p/invoke C function that returns pointer to a struct

How do I declare in C# a C function that returns a pointer to a structure?
I believe following is one way to do that, followed by Marshal.PtrToStructure to get actual structure value.
// C-function
SimpleStruct * Function(void);
// C# import
[DllImport("MyDll.dll")]
public static extern IntPtr Function();
Am I correct about that?
Are there other ways to accomplish the same? (It would be OK to get struct back by value)

Since the function returns a pointer (hopefully not a locally allocated one?) your best bet is to manually marshal it (via Marshal.PtrToStructure).
If it were a parameter you could create a managed version of the structure using the PInvoke Interop Assistant then pass it via ref or out.

Caveat: this will only work if the pointer returned is to memory already managed by the CLR
I believe what you are looking for is
// C# import
[DllImport("MyDll.dll")]
[return : MarshalAs(UnmanagedType.LPStruct)]
public static extern StructureName Function();
[StructLayout(LayoutKind.Sequential)]
public class StructureName {}
This should eliminate the need for any manual Marshal.PtrToStructure calls. Depending on what your structure contains, you may need to tag some fields with MarshalAs attributes as appropriate. MSDN has a good example of this.

I am not an expert here at all, but I happened to be looking at a piece of code (that i don't understand completely mind you) that is doing this same thing.
Here is what they are doing
[DllImport("")]
private static extern short MethodName([In,Out] ref StructureName variable);
and then on the structure they have the following attribute
[StructLayout(LayoutKind.Sequential, Size = #)]
public struct StructureName {}
I think the part you are looking for is the [In,Out] part, and since it's being passed via ref, you should be getting the same data back.
marked as community wiki so people can fix this if wrong.