I'm trying to map a bytearray in c#, which is of 56 bytes and the struct i got for it is like this in C
struct cequivalentstruct{
uint32_t Descriptor;
uint32_t Value;
uint32_t Minimum;
uint32_t Maximum;
uint32_t Default;
uint16_t Next;
uint16_t Previous;
char Units[4];
uint16_t Multiplier;
uint16_t Divisor;
uint16_t Base;
uint16_t Offset;
char Link[3];
char pad;
char Name[16];
}
and i have coverted that to
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
public struct ParameterResponse
{
[MarshalAs(UnmanagedType.U4, SizeConst = 4)]
public uint Descriptor;
[MarshalAs(UnmanagedType.I4, SizeConst = 4)]
public uint Value;
[MarshalAs(UnmanagedType.U4, SizeConst = 4)]
public uint Minimum;
[MarshalAs(UnmanagedType.U4, SizeConst = 4)]
public uint Maximum;
[MarshalAs(UnmanagedType.U4, SizeConst = 4)]
public uint Default;
[MarshalAs(UnmanagedType.U4, SizeConst = 2)]
public uint Next;
[MarshalAs(UnmanagedType.U4, SizeConst = 2)]
public uint Previous;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public char[] Units;
[MarshalAs(UnmanagedType.U4, SizeConst = 2)]
public uint Multiplier;
[MarshalAs(UnmanagedType.U4, SizeConst = 2)]
public uint Divisor;
[MarshalAs(UnmanagedType.U4, SizeConst = 2)]
public uint Base;
[MarshalAs(UnmanagedType.U4, SizeConst = 2)]
public uint Offset;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public char[] Link;
[MarshalAs(UnmanagedType.U1, SizeConst = 1)]
public char pad;
[MarshalAs(UnmanagedType.ByValArray)]
public byte[] Name;
public ParameterResponse(uint descriptior, uint value, uint maximum, uint minimum, uint defaultvalue, uint next, uint previous,
char[] units, uint multiplier, uint divisor, uint baseValue, uint offset, char[] link, char padValue, byte[] name)
{
Descriptor = descriptior;
Value = value;
Maximum= maximum;
Minimum= minimum;
Default = defaultvalue;
Next= next; Previous= previous;
Units = units;
Multiplier = multiplier;
Divisor = divisor;
Base = baseValue; Offset = offset;
Link = link;
pad = padValue;
Name = name;
}
}
}
I'm not sure if I'm missing something in this, because when I try to convert my byteArray to this struct, but the struct is not exactly taking the appropriate sizeconst defined, any inputs would be helpful.
Try this.
uint16_t should map to ushort, char should map to byte or sbyte, The Name field need a SizeConst attribute, Using the default pack size.
[StructLayout(LayoutKind.Sequential)]
public struct ParameterResponse
{
public uint Descriptor;
public uint Value;
public uint Minimum;
public uint Maximum;
public uint Default;
public ushort Next;
public ushort Previous;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] Units;
public ushort Multiplier;
public ushort Divisor;
public ushort Base;
public ushort Offset;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] Link;
public byte pad;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public byte[] Name;
}
Related
I'm getting a byte[] response from a service, and I'm trying to convert this byte[] to a struct in c#, but one of the values which I have is 4294967.295 or 2147483.647 and when im defining long, double etc in my response struct, I'm getting it as NaN, or the value is incorrect, any inputs on what the datatype should be for such values?
My Struct on c#, and the struct given by the api and the extension used to cast the byte array to struct
using System.Globalization;
using System.Runtime.InteropServices;
namespace SampleExample
{
[StructLayout(LayoutKind.Sequential)]
public struct ParameterResponse
{
public uint Descriptor;
[MarshalAs(UnmanagedType.R4, SizeConst = 4)]
public float Value;
//public float Minimum;
//public float Maximum;
[MarshalAs(UnmanagedType.R4, SizeConst = 4)]
public float Minimum;
[MarshalAs(UnmanagedType.R4, SizeConst = 4)]
public float Maximum;
public uint Default;
public ushort Next;
public ushort Previous;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] Units;
public ushort Multiplier;
public ushort Divisor;
public ushort Base;
public ushort Offset;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] Link;
public byte pad;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public byte[] Name;
public ParameterResponse(uint descriptior, uint value, float maximum, float minimum, uint defaultvalue, ushort next, ushort previous,
byte[] units, ushort multiplier, ushort divisor, ushort baseValue, ushort offset, byte[] link, byte padValue, byte[] name)
{
Descriptor = descriptior;
Value = value;
Maximum = maximum;
Minimum = minimum;
Default = defaultvalue;
Next = next; Previous = previous;
Units = units;
Multiplier = multiplier;
Divisor = divisor;
Base = baseValue; Offset = offset;
Link = link;
pad = padValue;
Name = name;
}
}
}
uint32_t Descriptor;
uint32_t Value;
uint32_t Minimum;
uint32_t Maximum;
uint32_t Default;
uint16_t Next;
uint16_t Previous;
char Units[4];
uint16_t Multiplier;
uint16_t Divisor;
uint16_t Base;
uint16_t Offset;
char Link[3];
char pad;
char Name[16];
public static T CastToStruct<T>(this byte[] data) where T : struct
{
var pData = GCHandle.Alloc(data, GCHandleType.Pinned);
var result = (T)Marshal.PtrToStructure(pData.AddrOfPinnedObject(), typeof(T));
pData.Free();
return result;
}
var resultInStruct = byteOutput.CastToStruct<ParameterResponse>();
I am using NVAPI.dll to change gpu's core clock. using NvAPI_GPU_SetPstates20 function in nvapi.dll
The struct in C# for nvapi.dll is this:
[StructLayout(LayoutKind.Explicit, Pack = 8)]
internal struct dataStruct
{
[FieldOffset(0)]
public singleStruct single;
[FieldOffset(0)]
public rangeStruct range;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct valuerange
{
public int min;
public int max;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY
{
public uint domainId;
public uint editable;//1
public uint reserved;//31
public uint voltageUV;
public NV_GPU_PERF_PSTATES20_PARAM_DELTA voltageDeltaUV;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct NV_GPU_PERF_PSTATES20_PARAM_DELTA
{
public int value;
public valuerange valueRanges;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct pstateStruct
{
public uint pStateId;
public uint editable;//1
public uint reserved;//31
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public NV_GPU_PSTATE20_CLOCK_ENTRY[]clocks;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY[]baseVoltages;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct singleStruct
{
public uint frequencyKHz;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct rangeStruct
{
public uint minFrequencyKHz;
public uint maxFrequencyKHz;
public uint domainId;
public uint minVoltageUV;
public uint maxVoltageUV;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct overVoltageStruct
{
public uint numVoltages;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY []voltages;//[4]
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct NV_GPU_PSTATE20_CLOCK_ENTRY
{
public uint domainId;
public uint typeId;
public uint editable;//1
public uint reserved;//31
public NV_GPU_PERF_PSTATES20_PARAM_DELTA frequencyDeltaKHz;
public dataStruct data;
}
[StructLayout(LayoutKind.Sequential, Pack = 8)]
internal struct NV_GPU_PERF_PSTATES20_INFO
{
public uint version;
public uint editable;//1
public uint reserved;//31
public uint numPStates;
public uint numClocks;
public uint numBaseVoltages;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public pstateStruct[] pStates;
public overVoltageStruct overVoltage;
}
This is my function:
public static void SetCoreClock(NvPhysicalGpuHandle handle,int clock)
{
NV_GPU_PERF_PSTATES20_INFO pStatesInfo=new NV_GPU_PERF_PSTATES20_INFO();
pStatesInfo.version = (uint) Marshal.SizeOf(typeof(NV_GPU_PERF_PSTATES20_INFO)) | 0x10000;
pStatesInfo.numPStates = 1;
pStatesInfo.numClocks = 1;
pStatesInfo.editable = 1;
pStatesInfo.reserved = 31;
pStatesInfo.pStates = new pstateStruct[16];
pStatesInfo.overVoltage.voltages = new NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY[4];
pStatesInfo.pStates[0].baseVoltages = new NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY[4];
pStatesInfo.pStates[0].clocks = new NV_GPU_PSTATE20_CLOCK_ENTRY[8];
pStatesInfo.pStates[0].clocks[0].editable = 1;
pStatesInfo.pStates[0].clocks[0].reserved = 31;
pStatesInfo.pStates[0].pStateId = 0;
pStatesInfo.pStates[0].clocks[0].domainId = 0;
pStatesInfo.pStates[0].clocks[0].typeId = 0;
pStatesInfo.pStates[0].clocks[0].frequencyDeltaKHz.value = clock;
pStatesInfo.pStates[0].clocks[0].frequencyDeltaKHz.valueRanges.max = 0;
pStatesInfo.pStates[0].clocks[0].frequencyDeltaKHz.valueRanges.min = 0;
a = NVAPI.NvAPI_GPU_SetPstates20(handle,ref pStatesInfo);
}
when I run the function "SetCoreClock". The value a return "INCOMPATIBLE_STRUCT_VERSION".
Is my struct wrong?
I found a C++ code. the code's struct is:
struct NV_GPU_PERF_PSTATES20_PARAM_DELTA
{
int value;
struct
{
int min;
int max;
} valueRange;
};
struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY
{
unsigned int domainId;
unsigned int editable : 1;
unsigned int reserved : 31;
unsigned int voltageUV;
NV_GPU_PERF_PSTATES20_PARAM_DELTA voltageDeltaUV;
};
struct NV_GPU_PSTATE20_CLOCK_ENTRY
{
unsigned int domainId;
unsigned int typeId;
unsigned int editable : 1;
unsigned int reserved : 31;
NV_GPU_PERF_PSTATES20_PARAM_DELTA frequencyDeltaKHz;
union
{
struct
{
unsigned int frequencyKHz;
} single;
struct
{
unsigned int minFrequencyKHz;
unsigned int maxFrequencyKHz;
unsigned int domainId;
unsigned int minVoltageUV;
unsigned int maxVoltageUV;
} range;
} data;
};
struct NV_GPU_PERF_PSTATES20_INFO
{
unsigned int version;
unsigned int editable : 1;
unsigned int reserved : 31;
unsigned int numPStates;
unsigned int numClocks;
unsigned int numBaseVoltages;
struct
{
unsigned int pStateId;
unsigned int editable : 1;
unsigned int reserved : 31;
NV_GPU_PSTATE20_CLOCK_ENTRY clocks[8];
NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY baseVoltages[4];
} pStates[16];
struct
{
unsigned int numVoltages;
NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY voltages[4];
} overVoltage;
};```
Thanks for helping me solved the problem.
it means you have the struct the incorrect size. a example I found said the version should be 0x11c94. things like reserved IMHO need to be removed. I had same issue and I did this to find the version:
uint GPUVER3 = (uint)Marshal.SizeOf(typeof(NV_GPU_PERF_PSTATES20_INFO_V1)) | 0x20000;
Once you get the version the same as 0x11c94 it should work.
C code I used to work this out
https://github.com/suppai/nvidia-overclock
I've found plenty of information about how to marshal wchar_t and wchar* on the internet, but right now I am trying to marshal the WINBIO_STRING type, which is defined as wchar[256]. Marshalling it as an array of char[] works, but then every other element in the array is \0, and I would like to avoid this. Is there a more proper way to marshal this data (which is a member of a struct, the WINBIO_UNIT_SCHEMA struct in particular). This is my code:
[StructLayout(LayoutKind.Sequential)]
public struct BiometricUnitSchema
{
public int UnitId;
public BiometricPoolType PoolType;
public BiometricType BiometricFactor;
public BiometricSubtype SensorSubType;
public BiometricCapabilities Capabilities;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public char[] DeviceInstanceId;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public char[] Description;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public char[] Manufacturer;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public char[] Model;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public char[] SerialNumber;
public BiometricVersion FirmwareVersion;
}
I also have the problem of the FirmwareVersion field always containing MajorVersion and MinorVersion values of 0, but I am not sure if this result is incorrect or simply misleading.
I fixed this problem by marshaling WINBIO_STRING as a string in C# instead of a char[]. I also had to add a Unicode charset to my structure.
My new structure:
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct BiometricUnitSchema
{
public int UnitId;
public BiometricPoolType PoolType;
public BiometricType BiometricFactor;
public BiometricSubtype SensorSubType;
public BiometricCapabilities Capabilities;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string DeviceInstanceId;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string Description;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string Manufacturer;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string Model;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string SerialNumber;
public BiometricVersion FirmwareVersion;
}
I have been trying to convert this struct to C# for the last couple of days, but to no avail...
https://msdn.microsoft.com/en-us/library/windows/desktop/bb736369(v=vs.85).aspx
typedef struct _WTSCLIENT {
TCHAR ClientName[CLIENTNAME_LENGTH + 1];
TCHAR Domain[DOMAIN_LENGTH + 1 ];
TCHAR UserName[USERNAME_LENGTH + 1];
TCHAR WorkDirectory[MAX_PATH + 1];
TCHAR InitialProgram[MAX_PATH + 1];
BYTE EncryptionLevel;
ULONG ClientAddressFamily;
USHORT ClientAddress[CLIENTADDRESS_LENGTH + 1];
USHORT HRes;
USHORT VRes;
USHORT ColorDepth;
TCHAR ClientDirectory[MAX_PATH + 1];
ULONG ClientBuildNumber;
ULONG ClientHardwareId;
USHORT ClientProductId;
USHORT OutBufCountHost;
USHORT OutBufCountClient;
USHORT OutBufLength;
TCHAR DeviceId[MAX_PATH + 1];
} WTSCLIENT, *PWTSCLIENT;
This is my attempt so far:
[StructLayout( LayoutKind.Sequential )]
public struct _WTSCLIENT {
[MarshalAs( UnmanagedType.LPTStr )]
public String ClientName;
[MarshalAs( UnmanagedType.LPTStr )]
public String Domain;
[MarshalAs( UnmanagedType.LPTStr )]
public String UserName;
[MarshalAs( UnmanagedType.LPTStr )]
public String WorkDirectory;
[MarshalAs( UnmanagedType.LPTStr )]
public String InitialProgram;
public Byte EncryptionLevel;
public uint ClientAddressFamily;
[MarshalAsAttribute( UnmanagedType.ByValArray)]
public byte[] ClientAddress;
public ushort HRes;
public ushort VRes;
public ushort ColorDepth;
[MarshalAs( UnmanagedType.LPTStr )]
public String ClientDirectory;
public uint ClientBuildNumber;
public uint ClientHardwareId;
public ushort ClientProductId;
public ushort OutBufCountHost;
public ushort OutBufCountClient;
public ushort OutBufLength;
[MarshalAs( UnmanagedType.LPTStr )]
public String DeviceId;
}
I use it like this:
WTSQuerySessionInformation( serverHandle, si.SessionID, WTS_INFO_CLASS.WTSClientInfo, out clientInfoPtr, out bytes );
clientInfo = (_WTSCLIENT)Marshal.PtrToStructure( clientInfoPtr, typeof( _WTSCLIENT ) );
...but it bombs out silently, so obviously I have not matched the structure...
Can anyone help me with the struct conversion to C#
TIA...
--
Dag.
Try
[StructLayout(LayoutKind.Sequential)]
public struct WTSCLIENT
{
private const int CLIENTNAME_LENGTH = 20;
private const int DOMAIN_LENGTH = 17;
private const int USERNAME_LENGTH = 20;
private const int MAX_PATH = 260;
private const int CLIENTADDRESS_LENGTH = 30;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CLIENTNAME_LENGTH + 1)]
public string ClientName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)]
public string Domain;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)]
public string UserName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
public string WorkDirectory;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
public string InitialProgram;
public byte EncryptionLevel;
public uint ClientAddressFamily;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = CLIENTADDRESS_LENGTH + 1)]
public ushort[] ClientAddress;
public ushort HRes;
public ushort VRes;
public ushort ColorDepth;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
public string ClientDirectory;
public uint ClientBuildNumber;
public uint ClientHardwareId;
public ushort ClientProductId;
public ushort OutBufCountHost;
public ushort OutBufCountClient;
public ushort OutBufLength;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
public string DeviceId;
}
It should work. Its Marshal.SizeOf is the "right" one, both at 32 and 64 bits, both Ansi and Unicode.
If you are using the Unicode version of the methods change the first line to:
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
You could try the P/Invoke Interop Assistant
For your ULONG ClientBuildNumber; and all other ULONG s in C++, you have used the C# type uint. It could be an error that your definition of ULONG is a different size than uint.
Maybe you can try using ulong in C# (unsigned 64-bit, 0 to 18,446,744,073,709,551,615). This should match the standard Microsoft C++ ULONG definition.
MSDN C++
MSDN C# ulong
The struct that i have built in c# when run against the function does not give me one of the error message that tell me something is wrong with the struct. It says that a source file could not be found. Again, I don't know much about this DLL b/c of lack of documentation. But I am still thinking it is because I set the struct up wrong. Most likely i'm thinking the 3rd struct where it is referencing a struct within the struct.
i was hoping for some feedback on the work I did.
Thanks for the assistance.
This is what was provided in C:
int BatchTotal_Transactions(int transType, pTGiftCardReqBatchTotal req, pTGiftCardRespBatchTotal resp, int (*Com)(char *));
typedef struct _tagGiftCardReqBatchTotal
{
char Password[9];
char OperatorID[9];
char BatchNum[14];
char StartDate[11];
char EndDate[11];
unsigned char Type;
} TGiftCardReqBatchTotal, *pTGiftCardReqBatchTotal;
typedef struct _tagGiftCardRespBatchTotal
{
char Result;
char TerminalId[17];
unsigned char DispMsgControl;
char DispMsg[256];
char Display[41];
char Date[11];
char Time[9];
char RespCode[4];
char BatchNum[14];
char ErrorFlag;
char CustLang;
char UserLang;
char OpenDate[17];
char ClosedDate[17];
char StartDate[11];
char EndDate[11];
char BatchStatus;
int CardTypeNum;
TGiftCardTotals GctHost[MAX_CARD_CODES];
TGiftCardTotals GctTRS[MAX_CARD_CODES];
} TGiftCardRespBatchTotal, *pTGiftCardRespBatchTotal;
typedef struct _tagGiftCardTotals
{
unsigned short CardCode;
unsigned short PurchaseNum;
long PurchaseTotal;
unsigned short RefundNum;
long RefundTotal;
unsigned short RedemptionNum;
long RedemptionTotal;
unsigned short CorrectionNum;
long CorrectionTotal;
long PurchaseBenefitTotal;
long RefundBenefitTotal;
long RedemptionBenefitTotal;
} TGiftCardTotals, *pTGiftCardTotals;
And this is how I did it in C#:
[DllImport("batch.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
public static extern int BatchTotal_Transactions(int transType, ref giftCardReqBatchTotal req, ref giftCardRespBatchTotal resp, IntPtr com);
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct _tagGiftCardReqBatchTotal
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 9)]
public string Password;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 9)]
public string OperatorID;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
public string BatchNum;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)]
public string StartDate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)]
public string EndDate;
public byte Type;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct _tagGiftCardRespBatchTotal
{
public byte Result;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 17)]
public string TerminalId;
public byte DispMsgControl;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string DispMsg;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 41)]
public string Display;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)]
public string Date;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 9)]
public string Time;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)]
public string RespCode;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
public string BatchNum;
public byte ErrorFlag;
public byte CustLang;
public byte UserLang;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 17)]
public string OpenDate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 17)]
public string ClosedDate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)]
public string StartDate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)]
public string EndDate;
public byte BatchStatus;
int CardTypeNum;
[MarshalAs(UnmanagedType.Struct, SizeConst = 1024)]
public _tagGiftCardTotals GctHost;
[MarshalAs(UnmanagedType.Struct, SizeConst = 1024)]
public _tagGiftCardTotals GctTRS;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct _tagGiftCardTotals
{
public UInt16 CardCode;
public UInt16 PurchaseNum;
public int PurchaseTotal;
public UInt16 RefundNum;
public int RefundTotal;
public UInt16 RedemptionNum;
public int RedemptionTotal;
public UInt16 CorrectionNum;
public int CorrectionTotal;
public int PurchaseBenefitTotal;
public int RefundBenefitTotal;
public int RedemptionBenefitTotal;
}
Are you sure the error isn't the following:
Specified module could not be found.
If this is the error then it is because the dll could not be found. Make sure the dll is in your path:
http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.dllimportattribute.value.aspx