我在本机dll中有一个函数，它的函数看起来像这个
int GetActiveNames(char* names[]);
我如何在C#中为上面的函数创建PInvoke包装方法，该函数会返回一个字符串/字符数组？
为了更具描述性。。
我尝试了p/Invoke方式，它显示了以下错误尝试读取或写入受保护的内存。这通常表示其他内存已损坏。
我只是简单地去掉了实际的C函数签名。但这里是完整的C函数签名和函数参数的描述
int OpalGetActiveProjects(unsigned short allocatedProjects,
unsigned short *numProjects,
unsigned short allocatedModels,
unsigned short *numModels,
unsigned short allocatedProjectsPathLen,
unsigned short *maxProjectPathLen,
unsigned short allocatedModelPathLen,
unsigned short *maxModelPathLen,
unsigned short allocatedMachineNameLen,
unsigned short *maxMachineNameLen,
unsigned short allocatedIpLen,
unsigned short *maxIpLen,
char *projectPaths[],
unsigned short instanceIDs[],
char *machineNames[],
char *controllerIPs[],
char *modelPaths[],
unsigned short numModelsPerProject[]
unsigned short modelIDs[],
unsigned short modelStates[]);
函数返回活动项目的列表。对于每个项目，此函数返回配置文件的完整路径、打开此项目的计算机的名称和IP地址、当前项目会话的实例ID以及属于此项目的型号列表。对于每个模型，都会返回路径、ID和状态。如果分配的存储对于任何参数来说都太小，则不会返回任何列表，但会设置numProjects、numModels、maxProjectPathLen、maxModelPathLen，maxMachineNameLen和maxIpLen值，返回值为E2BIG。应用程序可以使用此事实在第一次调用时指定长度为0，分配所需的存储空间，并发出第二次调用以获取信息。
输入参数
allocatedProjects：由路径、计算机名、IP地址的调用方和实例ID。allocatedModels：由名称、路径和实例id的调用方。allocatedProjectPathLen：用于接收项目路径的已分配存储长度allocatedModelPathLen：用于接收模型路径的已分配存储长度allocatedMachineNameLen：用于接收机器名称的已分配存储长度allocatedIpLen:用于接收IP地址的分配存储长度
输出参数
numProjects：指向API将存储活动项目的实际数量的指针。numModels:指向API将存储实际总数的指针所有活动项目的模型数。maxProjectPathLen:指向API将存储最长项目路径长度的位置的指针。maxModelPathLen:指向API将存储最长模型路径长度的位置的指针。maxMachineNameLen:指向API将存储最长机器名称长度的位置的指针。maxIpLen:指向API将存储最长的IP地址。项目路径：字符串数组，API将在其中存储活动项目的配置文件的路径。实例ID：数组，API将在其中存储活动项目的实例ID。机器名称：API将存储机器名称的数组。controllerIPs:API将存储IP地址的阵列。模型路径：数组，API将在其中存储所有活动项目的模型路径。numModelsPerProject:数组，API将在其中存储每个项目的模型数。使用这些值来确定模型属于哪个项目。模型ID：数组，API将在其中存储所有的模型ID活跃的项目。模型状态：数组，API将在其中存储所有活动项目的模型状态。
还有一个C程序，它使用OpalGetActiveProjects()函数来获取projectPaths、machineNames等
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
// Header for getcwd() is platform-dependent
#if defined(WIN32)
#include <direct.h>
#include <windows.h>
#elif defined(__linux__)
#include <unistd.h>
#define _MAX_PATH 256
#endif
#include "OpalApi.h"
void PrintError(int rc, char *funcName);
#define FALSE 0
#define TRUE 1
int main (int argc, char* argv[])
{
char **projectPath, **modelPath;
char *projectPaths, *modelPaths;
char **loaderMachineName, **controllerIp;
char *loaderMachineNames, *controllerIps;
int i, rc, projectIdx;
unsigned short *instId;
int *instId2;
int * modelIds;
unsigned short *numModelsPerProject;
unsigned short *modelId;
unsigned short *modelState;
unsigned short allocProjects, numProjects;
unsigned short allocModels, numModels;
unsigned short allocProjectPathLen, maxProjectPathLen;
unsigned short allocModelPathLen, maxModelPathLen;
unsigned short allocMachineLen, maxMachineLen;
unsigned short allocIpLen, maxIpLen;
// Obtenir la taille des données.
allocProjects =allocModels = 0;
allocProjectPathLen = allocModelPathLen = 0;
allocMachineLen = allocIpLen = 0;
rc = OpalGetActiveProjects( 0, &allocProjects,
0, &allocModels,
0, &allocProjectPathLen,
0, &allocModelPathLen,
0, &allocMachineLen,
0, &allocIpLen,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL );
if ((rc != 0) && (rc != E2BIG))
{
PrintError(rc, "OpalGetActiveProject");
printf(" - alGetActiveProjects error output !!!n");
printf("t numProjects - %i n", allocProjects);
printf("t numModels - %i n", allocModels);
printf("t maxProjectPathLen - %i n", allocProjectPathLen);
printf("t maxModelPathLen - %i n", allocModelPathLen);
//printf("t maxMachineNameLen - %i n", maxMachineNameLen);
printf("t maxIpLen - %i n", allocIpLen);
return (rc);
// Erreur
//return returnInstance;
}
projectPath = (char **)_alloca(allocProjects * sizeof(*projectPath));
projectPaths = (char *)_alloca(allocProjects * (allocProjectPathLen + 1) * sizeof(*projectPaths));
loaderMachineName = (char **)_alloca(allocProjects * sizeof(*loaderMachineName));
loaderMachineNames = (char *)_alloca(allocProjects * (allocMachineLen + 1) * sizeof(*loaderMachineNames));
controllerIp = (char **)_alloca(allocProjects * sizeof(*controllerIp));
controllerIps = (char *)_alloca(allocProjects * (allocIpLen + 1) * sizeof(*controllerIps));
numModelsPerProject = (unsigned short*)_alloca(allocProjects * sizeof(*numModelsPerProject));
modelPath = (char **)_alloca(allocModels * sizeof(*modelPath));
modelPaths = (char *)_alloca(allocModels * (allocModelPathLen + 1) * sizeof(*modelPaths));
for (i = 0; i < allocProjects; ++i)
{
projectPath[i] = &projectPaths[i * (allocProjectPathLen + 1)];
loaderMachineName[i] = &loaderMachineNames[i * (allocMachineLen + 1)];
controllerIp[i] = &controllerIps[i * (allocIpLen + 1)];
}
for (i = 0; i < allocModels; ++i)
{
modelPath[i] = &modelPaths[i * (allocModelPathLen + 1)];
}
instId = (unsigned short *)_alloca(allocProjects * sizeof(*instId));
instId2 = (int *)_alloca(allocProjects * sizeof(*instId2));
modelId = (unsigned short*)_alloca(allocModels * sizeof(*modelId));
modelState = (unsigned short *)_alloca(allocModels * sizeof(*modelState));
rc = OpalGetActiveProjects( allocProjects, &numProjects,
allocModels, &numModels,
allocProjectPathLen, &maxProjectPathLen,
allocModelPathLen, &maxModelPathLen,
allocMachineLen, &maxMachineLen,
allocIpLen, &maxIpLen,
projectPath, instId,
loaderMachineName, controllerIp, modelPath,
numModelsPerProject, modelId, modelState);
printf(" - OpalGetActiveProjects output !!!n");
printf("t numProjects - %i n", allocProjects);
printf("t numModels - %i n", allocModels);
printf("t maxProjectPathLen - %i n", allocProjectPathLen);
printf("t maxModelPathLen - %i n", allocModelPathLen);
//printf("t maxMachineNameLen - %i n", maxMachineNameLen);
printf("t maxIpLen - %i n", allocIpLen);
for(i=0; i<numProjects; i++)
{
printf("t t projectPath[%d] = %s n", i, *(projectPath +i));
printf("t t instId[%d] = %d n", i, *(instId + i));
printf("t t loaderMachineName[%d] = %s n", i, *(loaderMachineName + i));
printf("t t controllerIp[%d] = %s n", i, *(controllerIp + i));
printf("t t numModelsPerProject[%d] = %d n", i, * (numModelsPerProject +i));
}
for(i=0; i<numModels; i++)
{
printf("t t modelPath[%d] = %s n", i, *(modelPath+i));
printf("t t modelId[%d] = %d n", i, *(modelId +i));
printf("t t modelState[%d] = %d n", i, *(modelState+i));
}
OpalDisconnect();
getchar();
}
void PrintError(int rc, char *funcName)
{
char buf[512];
unsigned short len;
OpalGetLastErrMsg(buf, sizeof(buf), &len);
printf("Error !!! n %s (code %d) from %sn", buf, rc, funcName);
}
签名太奇怪，无法翻译成C#。我试着看看TlbImp.exe会把它翻译成什么，它说：
TlbImp:警告TI3015:运行时封送拆收器无法封送"Marshal2.IMarshal3.GetActiveNames"的至少一个参数。因此，此类参数将作为指针传递，并且可能需要不安全的代码进行操作
如果可以的话，我建议更改函数以返回包含BSTR的SAFEARRAY。在C#端，您会看到一个System.Array，它的元素(Object类型)可以转换为String。
我还建议将GetActiveNames作为COM类的一个方法。P/Invoke过于原始且不安全。
哇，这真是一个可怕的API。难道没有别的东西吗。。。哦，我不知道。。。DECENT，你可以用吗？但如果你真的想要…
using System;
using System.Runtime.InteropServices;
public class ActiveProjects
{
public string[] ProjectPaths { get; set; }
public ushort[] InstanceIds { get; set; }
public string[] MachineNames { get; set; }
public string[] ControllerIps { get; set; }
public string[] ModelPaths { get; set; }
public ushort[] NumberOfModelsPerProject { get; set; }
public ushort[] ModelIds { get; set; }
public ushort[] ModelStates { get; set; }
[DllImport("<the DLL>")]
unsafe private static int OpalGetActiveProjects(
ushort allocatedProjects,
ushort* numProjects,
ushort allocatedModels,
ushort* numModels,
ushort allocatedProjectsPathLen,
ushort* maxProjectPathLen,
ushort allocatedModelPathLen,
ushort* maxModelPathLen,
ushort allocatedMachineNameLen,
ushort* maxMachineNameLen,
ushort allocatedIpLen,
ushort* maxIpLen,
sbyte** projectPaths,
ushort* instanceIDs,
sbyte** machineNames,
sbyte** controllerIPs,
sbyte** modelPaths,
ushort* numModelsPerProject,
ushort* modelIDs,
ushort* modelStates
);
public void GetActiveProjects()
{
unsafe
{
ushort numberOfProjects = 0;
ushort numberOfModels = 0;
ushort maxProjectPathLength = 0;
ushort maxModelPathLength = 0;
ushort maxMachineNameLength = 0;
ushort maxIpLength = 0;
int result = OpalGetActiveProjects(
0,
&numberOfProjects,
0,
&numberOfModels,
0,
&maxProjectPathLength,
0,
&maxModelPathLength,
0,
&maxMachineNameLength,
0,
&maxIpLength,
null,
null,
null,
null,
null,
null,
null,
null
);
if (result != 0 && result != 123)
throw new Exception("Error getting active projects");
sbyte** projectPaths = null;
ushort* instanceIds = null;
sbyte** machineNames = null;
sbyte** controllerIps = null;
sbyte** modelPaths = null;
ushort* numberOfModelsPerProject = null;
ushort* modelIds = null;
ushort* modelStates = null;
try
{
projectPaths = (sbyte**)Marshal.AllocHGlobal(numberOfProjects * IntPtr.Size).ToPointer();
for (int i = 0; i < numberOfProjects; ++i)
projectPaths[i] = null;
for (int i = 0; i < numberOfProjects; ++i)
projectPaths[i] = (sbyte*)Marshal.AllocHGlobal(maxProjectPathLength);
instanceIds = (ushort*)Marshal.AllocHGlobal(numberOfProjects * 2).ToPointer();
machineNames = (sbyte**)Marshal.AllocHGlobal(numberOfProjects * IntPtr.Size).ToPointer();
for (int i = 0; i < numberOfProjects; ++i)
machineNames[i] = null;
for (int i = 0; i < numberOfProjects; ++i)
machineNames[i] = (sbyte*)Marshal.AllocHGlobal(maxMachineNameLength).ToPointer();
controllerIps = (sbyte**)Marshal.AllocHGlobal(numberOfProjects * IntPtr.Size).ToPointer();
for (int i = 0; i < numberOfProjects; ++i)
controllerIps[i] = null;
for (int i = 0; i < numberOfProjects; ++i)
controllerIps[i] = (sbyte*)Marshal.AlloHGlobal(maxIpLength).ToPointer();
modelPaths = (sbyte**)Marshal.AlloHGlobal(numberOfModels * IntPtr.Size).ToPointer();
for (int i = 0; i < numberOfProjects; ++i)
modelPaths = null;
for (int i = 0; i < numberOfProjects; ++i)
modelPaths = (sbyte*)Marshal.AllocHGlobal(maxModelPathLength).ToPointer();
numberOfModelsPerProject = (ushort*)Marshal.AlloHGlobal(numberOfProjects * 2).ToPointer();
modelIds = (ushort*)Marshal.AllocHGlobal(numberOfModels * 2).ToPointer();
modelStates = (ushort*)Marshal.AllocHGlobal(numberOfModels * 2).ToPointer();
ushort numberOfProjects2 = 0;
ushort numberOfModels2 = 0;
ushort maxProjectPathLength2 = 0;
ushort maxModelPathLength2 = 0;
ushort maxMachineNameLength2 = 0;
ushort maxIpLength2 = 0;
OpalGetActiveProjects(
numberOfProjects,
&numberOfProjects2,
numberOfModels,
&numberOfModels2,
maxProjectPathLength,
&maxProjectPathLength2,
maxModelPathLength,
&maxModelPathLength2,
maxMachineNameLength,
&maxMachineNameLength2,
maxIpLength,
&maxIpLength2,
projectPaths,
instanceIds,
machineNames,
controllerIps,
modelPaths,
numberOfModelsPerProject,
modelIds,
modelStates
);
ProjectPaths = new string[numberOfProjects2];
for (int i = 0; i < numberOfProjects2; ++i)
ProjectPaths[i] = new string(projectPaths[i]);
InstanceIds = new ushort[numberOfProjects2];
for (int i = 0; i < numberOfProjects2; ++i)
InstanceIds[i] = instanceIds[i];
MachineNames = new string[numberOfProjects2];
for (int i = 0; i < numberOfProjects2; ++i)
MachineNames[i] = new string(machineNames[i]);
ControllerIps = new string[numberOfProjects2];
for (int i = 0; i < numberOfProjects2; ++i)
ControllerIps[i] = new string(controllerIps[i]);
ModelPaths = new string[numberOfModels2];
for (int i = 0; i < numberOfModels2; ++i)
ModelPaths[i] = new string(modelPaths[i]);
NumberOfModelsPerProject = new ushort[numberOfProjects2];
for (int i = 0; i < numberOfProjects2; ++i)
NumberOfModelsPerProject[i] = numberOfModelsPerProject[i];
ModelIds = new ushort[numberOfModels2];
for (int i = 0; i < numberOfModels2; ++i)
ModelIds[i] = modelIds[i];
ModelStates = new ushort[numberOfModels2];
for (int i = 0; i < numberOfModels2; ++i)
ModelStates[i] = modelStates[i];
}
finally
{
if (projectPaths != null)
{
for (int i = 0; i < numberOfProjects && projectPaths[i] != null; ++i)
Marshal.FreeHGlobal(IntPtr((void*)projectPaths[i]));
Marshal.FreeHGlobal(IntPtr((void*)projectPaths));
}
if (instanceIds != null)
Marshal.FreeHGlobal(IntPtr((void*)instanceIds));
if (machineNames != null)
{
for (int i = 0; i < numberOfProjects && machineNames[i] != null; ++i)
Marshal.FreeHGlobal(IntPtr((void*)machineNames[i]));
Marshal.FreeHGlobal(IntPtr((void*)machineIds));
}
if (controllerIps != null)
{
for (int i = 0; i < numberOfProjects && controllerIps[i] != null; ++i)
Marshal.FreeHGlobal(IntPtr((void*)controllerIps[i]));
Marshal.FreeHGlobal(IntPtr((void*)controllerIps));
}
if (modelPaths != null)
{
for (int i = 0; i < numberOfModels && modelPaths[i] != null; ++i)
Marshal.FreeHGlobal(IntPtr((void*)modelPaths[i]));
Marshal.FreeHGlobal(IntPtr((void*)modelPaths));
}
if (numberOfModelsPerProject != null)
Marshal.FreeHGlobal(IntPtr((void*)numberOfModelsPerProject));
if (modelIds != null)
Marshal.FreeHGlobal(IntPtr((void*)modelIds));
if (modelStates != null)
Marshal.FreeHGlobal(IntPtr((void*)modelStates));
}
}
}
}
使用C#p/Invoke函数：
using System.Runtime.InteropServices;
public class ActiveNames
{
public string[] ActiveNames { get; set; }
[DllImport("GetActiveNames.dll")] // replace with the actual name of the DLL
unsafe private static int GetActiveNames(sbyte** names):
public void GetActiveNames()
{
unsafe
{
// I use 100 here as an artificial number. This may not be a reasonable
// assumption, but I don't know how the actual GetActiveNames works
sbyte** names = (sbyte**)Marshal.AllocHGlobal(100).ToPointer();
try
{
GetActiveNames(names);
// fill the ActiveNames property
ActiveNames = new string[100];
for (int i = 0; i < 100; ++i)
ActiveNames[i] = new string(names[i]);
}
finally
{
// deallocate the unmanaged names memory
Marshal.FreeHGlobal(IntPtr((void*)names));
}
}
}
}
并且使用C++/CLI(不需要p/Invoke)：
#include "GetActiveNames.h" // replace with the actual GetActiveNames's header
using namespace System;
using namespace System::Runtime::InteropServices;
public ref class ActiveNames
{
private:
array<String^>^ m_activeNames;
public:
property array<String^>^ ActiveNames
{
array<String^>^ get()
{
return m_activeNames;
}
void set(array<String^>^ names)
{
m_activeNames = names;
}
}
void GetActiveNames()
{
signed char** names = new signed char*[100];
try
{
::GetActiveNames(reinterpret_cast<char**>(names));
ActiveNames = gcnew array<String^>(100);
for (int i = 0; i < 100; ++i)
ActiveNames[i] = gcnew String(names[i]);
catch (...)
{
delete[] names;
throw;
}
delete[] names;
}
};
正如你所看到的，我做了一些不安全的假设，因为我不知道GetActiveNames是如何工作的(名称的内存是如何分配和释放的？你怎么知道返回了多少名称？)。如果你想要更多的帮助，你必须更加具体。