Пожалуйста, преобразуйте C# в C++

---

Здравствуйте, друзья, кто-нибудь может помочь мне преобразовать этот код из C # в C ++?

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Security.AccessControl;
using System.Security.Principal;
namespace FileLockInfo
{

    public class Win32API
    {
        [DllImport("ntdll.dll")]
        public static extern int NtQueryObject(IntPtr ObjectHandle, int
            ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength,
            ref int returnLength);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern uint QueryDosDevice(string lpDeviceName, StringBuilder lpTargetPath, int ucchMax);

        [DllImport("ntdll.dll")]
        public static extern uint NtQuerySystemInformation(int
            SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength,
            ref int returnLength);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern IntPtr OpenMutex(UInt32 desiredAccess, bool inheritHandle, string name);

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);

        [DllImport("kernel32.dll")]
        public static extern int CloseHandle(IntPtr hObject);

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle,
           ushort hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle,
           uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions);

        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentProcess();

        public enum ObjectInformationClass : int
        {
            ObjectBasicInformation = 0,
            ObjectNameInformation = 1,
            ObjectTypeInformation = 2,
            ObjectAllTypesInformation = 3,
            ObjectHandleInformation = 4
        }

        [Flags]
        public enum ProcessAccessFlags : uint
        {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct OBJECT_BASIC_INFORMATION
        { // Information Class 0
            public int Attributes;
            public int GrantedAccess;
            public int HandleCount;
            public int PointerCount;
            public int PagedPoolUsage;
            public int NonPagedPoolUsage;
            public int Reserved1;
            public int Reserved2;
            public int Reserved3;
            public int NameInformationLength;
            public int TypeInformationLength;
            public int SecurityDescriptorLength;
            public System.Runtime.InteropServices.ComTypes.FILETIME CreateTime;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct OBJECT_TYPE_INFORMATION
        { // Information Class 2
            public UNICODE_STRING Name;
            public int ObjectCount;
            public int HandleCount;
            public int Reserved1;
            public int Reserved2;
            public int Reserved3;
            public int Reserved4;
            public int PeakObjectCount;
            public int PeakHandleCount;
            public int Reserved5;
            public int Reserved6;
            public int Reserved7;
            public int Reserved8;
            public int InvalidAttributes;
            public GENERIC_MAPPING GenericMapping;
            public int ValidAccess;
            public byte Unknown;
            public byte MaintainHandleDatabase;
            public int PoolType;
            public int PagedPoolUsage;
            public int NonPagedPoolUsage;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct OBJECT_NAME_INFORMATION
        { // Information Class 1
            public UNICODE_STRING Name;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct UNICODE_STRING
        {
            public ushort Length;
            public ushort MaximumLength;
            public IntPtr Buffer;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct GENERIC_MAPPING
        {
            public int GenericRead;
            public int GenericWrite;
            public int GenericExecute;
            public int GenericAll;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct SYSTEM_HANDLE_INFORMATION
        { // Information Class 16
            public int ProcessID;
            public byte ObjectTypeNumber;
            public byte Flags; // 0x01 = PROTECT_FROM_CLOSE, 0x02 = INHERIT
            public ushort Handle;
            public int Object_Pointer;
            public UInt32 GrantedAccess;
        }

        public const int MAX_PATH = 260;
        public const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
        public const int DUPLICATE_SAME_ACCESS = 0x2;
        public const int DUPLICATE_CLOSE_SOURCE = 0x1;
    }

    public class Win32Processes
    {
        const int CNST_SYSTEM_HANDLE_INFORMATION = 16;
        const uint STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;

        public static string getObjectTypeName(Win32API.SYSTEM_HANDLE_INFORMATION shHandle, Process process)
        {
            IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
            IntPtr ipHandle = IntPtr.Zero;
            var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
            IntPtr ipBasic = IntPtr.Zero;
            var objObjectType = new Win32API.OBJECT_TYPE_INFORMATION();
            IntPtr ipObjectType = IntPtr.Zero;
            IntPtr ipObjectName = IntPtr.Zero;
            string strObjectTypeName = "";
            int nLength = 0;
            int nReturn = 0;
            IntPtr ipTemp = IntPtr.Zero;

            if (!Win32API.DuplicateHandle(m_ipProcessHwnd, shHandle.Handle,
                                          Win32API.GetCurrentProcess(), out ipHandle,
                                          0, false, Win32API.DUPLICATE_SAME_ACCESS))
                return null;

            ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
            Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation,
                                   ipBasic, Marshal.SizeOf(objBasic), ref nLength);
            objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
            Marshal.FreeHGlobal(ipBasic);

            ipObjectType = Marshal.AllocHGlobal(objBasic.TypeInformationLength);
            nLength = objBasic.TypeInformationLength;
            while ((uint)(nReturn = Win32API.NtQueryObject(
                ipHandle, (int)Win32API.ObjectInformationClass.ObjectTypeInformation, ipObjectType,
                  nLength, ref nLength)) ==
                Win32API.STATUS_INFO_LENGTH_MISMATCH)
            {
                Marshal.FreeHGlobal(ipObjectType);
                ipObjectType = Marshal.AllocHGlobal(nLength);
            }

            objObjectType = (Win32API.OBJECT_TYPE_INFORMATION)Marshal.PtrToStructure(ipObjectType, objObjectType.GetType());
            if (Is64Bits())
            {
                ipTemp = new IntPtr(Convert.ToInt64(objObjectType.Name.Buffer.ToString(), 10) >> 32);
            }
            else
            {
                ipTemp = objObjectType.Name.Buffer;
            }

            strObjectTypeName = Marshal.PtrToStringUni(ipTemp, objObjectType.Name.Length >> 1);
            Marshal.FreeHGlobal(ipObjectType);
            return strObjectTypeName;
        }


        public static string getObjectName(Win32API.SYSTEM_HANDLE_INFORMATION shHandle, Process process)
        {
            IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
            IntPtr ipHandle = IntPtr.Zero;
            var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
            IntPtr ipBasic = IntPtr.Zero;
            IntPtr ipObjectType = IntPtr.Zero;
            var objObjectName = new Win32API.OBJECT_NAME_INFORMATION();
            IntPtr ipObjectName = IntPtr.Zero;
            string strObjectName = "";
            int nLength = 0;
            int nReturn = 0;
            IntPtr ipTemp = IntPtr.Zero;

            if (!Win32API.DuplicateHandle(m_ipProcessHwnd, shHandle.Handle, Win32API.GetCurrentProcess(),
                                          out ipHandle, 0, false, Win32API.DUPLICATE_SAME_ACCESS))
                return null;

            ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
            Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation,
                                   ipBasic, Marshal.SizeOf(objBasic), ref nLength);
            objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
            Marshal.FreeHGlobal(ipBasic);


            nLength = objBasic.NameInformationLength;

            ipObjectName = Marshal.AllocHGlobal(nLength);
            while ((uint)(nReturn = Win32API.NtQueryObject(
                     ipHandle, (int)Win32API.ObjectInformationClass.ObjectNameInformation,
                     ipObjectName, nLength, ref nLength))
                   == Win32API.STATUS_INFO_LENGTH_MISMATCH)
            {
                Marshal.FreeHGlobal(ipObjectName);
                ipObjectName = Marshal.AllocHGlobal(nLength);
            }
            objObjectName = (Win32API.OBJECT_NAME_INFORMATION)Marshal.PtrToStructure(ipObjectName, objObjectName.GetType());

            if (Is64Bits())
            {
                ipTemp = new IntPtr(Convert.ToInt64(objObjectName.Name.Buffer.ToString(), 10) >> 32);
            }
            else
            {
                ipTemp = objObjectName.Name.Buffer;
            }

            if (ipTemp != IntPtr.Zero)
            {

                byte[] baTemp2 = new byte[nLength];
                try
                {
                    Marshal.Copy(ipTemp, baTemp2, 0, nLength);

                    strObjectName = Marshal.PtrToStringUni(Is64Bits() ?
                                                           new IntPtr(ipTemp.ToInt64()) :
                                                           new IntPtr(ipTemp.ToInt32()));
                    return strObjectName;
                }
                catch (AccessViolationException)
                {
                    return null;
                }
                finally
                {
                    Marshal.FreeHGlobal(ipObjectName);
                    Win32API.CloseHandle(ipHandle);
                }
            }
            return null;
        }

        public static List<Win32API.SYSTEM_HANDLE_INFORMATION>
        GetHandles(Process process = null, string IN_strObjectTypeName = null, string IN_strObjectName = null)
        {
            uint nStatus;
            int nHandleInfoSize = 0x10000;
            IntPtr ipHandlePointer = Marshal.AllocHGlobal(nHandleInfoSize);
            int nLength = 0;
            IntPtr ipHandle = IntPtr.Zero;

            while ((nStatus = Win32API.NtQuerySystemInformation(CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer,
                                                                nHandleInfoSize, ref nLength)) ==
                    STATUS_INFO_LENGTH_MISMATCH)
            {
                nHandleInfoSize = nLength;
                Marshal.FreeHGlobal(ipHandlePointer);
                ipHandlePointer = Marshal.AllocHGlobal(nLength);
            }

            byte[] baTemp = new byte[nLength];
            Marshal.Copy(ipHandlePointer, baTemp, 0, nLength);

            long lHandleCount = 0;
            if (Is64Bits())
            {
                lHandleCount = Marshal.ReadInt64(ipHandlePointer);
                ipHandle = new IntPtr(ipHandlePointer.ToInt64() + 8);
            }
            else
            {
                lHandleCount = Marshal.ReadInt32(ipHandlePointer);
                ipHandle = new IntPtr(ipHandlePointer.ToInt32() + 4);
            }

            Win32API.SYSTEM_HANDLE_INFORMATION shHandle;
            List<Win32API.SYSTEM_HANDLE_INFORMATION> lstHandles = new List<Win32API.SYSTEM_HANDLE_INFORMATION>();

            for (long lIndex = 0; lIndex < lHandleCount; lIndex++)
            {
                shHandle = new Win32API.SYSTEM_HANDLE_INFORMATION();
                if (Is64Bits())
                {
                    shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
                    ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle) + 8);
                }
                else
                {
                    ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle));
                    shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
                }

                if (process != null)
                {
                    if (shHandle.ProcessID != process.Id) continue;
                }

                string strObjectTypeName = "";
                if (IN_strObjectTypeName != null){
                     strObjectTypeName = getObjectTypeName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                    if (strObjectTypeName != IN_strObjectTypeName) continue;
                }

                string strObjectName = "";
                if (IN_strObjectName != null){
                     strObjectName = getObjectName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                    if (strObjectName != IN_strObjectName) continue;
                }

                string strObjectTypeName2 = getObjectTypeName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                string strObjectName2 = getObjectName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                Console.WriteLine("{0}   {1}   {2}", shHandle.ProcessID, strObjectTypeName2, strObjectName2);

                lstHandles.Add(shHandle);
            }
            return lstHandles;
        }

        public static bool Is64Bits()
        {
            return Marshal.SizeOf(typeof(IntPtr)) == 8 ? true : false;
        }
    }

    class Program
    {
        static void Main(string[] args)		
        {
		
		try
		{
				WindowsIdentity  identity  = WindowsIdentity.GetCurrent();
				WindowsPrincipal principal = new WindowsPrincipal(identity);
				if (!principal.IsInRole(WindowsBuiltInRole.Administrator))
				{
					Console.WriteLine("===========================================================");
					Console.WriteLine("                                                           ");
					Console.WriteLine("Please Run A3-Unlocker.exe as a \"Run As Administrator\" ");					
					Console.WriteLine("                                                           ");
					Console.WriteLine("===========================================================");
					Console.WriteLine("Press Enter to Exit");
				}
		    else {
            String MutexName = "OnceMutexA3Client";
            String ProcessName = "A3Client";
			bool Violated = false;
			Console.WriteLine("===========================================================");
			Console.WriteLine("                                                           ");			
			Console.WriteLine("Welcome To A3 Unlocker, Lets Kill Some Mutex");
			Console.WriteLine("                                                           ");
			Console.WriteLine("===========================================================");
			Console.WriteLine("                                                           ");
			try {
			Process [] processes = Process.GetProcessesByName(ProcessName);
				if (processes.Length == 0) { 
					Console.WriteLine("NO A3 Client Running");
					Console.WriteLine("                                                           ");
					Console.WriteLine(" Please Run A3 Client First!!!");
					Violated = false;
				}
				 else  {
							Console.WriteLine("{0} A3 Instance", processes.Length);
							foreach (var process in processes ) {
								try
									{                
										var handles = Win32Processes.GetHandles(process, "Mutant", "\\Sessions\\1\\BaseNamedObjects\\" + MutexName);
										if (handles.Count == 0) throw new System.ArgumentException("NoMutex", "original");
										foreach (var handle in handles) {
											IntPtr ipHandle = IntPtr.Zero;
											if (!Win32API.DuplicateHandle(Process.GetProcessById(handle.ProcessID).Handle, handle.Handle, Win32API.GetCurrentProcess(), out ipHandle, 0, false, Win32API.DUPLICATE_CLOSE_SOURCE))
											Console.WriteLine("DuplicateHandle() failed, error = {0}", Marshal.GetLastWin32Error());
											Console.WriteLine("Mutex was killed");
											Violated = true;
											}
									}
            
								catch (ArgumentException)
									{
										Console.WriteLine("The Mutex '{0}' was not found in the process '{1}'", MutexName, ProcessName);
										Violated = true;
									}            
							} 
						}			
				}
			catch (IndexOutOfRangeException)
            {
                Console.WriteLine("NO A3 Client Running");
				Console.WriteLine("                                                           ");
				Console.WriteLine(" Please Run A3 Client First!!!");
				Violated = false;
								
            }
			if (Violated) {
			Console.WriteLine("                                                           ");
			Console.WriteLine("We are done!!! Enjoy");
			Console.WriteLine("                                                           ");
			Console.WriteLine("Must close this EXE before running another A3 Instance. Press Enter to exit");			
			}
		}
		}
		 catch (Exception ex)
		{
			if (ex != null) {}
		}
			Console.ReadLine();
        }
    }
}

Что я уже пробовал:

Я уже пробовал преобразование по приложению, но оно возвращает мне ошибку

#include <string>
#include <vector>
#include <iostream>
#include <stdexcept>

namespace FileLockInfo
    {

    class Win32API
        {
    public:
        enum class ObjectInformationClass : int
            {
            ObjectBasicInformation = 0,
            ObjectNameInformation = 1,
            ObjectTypeInformation = 2,
            ObjectAllTypesInformation = 3,
            ObjectHandleInformation = 4
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [Flags] public enum ProcessAccessFlags : uint
        enum class ProcessAccessFlags : int
            {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct OBJECT_BASIC_INFORMATION
        class OBJECT_BASIC_INFORMATION
            { // Information Class 0
        public:
            int Attributes = 0;
            int GrantedAccess = 0;
            int HandleCount = 0;
            int PointerCount = 0;
            int PagedPoolUsage = 0;
            int NonPagedPoolUsage = 0;
            int Reserved1 = 0;
            int Reserved2 = 0;
            int Reserved3 = 0;
            int NameInformationLength = 0;
            int TypeInformationLength = 0;
            int SecurityDescriptorLength = 0;
            System::Runtime::InteropServices::ComTypes::FILETIME CreateTime;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct OBJECT_TYPE_INFORMATION
        class OBJECT_TYPE_INFORMATION
            { // Information Class 2
        public:
            UNICODE_STRING Name;
            int ObjectCount = 0;
            int HandleCount = 0;
            int Reserved1 = 0;
            int Reserved2 = 0;
            int Reserved3 = 0;
            int Reserved4 = 0;
            int PeakObjectCount = 0;
            int PeakHandleCount = 0;
            int Reserved5 = 0;
            int Reserved6 = 0;
            int Reserved7 = 0;
            int Reserved8 = 0;
            int InvalidAttributes = 0;
            GENERIC_MAPPING GenericMapping;
            int ValidAccess = 0;
            unsigned char Unknown = 0;
            unsigned char MaintainHandleDatabase = 0;
            int PoolType = 0;
            int PagedPoolUsage = 0;
            int NonPagedPoolUsage = 0;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct OBJECT_NAME_INFORMATION
        class OBJECT_NAME_INFORMATION
            { // Information Class 1
        public:
            UNICODE_STRING Name;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct UNICODE_STRING
        class UNICODE_STRING
            {
        public:
            unsigned short Length = 0;
            unsigned short MaximumLength = 0;
            void* Buffer;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct GENERIC_MAPPING
        class GENERIC_MAPPING
            {
        public:
            int GenericRead = 0;
            int GenericWrite = 0;
            int GenericExecute = 0;
            int GenericAll = 0;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct SYSTEM_HANDLE_INFORMATION
        class SYSTEM_HANDLE_INFORMATION
            { // Information Class 16
        public:
            int ProcessID = 0;
            unsigned char ObjectTypeNumber = 0;
            unsigned char Flags = 0; // 0x01 = PROTECT_FROM_CLOSE, 0x02 = INHERIT
            unsigned short Handle = 0;
            int Object_Pointer = 0;
            unsigned int GrantedAccess = 0;
            };

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("ntdll.dll")]
    public:
        __declspec( dllimport ) static int NtQueryObject( IntPtr ObjectHandle, int ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength, int& returnLength );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll", SetLastError = true)]
        __declspec( dllimport ) static unsigned int QueryDosDevice( const std::wstring& lpDeviceName, StringBuilder* lpTargetPath, int ucchMax );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("ntdll.dll")]
        __declspec( dllimport ) static unsigned int NtQuerySystemInformation( int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, int& returnLength );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll", CharSet = CharSet::Auto, SetLastError = true)]
        __declspec( dllimport ) static IntPtr OpenMutex( unsigned int desiredAccess, bool inheritHandle, const std::wstring& name );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll")]
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [DllImport("kernel32.dll")] public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
        __declspec( dllimport ) static IntPtr OpenProcess( ProcessAccessFlags dwDesiredAccess, bool bInheritHandle, int dwProcessId );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll")]
        __declspec( dllimport ) static int CloseHandle( IntPtr hObject );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll", SetLastError = true), return: MarshalAs(UnmanagedType::Bool)]
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [DllImport("kernel32.dll", SetLastError = true)][return: MarshalAs(UnmanagedType.Bool)] public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, ushort hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions);
        __declspec( dllimport ) static bool DuplicateHandle( IntPtr hSourceProcessHandle, unsigned short hSourceHandle, IntPtr hTargetProcessHandle, IntPtr& lpTargetHandle, unsigned int dwDesiredAccess, bool bInheritHandle, unsigned int dwOptions );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll")]
        __declspec( dllimport ) static IntPtr GetCurrentProcess();

        static constexpr int MAX_PATH = 260;
        static constexpr unsigned int STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
        static constexpr int DUPLICATE_SAME_ACCESS = 0x2;
        static constexpr int DUPLICATE_CLOSE_SOURCE = 0x1;
        };

    class Win32Processes
        {
    private:
        static constexpr int CNST_SYSTEM_HANDLE_INFORMATION = 16;
        static constexpr unsigned int STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;

    public:
        static std::wstring getObjectTypeName( Win32API::SYSTEM_HANDLE_INFORMATION shHandle, Process* process )
            {
            void* m_ipProcessHwnd = Win32API::OpenProcess( Win32API::ProcessAccessFlags::All, false, process->Id );
            void* ipHandle = void*::Zero;
            auto objBasic = Win32API::OBJECT_BASIC_INFORMATION();
            void* ipBasic = void*::Zero;
            auto objObjectType = Win32API::OBJECT_TYPE_INFORMATION();
            void* ipObjectType = void*::Zero;
            void* ipObjectName = void*::Zero;
            std::wstring strObjectTypeName = L"";
            int nLength = 0;
            int nReturn = 0;
            void* ipTemp = void*::Zero;

            if ( ! Win32API::DuplicateHandle( m_ipProcessHwnd, shHandle.Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_SAME_ACCESS ) )
                {
                return L"";
                }

            ipBasic = Marshal::AllocHGlobal( System::Runtime::InteropServices::Marshal::SizeOf( objBasic ) );
            Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectBasicInformation ), ipBasic, System::Runtime::InteropServices::Marshal::SizeOf( objBasic ), nLength );
            objBasic = static_cast<Win32API::OBJECT_BASIC_INFORMATION>( Marshal::PtrToStructure( ipBasic, objBasic->GetType() ) );
            Marshal::FreeHGlobal( ipBasic );

            ipObjectType = Marshal::AllocHGlobal( objBasic->TypeInformationLength );
            nLength = objBasic->TypeInformationLength;
            while ( static_cast<unsigned int>( nReturn = Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectTypeInformation ), ipObjectType, nLength, nLength ) ) == Win32API::STATUS_INFO_LENGTH_MISMATCH )
                {
                Marshal::FreeHGlobal( ipObjectType );
                ipObjectType = Marshal::AllocHGlobal( nLength );
                }

            objObjectType = static_cast<Win32API::OBJECT_TYPE_INFORMATION>( Marshal::PtrToStructure( ipObjectType, objObjectType->GetType() ) );
            if ( Is64Bits() )
                {
//C# TO C++ CONVERTER TODO TASK: There is no native C++ equivalent to 'ToString':
                ipTemp = new void*( Convert::ToInt64( objObjectType->Name->Buffer->ToString(), 10 ) >> 32 );
                } else
                    {
                ipTemp = objObjectType->Name->Buffer;
            }

            strObjectTypeName = Marshal::PtrToStringUni( ipTemp, objObjectType->Name->Length >> 1 );
            Marshal::FreeHGlobal( ipObjectType );
            return strObjectTypeName;
            }


        static std::wstring getObjectName( Win32API::SYSTEM_HANDLE_INFORMATION shHandle, Process* process )
            {
            void* m_ipProcessHwnd = Win32API::OpenProcess( Win32API::ProcessAccessFlags::All, false, process->Id );
            void* ipHandle = void*::Zero;
            auto objBasic = Win32API::OBJECT_BASIC_INFORMATION();
            void* ipBasic = void*::Zero;
            void* ipObjectType = void*::Zero;
            auto objObjectName = Win32API::OBJECT_NAME_INFORMATION();
            void* ipObjectName = void*::Zero;
            std::wstring strObjectName = L"";
            int nLength = 0;
            int nReturn = 0;
            void* ipTemp = void*::Zero;

            if ( ! Win32API::DuplicateHandle( m_ipProcessHwnd, shHandle.Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_SAME_ACCESS ) )
                {
                return L"";
                }

            ipBasic = Marshal::AllocHGlobal( System::Runtime::InteropServices::Marshal::SizeOf( objBasic ) );
            Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectBasicInformation ), ipBasic, System::Runtime::InteropServices::Marshal::SizeOf( objBasic ), nLength );
            objBasic = static_cast<Win32API::OBJECT_BASIC_INFORMATION>( Marshal::PtrToStructure( ipBasic, objBasic->GetType() ) );
            Marshal::FreeHGlobal( ipBasic );


            nLength = objBasic->NameInformationLength;

            ipObjectName = Marshal::AllocHGlobal( nLength );
            while ( static_cast<unsigned int>( nReturn = Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectNameInformation ), ipObjectName, nLength, nLength ) ) == Win32API::STATUS_INFO_LENGTH_MISMATCH )
                {
                Marshal::FreeHGlobal( ipObjectName );
                ipObjectName = Marshal::AllocHGlobal( nLength );
                }
            objObjectName = static_cast<Win32API::OBJECT_NAME_INFORMATION>( Marshal::PtrToStructure( ipObjectName, objObjectName->GetType() ) );

            if ( Is64Bits() )
                {
//C# TO C++ CONVERTER TODO TASK: There is no native C++ equivalent to 'ToString':
                ipTemp = new void*( Convert::ToInt64( objObjectName->Name->Buffer->ToString(), 10 ) >> 32 );
                } else
                    {
                ipTemp = objObjectName->Name->Buffer;
            }

            if ( ipTemp != void*::Zero )
                {

                unsigned char baTemp2[ nLength ];
                try
                    {
                    Marshal::Copy( ipTemp, baTemp2, 0, nLength );

                    strObjectName = Marshal::PtrToStringUni( Is64Bits() ? new void*(ipTemp.ToInt64()) : new void*(ipTemp.ToInt32()) );
                    return strObjectName;
                    } catch ( AccessViolationException e1 )
                        {
                    return L"";
                } finally
                    {
                    Marshal::FreeHGlobal( ipObjectName );
                    Win32API::CloseHandle( ipHandle );
                }
                }
            return L"";
            }

        static std::vector<Win32API::SYSTEM_HANDLE_INFORMATION> GetHandles( Process* process = nullptr, const std::wstring& IN_strObjectTypeName = L"", const std::wstring& IN_strObjectName = L"" )
            {
            unsigned int nStatus;
            int nHandleInfoSize = 0x10000;
            void* ipHandlePointer = Marshal::AllocHGlobal( nHandleInfoSize );
            int nLength = 0;
            void* ipHandle = void*::Zero;

            while ( ( nStatus = Win32API::NtQuerySystemInformation( CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer, nHandleInfoSize, nLength ) ) == STATUS_INFO_LENGTH_MISMATCH )
                {
                nHandleInfoSize = nLength;
                Marshal::FreeHGlobal( ipHandlePointer );
                ipHandlePointer = Marshal::AllocHGlobal( nLength );
                }

            unsigned char baTemp[ nLength ];
            Marshal::Copy( ipHandlePointer, baTemp, 0, nLength );

            long long lHandleCount = 0;
            if ( Is64Bits() )
                {
                lHandleCount = Marshal::ReadInt64( ipHandlePointer );
                ipHandle = new void*( ipHandlePointer.ToInt64() + 8 );
                } else
                    {
                lHandleCount = Marshal::ReadInt32( ipHandlePointer );
                ipHandle = new void*( ipHandlePointer.ToInt32() + 4 );
            }

            Win32API::SYSTEM_HANDLE_INFORMATION shHandle;
            std::vector<Win32API::SYSTEM_HANDLE_INFORMATION> lstHandles = std::vector<Win32API::SYSTEM_HANDLE_INFORMATION>();

            for ( long long lIndex = 0; lIndex < lHandleCount; lIndex ++ )
                {
                shHandle = Win32API::SYSTEM_HANDLE_INFORMATION();
                if ( Is64Bits() )
                    {
                    shHandle = static_cast<Win32API::SYSTEM_HANDLE_INFORMATION>( Marshal::PtrToStructure( ipHandle, shHandle.GetType() ) );
                    ipHandle = new void*( ipHandle.ToInt64() + System::Runtime::InteropServices::Marshal::SizeOf(shHandle) + 8 );
                    } else
                        {
                    ipHandle = new void*( ipHandle.ToInt64() + System::Runtime::InteropServices::Marshal::SizeOf(shHandle) );
                    shHandle = static_cast<Win32API::SYSTEM_HANDLE_INFORMATION>( Marshal::PtrToStructure( ipHandle, shHandle.GetType() ) );
                }

                if ( process != nullptr )
                    {
                    if ( shHandle.ProcessID != process->Id )
                        {
                        continue;
                        }
                    }

                std::wstring strObjectTypeName = L"";
                if ( IN_strObjectTypeName != L"" )
                    {
                     strObjectTypeName = getObjectTypeName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                    if ( strObjectTypeName != IN_strObjectTypeName )
                        {
                        continue;
                        }
                    }

                std::wstring strObjectName = L"";
                if ( IN_strObjectName != L"" )
                    {
                     strObjectName = getObjectName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                    if ( strObjectName != IN_strObjectName )
                        {
                        continue;
                        }
                    }

                std::wstring strObjectTypeName2 = getObjectTypeName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                std::wstring strObjectName2 = getObjectName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                std::cout << shHandle.ProcessID << std::wstring( L"   " ) << strObjectTypeName2 << std::wstring( L"   " ) << strObjectName2 << std::endl;

                lstHandles.push_back( shHandle );
                }
            return lstHandles;
            }

        static bool Is64Bits()
            {
            return System::Runtime::InteropServices::Marshal::SizeOf( void*::typeid ) == 8 ? true : false;
            }
        };

    class Program
        {
        static void Main( std::wstring& args[] )
            {

        try
            {
                WindowsIdentity* identity = WindowsIdentity::GetCurrent();
                WindowsPrincipal* principal = new WindowsPrincipal( identity );
                if ( ! principal->IsInRole( WindowsBuiltInRole::Administrator ) )
                    {
                    std::cout << std::wstring( L"===========================================================" ) << std::endl;
                    std::cout << std::wstring( L"                                                           " ) << std::endl;
                    std::cout << std::wstring( L"Please Run A3-Unlocker.exe as a \"Run As Administrator\" " ) << std::endl;
                    std::cout << std::wstring( L"                                                           " ) << std::endl;
                    std::cout << std::wstring( L"===========================================================" ) << std::endl;
                    std::cout << std::wstring( L"Press Enter to Exit" ) << std::endl;
                    } else
                        {
            std::wstring MutexName = L"OnceMutexA3Client";
            std::wstring ProcessName = L"A3Client";
            bool Violated = false;
            std::cout << std::wstring( L"===========================================================" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"Welcome To A3 Unlocker, Lets Kill Some Mutex" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"===========================================================" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            try
                {
//C# TO C++ CONVERTER WARNING: Since the array size is not known in this declaration, C# to C++ Converter has converted this array to a pointer.  You will need to call 'delete[]' where appropriate:
//ORIGINAL LINE: Process [] processes = Process.GetProcessesByName(ProcessName);
            Process* processes = Process::GetProcessesByName( ProcessName );
                if ( processes->Length == 0 )
                    {
                    std::cout << std::wstring( L"NO A3 Client Running" ) << std::endl;
                    std::cout << std::wstring( L"                                                           " ) << std::endl;
                    std::cout << std::wstring( L" Please Run A3 Client First!!!" ) << std::endl;
                    Violated = false;
                    } else
                        {
                            std::cout << processes->Length << std::endl;
                            for ( auto process : processes )
                                {
                                try
                                    {
                                        auto handles = Win32Processes::GetHandles( process, L"Mutant", std::wstring( L"\\Sessions\\1\\BaseNamedObjects\\" ) + MutexName );
                                        if ( handles->Count == 0 )
                                            {
                                            throw System::ArgumentException( L"NoMutex", L"original" );
                                            }
                                        for ( auto handle : handles )
                                            {
                                            void* ipHandle = void*::Zero;
                                            if ( ! Win32API::DuplicateHandle( Process::GetProcessById( handle->ProcessID )->Handle, handle->Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_CLOSE_SOURCE ) )
                                                {
                                            std::cout << std::wstring( L"DuplicateHandle() failed, error = " ) << Marshal::GetLastWin32Error() << std::endl;
                                                }
                                            std::cout << std::wstring( L"Mutex was killed" ) << std::endl;
                                            Violated = true;
                                            }
                                    }

                                catch ( ArgumentException e1 )
                                    {
                                        std::cout << std::wstring( L"The Mutex '" ) << MutexName << std::wstring( L"' was not found in the process '" ) << ProcessName << std::endl;
                                        Violated = true;
                                    }
                                }
                        }
                } catch ( IndexOutOfRangeException e2 )
                    {
                std::cout << std::wstring( L"NO A3 Client Running" ) << std::endl;
                std::cout << std::wstring( L"                                                           " ) << std::endl;
                std::cout << std::wstring( L" Please Run A3 Client First!!!" ) << std::endl;
                Violated = false;

            }
            if ( Violated )
                {
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"We are done!!! Enjoy" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"Must close this EXE before running another A3 Instance. Press Enter to exit" ) << std::endl;
                }
        }
            } catch ( std::exception& ex )
                {
            if ( ex != nullptr )
                {
                }
        }
            Console::ReadLine();
            }
        };
    }

---