C# 如何在C中使用（char*param[]）封送函数#
我在本机dll中有一个函数，其函数如下所示C# 如何在C中使用（char*param[]）封送函数#,c#,char,marshalling,param,C#,Char,Marshalling,Param,我在本机dll中有一个函数，其函数如下所示 int GetActiveNames(char* names[]); 如何在C#中为上述返回字符串/字符数组的函数创建PInvoke包装器方法 更具描述性地说 我尝试了p/Invoke方式，它显示了以下错误：试图读取或写入受保护的内存。这通常表示其他内存已损坏 我只是简化了实际的C函数签名。但这里是完整的C函数签名和函数参数的描述 int OpalGetActiveProjects(unsigned short allocatedProjects
int GetActiveNames(char* names[]);
更具描述性地说
我尝试了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[]);
输入参数
allocatedProjects：为其分配存储的项目数 路径、计算机名称、IP地址的调用方 和实例ID。 allocatedModels：为其分配存储的模型数 名称、路径和实例ID的调用方。 allocatedProjectPathLen：为接收项目路径而分配的存储长度 AllocatedModelPath：为接收模型路径分配的存储长度 allocatedMachineNameLen：为接收机器名而分配的存储长度 分配IP地址：为接收IP地址分配的存储长度
输出参数
numProjects：指向API将存储实际活动项目数的位置的指针。 numModels:指向API将存储实际总数的位置的指针 所有活动项目的模型数。 maxProjectPathLen:指向API将存储最长项目路径长度的位置的指针。 maxModelPathLen:指向API将存储最长模型路径长度的位置的指针。 MaxMachineName:指向API将存储最长机器名长度的位置的指针。 maxIpLen:指向API将存储数据长度的指针 最长的IP地址。 项目路径：字符串数组，API将在其中存储活动项目配置文件的路径。 实例ID:数组，API将在其中存储活动项目的实例ID。 machineNames:API将存储机器名的数组。 controllerIPs:API将存储IP地址的数组。 模型路径：数组，API将在其中存储所有活动项目的模型路径。 numModelsPerProject:数组，API将在其中存储每个项目的模型数量。使用这些值来确定 模型属于哪个项目。 modelIDs:数组，API将在其中存储所有用户的模型ID 积极的项目。 modelStates:数组，API将在其中存储所有活动项目的模型状态 还有一个C程序，它使用OpalGetActiveProjects（）函数获取项目路径、机器名等
#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 %s\n", buf, rc, funcName);
}
#包括
#包括
#包括
#包括
//getcwd（）的标头依赖于平台
#如果已定义（WIN32）
#包括
#包括
#已定义的elif（_linux__;）
#包括
#定义最大路径256
#恩迪夫
#包括“OpalApi.h”
无效打印错误（int-rc，char*funcName）；
#定义FALSE 0
#定义真1
int main（int argc，char*argv[]）
{
字符**项目路径，**模型路径；
char*projectpath，*modelpath；
字符**loaderMachineName，**控制器IP；
char*loaderMachineNames，*controllerIps；
int i、rc、PROJECTDX；
无符号短*插入；
国际*2；
int*modelIds；
无符号short*numModelsPerProject；
无符号短*modelId；
无符号短*模型状态；
未签署的短期allocProjects、numProjects；
无符号短allocModels，numModels；
未签名的短allocProjectPathLen，maxProjectPathLen；
无符号短allocModelPathLen，maxModelPathLen；
无符号短allocMachineLen，maxMachineLen；
无符号短allocIpLen，maxIpLen；
//这是一个很好的选择。
allocProjects=allocModels=0；
allocProjectPathLen=allocModelPathLen=0；
allocMachineLen=Allocipelen=0；
rc=OpalGetActiveProjects（0和allocProjects，
0和allocModels，
0和allocProjectPathLen，
0和AllocModelPath，
0和allocMachineLen，
0和allocIpLen，
空，空，空，空，
空，空，空，N
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));
}
}
}
}
#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;
}
};
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));
}
}
}
}