From 72bae110738dfae7110e35f40c97db5bf2d931fa Mon Sep 17 00:00:00 2001 From: Phyxion Date: Tue, 5 Sep 2017 13:29:07 +0200 Subject: [PATCH 1/9] Fixed InstallFolder exception This folder does not always exist. --- Facepunch.Steamworks/Client.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Facepunch.Steamworks/Client.cs b/Facepunch.Steamworks/Client.cs index 32419bd..e70ee7a 100644 --- a/Facepunch.Steamworks/Client.cs +++ b/Facepunch.Steamworks/Client.cs @@ -114,7 +114,8 @@ namespace Facepunch.Steamworks SteamId = native.user.GetSteamID(); BetaName = native.apps.GetCurrentBetaName(); OwnerSteamId = native.apps.GetAppOwner(); - InstallFolder = new DirectoryInfo( native.apps.GetAppInstallDir( AppId ) ); + if (!String.IsNullOrEmpty(native.apps.GetAppInstallDir(AppId)) && Directory.Exists(native.apps.GetAppInstallDir(AppId))) + InstallFolder = new DirectoryInfo( native.apps.GetAppInstallDir( AppId ) ); BuildId = native.apps.GetAppBuildId(); CurrentLanguage = native.apps.GetCurrentGameLanguage(); AvailableLanguages = native.apps.GetAvailableGameLanguages().Split( new[] {';'}, StringSplitOptions.RemoveEmptyEntries ); // TODO: Assumed colon separated From e8b6f31bb2015eca742100dfddb3ff8bd6a42f77 Mon Sep 17 00:00:00 2001 From: Phyxion Date: Tue, 5 Sep 2017 13:53:29 +0200 Subject: [PATCH 2/9] Update Client.cs --- Facepunch.Steamworks/Client.cs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Facepunch.Steamworks/Client.cs b/Facepunch.Steamworks/Client.cs index e70ee7a..d8c5490 100644 --- a/Facepunch.Steamworks/Client.cs +++ b/Facepunch.Steamworks/Client.cs @@ -114,8 +114,9 @@ namespace Facepunch.Steamworks SteamId = native.user.GetSteamID(); BetaName = native.apps.GetCurrentBetaName(); OwnerSteamId = native.apps.GetAppOwner(); - if (!String.IsNullOrEmpty(native.apps.GetAppInstallDir(AppId)) && Directory.Exists(native.apps.GetAppInstallDir(AppId))) - InstallFolder = new DirectoryInfo( native.apps.GetAppInstallDir( AppId ) ); + var appInstallDir = native.apps.GetAppInstallDir(AppId); + if (!String.IsNullOrEmpty(appInstallDir) && Directory.Exists(appInstallDir)) + InstallFolder = new DirectoryInfo(appInstallDir); BuildId = native.apps.GetAppBuildId(); CurrentLanguage = native.apps.GetCurrentGameLanguage(); AvailableLanguages = native.apps.GetAvailableGameLanguages().Split( new[] {';'}, StringSplitOptions.RemoveEmptyEntries ); // TODO: Assumed colon separated From d7fd203c028defcb0f96c64b204934aac56b8681 Mon Sep 17 00:00:00 2001 From: Leonardo D'Aubeterre Date: Thu, 14 Sep 2017 17:18:52 +0200 Subject: [PATCH 3/9] Update README.md Change the Create Server example to reflect the latest version. --- README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 30d4f9e..3002faf 100644 --- a/README.md +++ b/README.md @@ -63,7 +63,11 @@ Or use it in a using block if you can. To create a server do this. ```csharp -var server = new Facepunch.Steamworks.Server( 252490, 0, 28015, true, "MyGame453" ); +ServerInit options = new ServerInit("GameDirectoryName", "GameDescription"); +``` + +```csharp +var server = new Facepunch.Steamworks.Server(252490, options); ``` This will register a secure server for game 252490, any ip, port 28015. Again, more usage in the Facepunch.Steamworks.Test project. From 60933de24019a0680428b4a66a44241f46011323 Mon Sep 17 00:00:00 2001 From: Rohan Singh Date: Thu, 26 Oct 2017 09:35:09 -0400 Subject: [PATCH 4/9] Don't require unsafe to use voice --- Facepunch.Steamworks.Test/Client/Voice.cs | 10 ++--- Facepunch.Steamworks/Client.cs | 1 - Facepunch.Steamworks/Client/Voice.cs | 53 ++++++++++++++--------- 3 files changed, 37 insertions(+), 27 deletions(-) diff --git a/Facepunch.Steamworks.Test/Client/Voice.cs b/Facepunch.Steamworks.Test/Client/Voice.cs index 46c4c8a..a894179 100644 --- a/Facepunch.Steamworks.Test/Client/Voice.cs +++ b/Facepunch.Steamworks.Test/Client/Voice.cs @@ -21,17 +21,17 @@ namespace Facepunch.Steamworks.Test int unCompressed = 0; int compressed = 0; - client.Voice.OnCompressedData = ( ptr, length ) => + client.Voice.OnCompressedData = ( buffer, length ) => { compressed += length; - if ( !client.Voice.Decompress( ptr, 0, length, decompressStream ) ) + if ( !client.Voice.Decompress( buffer, length, decompressStream ) ) { Assert.Fail( "Decompress returned false" ); } }; - client.Voice.OnUncompressedData = ( ptr, length ) => + client.Voice.OnUncompressedData = ( buffer, length ) => { unCompressed += length; }; @@ -62,7 +62,7 @@ namespace Facepunch.Steamworks.Test { int compressed = 0; - client.Voice.OnCompressedData = ( ptr, length ) => + client.Voice.OnCompressedData = ( buffer, length ) => { compressed += length; }; @@ -89,7 +89,7 @@ namespace Facepunch.Steamworks.Test { int unCompressed = 0; - client.Voice.OnUncompressedData = ( ptr, length ) => + client.Voice.OnUncompressedData = ( buffer, length ) => { unCompressed += length; }; diff --git a/Facepunch.Steamworks/Client.cs b/Facepunch.Steamworks/Client.cs index d8c5490..0a4bbb6 100644 --- a/Facepunch.Steamworks/Client.cs +++ b/Facepunch.Steamworks/Client.cs @@ -158,7 +158,6 @@ namespace Facepunch.Steamworks { if ( Voice != null ) { - Voice.Dispose(); Voice = null; } diff --git a/Facepunch.Steamworks/Client/Voice.cs b/Facepunch.Steamworks/Client/Voice.cs index c4e5846..fa0cf68 100644 --- a/Facepunch.Steamworks/Client/Voice.cs +++ b/Facepunch.Steamworks/Client/Voice.cs @@ -7,19 +7,19 @@ using System.Text; namespace Facepunch.Steamworks { - public class Voice : IDisposable + public class Voice { const int ReadBufferSize = 1024 * 128; internal Client client; - internal IntPtr ReadCompressedBuffer; - internal IntPtr ReadUncompressedBuffer; + internal byte[] ReadCompressedBuffer = new byte[ReadBufferSize]; + internal byte[] ReadUncompressedBuffer = new byte[ReadBufferSize]; internal byte[] UncompressBuffer = new byte[1024 * 256]; - public Action OnCompressedData; - public Action OnUncompressedData; + public Action OnCompressedData; + public Action OnUncompressedData; private System.Diagnostics.Stopwatch UpdateTimer = System.Diagnostics.Stopwatch.StartNew(); @@ -73,21 +73,12 @@ namespace Facepunch.Steamworks internal Voice( Client client ) { this.client = client; - - ReadCompressedBuffer = Marshal.AllocHGlobal( ReadBufferSize ); - ReadUncompressedBuffer = Marshal.AllocHGlobal( ReadBufferSize ); - } - - public void Dispose() - { - Marshal.FreeHGlobal( ReadCompressedBuffer ); - Marshal.FreeHGlobal( ReadUncompressedBuffer ); } /// /// This gets called inside Update - so there's no need to call this manually if you're calling update /// - public void Update() + public unsafe void Update() { if ( OnCompressedData == null && OnUncompressedData == null ) return; @@ -109,9 +100,13 @@ namespace Facepunch.Steamworks return; } - result = client.native.user.GetVoice( OnCompressedData != null, ReadCompressedBuffer, ReadBufferSize, out bufferCompressedLastWrite, - OnUncompressedData != null, (IntPtr) ReadUncompressedBuffer, ReadBufferSize, out bufferRegularLastWrite, - DesiredSampleRate == 0 ? OptimalSampleRate : DesiredSampleRate ); + fixed (byte* compressedPtr = ReadCompressedBuffer) + fixed (byte* uncompressedPtr = ReadUncompressedBuffer) + { + result = client.native.user.GetVoice( OnCompressedData != null, (IntPtr) compressedPtr, ReadBufferSize, out bufferCompressedLastWrite, + OnUncompressedData != null, (IntPtr) uncompressedPtr, ReadBufferSize, out bufferRegularLastWrite, + DesiredSampleRate == 0 ? OptimalSampleRate : DesiredSampleRate ); + } IsRecording = true; @@ -136,15 +131,31 @@ namespace Facepunch.Steamworks } - public unsafe bool Decompress( byte[] input, MemoryStream output, uint samepleRate = 0 ) + public bool Decompress( byte[] input, MemoryStream output, uint samepleRate = 0 ) { + return Decompress( input, 0, input.Length, output, samepleRate ); + } + + public bool Decompress( byte[] input, int inputsize, MemoryStream output, uint samepleRate = 0 ) + { + return Decompress( input, 0, inputsize, output, samepleRate ); + } + + public unsafe bool Decompress( byte[] input, int inputoffset, int inputsize, MemoryStream output, uint samepleRate = 0 ) + { + if ( inputoffset < 0 || inputoffset >= input.Length ) + throw new ArgumentOutOfRangeException( "inputoffset" ); + + if ( inputsize <= 0 || inputoffset + inputsize > input.Length ) + throw new ArgumentOutOfRangeException( "inputsize" ); + fixed ( byte* p = input ) { - return Decompress( (IntPtr)p, 0, input.Length, output, samepleRate ); + return Decompress( (IntPtr)p, inputoffset, inputsize, output, samepleRate ); } } - public unsafe bool Decompress( IntPtr input, int inputoffset, int inputsize, MemoryStream output, uint samepleRate = 0 ) + private unsafe bool Decompress( IntPtr input, int inputoffset, int inputsize, MemoryStream output, uint samepleRate = 0 ) { if ( samepleRate == 0 ) samepleRate = OptimalSampleRate; From 7d30ffc73414be91945823b257d23f7b8080ab89 Mon Sep 17 00:00:00 2001 From: James King Date: Mon, 6 Nov 2017 20:42:50 +0000 Subject: [PATCH 5/9] Replaced `NETCORE` defines with `NET_CORE` --- Facepunch.Steamworks/BaseSteamworks.cs | 8 +++++++- Facepunch.Steamworks/Client/RemoteStorage.FileStream.cs | 2 +- Facepunch.Steamworks/Client/ServerQuery.cs | 2 +- Facepunch.Steamworks/Interfaces/Workshop.Query.cs | 8 +++++++- Facepunch.Steamworks/Properties/AssemblyInfo.cs | 2 +- Facepunch.Steamworks/SteamNative/SteamNative.Platform.cs | 2 +- 6 files changed, 18 insertions(+), 6 deletions(-) diff --git a/Facepunch.Steamworks/BaseSteamworks.cs b/Facepunch.Steamworks/BaseSteamworks.cs index 435890c..8bb71d7 100644 --- a/Facepunch.Steamworks/BaseSteamworks.cs +++ b/Facepunch.Steamworks/BaseSteamworks.cs @@ -108,10 +108,16 @@ namespace Facepunch.Steamworks /// public void UpdateWhile( Func func ) { + const int sleepMs = 1; + while ( func() ) { Update(); - System.Threading.Thread.Sleep( 1 ); +#if NET_CORE + System.Threading.Tasks.Task.Delay( sleepMs ).Wait(); +#else + System.Threading.Thread.Sleep( sleepMs ); +#endif } } } diff --git a/Facepunch.Steamworks/Client/RemoteStorage.FileStream.cs b/Facepunch.Steamworks/Client/RemoteStorage.FileStream.cs index ea98e87..2c1eecb 100644 --- a/Facepunch.Steamworks/Client/RemoteStorage.FileStream.cs +++ b/Facepunch.Steamworks/Client/RemoteStorage.FileStream.cs @@ -75,7 +75,7 @@ namespace Facepunch.Steamworks remoteStorage.native.FileWriteStreamCancel( _handle ); } -#if NETCORE +#if NET_CORE public void Close() #else public override void Close() diff --git a/Facepunch.Steamworks/Client/ServerQuery.cs b/Facepunch.Steamworks/Client/ServerQuery.cs index 159d757..b1abaac 100644 --- a/Facepunch.Steamworks/Client/ServerQuery.cs +++ b/Facepunch.Steamworks/Client/ServerQuery.cs @@ -5,7 +5,7 @@ using System.Net; using System.Net.Sockets; using System.IO; -#if !NETCORE +#if !NET_CORE internal class SourceServerQuery :IDisposable { diff --git a/Facepunch.Steamworks/Interfaces/Workshop.Query.cs b/Facepunch.Steamworks/Interfaces/Workshop.Query.cs index e847ee3..4b26d47 100644 --- a/Facepunch.Steamworks/Interfaces/Workshop.Query.cs +++ b/Facepunch.Steamworks/Interfaces/Workshop.Query.cs @@ -227,11 +227,17 @@ namespace Facepunch.Steamworks /// public void Block() { + const int sleepMs = 10; + workshop.steamworks.Update(); while ( IsRunning ) { - System.Threading.Thread.Sleep( 10 ); +#if NET_CORE + System.Threading.Tasks.Task.Delay( sleepMs ).Wait(); +#else + System.Threading.Thread.Sleep( sleepMs ); +#endif workshop.steamworks.Update(); } } diff --git a/Facepunch.Steamworks/Properties/AssemblyInfo.cs b/Facepunch.Steamworks/Properties/AssemblyInfo.cs index eba09bd..83de1b3 100644 --- a/Facepunch.Steamworks/Properties/AssemblyInfo.cs +++ b/Facepunch.Steamworks/Properties/AssemblyInfo.cs @@ -2,7 +2,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -#if !NETCORE +#if !NET_CORE // General Information about an assembly is controlled through the following // set of attributes. Change these attribute values to modify the information diff --git a/Facepunch.Steamworks/SteamNative/SteamNative.Platform.cs b/Facepunch.Steamworks/SteamNative/SteamNative.Platform.cs index 81465af..1d9fc7b 100644 --- a/Facepunch.Steamworks/SteamNative/SteamNative.Platform.cs +++ b/Facepunch.Steamworks/SteamNative/SteamNative.Platform.cs @@ -37,7 +37,7 @@ namespace SteamNative { _os = Facepunch.Steamworks.OperatingSystem.Windows; -#if !NETCORE +#if !NET_CORE // // These checks aren't so accurate on older versions of mono // From 1d0fe2b8145264474774e4a23048bc06c80f2300 Mon Sep 17 00:00:00 2001 From: James King Date: Tue, 7 Nov 2017 16:58:24 +0000 Subject: [PATCH 6/9] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3002faf..a2edc9f 100644 --- a/README.md +++ b/README.md @@ -112,7 +112,7 @@ The TLDR is before you create the Client or the Server, call this to let Facepun Facepunch.Steamworks.Config.ForUnity( Application.platform.ToString() ); ``` -You'll also want to put steam_api64.dll and steam_appid.txt (on windows 64) in your project root next to Assets. +You'll also want to put steam_api64.dll and steam_appid.txt (on windows 64) in your project root next to Assets, and use an editor script like [this](https://github.com/Facepunch/Facepunch.Steamworks.Unity/blob/master/Assets/Scripts/Editor/CopySteamLibraries.cs) to copy them into standalone builds. # Help From 47f153ffa67e37eb0b9a35eb583d5dc6f61f354e Mon Sep 17 00:00:00 2001 From: James King Date: Thu, 9 Nov 2017 11:00:10 +0000 Subject: [PATCH 7/9] Added RemoteFile.Forget() --- Facepunch.Steamworks/Client/RemoteStorage.File.cs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/Facepunch.Steamworks/Client/RemoteStorage.File.cs b/Facepunch.Steamworks/Client/RemoteStorage.File.cs index 3cac8c8..58b93ae 100644 --- a/Facepunch.Steamworks/Client/RemoteStorage.File.cs +++ b/Facepunch.Steamworks/Client/RemoteStorage.File.cs @@ -278,6 +278,19 @@ namespace Facepunch.Steamworks return true; } + /// + /// Remove this file from remote storage, while keeping a local copy. + /// Writing to this file again will re-add it to the cloud. + /// + /// True if the file was forgotten + public bool Forget() + { + if ( !Exists ) return false; + if ( _isUgc ) return false; + + return remoteStorage.native.FileForget( FileName ); + } + private void GetUGCDetails() { if ( !_isUgc ) throw new InvalidOperationException(); From e2ef2b0bf7d35da9e452fe528105c3bfaabd8d3e Mon Sep 17 00:00:00 2001 From: James King Date: Tue, 28 Nov 2017 10:37:40 +0000 Subject: [PATCH 8/9] Now pinning delegates in callbacks / callresults --- .../SteamNative/SteamNative.Structs.cs | 2532 ++++++++--------- Generator/CodeWriter/Struct.cs | 6 +- 2 files changed, 1269 insertions(+), 1269 deletions(-) diff --git a/Facepunch.Steamworks/SteamNative/SteamNative.Structs.cs b/Facepunch.Steamworks/SteamNative/SteamNative.Structs.cs index edb08c1..12db6a8 100644 --- a/Facepunch.Steamworks/SteamNative/SteamNative.Structs.cs +++ b/Facepunch.Steamworks/SteamNative/SteamNative.Structs.cs @@ -107,9 +107,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -148,9 +148,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -252,9 +252,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -293,9 +293,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -409,9 +409,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -450,9 +450,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -560,9 +560,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -601,9 +601,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -711,9 +711,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -752,9 +752,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -866,9 +866,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -915,9 +915,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -986,9 +986,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1027,9 +1027,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1134,9 +1134,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1175,9 +1175,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1281,9 +1281,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1322,9 +1322,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1438,9 +1438,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1487,9 +1487,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1558,9 +1558,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1599,9 +1599,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1785,9 +1785,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1826,9 +1826,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1930,9 +1930,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -1971,9 +1971,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2082,9 +2082,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2123,9 +2123,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2230,9 +2230,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2271,9 +2271,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2384,9 +2384,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2425,9 +2425,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2545,9 +2545,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2594,9 +2594,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2665,9 +2665,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2706,9 +2706,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2813,9 +2813,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2854,9 +2854,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -2963,9 +2963,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3004,9 +3004,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3114,9 +3114,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3155,9 +3155,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3262,9 +3262,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3303,9 +3303,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3420,9 +3420,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3461,9 +3461,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3567,9 +3567,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3608,9 +3608,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3725,9 +3725,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3774,9 +3774,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3845,9 +3845,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3886,9 +3886,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -3993,9 +3993,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4034,9 +4034,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4154,9 +4154,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4203,9 +4203,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4274,9 +4274,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4315,9 +4315,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4437,9 +4437,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4486,9 +4486,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4557,9 +4557,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4598,9 +4598,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4723,9 +4723,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4772,9 +4772,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4843,9 +4843,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -4884,9 +4884,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5008,9 +5008,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5057,9 +5057,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5128,9 +5128,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5169,9 +5169,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5273,9 +5273,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5314,9 +5314,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5424,9 +5424,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5465,9 +5465,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5579,9 +5579,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5628,9 +5628,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5699,9 +5699,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5740,9 +5740,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5849,9 +5849,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -5890,9 +5890,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6192,9 +6192,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6233,9 +6233,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6343,9 +6343,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6384,9 +6384,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6509,9 +6509,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6558,9 +6558,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6629,9 +6629,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6670,9 +6670,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6780,9 +6780,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6821,9 +6821,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6934,9 +6934,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -6975,9 +6975,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7088,9 +7088,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7129,9 +7129,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7242,9 +7242,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7283,9 +7283,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7397,9 +7397,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7446,9 +7446,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7517,9 +7517,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7558,9 +7558,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7668,9 +7668,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7709,9 +7709,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7826,9 +7826,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7875,9 +7875,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7946,9 +7946,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -7987,9 +7987,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8096,9 +8096,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8137,9 +8137,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8241,9 +8241,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8282,9 +8282,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8427,9 +8427,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8468,9 +8468,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8578,9 +8578,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8619,9 +8619,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8739,9 +8739,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8780,9 +8780,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8887,9 +8887,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -8928,9 +8928,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9050,9 +9050,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9099,9 +9099,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9170,9 +9170,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9211,9 +9211,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9323,9 +9323,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9364,9 +9364,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9481,9 +9481,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9530,9 +9530,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9601,9 +9601,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9642,9 +9642,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9767,9 +9767,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9816,9 +9816,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9887,9 +9887,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -9928,9 +9928,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10045,9 +10045,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10094,9 +10094,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10165,9 +10165,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10206,9 +10206,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10336,9 +10336,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10385,9 +10385,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10456,9 +10456,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10497,9 +10497,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10614,9 +10614,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10663,9 +10663,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10734,9 +10734,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10775,9 +10775,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10897,9 +10897,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -10946,9 +10946,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11017,9 +11017,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11058,9 +11058,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11189,9 +11189,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11238,9 +11238,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11309,9 +11309,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11350,9 +11350,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11540,9 +11540,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11589,9 +11589,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11660,9 +11660,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11701,9 +11701,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11837,9 +11837,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11886,9 +11886,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11957,9 +11957,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -11998,9 +11998,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12127,9 +12127,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12176,9 +12176,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12247,9 +12247,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12288,9 +12288,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12395,9 +12395,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12436,9 +12436,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12543,9 +12543,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12584,9 +12584,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12691,9 +12691,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12732,9 +12732,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12849,9 +12849,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12898,9 +12898,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -12969,9 +12969,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13010,9 +13010,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13120,9 +13120,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13161,9 +13161,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13276,9 +13276,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13317,9 +13317,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13437,9 +13437,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13486,9 +13486,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13557,9 +13557,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13598,9 +13598,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13731,9 +13731,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13780,9 +13780,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13851,9 +13851,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -13892,9 +13892,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14011,9 +14011,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14060,9 +14060,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14131,9 +14131,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14172,9 +14172,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14282,9 +14282,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14323,9 +14323,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14437,9 +14437,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14486,9 +14486,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14557,9 +14557,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14598,9 +14598,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14721,9 +14721,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14770,9 +14770,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14841,9 +14841,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -14882,9 +14882,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15046,9 +15046,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15095,9 +15095,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15166,9 +15166,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15207,9 +15207,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15314,9 +15314,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15355,9 +15355,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15475,9 +15475,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15516,9 +15516,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15633,9 +15633,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15682,9 +15682,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15753,9 +15753,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15794,9 +15794,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15914,9 +15914,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -15963,9 +15963,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16034,9 +16034,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16075,9 +16075,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16204,9 +16204,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16253,9 +16253,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16324,9 +16324,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16365,9 +16365,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16482,9 +16482,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16531,9 +16531,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16602,9 +16602,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16643,9 +16643,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16747,9 +16747,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16788,9 +16788,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16905,9 +16905,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -16946,9 +16946,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17063,9 +17063,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17112,9 +17112,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17183,9 +17183,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17224,9 +17224,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17341,9 +17341,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17390,9 +17390,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17461,9 +17461,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17502,9 +17502,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17612,9 +17612,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17653,9 +17653,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17770,9 +17770,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17819,9 +17819,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17890,9 +17890,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -17931,9 +17931,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18035,9 +18035,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18076,9 +18076,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18183,9 +18183,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18224,9 +18224,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18339,9 +18339,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18380,9 +18380,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18505,9 +18505,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18554,9 +18554,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18625,9 +18625,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18666,9 +18666,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18823,9 +18823,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18864,9 +18864,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -18971,9 +18971,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19012,9 +19012,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19125,9 +19125,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19166,9 +19166,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19273,9 +19273,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19314,9 +19314,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19418,9 +19418,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19459,9 +19459,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19565,9 +19565,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19606,9 +19606,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19712,9 +19712,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19753,9 +19753,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19857,9 +19857,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -19898,9 +19898,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20002,9 +20002,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20043,9 +20043,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20147,9 +20147,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20188,9 +20188,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20292,9 +20292,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20333,9 +20333,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20451,9 +20451,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20492,9 +20492,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20599,9 +20599,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20640,9 +20640,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20753,9 +20753,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20794,9 +20794,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20907,9 +20907,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -20948,9 +20948,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21340,9 +21340,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21389,9 +21389,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21460,9 +21460,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21501,9 +21501,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21610,9 +21610,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21651,9 +21651,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21773,9 +21773,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21822,9 +21822,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21893,9 +21893,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -21934,9 +21934,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22053,9 +22053,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22102,9 +22102,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22173,9 +22173,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22214,9 +22214,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22324,9 +22324,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22365,9 +22365,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22487,9 +22487,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22536,9 +22536,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22607,9 +22607,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22648,9 +22648,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22770,9 +22770,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22819,9 +22819,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22890,9 +22890,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -22931,9 +22931,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23063,9 +23063,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23112,9 +23112,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23183,9 +23183,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23224,9 +23224,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23338,9 +23338,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23387,9 +23387,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23458,9 +23458,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23499,9 +23499,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23613,9 +23613,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23662,9 +23662,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23733,9 +23733,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23774,9 +23774,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23894,9 +23894,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -23943,9 +23943,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24014,9 +24014,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24055,9 +24055,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24175,9 +24175,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24224,9 +24224,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24295,9 +24295,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24336,9 +24336,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24440,9 +24440,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24481,9 +24481,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24585,9 +24585,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24626,9 +24626,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24740,9 +24740,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24789,9 +24789,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24860,9 +24860,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -24901,9 +24901,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25167,9 +25167,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25208,9 +25208,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25318,9 +25318,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25359,9 +25359,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25466,9 +25466,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25507,9 +25507,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25614,9 +25614,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25655,9 +25655,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25765,9 +25765,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25806,9 +25806,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25920,9 +25920,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -25961,9 +25961,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26082,9 +26082,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26123,9 +26123,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26244,9 +26244,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26285,9 +26285,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26408,9 +26408,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26449,9 +26449,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26556,9 +26556,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26597,9 +26597,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26704,9 +26704,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26745,9 +26745,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26855,9 +26855,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -26896,9 +26896,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27018,9 +27018,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27059,9 +27059,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27166,9 +27166,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27207,9 +27207,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27314,9 +27314,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27355,9 +27355,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27462,9 +27462,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27503,9 +27503,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27610,9 +27610,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27651,9 +27651,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27755,9 +27755,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27796,9 +27796,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27944,9 +27944,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -27985,9 +27985,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28089,9 +28089,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28130,9 +28130,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28255,9 +28255,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28304,9 +28304,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28375,9 +28375,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28416,9 +28416,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28520,9 +28520,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28561,9 +28561,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28673,9 +28673,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28714,9 +28714,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28821,9 +28821,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28862,9 +28862,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -28969,9 +28969,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29010,9 +29010,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29122,9 +29122,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29163,9 +29163,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29270,9 +29270,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29311,9 +29311,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29425,9 +29425,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29466,9 +29466,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29570,9 +29570,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29611,9 +29611,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29724,9 +29724,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29765,9 +29765,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29882,9 +29882,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -29923,9 +29923,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30057,9 +30057,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30106,9 +30106,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30177,9 +30177,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30218,9 +30218,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30332,9 +30332,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30381,9 +30381,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30452,9 +30452,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30493,9 +30493,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30619,9 +30619,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30668,9 +30668,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30739,9 +30739,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30780,9 +30780,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30897,9 +30897,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -30946,9 +30946,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31017,9 +31017,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31058,9 +31058,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31175,9 +31175,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31224,9 +31224,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31295,9 +31295,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31336,9 +31336,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31440,9 +31440,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31481,9 +31481,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31588,9 +31588,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across @@ -31629,9 +31629,9 @@ namespace SteamNative // // Allocate a handle to each function, so they don't get disposed // - handle.FuncA = GCHandle.Alloc( funcA ); - handle.FuncB = GCHandle.Alloc( funcB ); - handle.FuncC = GCHandle.Alloc( funcC ); + handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned ); + handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned ); + handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned ); // // Create the VTable by manually allocating the memory and copying across diff --git a/Generator/CodeWriter/Struct.cs b/Generator/CodeWriter/Struct.cs index 4e12be4..2164aed 100644 --- a/Generator/CodeWriter/Struct.cs +++ b/Generator/CodeWriter/Struct.cs @@ -317,9 +317,9 @@ namespace Generator WriteLine( "//" ); WriteLine( "// Allocate a handle to each function, so they don't get disposed" ); WriteLine( "//" ); - WriteLine( "handle.FuncA = GCHandle.Alloc( funcA );" ); - WriteLine( "handle.FuncB = GCHandle.Alloc( funcB );" ); - WriteLine( "handle.FuncC = GCHandle.Alloc( funcC );" ); + WriteLine( "handle.FuncA = GCHandle.Alloc( funcA, GCHandleType.Pinned );" ); + WriteLine( "handle.FuncB = GCHandle.Alloc( funcB, GCHandleType.Pinned );" ); + WriteLine( "handle.FuncC = GCHandle.Alloc( funcC, GCHandleType.Pinned );" ); WriteLine(); WriteLine( "//" ); From 7913ccd17150d3a242052450d3dac9325b5a7bd4 Mon Sep 17 00:00:00 2001 From: James King Date: Tue, 28 Nov 2017 11:22:43 +0000 Subject: [PATCH 9/9] Pinned some more delegates --- Facepunch.Steamworks/Interop/ServerRules.cs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Facepunch.Steamworks/Interop/ServerRules.cs b/Facepunch.Steamworks/Interop/ServerRules.cs index 2cdb16a..3acff8d 100644 --- a/Facepunch.Steamworks/Interop/ServerRules.cs +++ b/Facepunch.Steamworks/Interop/ServerRules.cs @@ -71,9 +71,9 @@ namespace Facepunch.Steamworks.Interop ThisVTable.InternalRulesFailedToRespond db = ( _ ) => InternalOnRulesFailedToRespond(); ThisVTable.InternalRulesRefreshComplete dc = ( _ ) => InternalOnRulesRefreshComplete(); - RulesRespondPin = GCHandle.Alloc( da ); - FailedRespondPin = GCHandle.Alloc( db ); - CompletePin = GCHandle.Alloc( dc ); + RulesRespondPin = GCHandle.Alloc( da, GCHandleType.Pinned ); + FailedRespondPin = GCHandle.Alloc( db, GCHandleType.Pinned ); + CompletePin = GCHandle.Alloc( dc, GCHandleType.Pinned ); var t = new ThisVTable() { @@ -93,9 +93,9 @@ namespace Facepunch.Steamworks.Interop StdVTable.InternalRulesFailedToRespond db = InternalOnRulesFailedToRespond; StdVTable.InternalRulesRefreshComplete dc = InternalOnRulesRefreshComplete; - RulesRespondPin = GCHandle.Alloc( da ); - FailedRespondPin = GCHandle.Alloc( db ); - CompletePin = GCHandle.Alloc( dc ); + RulesRespondPin = GCHandle.Alloc( da, GCHandleType.Pinned ); + FailedRespondPin = GCHandle.Alloc( db, GCHandleType.Pinned ); + CompletePin = GCHandle.Alloc( dc, GCHandleType.Pinned ); var t = new StdVTable() {