C # Call the C/C ++ dynamic library to send struct, struct Array

Because the company has always been engaged in C ++ development, because the customer needs to provide the C # version interface, I studied C # and found that it is powerful and concise, it is completely encapsulated in cross-language calls and provides powerful API interaction. this is much more convenient than JNA. both Java and C # can only call the C format to export the dynamic library, because C has a single data type and is easy to map. both of them provide a set of ing C #/java description interfaces on the local end, which can be called through the underlying processing of this ing relationship.

 

I.Transfer of struct

 

Cpp Code

1. # Define JNAAPI extern "C" _ declspec (dllexport) // export functions in C mode
3. Typedef struct
4. {
5. Int osVersion;
6. Int majorVersion;
7. Int minorVersion;
8. Int buildNum;
9. Int platFormId;
10. Char szVersion [128];
11. } OSINFO;
13. // 1. Get version information (passing the struct pointer)
14. JNAAPI bool GetVersionPtr (OSINFO * info );
15. // 2. Get version information (Transfer struct reference)
16. JNAAPI bool GetVersionRef (OSINFO & info );

 

 

You can call the following two methods:

 

C # code

1. // OSINFO Definition
2. [StructLayout (LayoutKind. Sequential)]
3. Public struct OSINFO
4. {
5. Public int osVersion;
6. Public int majorVersion;
7. Public int minorVersion;
8. Public int buildNum;
9. Public int platFormId;
10. [Financialas (UnmanagedType. ByValTStr, SizeConst = 128)]
11. Public string szVersion;
12. }

 

1. method 1Struct referenceIn C #, the struct is passed by passing the value, and the class is passed by passing the address. Add the keyword ref. two different types of parameters are passed on the C-end, which can be solved through reference.

 

C # code

1. [DllImport ("jnalib. dll", EntryPoint = "GetVersionPtr")]
2. Public static extern bool GetVersionPtr (ref OSINFO info );
3. Public static extern bool GetVersionRef (ref OSINFO info );

 

2. method 2 (Input IntPtr(Universal platform pointer ))

 

Cpp Code

1. IntPtr pv = Marshal. AllocHGlobal (148); // The struct must be allocated space (4 * sizeof (int) + 128) during use)
2. Marshal. WriteInt32 (pv, 148); // write a value to the memory block
3. If (GetVersionPtr (pv) // directly takes the unhosted memory block address as the parameter
4. {
5. Console. WriteLine ("-- osVersion: {0}", Marshal. ReadInt32 (pv, 0 ));
6. Console. WriteLine ("-- Major: {0}", Marshal. ReadInt32 (pv, 4); // move 4 bytes
7. Console. WriteLine ("-- BuildNum:" + Marshal. ReadInt32 (pv, 12 ));
8. Console. WriteLine ("-- szVersion:" + Marshal. PtrToStringAnsi (IntPtr) (pv. ToInt32 () + 20 )));
9. }
10. Marshal. FreeHGlobal (pv); // after processing, remember to release the memory.

 

 

II.Transfer of struct Arrays

 

Cpp Code

1. // Pass the struct pointer
2. JNAAPI bool GetVersionArray (OSINFO * info, int nLen );

Call code:

 

C # code

1. /**
2. * C # interface. For an array type, only IntPtr can be passed.
3. */
4. [DllImport ("jnalib. dll", EntryPoint = "GetVersionArray")]
5. Public static extern bool GetVersionArray (IntPtr p, int nLen );
7. // Source target parameter
8. OSINFO [] infos = new OSINFO [2];
9. For (int I = 0; I <infos. Length; I ++)
10. {
11. Infos [I] = new OSINFO ();
12. }
14. IntPtr [] ptArr = new IntPtr [1];
15. PtArr [0] = Marshal. AllocHGlobal (Marshal. SizeOf (typeof (OSINFO) * 2); // assign an array containing two elements
16. IntPtr pt = Marshal. AllocHGlobal (Marshal. SizeOf (typeof (OSINFO )));
17. Marshal. Copy (ptArr, 0, pt, 1); // Copy the pointer Array
18. GetVersionArray (pt, 2); // call
20. // Restore to a struct Array
21. For (int I = 0; I <2; I ++)
22. {
23. Infos [I] = (OSINFO) Marshal. ptrToStructure (IntPtr) (pt. toInt32 () + I * Marshal. sizeOf (typeof (OSINFO), typeof (OSINFO ));
24. Console. WriteLine ("OsVersion: {0} szVersion: {1}", infos [I]. osVersion, infos [I]. szVersion );
25. }

 

 

III.Transfer of complex struct

 

1. output parameters. The struct is used as the pointer to output data.

Cpp Code

1. Typedef struct
2. {
3. Char name [20];
4. Int age;
5. Double scores [30];
6. } Student;
8. // Class contains the struct array type
9. Typedef struct
10. {
11. Int number;
12. Student students [50];
13. } Class;
15. // Pass in complex struct Test
16. JNAAPI int GetClass (Class * pClass, int len );

 

Cpp Code

1. // Interface Definition
2. [DllImport ("jnalib. dll", EntryPoint = "GetClass")]
3. Public static extern int GetClass (IntPtr pv, int len );
5. // Struct Definition
6. // Student
7. [StructLayout (LayoutKind. Sequential)]
8. Public struct Student
9. {
10. [Financialas (UnmanagedType. ByValTStr, SizeConst = 20)]
11. Public string name;
12. Public int age;
13. [Financialas (UnmanagedType. ByValArray, SizeConst = 30)]
14. Public double [] scores;
15. }
17. // Class
18. [StructLayout (LayoutKind. Sequential)]
19. Public struct Class
20. {
21. Public int number;
22. [Financialas (UnmanagedType. ByValArray, SizeConst = 50)] // specify the array size
23. Public Student [] students; // struct array Definition
24. }
26. // Call the complex struct Test
27. Int size = Marshal. SizeOf (typeof (Class) * 50;
28. IntPtr pBuff = Marshal. AllocHGlobal (size); // directly allocate space for 50 elements, which is much easier than Marshal. copy.
29. GetClass (pBuff, 50 );
31. Class [] pClass = new Class [50];
32. For (int I = 0; I <50; I ++)
33. {
34. IntPtr ptr = new IntPtr (pBuff. ToInt64 () + Marshal. SizeOf (typeof (Class) * I );
35. PClass [I] = (Class) Marshal. PtrToStructure (ptr, typeof (Class ));
36. }
37. Marshal. FreeHGlobal (pBuff); // release the memory

 

2. input parameters. assign values to the complex struct and pass them as input parameters.

For large struct pointers, you cannot directly apply the struct type to the IntPtr type. In this case, you need to convert the native type to the pointer and assign a value to the pointer.

Call method: Marshal. StructureToPtr (stu, ptr1, true)