protected bool finished; // True if close has been received from the peer. public AsyncCallBase(Func <TWrite, byte[]> serializer, Func <byte[], TRead> deserializer) { this.serializer = Preconditions.CheckNotNull(serializer); this.deserializer = Preconditions.CheckNotNull(deserializer); this.sendFinishedHandler = CreateBatchCompletionCallback(HandleSendFinished); this.readFinishedHandler = CreateBatchCompletionCallback(HandleReadFinished); this.halfclosedHandler = CreateBatchCompletionCallback(HandleHalfclosed); }
public AsyncCall(Func <TWrite, byte[]> serializer, Func <byte[], TRead> deserializer) { this.serializer = serializer; this.deserializer = deserializer; this.unaryResponseHandler = HandleUnaryResponse; this.finishedHandler = HandleFinished; this.writeFinishedHandler = HandleWriteFinished; this.readFinishedHandler = HandleReadFinished; this.halfclosedHandler = HandleHalfclosed; this.finishedServersideHandler = HandleFinishedServerside; }
public void NopPInvokeBenchmark() { CompletionCallbackDelegate handler = Handler; BenchmarkUtil.RunBenchmark( 1000000, 100000000, () => { grpcsharp_test_nop(IntPtr.Zero); } ); }
public void NativeCallbackBenchmark() { CompletionCallbackDelegate handler = Handler; counter = 0; BenchmarkUtil.RunBenchmark( 1000000, 10000000, () => { grpcsharp_test_callback(handler); } ); Assert.AreNotEqual(0, counter); }
public void ShutdownAndNotify(CompletionCallbackDelegate callback) { grpcsharp_server_shutdown_and_notify_callback(this, callback); }
public GRPCCallError RequestCall(CompletionQueueSafeHandle cq, CompletionCallbackDelegate callback) { return grpcsharp_server_request_call(this, cq, callback); }
static extern GRPCCallError grpcsharp_call_send_status_from_server(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback, StatusCode statusCode, string statusMessage);
static extern GRPCCallError grpcsharp_call_send_message(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback, byte[] send_buffer, UIntPtr send_buffer_len);
public void StartDuplexStreaming(CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_start_duplex_streaming(this, callback)); }
public void StartServerSide(CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_start_serverside(this, callback)); }
public void StartSendStatusFromServer(Status status, CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_send_status_from_server(this, callback, status.StatusCode, status.Detail)); }
public void StartSendMessage(byte[] payload, CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_send_message(this, callback, payload, new UIntPtr((ulong)payload.Length))); }
public void StartSendCloseFromClient(CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_send_close_from_client(this, callback)); }
public void StartDuplexStreaming(CompletionCallbackDelegate callback, MetadataArraySafeHandle metadataArray) { AssertCallOk(grpcsharp_call_start_duplex_streaming(this, callback, metadataArray)); }
public void StartUnary(byte[] payload, CompletionCallbackDelegate callback, MetadataArraySafeHandle metadataArray) { AssertCallOk(grpcsharp_call_start_unary(this, callback, payload, new UIntPtr((ulong)payload.Length), metadataArray)); }
static extern GRPCCallError grpcsharp_call_start_client_streaming(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
static extern GRPCCallError grpcsharp_server_request_call(ServerSafeHandle server, CompletionQueueSafeHandle cq, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
public Server() { this.handle = ServerSafeHandle.NewServer(GetCompletionQueue(), IntPtr.Zero); this.newServerRpcHandler = HandleNewServerRpc; this.serverShutdownHandler = HandleServerShutdown; }
public void StartServerStreaming(byte[] payload, CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_start_server_streaming(this, callback, payload, new UIntPtr((ulong)payload.Length))); }
static extern GRPCCallError grpcsharp_call_start_server_streaming(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback, byte[] send_buffer, UIntPtr send_buffer_len, MetadataArraySafeHandle metadataArray);
public void StartUnary(byte[] payload, CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_start_unary(this, callback, payload, new UIntPtr((ulong)payload.Length))); }
public void StartClientStreaming(CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_start_client_streaming(this, callback)); }
static extern void grpcsharp_call_blocking_unary(CallSafeHandle call, CompletionQueueSafeHandle dedicatedCq, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback, byte[] send_buffer, UIntPtr send_buffer_len, MetadataArraySafeHandle metadataArray);
public void BlockingUnary(CompletionQueueSafeHandle dedicatedCq, byte[] payload, CompletionCallbackDelegate callback) { grpcsharp_call_blocking_unary(this, dedicatedCq, callback, payload, new UIntPtr((ulong)payload.Length)); }
static extern GRPCCallError grpcsharp_call_start_duplex_streaming(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback, MetadataArraySafeHandle metadataArray);
static extern GRPCCallError grpcsharp_call_send_close_from_client(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
static extern GRPCCallError grpcsharp_call_recv_message(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
public void StartReceiveMessage(CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_call_recv_message(this, callback)); }
static extern void grpcsharp_server_shutdown_and_notify_callback(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);
public void BlockingUnary(CompletionQueueSafeHandle dedicatedCq, byte[] payload, CompletionCallbackDelegate callback, MetadataArraySafeHandle metadataArray) { grpcsharp_call_blocking_unary(this, dedicatedCq, callback, payload, new UIntPtr((ulong)payload.Length), metadataArray); }
public void RequestCall(CompletionQueueSafeHandle cq, CompletionCallbackDelegate callback) { AssertCallOk(grpcsharp_server_request_call(this, cq, callback)); }
public void StartServerStreaming(byte[] payload, CompletionCallbackDelegate callback, MetadataArraySafeHandle metadataArray) { AssertCallOk(grpcsharp_call_start_server_streaming(this, callback, payload, new UIntPtr((ulong)payload.Length), metadataArray)); }
bool readObserverCompleted; // True if readObserver has already been completed. public AsyncCall(Func <TRequest, byte[]> serializer, Func <byte[], TResponse> deserializer) : base(serializer, deserializer) { this.unaryResponseHandler = CreateBatchCompletionCallback(HandleUnaryResponse); this.finishedHandler = CreateBatchCompletionCallback(HandleFinished); }
public AsyncCallServer(Func <TResponse, byte[]> serializer, Func <byte[], TRequest> deserializer) : base(serializer, deserializer) { this.finishedServersideHandler = CreateBatchCompletionCallback(HandleFinishedServerside); }
static extern GRPCCallError grpcsharp_test_callback([MarshalAs(UnmanagedType.FunctionPtr)] CompletionCallbackDelegate callback);