Не отлавливаемое исключение при использовании неуправляемого кода

 [DllImport("advapi32.dll", EntryPoint = "RegEnumValue")]
  public static extern int RegEnumValueA(
           UIntPtr hKey,
           int dwIndex,
           out string lpValueName,
           out int lpcbValueName,
           int lpReserved,
           out int lpType,
           out IntPtr lpData,
           out int lpcbData);

              
                        int lpcbValueName = 1024, lpType, lpcbData = 1024;
                        IntPtr lpData = Marshal.AllocHGlobal(1024);
                        string lpValueName = "";
                        for (int i = 0; i < ValueCount; i++)
                        {
                            int ValueError = RegEnumValueA(
                                OpenKey,
                                i,
                                out lpValueName,
                                out lpcbValueName,
                                0,
                                out lpType,
                                out lpData,
                                out lpcbData);
                            string dt = Marshal.PtrToStringUni(lpData);
                        }

[DllImport("advapi32.dll", EntryPoint = "RegEnumValue",SetLastError = true)]
        static extern uint RegEnumValue(
         IntPtr hKey,
         uint dwIndex,
         StringBuilder lpValueName,
         ref uint lpcValueName,
         IntPtr lpReserved,
         IntPtr lpType,
         IntPtr lpData,
         IntPtr lpcbData);

 if (ValueCount > 0)
                {
                    IntPtr lpType = Marshal.AllocHGlobal(4);
                    IntPtr lpcbData = Marshal.AllocHGlobal(4);
                    IntPtr lpReserved = Marshal.AllocHGlobal(4);
                    Marshal.WriteInt32(lpType,0);
                    Marshal.WriteInt32(lpcbData, 1024);
                    Marshal.WriteInt32(lpReserved, 0);
                    IntPtr lpData = Marshal.AllocHGlobal(1024);
                    uint lpcbValueName = 1024;
                    StringBuilder lpValueName=new StringBuilder("");
                        for (int i = 0; i < ValueCount; i++)
                        {
                      
                            uint ValueError = RegEnumValue(
                                OpenKey,
                                (uint)i,
                                lpValueName,
                                ref lpcbValueName,
                                lpReserved,
                                lpType,
                                lpData,
                                lpcbData);
                            string dt = Marshal.PtrToStringAnsi(lpData);                     
                    }
                    
                    }

StringBuilder lpValueName=new StringBuilder(256);

        [DllImport("advapi32.dll", EntryPoint = "RegEnumValue", SetLastError = true)]
        static extern uint RegEnumValue(
         IntPtr hKey,
         int dwIndex,
         IntPtr lpValueName,
         ref int lpcValueName,
         IntPtr lpReserved,
         out int lpType,
         IntPtr lpData,
         out int lpcbData);
 
            IntPtr hReg = Registry.LocalMachine.Handle.DangerousGetHandle();
 
            int valueType, valueNameSize, dataSize;
 
            IntPtr valueName = Marshal.AllocHGlobal(1024);
            IntPtr data = Marshal.AllocHGlobal(1024);
 
            int valuesCount = 5;
 
            for(int i = 0; i < valuesCount; i++)
            {
                valueNameSize = 1024;
                dataSize = 1024;
 
                uint retval = RegEnumValue(hReg, i, valueName, ref valueNameSize, IntPtr.Zero, out valueType, data, out dataSize);
 
                if (retval == 0)
                {
                    /*
                    #define REG_NONE                    ( 0 )   // No value type
                    #define REG_SZ                      ( 1 )   // Unicode nul terminated string
                    #define REG_EXPAND_SZ               ( 2 )   // Unicode nul terminated string
                                                                // (with environment variable references)
                    #define REG_BINARY                  ( 3 )   // Free form binary
                    #define REG_DWORD                   ( 4 )   // 32-bit number
                    #define REG_DWORD_LITTLE_ENDIAN     ( 4 )   // 32-bit number (same as REG_DWORD)
                    #define REG_DWORD_BIG_ENDIAN        ( 5 )   // 32-bit number
                    #define REG_LINK                    ( 6 )   // Symbolic Link (unicode)
                    #define REG_MULTI_SZ                ( 7 )   // Multiple Unicode strings
                    #define REG_RESOURCE_LIST           ( 8 )   // Resource list in the resource map
                    #define REG_FULL_RESOURCE_DESCRIPTOR ( 9 )  // Resource list in the hardware description
                    #define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
                    #define REG_QWORD                   ( 11 )  // 64-bit number
                    #define REG_QWORD_LITTLE_ENDIAN     ( 11 )  // 64-bit number (same as REG_QWORD)
                    */
                    string name = Marshal.PtrToStringAnsi(valueName, valueNameSize);
 
                    if (valueType == 1) // REG_SZ
                    {
                        string val = Marshal.PtrToStringAnsi(data, dataSize);
 
                        Debug.WriteLine("type {0}, name {1}, value {2}", valueType, name, val);
                    }
                    else if(valueType == 4) // REG_DWORD
                    {
                        int val = Marshal.ReadInt32(data);
 
                        Debug.WriteLine("type {0}, name {1}, value {2}", valueType, name, val);
                    }
                    else if (valueType == 11) // REG_QWORD
                    {
                        long val = Marshal.ReadInt64(data);
 
                        Debug.WriteLine("type {0}, name {1}, value {2}", valueType, name, val);
                    }
                    else
                    {
                        Debug.WriteLine("type {0}, name {1}", valueType, name);
                    }
                }
            }
 
            Marshal.FreeHGlobal(valueName);
            Marshal.FreeHGlobal(data);

            var lm = Registry.LocalMachine;
 
            var subKeys = lm.GetSubKeyNames();
 
            var values = lm.GetValueNames();
 
            foreach (var name in subKeys)
            {
                Debug.WriteLine(string.Format("subkey: name {0}", name));
            }
 
            foreach (var name in values)
            {
                Debug.WriteLine("value: type {0}, name {1}, value {2}", lm.GetValueKind(name), name, lm.GetValue(name));
            }