Use function pointers for reverse pinvokes (#28249)

davidfowl · web-flow · commit 6606d7c89f3f · 2020-11-30T15:38:50.000-04:00
* Use function pointers for reverse pinvokes
- Mostly a mechanical change to use function pointers
diff --git a/src/Servers/IIS/IIS/src/Core/IISHttpServer.cs b/src/Servers/IIS/IIS/src/Core/IISHttpServer.cs
@@ -8,7 +8,6 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Hosting.Server;
 using Microsoft.AspNetCore.Hosting.Server.Features;
 using Microsoft.AspNetCore.Http.Features;
@@ -22,12 +21,6 @@ internal class IISHttpServer : IServer
     {
         private const string WebSocketVersionString = "WEBSOCKET_VERSION";
 
-        private static readonly NativeMethods.PFN_REQUEST_HANDLER _requestHandler = HandleRequest;
-        private static readonly NativeMethods.PFN_SHUTDOWN_HANDLER _shutdownHandler = HandleShutdown;
-        private static readonly NativeMethods.PFN_DISCONNECT_HANDLER _onDisconnect = OnDisconnect;
-        private static readonly NativeMethods.PFN_ASYNC_COMPLETION _onAsyncCompletion = OnAsyncCompletion;
-        private static readonly NativeMethods.PFN_REQUESTS_DRAINED_HANDLER _requestsDrainedHandler = OnRequestsDrained;
-
         private IISContextFactory _iisContextFactory;
         private readonly MemoryPool<byte> _memoryPool = new SlabMemoryPool();
         private GCHandle _httpServerHandle;
@@ -89,12 +82,19 @@ ILogger<IISHttpServer> logger
             }
         }
 
-        public Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
+        public unsafe Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
         {
             _httpServerHandle = GCHandle.Alloc(this);
 
             _iisContextFactory = new IISContextFactory<TContext>(_memoryPool, application, _options, this, _logger);
-            _nativeApplication.RegisterCallbacks(_requestHandler, _shutdownHandler, _onDisconnect, _onAsyncCompletion, _requestsDrainedHandler, (IntPtr)_httpServerHandle, (IntPtr)_httpServerHandle);
+            _nativeApplication.RegisterCallbacks(
+                &HandleRequest,
+                &HandleShutdown,
+                &OnDisconnect,
+                &OnAsyncCompletion,
+                &OnRequestsDrained,
+                (IntPtr)_httpServerHandle,
+                (IntPtr)_httpServerHandle);
 
             _serverAddressesFeature.Addresses = _options.ServerAddresses;
 
@@ -134,6 +134,7 @@ public void Dispose()
             _nativeApplication.Dispose();
         }
 
+        [UnmanagedCallersOnly]
         private static NativeMethods.REQUEST_NOTIFICATION_STATUS HandleRequest(IntPtr pInProcessHandler, IntPtr pvRequestContext)
         {
             IISHttpServer server = null;
@@ -163,7 +164,8 @@ private static NativeMethods.REQUEST_NOTIFICATION_STATUS HandleRequest(IntPtr pI
             }
         }
 
-        private static bool HandleShutdown(IntPtr pvRequestContext)
+        [UnmanagedCallersOnly]
+        private static int HandleShutdown(IntPtr pvRequestContext)
         {
             IISHttpServer server = null;
             try
@@ -174,7 +176,7 @@ private static bool HandleShutdown(IntPtr pvRequestContext)
                 if (server ==  null)
                 {
                     // return value isn't checked.
-                    return true;
+                    return 1;
                 }
 
                 server._applicationLifetime.StopApplication();
@@ -183,9 +185,10 @@ private static bool HandleShutdown(IntPtr pvRequestContext)
             {
                 server?._logger.LogError(0, ex, $"Unexpected exception in {nameof(IISHttpServer)}.{nameof(HandleShutdown)}.");
             }
-            return true;
+            return 1;
         }
 
+        [UnmanagedCallersOnly]
         private static void OnDisconnect(IntPtr pvManagedHttpContext)
         {
             IISHttpContext context = null;
@@ -207,6 +210,7 @@ private static void OnDisconnect(IntPtr pvManagedHttpContext)
             }
         }
 
+        [UnmanagedCallersOnly]
         private static NativeMethods.REQUEST_NOTIFICATION_STATUS OnAsyncCompletion(IntPtr pvManagedHttpContext, int hr, int bytes)
         {
             IISHttpContext context = null;
@@ -231,6 +235,7 @@ private static NativeMethods.REQUEST_NOTIFICATION_STATUS OnAsyncCompletion(IntPt
             }
         }
 
+        [UnmanagedCallersOnly]
         private static void OnRequestsDrained(IntPtr serverContext)
         {
             IISHttpServer server = null;
diff --git a/src/Servers/IIS/IIS/src/Core/IISNativeApplication.cs b/src/Servers/IIS/IIS/src/Core/IISNativeApplication.cs
@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.IO;
 
 namespace Microsoft.AspNetCore.Server.IIS.Core
 {
@@ -38,24 +37,24 @@ public void StopCallsIntoManaged()
             }
         }
 
-        public void RegisterCallbacks(
-            NativeMethods.PFN_REQUEST_HANDLER requestHandler,
-            NativeMethods.PFN_SHUTDOWN_HANDLER shutdownHandler,
-            NativeMethods.PFN_DISCONNECT_HANDLER disconnectHandler,
-            NativeMethods.PFN_ASYNC_COMPLETION onAsyncCompletion,
-            NativeMethods.PFN_REQUESTS_DRAINED_HANDLER requestDrainedHandler,
-            IntPtr requestContext,
-            IntPtr shutdownContext)
+        public unsafe void RegisterCallbacks(
+            delegate* unmanaged<nint, nint, NativeMethods.REQUEST_NOTIFICATION_STATUS> requestCallback,
+            delegate* unmanaged<nint, int> shutdownCallback,
+            delegate* unmanaged<nint, void> disconnectCallback,
+            delegate* unmanaged<nint, int, int, NativeMethods.REQUEST_NOTIFICATION_STATUS> asyncCallback,
+            delegate* unmanaged<nint, void> requestsDrainedHandler,
+            nint pvRequestContext,
+            nint pvShutdownContext)
         {
             NativeMethods.HttpRegisterCallbacks(
                 _nativeApplication,
-                requestHandler,
-                shutdownHandler,
-                disconnectHandler,
-                onAsyncCompletion,
-                requestDrainedHandler,
-                requestContext,
-                shutdownContext);
+                requestCallback,
+                shutdownCallback,
+                disconnectCallback,
+                asyncCallback,
+                requestsDrainedHandler,
+                pvRequestContext,
+                pvShutdownContext);
         }
 
         public void Dispose()
diff --git a/src/Servers/IIS/IIS/src/Core/IO/WebSocketsAsyncIOEngine.Read.cs b/src/Servers/IIS/IIS/src/Core/IO/WebSocketsAsyncIOEngine.Read.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Buffers;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace Microsoft.AspNetCore.Server.IIS.Core.IO
@@ -11,7 +12,8 @@ internal partial class WebSocketsAsyncIOEngine
     {
         internal class WebSocketReadOperation : AsyncIOOperation
         {
-            public static readonly NativeMethods.PFN_WEBSOCKET_ASYNC_COMPLETION ReadCallback = (httpContext, completionInfo, completionContext) =>
+            [UnmanagedCallersOnly]
+            public static NativeMethods.REQUEST_NOTIFICATION_STATUS ReadCallback(IntPtr httpContext, IntPtr completionInfo, IntPtr completionContext)
             {
                 var context = (WebSocketReadOperation)GCHandle.FromIntPtr(completionContext).Target;
 
@@ -22,7 +24,7 @@ internal class WebSocketReadOperation : AsyncIOOperation
                 continuation.Invoke();
 
                 return NativeMethods.REQUEST_NOTIFICATION_STATUS.RQ_NOTIFICATION_PENDING;
-            };
+            }
 
             private readonly WebSocketsAsyncIOEngine _engine;
             private GCHandle _thisHandle;
@@ -44,7 +46,7 @@ protected override unsafe bool InvokeOperation(out int hr, out int bytes)
                     _requestHandler,
                     (byte*)_inputHandle.Pointer,
                     _memory.Length,
-                    ReadCallback,
+                    &ReadCallback,
                     (IntPtr)_thisHandle,
                     out bytes,
                     out var completionExpected);
diff --git a/src/Servers/IIS/IIS/src/Core/IO/WebSocketsAsyncIOEngine.Write.cs b/src/Servers/IIS/IIS/src/Core/IO/WebSocketsAsyncIOEngine.Write.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Microsoft.AspNetCore.HttpSys.Internal;
 
@@ -11,8 +12,8 @@ internal partial class WebSocketsAsyncIOEngine
     {
         internal sealed class WebSocketWriteOperation : AsyncWriteOperationBase
         {
-
-            private static readonly NativeMethods.PFN_WEBSOCKET_ASYNC_COMPLETION WriteCallback = (httpContext, completionInfo, completionContext) =>
+            [UnmanagedCallersOnly]
+            private static NativeMethods.REQUEST_NOTIFICATION_STATUS WriteCallback(IntPtr httpContext, IntPtr completionInfo, IntPtr completionContext)
             {
                 var context = (WebSocketWriteOperation)GCHandle.FromIntPtr(completionContext).Target;
 
@@ -22,7 +23,7 @@ internal sealed class WebSocketWriteOperation : AsyncWriteOperationBase
                 continuation.Invoke();
 
                 return NativeMethods.REQUEST_NOTIFICATION_STATUS.RQ_NOTIFICATION_PENDING;
-            };
+            }
 
             private readonly WebSocketsAsyncIOEngine _engine;
             private GCHandle _thisHandle;
@@ -35,7 +36,7 @@ public WebSocketWriteOperation(WebSocketsAsyncIOEngine engine)
             protected override unsafe int WriteChunks(NativeSafeHandle requestHandler, int chunkCount, HttpApiTypes.HTTP_DATA_CHUNK* dataChunks, out bool completionExpected)
             {
                 _thisHandle = GCHandle.Alloc(this);
-                return NativeMethods.HttpWebsocketsWriteBytes(requestHandler, dataChunks, chunkCount, WriteCallback, (IntPtr)_thisHandle, out completionExpected);
+                return NativeMethods.HttpWebsocketsWriteBytes(requestHandler, dataChunks, chunkCount, &WriteCallback, (IntPtr)_thisHandle, out completionExpected);
             }
 
             protected override void ResetOperation()
diff --git a/src/Servers/IIS/IIS/src/NativeMethods.cs b/src/Servers/IIS/IIS/src/NativeMethods.cs
@@ -39,13 +39,6 @@ public enum REQUEST_NOTIFICATION_STATUS
             RQ_NOTIFICATION_FINISH_REQUEST
         }
 
-        public delegate REQUEST_NOTIFICATION_STATUS PFN_REQUEST_HANDLER(IntPtr pInProcessHandler, IntPtr pvRequestContext);
-        public delegate void PFN_DISCONNECT_HANDLER(IntPtr pvManagedHttpContext);
-        public delegate bool PFN_SHUTDOWN_HANDLER(IntPtr pvRequestContext);
-        public delegate REQUEST_NOTIFICATION_STATUS PFN_ASYNC_COMPLETION(IntPtr pvManagedHttpContext, int hr, int bytes);
-        public delegate REQUEST_NOTIFICATION_STATUS PFN_WEBSOCKET_ASYNC_COMPLETION(IntPtr pInProcessHandler, IntPtr completionInfo, IntPtr pvCompletionContext);
-        public delegate void PFN_REQUESTS_DRAINED_HANDLER(IntPtr pvRequestContext);
-
         [DllImport(AspNetCoreModuleDll)]
         private static extern int http_post_completion(NativeSafeHandle pInProcessHandler, int cbBytes);
 
@@ -56,12 +49,12 @@ public enum REQUEST_NOTIFICATION_STATUS
         private static extern void http_indicate_completion(NativeSafeHandle pInProcessHandler, REQUEST_NOTIFICATION_STATUS notificationStatus);
 
         [DllImport(AspNetCoreModuleDll)]
-        private static extern int register_callbacks(NativeSafeHandle pInProcessApplication,
-            PFN_REQUEST_HANDLER requestCallback,
-            PFN_SHUTDOWN_HANDLER shutdownCallback,
-            PFN_DISCONNECT_HANDLER disconnectCallback,
-            PFN_ASYNC_COMPLETION asyncCallback,
-            PFN_REQUESTS_DRAINED_HANDLER requestsDrainedHandler,
+        private unsafe static extern int register_callbacks(NativeSafeHandle pInProcessApplication,
+            delegate* unmanaged<IntPtr, IntPtr, REQUEST_NOTIFICATION_STATUS> requestCallback,
+            delegate* unmanaged<IntPtr, int> shutdownCallback,
+            delegate* unmanaged<IntPtr, void> disconnectCallback,
+            delegate* unmanaged<IntPtr, int, int, REQUEST_NOTIFICATION_STATUS> asyncCallback,
+            delegate* unmanaged<IntPtr, void> requestsDrainedHandler,
             IntPtr pvRequestContext,
             IntPtr pvShutdownContext);
 
@@ -115,7 +108,7 @@ private static extern unsafe int http_websockets_read_bytes(
             NativeSafeHandle pInProcessHandler,
             byte* pvBuffer,
             int cbBuffer,
-            PFN_WEBSOCKET_ASYNC_COMPLETION pfnCompletionCallback,
+            delegate* unmanaged<IntPtr, IntPtr, IntPtr, REQUEST_NOTIFICATION_STATUS> pfnCompletionCallback,
             IntPtr pvCompletionContext,
             out int dwBytesReceived,
             out bool fCompletionExpected);
@@ -125,7 +118,7 @@ private static extern unsafe int http_websockets_write_bytes(
             NativeSafeHandle pInProcessHandler,
             HttpApiTypes.HTTP_DATA_CHUNK* pDataChunks,
             int nChunks,
-            PFN_WEBSOCKET_ASYNC_COMPLETION pfnCompletionCallback,
+            delegate* unmanaged<IntPtr, IntPtr, IntPtr, REQUEST_NOTIFICATION_STATUS> pfnCompletionCallback,
             IntPtr pvCompletionContext,
             out bool fCompletionExpected);
 
@@ -168,12 +161,12 @@ public static void HttpSetCompletionStatus(NativeSafeHandle pInProcessHandler, R
             Validate(http_set_completion_status(pInProcessHandler, rquestNotificationStatus));
         }
 
-        public static void HttpRegisterCallbacks(NativeSafeHandle pInProcessApplication,
-            PFN_REQUEST_HANDLER requestCallback,
-            PFN_SHUTDOWN_HANDLER shutdownCallback,
-            PFN_DISCONNECT_HANDLER disconnectCallback,
-            PFN_ASYNC_COMPLETION asyncCallback,
-            PFN_REQUESTS_DRAINED_HANDLER requestsDrainedHandler,
+        public static unsafe void HttpRegisterCallbacks(NativeSafeHandle pInProcessApplication,
+            delegate* unmanaged<IntPtr, IntPtr, REQUEST_NOTIFICATION_STATUS> requestCallback,
+            delegate* unmanaged<IntPtr, int> shutdownCallback,
+            delegate* unmanaged<IntPtr, void> disconnectCallback,
+            delegate* unmanaged<IntPtr, int, int, REQUEST_NOTIFICATION_STATUS> asyncCallback,
+            delegate* unmanaged<IntPtr, void> requestsDrainedHandler,
             IntPtr pvRequestContext,
             IntPtr pvShutdownContext)
         {
@@ -251,7 +244,7 @@ public static unsafe int HttpWebsocketsReadBytes(
             NativeSafeHandle pInProcessHandler,
             byte* pvBuffer,
             int cbBuffer,
-            PFN_WEBSOCKET_ASYNC_COMPLETION pfnCompletionCallback,
+            delegate* unmanaged<IntPtr, IntPtr, IntPtr, REQUEST_NOTIFICATION_STATUS> pfnCompletionCallback,
             IntPtr pvCompletionContext, out int dwBytesReceived,
             out bool fCompletionExpected)
         {
@@ -262,7 +255,7 @@ internal static unsafe int HttpWebsocketsWriteBytes(
             NativeSafeHandle pInProcessHandler,
             HttpApiTypes.HTTP_DATA_CHUNK* pDataChunks,
             int nChunks,
-            PFN_WEBSOCKET_ASYNC_COMPLETION pfnCompletionCallback,
+            delegate* unmanaged<IntPtr, IntPtr, IntPtr, REQUEST_NOTIFICATION_STATUS> pfnCompletionCallback,
             IntPtr pvCompletionContext,
             out bool fCompletionExpected)
         {
@@ -280,7 +273,7 @@ public static bool HttpTryCancelIO(NativeSafeHandle pInProcessHandler)
             // ERROR_NOT_FOUND is expected if async operation finished
             // https://msdn.microsoft.com/en-us/library/windows/desktop/aa363792(v=vs.85).aspx
             // ERROR_INVALID_PARAMETER is expected for "fake" requests like applicationInitialization ones
-            if (hr == ERROR_NOT_FOUND || hr ==  ERROR_INVALID_PARAMETER)
+            if (hr == ERROR_NOT_FOUND || hr == ERROR_INVALID_PARAMETER)
             {
                 return false;
             }
@@ -310,7 +303,7 @@ public static void HttpGetAuthenticationInformation(NativeSafeHandle pInProcessH
 
         internal static unsafe void HttpSetStartupErrorPageContent(byte[] content)
         {
-            fixed(byte* bytePtr = content)
+            fixed (byte* bytePtr = content)
             {
                 http_set_startup_error_page_content(bytePtr, content.Length);
             }

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@`
`8`	`8`	`using System.Threading.Tasks;`
`9`	`9`	`using Microsoft.AspNetCore.Authentication;`
`10`	`10`	`using Microsoft.AspNetCore.Builder;`
`11`		`-using Microsoft.AspNetCore.Hosting;`
`12`	`11`	`using Microsoft.AspNetCore.Hosting.Server;`
`13`	`12`	`using Microsoft.AspNetCore.Hosting.Server.Features;`
`14`	`13`	`using Microsoft.AspNetCore.Http.Features;`
`@@ -22,12 +21,6 @@ internal class IISHttpServer : IServer`
`22`	`21`	`{`
`23`	`22`	`private const string WebSocketVersionString = "WEBSOCKET_VERSION";`
`24`	`23`
`25`		`- private static readonly NativeMethods.PFN_REQUEST_HANDLER _requestHandler = HandleRequest;`
`26`		`- private static readonly NativeMethods.PFN_SHUTDOWN_HANDLER _shutdownHandler = HandleShutdown;`
`27`		`- private static readonly NativeMethods.PFN_DISCONNECT_HANDLER _onDisconnect = OnDisconnect;`
`28`		`- private static readonly NativeMethods.PFN_ASYNC_COMPLETION _onAsyncCompletion = OnAsyncCompletion;`
`29`		`- private static readonly NativeMethods.PFN_REQUESTS_DRAINED_HANDLER _requestsDrainedHandler = OnRequestsDrained;`
`30`		`-`
`31`	`24`	`private IISContextFactory _iisContextFactory;`
`32`	`25`	`private readonly MemoryPool<byte> _memoryPool = new SlabMemoryPool();`
`33`	`26`	`private GCHandle _httpServerHandle;`
`@@ -89,12 +82,19 @@ ILogger<IISHttpServer> logger`
`89`	`82`	`}`
`90`	`83`	`}`
`91`	`84`
`92`		`- public Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)`
	`85`	`+ public unsafe Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)`
`93`	`86`	`{`
`94`	`87`	`_httpServerHandle = GCHandle.Alloc(this);`
`95`	`88`
`96`	`89`	`_iisContextFactory = new IISContextFactory<TContext>(_memoryPool, application, _options, this, _logger);`
`97`		`- _nativeApplication.RegisterCallbacks(_requestHandler, _shutdownHandler, _onDisconnect, _onAsyncCompletion, _requestsDrainedHandler, (IntPtr)_httpServerHandle, (IntPtr)_httpServerHandle);`
	`90`	`+ _nativeApplication.RegisterCallbacks(`
	`91`	`+ &HandleRequest,`
	`92`	`+ &HandleShutdown,`
	`93`	`+ &OnDisconnect,`
	`94`	`+ &OnAsyncCompletion,`
	`95`	`+ &OnRequestsDrained,`
	`96`	`+ (IntPtr)_httpServerHandle,`
	`97`	`+ (IntPtr)_httpServerHandle);`
`98`	`98`
`99`	`99`	`_serverAddressesFeature.Addresses = _options.ServerAddresses;`
`100`	`100`
`@@ -134,6 +134,7 @@ public void Dispose()`
`134`	`134`	`_nativeApplication.Dispose();`
`135`	`135`	`}`
`136`	`136`
	`137`	`+ [UnmanagedCallersOnly]`
`137`	`138`	`private static NativeMethods.REQUEST_NOTIFICATION_STATUS HandleRequest(IntPtr pInProcessHandler, IntPtr pvRequestContext)`
`138`	`139`	`{`
`139`	`140`	`IISHttpServer server = null;`
`@@ -163,7 +164,8 @@ private static NativeMethods.REQUEST_NOTIFICATION_STATUS HandleRequest(IntPtr pI`
`163`	`164`	`}`
`164`	`165`	`}`
`165`	`166`
`166`		`- private static bool HandleShutdown(IntPtr pvRequestContext)`
	`167`	`+ [UnmanagedCallersOnly]`
	`168`	`+ private static int HandleShutdown(IntPtr pvRequestContext)`
`167`	`169`	`{`
`168`	`170`	`IISHttpServer server = null;`
`169`	`171`	`try`
`@@ -174,7 +176,7 @@ private static bool HandleShutdown(IntPtr pvRequestContext)`
`174`	`176`	`if (server == null)`
`175`	`177`	`{`
`176`	`178`	`// return value isn't checked.`
`177`		`- return true;`
	`179`	`+ return 1;`
`178`	`180`	`}`
`179`	`181`
`180`	`182`	`server._applicationLifetime.StopApplication();`
`@@ -183,9 +185,10 @@ private static bool HandleShutdown(IntPtr pvRequestContext)`
`183`	`185`	`{`
`184`	`186`	`server?._logger.LogError(0, ex, $"Unexpected exception in {nameof(IISHttpServer)}.{nameof(HandleShutdown)}.");`
`185`	`187`	`}`
`186`		`- return true;`
	`188`	`+ return 1;`
`187`	`189`	`}`
`188`	`190`
	`191`	`+ [UnmanagedCallersOnly]`
`189`	`192`	`private static void OnDisconnect(IntPtr pvManagedHttpContext)`
`190`	`193`	`{`
`191`	`194`	`IISHttpContext context = null;`
`@@ -207,6 +210,7 @@ private static void OnDisconnect(IntPtr pvManagedHttpContext)`
`207`	`210`	`}`
`208`	`211`	`}`
`209`	`212`
	`213`	`+ [UnmanagedCallersOnly]`
`210`	`214`	`private static NativeMethods.REQUEST_NOTIFICATION_STATUS OnAsyncCompletion(IntPtr pvManagedHttpContext, int hr, int bytes)`
`211`	`215`	`{`
`212`	`216`	`IISHttpContext context = null;`
`@@ -231,6 +235,7 @@ private static NativeMethods.REQUEST_NOTIFICATION_STATUS OnAsyncCompletion(IntPt`
`231`	`235`	`}`
`232`	`236`	`}`
`233`	`237`
	`238`	`+ [UnmanagedCallersOnly]`
`234`	`239`	`private static void OnRequestsDrained(IntPtr serverContext)`
`235`	`240`	`{`
`236`	`241`	`IISHttpServer server = null;`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System;`
	`5`	`+using System.Runtime.CompilerServices;`
`5`	`6`	`using System.Runtime.InteropServices;`
`6`	`7`	`using Microsoft.AspNetCore.HttpSys.Internal;`
`7`	`8`
`@@ -11,8 +12,8 @@ internal partial class WebSocketsAsyncIOEngine`
`11`	`12`	`{`
`12`	`13`	`internal sealed class WebSocketWriteOperation : AsyncWriteOperationBase`
`13`	`14`	`{`
`14`		`-`
`15`		`- private static readonly NativeMethods.PFN_WEBSOCKET_ASYNC_COMPLETION WriteCallback = (httpContext, completionInfo, completionContext) =>`
	`15`	`+ [UnmanagedCallersOnly]`
	`16`	`+ private static NativeMethods.REQUEST_NOTIFICATION_STATUS WriteCallback(IntPtr httpContext, IntPtr completionInfo, IntPtr completionContext)`
`16`	`17`	`{`
`17`	`18`	`var context = (WebSocketWriteOperation)GCHandle.FromIntPtr(completionContext).Target;`
`18`	`19`
`@@ -22,7 +23,7 @@ internal sealed class WebSocketWriteOperation : AsyncWriteOperationBase`
`22`	`23`	`continuation.Invoke();`
`23`	`24`
`24`	`25`	`return NativeMethods.REQUEST_NOTIFICATION_STATUS.RQ_NOTIFICATION_PENDING;`
`25`		`- };`
	`26`	`+ }`
`26`	`27`
`27`	`28`	`private readonly WebSocketsAsyncIOEngine _engine;`
`28`	`29`	`private GCHandle _thisHandle;`
`@@ -35,7 +36,7 @@ public WebSocketWriteOperation(WebSocketsAsyncIOEngine engine)`
`35`	`36`	`protected override unsafe int WriteChunks(NativeSafeHandle requestHandler, int chunkCount, HttpApiTypes.HTTP_DATA_CHUNK* dataChunks, out bool completionExpected)`
`36`	`37`	`{`
`37`	`38`	`_thisHandle = GCHandle.Alloc(this);`
`38`		`- return NativeMethods.HttpWebsocketsWriteBytes(requestHandler, dataChunks, chunkCount, WriteCallback, (IntPtr)_thisHandle, out completionExpected);`
	`39`	`+ return NativeMethods.HttpWebsocketsWriteBytes(requestHandler, dataChunks, chunkCount, &WriteCallback, (IntPtr)_thisHandle, out completionExpected);`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`protected override void ResetOperation()`