C# GCHandle.Free方法代码示例

        static void Main(string[] args)
        {
            Console.Write("Enter Passphrase: ");
            using (var passphrase = GetPassphraseFromConsole())
            {
                Console.WriteLine("Your password:");

                RuntimeHelpers.PrepareConstrainedRegions();

                unsafe
                {
                    var arPass = new char[passphrase.Length];

                    var handle = new GCHandle();

                    System.IntPtr ptr = System.IntPtr.Zero;

                    ptr = Marshal.SecureStringToBSTR(passphrase);

                    char* ptrPassword = (char*)ptr;

                    RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(
                        (uData) =>
                        {
                            handle = GCHandle.Alloc(arPass, System.Runtime.InteropServices.GCHandleType.Pinned);

                            ptrPassword = (char*)ptr;

                            char* ptrArPass = (char*)handle.AddrOfPinnedObject();

                            for (var ii = 0; ii < arPass.Length; ii++)
                            {
                                ptrArPass[ii] = ptrPassword[ii];
                            }

                            Console.WriteLine(arPass);
                        },

                        (uData, exceptionThrown) =>
                        {
                            if (exceptionThrown)
                            {
                                Console.WriteLine("Exception thrown.");
                            }

                            Marshal.ZeroFreeBSTR(ptr);

                            for (var ii = 0; ii < arPass.Length; ii++)
                            {
                                arPass[ii] = '\0';
                            }

                            handle.Free();

                        },
                            null
                        );
                }
            }
        }

        public static void FreeString(ref GCHandle handle)
        {
            if (handle == NullHandle)
                return;

            handle.Free();
        }

        private int Invoke(SOCKET socket)
        {
            _recvOverlapped.hEvent = SocketImports.WSACreateEvent();
            if (_recvOverlapped.hEvent == IntPtr.Zero)
            {
                // dead, close socket?
                return -1;
            }

            _gcWSABuffer = GCHandle.Alloc(_WSABuffer, GCHandleType.Pinned);
            var lpWSABuffer = (WSABuffer*)_gcWSABuffer.AddrOfPinnedObject();

            _gcRecvOverlapped = GCHandle.Alloc(_recvOverlapped, GCHandleType.Pinned);
            var plRecvOverlapped = (WSAOverlapped*)_gcRecvOverlapped.AddrOfPinnedObject();

            int rc = SocketImports.WSARecv(socket, lpWSABuffer, 1, out _bytesTransferred, ref _socketFlags, plRecvOverlapped, IntPtr.Zero);

            _gcWSABuffer.Free();
            _gcRecvOverlapped.Free();

            if (rc == SocketImports.SOCKET_ERROR)
            {
                int err = SocketImports.WSAGetLastError();
                if (SocketImports.WSA_IO_PENDING != err)
                {
                    Console.WriteLine("WSARecv failed with error: {0}/{1}", rc, err);
                }
            }

            return rc;
        }

        public void Execute()
        {
            // Create GS Instance (GS-API)
            gsapi_new_instance(out _gsInstancePtr, IntPtr.Zero);
            // Build Argument Arrays
            _gsArgStrHandles = new GCHandle[_gsParams.Count];
            _gsArgPtrs = new IntPtr[_gsParams.Count];

            // Populate Argument Arrays
            for (int i = 0; i < _gsParams.Count; i++)
            {
                _gsArgStrHandles[i] = GCHandle.Alloc(System.Text.ASCIIEncoding.ASCII.GetBytes(_gsParams[i].ToString()), GCHandleType.Pinned);
                _gsArgPtrs[i] = _gsArgStrHandles[i].AddrOfPinnedObject();
            }

            // Allocate memory that is protected from Garbage Collection
            _gsArgPtrsHandle = GCHandle.Alloc(_gsArgPtrs, GCHandleType.Pinned);
            // Init args with GS instance (GS-API)
            gsapi_init_with_args(_gsInstancePtr, _gsArgStrHandles.Length, _gsArgPtrsHandle.AddrOfPinnedObject());
            // Free unmanaged memory
            for (int i = 0; i < _gsArgStrHandles.Length; i++)
                _gsArgStrHandles[i].Free();
            _gsArgPtrsHandle.Free();

            // Exit the api (GS-API)
            gsapi_exit(_gsInstancePtr);
            // Delete GS Instance (GS-API)
            gsapi_delete_instance(_gsInstancePtr);
        }

        public static string MongoPasswordDigest(string username, SecureString password)
        {
            using (var md5 = MD5.Create())
            {
                var bytes = Utf8Encodings.Strict.GetBytes(username + ":mongo:");
                md5.TransformBlock(bytes, 0, bytes.Length, null, 0);

                IntPtr unmanagedPassword = IntPtr.Zero;
                try
                {
                    unmanagedPassword = Marshal.SecureStringToBSTR(password);
                    var passwordChars = new char[password.Length];
                    GCHandle passwordCharsHandle = new GCHandle();
                    try
                    {
                        passwordCharsHandle = GCHandle.Alloc(passwordChars, GCHandleType.Pinned);
                        Marshal.Copy(unmanagedPassword, passwordChars, 0, passwordChars.Length);

                        var byteCount = Utf8Encodings.Strict.GetByteCount(passwordChars);
                        var passwordBytes = new byte[byteCount];
                        GCHandle passwordBytesHandle = new GCHandle();
                        try
                        {
                            passwordBytesHandle = GCHandle.Alloc(passwordBytesHandle, GCHandleType.Pinned);
                            Utf8Encodings.Strict.GetBytes(passwordChars, 0, passwordChars.Length, passwordBytes, 0);
                            md5.TransformFinalBlock(passwordBytes, 0, passwordBytes.Length);
                            return BsonUtils.ToHexString(md5.Hash);
                        }
                        finally
                        {
                            Array.Clear(passwordBytes, 0, passwordBytes.Length);

                            if (passwordBytesHandle.IsAllocated)
                            {
                                passwordBytesHandle.Free();
                            }
                        }
                    }
                    finally
                    {
                        Array.Clear(passwordChars, 0, passwordChars.Length);

                        if (passwordCharsHandle.IsAllocated)
                        {
                            passwordCharsHandle.Free();
                        }
                    }
                }
                finally
                {
                    if (unmanagedPassword != IntPtr.Zero)
                    {
                        Marshal.ZeroFreeBSTR(unmanagedPassword);
                    }
                }
            }
        }

        public static void DibToFile(Stream stream, string filePath)
        {
            // Read the DIB into a Byte array and pin it
            // This is necessary because some of the unmanaged calls
            // need a pointer to the Dib bytes.
            byte[] bytes = new byte[stream.Length];
            stream.Read(bytes, 0, (int)stream.Length);

            string imagePath = string.Empty;
            GCHandle gcHandle = new GCHandle();
            try
            {
                gcHandle = GCHandle.Alloc(bytes, GCHandleType.Pinned);

                // Reset the stream position since it was read into the byte array
                // Get the bitmapInfoHeader so we can do some calculations
                stream.Position = 0;
                BITMAPINFOHEADER bmpInfoHeader = GetBitMapInfoHeader(stream);
                if ((bmpInfoHeader.biClrUsed == 0) && (bmpInfoHeader.biBitCount < 16))
                    bmpInfoHeader.biClrUsed = 1 << bmpInfoHeader.biBitCount;

                // Get IntPtrs for the DIB itself as well as for the actual pixels in the DIB
                IntPtr dibPtr = Marshal.UnsafeAddrOfPinnedArrayElement(bytes, 0);
                IntPtr pixPtr = new IntPtr((int)dibPtr + bmpInfoHeader.biSize + (bmpInfoHeader.biClrUsed * 4));

                // Get a GDI Bitmap
                IntPtr img = IntPtr.Zero;

                try
                {
                    int st = GdiPlus.GdipCreateBitmapFromGdiDib(dibPtr, pixPtr, ref img);

                    // Couldn't create bitmap, return null and log
                    if ((st != 0) || (img == IntPtr.Zero))
                    {
                        throw new DIBHelperException("Couldn't get DIB IntPtr");
                    }

                    // Write the bitmap to a file of the specified type
                    Guid clsid = GetCodecClsid(filePath);
                    st = GdiPlus.GdipSaveImageToFile(img, filePath, ref clsid, IntPtr.Zero);
                    if (st != 0)
                    {
                        throw new DIBHelperException("Couldn't write Dib to File");
                    }
                }
                finally
                {
                    // Dispose of resources
                    GdiPlus.GdipDisposeImage(img);
                }
            }
            finally
            {
                gcHandle.Free();
            }
        }

        public WaveRecorder(int deviceIndex, double sampleRate, int framesPerBuffer, AudioBufferAvailableDelegate bufferAvailable)
        {
            _bufferAvailable = bufferAvailable;

            var inputParams = new PaStreamParameters();
            inputParams.device = deviceIndex;
            inputParams.channelCount = 2;
            inputParams.suggestedLatency = 0;
            inputParams.sampleFormat = PaSampleFormat.PaFloat32;

            var pe = PortAudioAPI.Pa_IsFormatSupported(ref inputParams, IntPtr.Zero, sampleRate);
            if (pe != PaError.paNoError)
            {
                throw new ApplicationException(pe.ToString());
            }

            _gcHandle = GCHandle.Alloc(this);

            pe = PortAudioAPI.Pa_OpenStream(
                out _streamHandle,
                ref inputParams,
                IntPtr.Zero,
                sampleRate,
                (uint) framesPerBuffer,
                PaStreamFlags.PaNoFlag,
                _paCallback,
                (IntPtr) _gcHandle);

            if (pe != PaError.paNoError)
            {
                _gcHandle.Free();
                throw new ApplicationException(pe.ToString());
            }

            pe = PortAudioAPI.Pa_StartStream(_streamHandle);
            if (pe != PaError.paNoError)
            {
                PortAudioAPI.Pa_CloseStream(_streamHandle);
                _gcHandle.Free();
                throw new ApplicationException(pe.ToString());
            }
        }

 public static ModuleInfo[] GetModuleInfos(int processId)
 {
     IntPtr ptr = (IntPtr) (-1);
     GCHandle handle = new GCHandle();
     ArrayList list = new ArrayList();
     try
     {
         ptr = Microsoft.Win32.NativeMethods.CreateToolhelp32Snapshot(8, processId);
         if (ptr == ((IntPtr) (-1)))
         {
             throw new Win32Exception();
         }
         int num = Marshal.SizeOf(typeof(Microsoft.Win32.NativeMethods.WinModuleEntry));
         int val = (num + 260) + 0x100;
         int[] numArray = new int[val / 4];
         handle = GCHandle.Alloc(numArray, GCHandleType.Pinned);
         IntPtr ptr2 = handle.AddrOfPinnedObject();
         Marshal.WriteInt32(ptr2, val);
         HandleRef ref2 = new HandleRef(null, ptr);
         if (Microsoft.Win32.NativeMethods.Module32First(ref2, ptr2))
         {
             do
             {
                 Microsoft.Win32.NativeMethods.WinModuleEntry structure = new Microsoft.Win32.NativeMethods.WinModuleEntry();
                 Marshal.PtrToStructure(ptr2, structure);
                 ModuleInfo info = new ModuleInfo {
                     baseName = Marshal.PtrToStringAnsi((IntPtr) (((long) ptr2) + num)),
                     fileName = Marshal.PtrToStringAnsi((IntPtr) ((((long) ptr2) + num) + 0x100L)),
                     baseOfDll = structure.modBaseAddr,
                     sizeOfImage = structure.modBaseSize,
                     Id = structure.th32ModuleID
                 };
                 list.Add(info);
                 Marshal.WriteInt32(ptr2, val);
             }
             while (Microsoft.Win32.NativeMethods.Module32Next(ref2, ptr2));
         }
     }
     finally
     {
         if (handle.IsAllocated)
         {
             handle.Free();
         }
         if (ptr != ((IntPtr) (-1)))
         {
             Microsoft.Win32.SafeNativeMethods.CloseHandle(new HandleRef(null, ptr));
         }
     }
     ModuleInfo[] array = new ModuleInfo[list.Count];
     list.CopyTo(array, 0);
     return array;
 }

 public void GDIRead()
 {
     CheckDisposed();
     if (source.IsLocked) throw new
         glResourceLockedException(source);
     gcHandle = GCHandle.Alloc(source.Data, GCHandleType.Pinned);
     var bitmapData = bitmap.LockBits(bitmapRect, ImageLockMode
         .ReadOnly, PixelFormat.Format32bppArgb);
     IntPtr dataHandle = gcHandle.AddrOfPinnedObject();
     NativeMethods.CopyMemory(dataHandle,
         bitmapData.Scan0, (uint)source.SizeInBytes);
     bitmap.UnlockBits(bitmapData);
     gcHandle.Free();
 }

        public void PopulateCrlWrapperFields(byte[] CrlFileBinary)
        {
            var phCertStore = IntPtr.Zero;
            var pvContext = IntPtr.Zero;
            var hCrlData = new GCHandle();
            var hCryptBlob = new GCHandle();
            try
            {
                hCrlData = GCHandle.Alloc(CrlFileBinary, GCHandleType.Pinned);
                WinCrypt32.CRYPTOAPI_BLOB stCryptBlob;
                stCryptBlob.cbData = CrlFileBinary.Length;
                stCryptBlob.pbData = hCrlData.AddrOfPinnedObject();
                hCryptBlob = GCHandle.Alloc(stCryptBlob, GCHandleType.Pinned);

                if (!WinCrypt32.CryptQueryObject(
                WinCrypt32.CERT_QUERY_OBJECT_BLOB,
                hCryptBlob.AddrOfPinnedObject(),
                WinCrypt32.CERT_QUERY_CONTENT_FLAG_CRL,
                WinCrypt32.CERT_QUERY_FORMAT_FLAG_BINARY,
                0,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero,
                ref phCertStore,
                IntPtr.Zero,
                ref pvContext
                ))
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error(), "CRL is Corrupted.");
                }

                var stCrlContext = (WinCrypt32.CRL_CONTEXT)Marshal.PtrToStructure(pvContext, typeof(WinCrypt32.CRL_CONTEXT));
                var stCrlInfo = (WinCrypt32.CRL_INFO)Marshal.PtrToStructure(stCrlContext.pCrlInfo, typeof(WinCrypt32.CRL_INFO));

                _validUntil = ReadFromFileTime(stCrlInfo.NextUpdate);
                _validFrom = ReadFromFileTime(stCrlInfo.ThisUpdate);
                PopulateRevokedSerialNumbers(stCrlInfo);

            }
            finally
            {
                if (hCrlData.IsAllocated) hCrlData.Free();
                if (hCryptBlob.IsAllocated) hCryptBlob.Free();
                if (!pvContext.Equals(IntPtr.Zero))
                {
                    WinCrypt32.CertFreeCRLContext(pvContext);
                }
            }
        }

 public unsafe void Init(byte[] buffer, int offset, int capacityWords, int activeWords)
 {
     if (activeWords < capacityWords) Array.Clear(buffer, offset, capacityWords - activeWords);
     var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
     try
     {
         var ptr = (byte*)handle.AddrOfPinnedObject();
         base.Initialize(new IntPtr(ptr + offset), capacityWords, activeWords);
         this.handle = handle;
         handle = default(GCHandle);
     }
     finally
     {
         if (handle.IsAllocated) handle.Free();
     }
 }

		private void MainCycle()
		{
			var cb = new Event.D.evhttp_request_callback (RequestHandler);
			_httpCallbackHandle = GCHandle.Alloc (cb);
			Event.EvHttpSetAllowedMethods (_evHttp, EvHttpCmdType.All);
			Event.EvHttpSetGenCb (_evHttp, cb, GCHandle.ToIntPtr (_httpCallbackHandle));

			var syncCb = new Event.D.event_callback (SyncCallback);
			_syncCbHandle = GCHandle.Alloc (syncCb);
			using (_syncCbEvent = Event.EventNew(_eventBase, -1, 0, syncCb, IntPtr.Zero))
			{
				while (!_stop)
				{
					Event.EventBaseDispatch(_eventBase);
				}
			}
			//We've recieved loopbreak from actual Dispose, so dispose now
			DoDispose ();
			_httpCallbackHandle.Free ();
			_syncCbHandle.Free ();
		}

 public override Object ReadGameData(Boolean forSpotter)
 {
     lock (this)
     {
         pCarsAPIStruct _pcarsapistruct = new pCarsAPIStruct();
         if (!initialised)
         {
             if (!InitialiseInternal())
             {
                 throw new GameDataReadException("Failed to initialise shared memory");
             }
         }
         try
         {
             using (var sharedMemoryStreamView = memoryMappedFile.CreateViewStream())
             {
                 BinaryReader _SharedMemoryStream = new BinaryReader(sharedMemoryStreamView);
                 sharedMemoryReadBuffer = _SharedMemoryStream.ReadBytes(sharedmemorysize);
                 handle = GCHandle.Alloc(sharedMemoryReadBuffer, GCHandleType.Pinned);
                 _pcarsapistruct = (pCarsAPIStruct)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(pCarsAPIStruct));
                 //Console.WriteLine(_pcarsapistruct.mSpeed);
                 handle.Free();
             }
             PCarsStructWrapper structWrapper = new PCarsStructWrapper();
             structWrapper.ticksWhenRead = DateTime.Now.Ticks;
             structWrapper.data = _pcarsapistruct;
             if (!forSpotter && dumpToFile && dataToDump != null && _pcarsapistruct.mTrackLocation != null &&
                 _pcarsapistruct.mTrackLocation.Length > 0)
             {
                 dataToDump.Add(structWrapper);
             }
             return structWrapper;
         }
         catch (Exception ex)
         {
             throw new GameDataReadException(ex.Message, ex);
         }
     }
 }

 public override Object ReadGameData(Boolean forSpotter)
 {
     lock (this)
     {
         RaceRoomShared _raceroomapistruct = new RaceRoomShared();
         if (!initialised)
         {
             if (!InitialiseInternal())
             {
                 throw new GameDataReadException("Failed to initialise shared memory");
             }
         }
         try
         {
             using (var sharedMemoryStreamView = memoryMappedFile.CreateViewStream())
             {
                 BinaryReader _SharedMemoryStream = new BinaryReader(sharedMemoryStreamView);
                 sharedMemoryReadBuffer = _SharedMemoryStream.ReadBytes(sharedmemorysize);
                 handle = GCHandle.Alloc(sharedMemoryReadBuffer, GCHandleType.Pinned);
                 _raceroomapistruct = (RaceRoomShared)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(RaceRoomShared));
                 handle.Free();
             }
             R3EStructWrapper structWrapper = new R3EStructWrapper();
             structWrapper.ticksWhenRead = DateTime.Now.Ticks;
             structWrapper.data = _raceroomapistruct;
             if (!forSpotter && dumpToFile && dataToDump != null)
             {
                 dataToDump.Add(structWrapper);
             }
             return structWrapper;
         }
         catch (Exception ex)
         {
             throw new GameDataReadException(ex.Message, ex);
         }
     }
 }

        public static Signal DeserializeFromStream(Stream stream)
        {
            Contract.Requires<ArgumentNullException>(stream != null);

            using (var reader = new BinaryReader(stream))
            {
                var streamHeader = Encoding.ASCII.GetString(reader.ReadBytes(4));
                if (!streamHeader.StartsWith("TMB"))
                {
                    throw new NotSupportedException($"File is not supported. Invalid header: {streamHeader}.");
                }
                var handle = new GCHandle();
                SignalHeader header;
                try
                {
                    var data = reader.ReadBytes(Marshal.SizeOf(typeof (SignalHeader)));
                    handle = GCHandle.Alloc(data, GCHandleType.Pinned);
                    header = (SignalHeader) Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof (SignalHeader));
                }
                finally
                {
                    if (handle.IsAllocated)
                    {
                        handle.Free();
                    }
                }
                var buffer = new byte[stream.Length - stream.Position];
                reader.BaseStream.Read(buffer, 0, buffer.Length);
                var values = Enumerable.Range(0, buffer.Length)
                    .Where(x => x%4 == 0)
                    .Select(i => BitConverter.ToSingle(buffer, i))
                    .Select(Convert.ToDouble)
                    .ToArray();
                return new Signal(header, values);
            }
        }