bind Pinvoke c# call to the new wrappers

7 files changed, 141 insertions, 136 deletions

diff --git a/src/csharp/GrpcCore/GrpcEnvironment.cs b/src/csharp/GrpcCore/GrpcEnvironment.cs
index 201320828b..7a7ff39179 100644
--- a/src/csharp/GrpcCore/GrpcEnvironment.cs
+++ b/src/csharp/GrpcCore/GrpcEnvironment.cs
@@ -13,11 +13,11 @@ namespace Google.GRPC.Core
     {
         const int THREAD_POOL_SIZE = 1;
 
-        [DllImport("grpc.dll")]
-        static extern void grpc_init();
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_init();
 
-        [DllImport("grpc.dll")]
-        static extern void grpc_shutdown();
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_shutdown();
 
         static object staticLock = new object();
         static bool initCalled = false;
@@ -61,7 +61,7 @@ namespace Google.GRPC.Core
         /// </summary>
         private static void GrpcInit()
         {
-            grpc_init();
+            grpcsharp_init();
             threadPool.Start();
             // TODO: use proper logging here
             Console.WriteLine("GRPC initialized.");
@@ -73,7 +73,7 @@ namespace Google.GRPC.Core
         private static void GrpcShutdown()
         {
             threadPool.Stop();
-            grpc_shutdown();
+            grpcsharp_shutdown();
 
             // TODO: use proper logging here
             Console.WriteLine("GRPC shutdown.");
diff --git a/src/csharp/GrpcCore/Internal/CallSafeHandle.cs b/src/csharp/GrpcCore/Internal/CallSafeHandle.cs
index bbb830b355..f5973e2709 100644
--- a/src/csharp/GrpcCore/Internal/CallSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/CallSafeHandle.cs
@@ -15,67 +15,67 @@ namespace Google.GRPC.Core.Internal
 	{
         const UInt32 GRPC_WRITE_BUFFER_HINT = 1;
 
-        [DllImport("grpc.dll")]
-        static extern CallSafeHandle grpc_channel_create_call_old(ChannelSafeHandle channel, string method, string host, Timespec deadline);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern CallSafeHandle grpcsharp_channel_create_call_old(ChannelSafeHandle channel, string method, string host, Timespec deadline);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_add_metadata(CallSafeHandle call, IntPtr metadata, UInt32 flags);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_add_metadata(CallSafeHandle call, IntPtr metadata, UInt32 flags);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_invoke_old(CallSafeHandle call, CompletionQueueSafeHandle cq, IntPtr metadataReadTag, IntPtr finishedTag, UInt32 flags);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_invoke_old(CallSafeHandle call, CompletionQueueSafeHandle cq, IntPtr metadataReadTag, IntPtr finishedTag, UInt32 flags);
 
-        [DllImport("grpc.dll", EntryPoint = "grpc_call_invoke_old")]
-        static extern GRPCCallError grpc_call_invoke_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle cq,
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_invoke_old")]
+        static extern GRPCCallError grpcsharp_call_invoke_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle cq,
                                                               [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate metadataReadCallback, 
                                                               [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate finishedCallback, 
                                                               UInt32 flags);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_server_accept_old(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, IntPtr finishedTag);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_server_accept_old(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, IntPtr finishedTag);
 
-        [DllImport("grpc.dll", EntryPoint = "grpc_call_server_accept_old")]
-        static extern GRPCCallError grpc_call_server_accept_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate finishedCallback);
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_server_accept_old")]
+        static extern GRPCCallError grpcsharp_call_server_accept_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate finishedCallback);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_server_end_initial_metadata_old(CallSafeHandle call, UInt32 flags);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_server_end_initial_metadata_old(CallSafeHandle call, UInt32 flags);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_cancel(CallSafeHandle call);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_cancel(CallSafeHandle call);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_cancel_with_status(CallSafeHandle call, StatusCode status, string description);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_cancel_with_status(CallSafeHandle call, StatusCode status, string description);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_start_write_status_old(CallSafeHandle call, StatusCode statusCode, string statusMessage, IntPtr tag);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_start_write_status_old(CallSafeHandle call, StatusCode statusCode, string statusMessage, IntPtr tag);
 
-        [DllImport("grpc.dll", EntryPoint = "grpc_call_start_write_status_old")]
-        static extern GRPCCallError grpc_call_start_write_status_old_CALLBACK(CallSafeHandle call, StatusCode statusCode, string statusMessage, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_start_write_status_old")]
+        static extern GRPCCallError grpcsharp_call_start_write_status_old_CALLBACK(CallSafeHandle call, StatusCode statusCode, string statusMessage, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_writes_done_old(CallSafeHandle call, IntPtr tag);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_writes_done_old(CallSafeHandle call, IntPtr tag);
 
-        [DllImport("grpc.dll", EntryPoint = "grpc_call_writes_done_old")]
-        static extern GRPCCallError grpc_call_writes_done_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_writes_done_old")]
+        static extern GRPCCallError grpcsharp_call_writes_done_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
 
-        [DllImport("grpc.dll")]
-        static extern GRPCCallError grpc_call_start_read_old(CallSafeHandle call, IntPtr tag);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern GRPCCallError grpcsharp_call_start_read_old(CallSafeHandle call, IntPtr tag);
 
-        [DllImport("grpc.dll", EntryPoint = "grpc_call_start_read_old")]
-        static extern GRPCCallError grpc_call_start_read_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_start_read_old")]
+        static extern GRPCCallError grpcsharp_call_start_read_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern void grpc_call_start_write_from_copied_buffer(CallSafeHandle call,
+        static extern void grpcsharp_call_start_write_from_copied_buffer(CallSafeHandle call,
                                                                     byte[] buffer, UIntPtr length,
                                                                     IntPtr tag, UInt32 flags);
 
-        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpc_call_start_write_from_copied_buffer")]
-        static extern void grpc_call_start_write_from_copied_buffer_CALLBACK(CallSafeHandle call,
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_start_write_from_copied_buffer")]
+        static extern void grpcsharp_call_start_write_from_copied_buffer_CALLBACK(CallSafeHandle call,
                                                                              byte[] buffer, UIntPtr length,
                                                                              [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback,
                                                                              UInt32 flags);
 
-		[DllImport("grpc.dll")]
-		static extern void grpc_call_destroy(IntPtr call);
+		[DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_call_destroy(IntPtr call);
 
         private CallSafeHandle()
         {
@@ -86,87 +86,87 @@ namespace Google.GRPC.Core.Internal
         /// </summary>
         public static CallSafeHandle Create(ChannelSafeHandle channel, string method, string host, Timespec deadline)
         {
-            return grpc_channel_create_call_old(channel, method, host, deadline);
+            return grpcsharp_channel_create_call_old(channel, method, host, deadline);
         }
 
         public void Invoke(CompletionQueueSafeHandle cq, IntPtr metadataReadTag, IntPtr finishedTag, bool buffered)
         {   
-            AssertCallOk(grpc_call_invoke_old(this, cq, metadataReadTag, finishedTag, GetFlags(buffered)));
+            AssertCallOk(grpcsharp_call_invoke_old(this, cq, metadataReadTag, finishedTag, GetFlags(buffered)));
         }
 
         public void Invoke(CompletionQueueSafeHandle cq, bool buffered, EventCallbackDelegate metadataReadCallback, EventCallbackDelegate finishedCallback)
         {   
-            AssertCallOk(grpc_call_invoke_old_CALLBACK(this, cq, metadataReadCallback, finishedCallback, GetFlags(buffered)));
+            AssertCallOk(grpcsharp_call_invoke_old_CALLBACK(this, cq, metadataReadCallback, finishedCallback, GetFlags(buffered)));
         }
 
         public void ServerAccept(CompletionQueueSafeHandle cq, IntPtr finishedTag)
         {
-            AssertCallOk(grpc_call_server_accept_old(this, cq, finishedTag));
+            AssertCallOk(grpcsharp_call_server_accept_old(this, cq, finishedTag));
         }
 
         public void ServerAccept(CompletionQueueSafeHandle cq, EventCallbackDelegate callback)
         {
-            AssertCallOk(grpc_call_server_accept_old_CALLBACK(this, cq, callback));
+            AssertCallOk(grpcsharp_call_server_accept_old_CALLBACK(this, cq, callback));
         }
 
         public void ServerEndInitialMetadata(UInt32 flags)
         {
-            AssertCallOk(grpc_call_server_end_initial_metadata_old(this, flags));
+            AssertCallOk(grpcsharp_call_server_end_initial_metadata_old(this, flags));
         }
 
         public void StartWrite(byte[] payload, IntPtr tag, bool buffered)
         {
-            grpc_call_start_write_from_copied_buffer(this, payload, new UIntPtr((ulong) payload.Length), tag, GetFlags(buffered));
+            grpcsharp_call_start_write_from_copied_buffer(this, payload, new UIntPtr((ulong) payload.Length), tag, GetFlags(buffered));
         }
 
         public void StartWrite(byte[] payload, bool buffered, EventCallbackDelegate callback)
         {
-            grpc_call_start_write_from_copied_buffer_CALLBACK(this, payload, new UIntPtr((ulong) payload.Length), callback, GetFlags(buffered));
+            grpcsharp_call_start_write_from_copied_buffer_CALLBACK(this, payload, new UIntPtr((ulong) payload.Length), callback, GetFlags(buffered));
         }
 
         public void StartWriteStatus(Status status, IntPtr tag)
         {
-            AssertCallOk(grpc_call_start_write_status_old(this, status.StatusCode, status.Detail, tag));
+            AssertCallOk(grpcsharp_call_start_write_status_old(this, status.StatusCode, status.Detail, tag));
         }
 
         public void StartWriteStatus(Status status, EventCallbackDelegate callback)
         {
-            AssertCallOk(grpc_call_start_write_status_old_CALLBACK(this, status.StatusCode, status.Detail, callback));
+            AssertCallOk(grpcsharp_call_start_write_status_old_CALLBACK(this, status.StatusCode, status.Detail, callback));
         }
 
         public void WritesDone(IntPtr tag)
         {
-            AssertCallOk(grpc_call_writes_done_old(this, tag));
+            AssertCallOk(grpcsharp_call_writes_done_old(this, tag));
         }
 
         public void WritesDone(EventCallbackDelegate callback)
         {
-            AssertCallOk(grpc_call_writes_done_old_CALLBACK(this, callback));
+            AssertCallOk(grpcsharp_call_writes_done_old_CALLBACK(this, callback));
         }
 
         public void StartRead(IntPtr tag)
         {
-            AssertCallOk(grpc_call_start_read_old(this, tag));
+            AssertCallOk(grpcsharp_call_start_read_old(this, tag));
         }
 
         public void StartRead(EventCallbackDelegate callback)
         {
-            AssertCallOk(grpc_call_start_read_old_CALLBACK(this, callback));
+            AssertCallOk(grpcsharp_call_start_read_old_CALLBACK(this, callback));
         }
 
         public void Cancel()
         {
-            AssertCallOk(grpc_call_cancel(this));
+            AssertCallOk(grpcsharp_call_cancel(this));
         }
 
         public void CancelWithStatus(Status status)
         {
-            AssertCallOk(grpc_call_cancel_with_status(this, status.StatusCode, status.Detail));
+            AssertCallOk(grpcsharp_call_cancel_with_status(this, status.StatusCode, status.Detail));
         }
 
 		protected override bool ReleaseHandle()
 		{
-			grpc_call_destroy(handle);
+            grpcsharp_call_destroy(handle);
 			return true;
 		}
 
diff --git a/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs b/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs
index 0f38d63f98..6436f2bb31 100644
--- a/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs
@@ -10,11 +10,11 @@ namespace Google.GRPC.Core.Internal
     /// </summary>
 	internal class ChannelSafeHandle : SafeHandleZeroIsInvalid
 	{
-        [DllImport("grpc.dll")]
-        static extern ChannelSafeHandle grpc_channel_create(string target, IntPtr channelArgs);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern ChannelSafeHandle grpcsharp_channel_create(string target, IntPtr channelArgs);
 
-		[DllImport("grpc.dll")]
-		static extern void grpc_channel_destroy(IntPtr channel);
+		[DllImport("grpc_csharp_ext.dll")]
+		static extern void grpcsharp_channel_destroy(IntPtr channel);
 
         private ChannelSafeHandle()
         {
@@ -22,12 +22,12 @@ namespace Google.GRPC.Core.Internal
 
         public static ChannelSafeHandle Create(string target, IntPtr channelArgs)
         {
-            return grpc_channel_create(target, channelArgs);
+            return grpcsharp_channel_create(target, channelArgs);
         }
 
 		protected override bool ReleaseHandle()
 		{
-			grpc_channel_destroy(handle);
+			grpcsharp_channel_destroy(handle);
 			return true;
 		}
 	}
diff --git a/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs b/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs
index f098de6820..77d8bde375 100644
--- a/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs
@@ -9,23 +9,23 @@ namespace Google.GRPC.Core.Internal
     /// </summary>
 	internal class CompletionQueueSafeHandle : SafeHandleZeroIsInvalid
 	{
-        [DllImport("grpc.dll")]
-        static extern CompletionQueueSafeHandle grpc_completion_queue_create();
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern CompletionQueueSafeHandle grpcsharp_completion_queue_create();
 
-        [DllImport("grpc.dll")]
-        static extern EventSafeHandle grpc_completion_queue_pluck(CompletionQueueSafeHandle cq, IntPtr tag, Timespec deadline);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern EventSafeHandle grpcsharp_completion_queue_pluck(CompletionQueueSafeHandle cq, IntPtr tag, Timespec deadline);
 
-        [DllImport("grpc.dll")]
-        static extern EventSafeHandle grpc_completion_queue_next(CompletionQueueSafeHandle cq, Timespec deadline);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern EventSafeHandle grpcsharp_completion_queue_next(CompletionQueueSafeHandle cq, Timespec deadline);
 
-        [DllImport("grpc.dll")]
-        static extern void grpc_completion_queue_shutdown(CompletionQueueSafeHandle cq);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_completion_queue_shutdown(CompletionQueueSafeHandle cq);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCCompletionType grpc_completion_queue_next_with_callback(CompletionQueueSafeHandle cq);
+        static extern GRPCCompletionType grpcsharp_completion_queue_next_with_callback(CompletionQueueSafeHandle cq);
 
-        [DllImport("grpc.dll")]
-        static extern void grpc_completion_queue_destroy(IntPtr cq);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_completion_queue_destroy(IntPtr cq);
 
         private CompletionQueueSafeHandle()
         {
@@ -33,32 +33,32 @@ namespace Google.GRPC.Core.Internal
 
         public static CompletionQueueSafeHandle Create()
         {
-            return grpc_completion_queue_create();
+            return grpcsharp_completion_queue_create();
         }
 
         public EventSafeHandle Next(Timespec deadline)
         {
-            return grpc_completion_queue_next(this, deadline);
+            return grpcsharp_completion_queue_next(this, deadline);
         }
 
         public GRPCCompletionType NextWithCallback()
         {
-            return grpc_completion_queue_next_with_callback(this);
+            return grpcsharp_completion_queue_next_with_callback(this);
         }
 
         public EventSafeHandle Pluck(IntPtr tag, Timespec deadline)
         {
-            return grpc_completion_queue_pluck(this, tag, deadline);
+            return grpcsharp_completion_queue_pluck(this, tag, deadline);
         }
 
         public void Shutdown()
         {
-            grpc_completion_queue_shutdown(this);
+            grpcsharp_completion_queue_shutdown(this);
         }
 
 		protected override bool ReleaseHandle()
         {
-            grpc_completion_queue_destroy(handle);
+            grpcsharp_completion_queue_destroy(handle);
 			return true;
 		}
 	}
diff --git a/src/csharp/GrpcCore/Internal/Event.cs b/src/csharp/GrpcCore/Internal/Event.cs
index 5853ddd570..cefe8cfbb2 100644
--- a/src/csharp/GrpcCore/Internal/Event.cs
+++ b/src/csharp/GrpcCore/Internal/Event.cs
@@ -9,84 +9,84 @@ namespace Google.GRPC.Core.Internal
     /// </summary>
     internal class EventSafeHandle : SafeHandleZeroIsInvalid
     {
-        [DllImport("grpc.dll")]
-        static extern void grpc_event_finish(IntPtr ev);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_event_finish(IntPtr ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCCompletionType grpc_event_type(EventSafeHandle ev);
+        static extern GRPCCompletionType grpcsharp_event_type(EventSafeHandle ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern CallSafeHandle grpc_event_call(EventSafeHandle ev);
+        static extern CallSafeHandle grpcsharp_event_call(EventSafeHandle ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCOpError grpc_event_write_accepted(EventSafeHandle ev);
+        static extern GRPCOpError grpcsharp_event_write_accepted(EventSafeHandle ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCOpError grpc_event_finish_accepted(EventSafeHandle ev);
+        static extern GRPCOpError grpcsharp_event_finish_accepted(EventSafeHandle ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern StatusCode grpc_event_finished_status(EventSafeHandle ev);
+        static extern StatusCode grpcsharp_event_finished_status(EventSafeHandle ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern IntPtr grpc_event_finished_details(EventSafeHandle ev);  // returns const char*
+        static extern IntPtr grpcsharp_event_finished_details(EventSafeHandle ev);  // returns const char*
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern IntPtr grpc_event_read_length(EventSafeHandle ev);
+        static extern IntPtr grpcsharp_event_read_length(EventSafeHandle ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern void grpc_event_read_copy_to_buffer(EventSafeHandle ev, byte[] buffer, UIntPtr bufferLen);
+        static extern void grpcsharp_event_read_copy_to_buffer(EventSafeHandle ev, byte[] buffer, UIntPtr bufferLen);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern IntPtr grpc_event_server_rpc_new_method(EventSafeHandle ev); // returns const char*
+        static extern IntPtr grpcsharp_event_server_rpc_new_method(EventSafeHandle ev); // returns const char*
 
         public GRPCCompletionType GetCompletionType()
         {
-            return grpc_event_type(this);
+            return grpcsharp_event_type(this);
         }
 
         public GRPCOpError GetWriteAccepted()
         {
-            return grpc_event_write_accepted(this);
+            return grpcsharp_event_write_accepted(this);
         }
 
         public GRPCOpError GetFinishAccepted()
         {
-            return grpc_event_finish_accepted(this);
+            return grpcsharp_event_finish_accepted(this);
         }
 
         public Status GetFinished()
         {
             // TODO: can the native method return string directly?
-            string details = Marshal.PtrToStringAnsi(grpc_event_finished_details(this));
-            return new Status(grpc_event_finished_status(this), details);
+            string details = Marshal.PtrToStringAnsi(grpcsharp_event_finished_details(this));
+            return new Status(grpcsharp_event_finished_status(this), details);
         }
 
         public byte[] GetReadData()
         {
-            IntPtr len = grpc_event_read_length(this);
+            IntPtr len = grpcsharp_event_read_length(this);
             if (len == new IntPtr(-1))
             {
                 return null;
             }
             byte[] data = new byte[(int) len];
-            grpc_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
+            grpcsharp_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
             return data;
         }
 
         public CallSafeHandle GetCall() {
-            return grpc_event_call(this);
+            return grpcsharp_event_call(this);
         }
 
         public string GetServerRpcNewMethod() {
             // TODO: can the native method return string directly?
-            return Marshal.PtrToStringAnsi(grpc_event_server_rpc_new_method(this));
+            return Marshal.PtrToStringAnsi(grpcsharp_event_server_rpc_new_method(this));
         }
 
         //TODO: client_metadata_read event type
 
         protected override bool ReleaseHandle()
         {
-            grpc_event_finish(handle);
+            grpcsharp_event_finish(handle);
             return true;
         }
     }
@@ -98,35 +98,35 @@ namespace Google.GRPC.Core.Internal
     /// </summary>
     internal class EventSafeHandleNotOwned : SafeHandleZeroIsInvalid
     {
-        [DllImport("grpc.dll")]
-        static extern void grpc_event_finish(IntPtr ev);
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern void grpcsharp_event_finish(IntPtr ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCCompletionType grpc_event_type(EventSafeHandleNotOwned ev);
+        static extern GRPCCompletionType grpcsharp_event_type(EventSafeHandleNotOwned ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern CallSafeHandle grpc_event_call(EventSafeHandleNotOwned ev);
+        static extern CallSafeHandle grpcsharp_event_call(EventSafeHandleNotOwned ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCOpError grpc_event_write_accepted(EventSafeHandleNotOwned ev);
+        static extern GRPCOpError grpcsharp_event_write_accepted(EventSafeHandleNotOwned ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern GRPCOpError grpc_event_finish_accepted(EventSafeHandleNotOwned ev);
+        static extern GRPCOpError grpcsharp_event_finish_accepted(EventSafeHandleNotOwned ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern StatusCode grpc_event_finished_status(EventSafeHandleNotOwned ev);
+        static extern StatusCode grpcsharp_event_finished_status(EventSafeHandleNotOwned ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern IntPtr grpc_event_finished_details(EventSafeHandleNotOwned ev);  // returns const char*
+        static extern IntPtr grpcsharp_event_finished_details(EventSafeHandleNotOwned ev);  // returns const char*
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern IntPtr grpc_event_read_length(EventSafeHandleNotOwned ev);
+        static extern IntPtr grpcsharp_event_read_length(EventSafeHandleNotOwned ev);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern void grpc_event_read_copy_to_buffer(EventSafeHandleNotOwned ev, byte[] buffer, UIntPtr bufferLen);
+        static extern void grpcsharp_event_read_copy_to_buffer(EventSafeHandleNotOwned ev, byte[] buffer, UIntPtr bufferLen);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern IntPtr grpc_event_server_rpc_new_method(EventSafeHandleNotOwned ev); // returns const char*
+        static extern IntPtr grpcsharp_event_server_rpc_new_method(EventSafeHandleNotOwned ev); // returns const char*
 
         public EventSafeHandleNotOwned() : base(false)
         {
@@ -139,52 +139,52 @@ namespace Google.GRPC.Core.Internal
 
         public GRPCCompletionType GetCompletionType()
         {
-            return grpc_event_type(this);
+            return grpcsharp_event_type(this);
         }
 
         public GRPCOpError GetWriteAccepted()
         {
-            return grpc_event_write_accepted(this);
+            return grpcsharp_event_write_accepted(this);
         }
 
         public GRPCOpError GetFinishAccepted()
         {
-            return grpc_event_finish_accepted(this);
+            return grpcsharp_event_finish_accepted(this);
         }
 
         public Status GetFinished()
         {
             // TODO: can the native method return string directly?
-            string details = Marshal.PtrToStringAnsi(grpc_event_finished_details(this));
-            return new Status(grpc_event_finished_status(this), details);
+            string details = Marshal.PtrToStringAnsi(grpcsharp_event_finished_details(this));
+            return new Status(grpcsharp_event_finished_status(this), details);
         }
 
         public byte[] GetReadData()
         {
-            IntPtr len = grpc_event_read_length(this);
+            IntPtr len = grpcsharp_event_read_length(this);
             if (len == new IntPtr(-1))
             {
                 return null;
             }
             byte[] data = new byte[(int) len];
-            grpc_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
+            grpcsharp_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
             return data;
         }
 
         public CallSafeHandle GetCall() {
-            return grpc_event_call(this);
+            return grpcsharp_event_call(this);
         }
 
         public string GetServerRpcNewMethod() {
             // TODO: can the native method return string directly?
-            return Marshal.PtrToStringAnsi(grpc_event_server_rpc_new_method(this));
+            return Marshal.PtrToStringAnsi(grpcsharp_event_server_rpc_new_method(this));
         }
 
         //TODO: client_metadata_read event type
 
         protected override bool ReleaseHandle()
         {
-            grpc_event_finish(handle);
+            grpcsharp_event_finish(handle);
             return true;
         }
     }
diff --git a/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs b/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs
index d363b34f0b..82587c88b7 100644
--- a/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs
@@ -10,30 +10,30 @@ namespace Google.GRPC.Core.Internal
     /// </summary>
     internal sealed class ServerSafeHandle : SafeHandleZeroIsInvalid
     {
-        [DllImport("grpc.dll", EntryPoint = "grpc_server_request_call_old")]
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpc_server_request_call_old")]
         static extern GRPCCallError grpc_server_request_call_old_CALLBACK(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
 
-        [DllImport("grpc.dll")]
+        [DllImport("grpc_csharp_ext.dll")]
         static extern ServerSafeHandle grpc_server_create(CompletionQueueSafeHandle cq, IntPtr args);
 
         // TODO: check int representation size
-        [DllImport("grpc.dll")]
+        [DllImport("grpc_csharp_ext.dll")]
         static extern int grpc_server_add_http2_port(ServerSafeHandle server, string addr);
 
         // TODO: check int representation size
-        [DllImport("grpc.dll")]
+        [DllImport("grpc_csharp_ext.dll")]
         static extern int grpc_server_add_secure_http2_port(ServerSafeHandle server, string addr);
 
-        [DllImport("grpc.dll")]
+        [DllImport("grpc_csharp_ext.dll")]
         static extern void grpc_server_start(ServerSafeHandle server);
 
-        [DllImport("grpc.dll")]
+        [DllImport("grpc_csharp_ext.dll")]
         static extern void grpc_server_shutdown(ServerSafeHandle server);
 
-        [DllImport("grpc.dll", EntryPoint = "grpc_server_shutdown_and_notify")]
+        [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpc_server_shutdown_and_notify")]
         static extern void grpc_server_shutdown_and_notify_CALLBACK(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
 
-        [DllImport("grpc.dll")]
+        [DllImport("grpc_csharp_ext.dll")]
         static extern void grpc_server_destroy(IntPtr server);
 
         private ServerSafeHandle()
diff --git a/src/csharp/GrpcCore/Internal/Timespec.cs b/src/csharp/GrpcCore/Internal/Timespec.cs
index 5a197e121c..d874691172 100644
--- a/src/csharp/GrpcCore/Internal/Timespec.cs
+++ b/src/csharp/GrpcCore/Internal/Timespec.cs
@@ -13,8 +13,14 @@ namespace Google.GRPC.Core.Internal
         const int nanosPerSecond = 1000 * 1000 * 1000;
         const int nanosPerTick = 100;
 
-        [DllImport("gpr.dll")]
-        static extern Timespec gpr_now();
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern Timespec gprsharp_now();
+
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern Timespec gprsharp_inf_future();
+
+        [DllImport("grpc_csharp_ext.dll")]
+        static extern int gprsharp_sizeof_timespec();
 
 		// TODO: this only works on 64bit linux, can we autoselect the right size of ints?
 		// perhaps using IntPtr would work.
@@ -28,8 +34,7 @@ namespace Google.GRPC.Core.Internal
 		{
 			get
 			{
-				// TODO: set correct value based on the length of the struct
-				return new Timespec { tv_sec = Int32.MaxValue, tv_nsec = 0 };
+                return gprsharp_inf_future();
 			}
 		}
 
@@ -37,7 +42,7 @@ namespace Google.GRPC.Core.Internal
         {
             get
             {
-                return gpr_now();
+                return gprsharp_now();
             }
         }