Помощь по работе с SDK для считывателя от HIKVISION

//Program.cs
using System;
 
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Попытка инициализации SDK...");
 
        if (!SDKManager.Initialize())
        {
            return;
        }
 
        var device = DeviceManager.EnumerateAndFindDevice("DS-K1F100-D8E");
        if (device == null)
        {
            Console.WriteLine("Устройство не найдено.");
            return;
        }
 
        var userId = DeviceManager.LoginToDevice(device.Value);
        if (userId == -1)
        {
            return;
        }
 
        // Вызов класса CardReader для активации карты
        CardReader.ActivateCard(userId);
 
        DeviceManager.LogoutAndCleanup(userId);
    }
}

//structures.cs
using System.Runtime.InteropServices;
 
public struct USB_SDK_DEVICE_INFO
{
    public uint dwSize;
    public uint dwVID;
    public uint dwPID;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string szManufacturer;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string szDeviceName;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 48)]
    public string szSerialNumber;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 68)]
    public byte[] byRes;
}
 
public struct USB_SDK_USER_LOGIN_INFO
{
    public uint dwSize;
    public uint dwTimeout;
    public uint dwVID;
    public uint dwPID;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string szUserName;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    public string szPassword;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 48)]
    public string szSerialNumber;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
    public byte[] byRes;
}
 
public struct USB_SDK_DEVICE_REG_RES
{
    public uint dwSize;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string szDeviceName;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 48)]
    public string szSerialNumber;
    public uint dwSoftwareVersion;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)]
    public byte[] byRes;
}
 
public struct USB_SDK_WAIT_SECOND
{
    public uint dwSize;
    public byte byWait;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 27)]
    public byte[] byRes;
}
 
public struct USB_SDK_ACTIVATE_CARD_RES
{
    public uint dwSize;
    public byte byCardType;
    public byte bySerialLen;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
    public byte[] bySerial;
    public byte bySelectVerifyLen;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public byte[] bySelectVerify;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
    public byte[] byRes;
}
 
public struct USB_CONFIG_INPUT_INFO
{
    public IntPtr lpCondBuffer;
    public uint dwCondBufferSize;
    public IntPtr lpInBuffer;
    public uint dwInBufferSize;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 48)]
    public byte[] byRes;
}
 
public struct USB_CONFIG_OUTPUT_INFO
{
    public IntPtr lpOutBuffer;
    public uint dwOutBufferSize;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 56)]
    public byte[] byRes;
}

//CardReader.cs
using System;
using System.Runtime.InteropServices;
 
public static class CardReader
{
    private const uint USB_SDK_GET_ACTIVATE_CARD = 0x0104;
 
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USB_SDK_WAIT_SECOND
    {
        public uint dwSize;
        public byte byWait;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 27)]
        public byte[] byRes;
    }
 
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USB_SDK_ACTIVATE_CARD_RES
    {
        public uint dwSize;
        public byte byCardType;
        public byte bySerialLen;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
        public byte[] bySerial;
        public byte bySelectVerifyLen;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public byte[] bySelectVerify;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
        public byte[] byRes;
    }
 
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USB_CONFIG_INPUT_INFO
    {
        public IntPtr lpCondBuffer;
        public uint dwCondBufferSize;
        public IntPtr lpInBuffer;
        public uint dwInBufferSize;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 48)]
        public byte[] byRes;
    }
 
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USB_CONFIG_OUTPUT_INFO
    {
        public IntPtr lpOutBuffer;
        public uint dwOutBufferSize;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 56)]
        public byte[] byRes;
    }
 
    [DllImport("HCUsbSDK.dll", CallingConvention = CallingConvention.StdCall)]
    private static extern bool USB_SDK_GetDeviceConfig(long lUserID, uint dwCommand, 
        ref USB_CONFIG_INPUT_INFO pInputInfo, ref USB_CONFIG_OUTPUT_INFO pOutputInfo);
 
    [DllImport("HCUsbSDK.dll", CallingConvention = CallingConvention.StdCall)]
    private static extern int USB_SDK_GetLastError();
 
    [DllImport("HCUsbSDK.dll", CallingConvention = CallingConvention.StdCall)]
    private static extern IntPtr USB_SDK_GetErrorMsg(int iErrorCode);
 
public static void ActivateCard(long userId)
{
    if (userId <= 0)
    {
        Console.WriteLine("Invalid user ID.");
        return;
    }
 
    // Инициализация структуры ожидания
    var waitInfo = new USB_SDK_WAIT_SECOND
    {
        dwSize = (uint)Marshal.SizeOf(typeof(USB_SDK_WAIT_SECOND)),
        byWait = 5,
        byRes = new byte[27]
    };
 
    // Инициализация структуры результата активации карты
    var activateRes = new USB_SDK_ACTIVATE_CARD_RES
    {
        dwSize = (uint)Marshal.SizeOf(typeof(USB_SDK_ACTIVATE_CARD_RES)),
        bySerial = new byte[10],
        bySelectVerify = new byte[3],
        byRes = new byte[12]
    };
 
    // Выделение и инициализация указателей на буферы
    IntPtr ptrWaitInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB_SDK_WAIT_SECOND)));
    Marshal.StructureToPtr(waitInfo, ptrWaitInfo, false);
 
    IntPtr ptrActivateRes = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB_SDK_ACTIVATE_CARD_RES)));
    Marshal.StructureToPtr(activateRes, ptrActivateRes, false);
 
    var inputInfo = new USB_CONFIG_INPUT_INFO
    {
        lpCondBuffer = ptrWaitInfo,
        dwCondBufferSize = (uint)Marshal.SizeOf(typeof(USB_SDK_WAIT_SECOND)),
        lpInBuffer = ptrWaitInfo,
        dwInBufferSize = (uint)Marshal.SizeOf(typeof(USB_SDK_WAIT_SECOND)),
        byRes = new byte[48]
    };
 
    var outputInfo = new USB_CONFIG_OUTPUT_INFO
    {
        lpOutBuffer = ptrActivateRes,
        dwOutBufferSize = (uint)Marshal.SizeOf(typeof(USB_SDK_ACTIVATE_CARD_RES)),
        byRes = new byte[56]
    };
 
    try
    {
        Console.WriteLine($"dwCondBufferSize: {inputInfo.dwCondBufferSize}, dwInBufferSize: {inputInfo.dwInBufferSize}");
        Console.WriteLine($"dwOutBufferSize: {outputInfo.dwOutBufferSize}");
 
        Console.WriteLine($"Содержимое входного буфера (Wait Info): {BitConverter.ToString(waitInfo.byRes)}");
        Console.WriteLine($"Содержимое выходного буфера (Activate Res) до вызова: {BitConverter.ToString(activateRes.bySerial)}");
 
        // Вызов функции SDK
        bool result = USB_SDK_GetDeviceConfig(userId, USB_SDK_GET_ACTIVATE_CARD, ref inputInfo, ref outputInfo);
        if (result)
        {
            Console.WriteLine("SUCCESS USB_SDK_GetDeviceConfig() Command = USB_SDK_GET_ACTIVATE_CARD");
 
            // Преобразование выходных данных
            var cardRes = Marshal.PtrToStructure<USB_SDK_ACTIVATE_CARD_RES>(outputInfo.lpOutBuffer);
 
            Console.WriteLine($"Тип: {GetCardTypeName(cardRes.byCardType)}");
            Console.WriteLine($"Длинна номера: {cardRes.bySerialLen}");
            Console.WriteLine($"Номер: {BitConverter.ToString(cardRes.bySerial, 0, cardRes.bySerialLen)}");
            //Console.WriteLine($"Select Verify Length: {cardRes.bySelectVerifyLen}");
            //Console.WriteLine($"Select Verify: {BitConverter.ToString(cardRes.bySelectVerify, 0, cardRes.bySelectVerifyLen)}");
        }
        else
        {
            int errorCode = USB_SDK_GetLastError();
            IntPtr errorMsgPtr = USB_SDK_GetErrorMsg(errorCode);
            string errorMsg = Marshal.PtrToStringAnsi(errorMsgPtr);
            Console.WriteLine($"FAILED USB_SDK_GetDeviceConfig() Command = USB_SDK_GET_ACTIVATE_CARD");
            Console.WriteLine($"ErrorCode = [{errorCode}], ErrorMsg = [{errorMsg}]");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception: {ex.Message}");
    }
    finally
    {
        // Освобождение выделенной памяти
        if (ptrWaitInfo != IntPtr.Zero)
            Marshal.FreeHGlobal(ptrWaitInfo);
        if (ptrActivateRes != IntPtr.Zero)
            Marshal.FreeHGlobal(ptrActivateRes);
 
        Console.WriteLine("Память успешно освобождена.");
    }
}
 
// Метод GetCardTypeName для преобразования типа карты
private static string GetCardTypeName(byte cardType)
{
    return cardType switch
    {
        0 => "A M1 Card",
        1 => "A CPU Card",
        2 => "B",
        3 => "125KHz ID Card",
        _ => "Unknown",
    };
}
 
}

 else
        {
            int errorCode = USB_SDK_GetLastError();
            IntPtr errorMsgPtr = USB_SDK_GetErrorMsg(errorCode);
            string errorMsg = Marshal.PtrToStringAnsi(errorMsgPtr);
            Console.WriteLine($"FAILED USB_SDK_GetDeviceConfig() Command = USB_SDK_GET_ACTIVATE_CARD");
            Console.WriteLine($"ErrorCode = [{errorCode}], ErrorMsg = [{errorMsg}]");
        }