adapt C# to the new server shutdown API

src/csharp/Grpc.Core/Internal/ServerSafeHandle.cs

@@ -60,10 +60,10 @@ namespace Grpc.Core.Internal
         static extern void grpcsharp_server_start(ServerSafeHandle server);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern void grpcsharp_server_shutdown(ServerSafeHandle server);
+        static extern void grpcsharp_server_shutdown_and_notify_callback(ServerSafeHandle server, CompletionQueueSafeHandle cq, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern void grpcsharp_server_shutdown_and_notify_callback(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
+        static extern void grpcsharp_server_cancel_all_calls(ServerSafeHandle server);
 
         [DllImport("grpc_csharp_ext.dll")]
         static extern void grpcsharp_server_destroy(IntPtr server);
@@ -92,14 +92,9 @@ namespace Grpc.Core.Internal
             grpcsharp_server_start(this);
         }
 
-        public void Shutdown()
+        public void ShutdownAndNotify(CompletionQueueSafeHandle cq, CompletionCallbackDelegate callback)
         {
-            grpcsharp_server_shutdown(this);
-        }
-
-        public void ShutdownAndNotify(CompletionCallbackDelegate callback)
-        {
-            grpcsharp_server_shutdown_and_notify_callback(this, callback);
+            grpcsharp_server_shutdown_and_notify_callback(this, cq, callback);
         }
 
         public void RequestCall(CompletionQueueSafeHandle cq, CompletionCallbackDelegate callback)
@@ -112,6 +107,12 @@ namespace Grpc.Core.Internal
             grpcsharp_server_destroy(handle);
             return true;
         }
+            
+        // Only to be called after ShutdownAndNotify.
+        public void CancelAllCalls()
+        {
+            grpcsharp_server_cancel_all_calls(this);
+        }
 
         private static void AssertCallOk(GRPCCallError callError)
         {

src/csharp/Grpc.Core/Server.cs

@@ -144,7 +144,7 @@ namespace Grpc.Core
                 shutdownRequested = true;
             }
 
-            handle.ShutdownAndNotify(serverShutdownHandler);
+            handle.ShutdownAndNotify(GetCompletionQueue(), serverShutdownHandler);
             await shutdownTcs.Task;
             handle.Dispose();
         }
@@ -160,8 +160,22 @@ namespace Grpc.Core
             }
         }
 
-        public void Kill()
+        /// <summary>
+        /// Requests server shutdown while cancelling all the in-progress calls.
+        /// The returned task finishes when shutdown procedure is complete.
+        /// </summary>
+        public async Task KillAsync()
         {
+            lock (myLock)
+            {
+                Preconditions.CheckState(startRequested);
+                Preconditions.CheckState(!shutdownRequested);
+                shutdownRequested = true;
+            }
+
+            handle.ShutdownAndNotify(GetCompletionQueue(), serverShutdownHandler);
+            handle.CancelAllCalls();
+            await shutdownTcs.Task;
             handle.Dispose();
         }
 

src/csharp/ext/grpc_csharp_ext.c

@@ -677,16 +677,17 @@ GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_start(grpc_server *server) {
   grpc_server_start(server);
 }
 
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_shutdown(grpc_server *server) {
-  grpc_server_shutdown(server);
-}
-
 GPR_EXPORT void GPR_CALLTYPE
 grpcsharp_server_shutdown_and_notify_callback(grpc_server *server,
+                                              grpc_completion_queue *cq,
                                               callback_funcptr callback) {
   grpcsharp_batch_context *ctx = grpcsharp_batch_context_create();
   ctx->callback = callback;
-  grpc_server_shutdown_and_notify(server, ctx);
+  grpc_server_shutdown_and_notify(server, cq, ctx);
+}
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_cancel_all_calls(grpc_server *server) {
+  grpc_server_cancel_all_calls(server);
 }
 
 GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_destroy(grpc_server *server) {