public void SendMessage(string message) { lock (this) { AttachedDuplexOutputChannel.SendMessage(message); } }
public virtual void AttachDuplexOutputChannel(IDuplexOutputChannel duplexOutputChannel) { using (EneterTrace.Entering()) { using (ThreadLock.Lock(myDuplexOutputChannelManipulatorLock)) { Attach(duplexOutputChannel); try { AttachedDuplexOutputChannel.OpenConnection(); } catch (Exception err) { try { DetachDuplexOutputChannel(); } catch { // Ignore exception in exception. } string aMessage = TracedObject + ErrorHandler.FailedToOpenConnection; EneterTrace.Error(aMessage, err); throw; } } } }
/// <summary> /// The method is called when a message from the attached duplex input channel is received. /// The received message is wrapped and sent to the duplex output channel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnMessageReceived(object sender, DuplexChannelMessageEventArgs e) { using (EneterTrace.Entering()) { if (!IsDuplexOutputChannelAttached) { EneterTrace.Error(TracedObject + "is not attached to the duplex output channel."); return; } try { using (ThreadLock.Lock(myDuplexInputChannels)) { myDuplexInputChannels[e.ChannelId].ResponseReceiverId = e.ResponseReceiverId; } ISerializer aSerializer = mySerializer.ForResponseReceiver(e.ResponseReceiverId); object aMessage = DataWrapper.Wrap(e.ChannelId, e.Message, aSerializer); AttachedDuplexOutputChannel.SendMessage(aMessage); } catch (Exception err) { EneterTrace.Error(TracedObject + "failed to send the message to the duplex output channel '" + e.ChannelId + "'.", err); } } }
public virtual void DetachDuplexOutputChannel() { using (EneterTrace.Entering()) { using (ThreadLock.Lock(myDuplexOutputChannelManipulatorLock)) { if (AttachedDuplexOutputChannel != null) { try { // Try to notify, the connection is closed. AttachedDuplexOutputChannel.CloseConnection(); } finally { // Detach the event handler. AttachedDuplexOutputChannel.ConnectionOpened -= OnConnectionOpened; AttachedDuplexOutputChannel.ConnectionClosed -= OnConnectionClosed; AttachedDuplexOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; AttachedDuplexOutputChannel = null; } } } } }
public void AttachDuplexOutputChannel(IDuplexOutputChannel duplexOutputChannel) { lock (this) { Attach(duplexOutputChannel); AttachedDuplexOutputChannel.OpenConnection(); } }
public void DetachDuplexOutputChannel() { lock (this) { if (AttachedDuplexOutputChannel != null) { AttachedDuplexOutputChannel.CloseConnection(); AttachedDuplexOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; AttachedDuplexOutputChannel = null; } } }
private object CallService(RpcMessage rpcRequest) { using (EneterTrace.Entering()) { if (AttachedDuplexOutputChannel == null) { string anError = TracedObject + ErrorHandler.FailedToSendMessageBecauseNotAttached; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } try { RemoteCallContext anRpcSyncContext = new RemoteCallContext(); using (ThreadLock.Lock(myPendingRemoteCalls)) { myPendingRemoteCalls.Add(rpcRequest.Id, anRpcSyncContext); } // Send the request. object aSerializedMessage = mySerializer.ForResponseReceiver(AttachedDuplexOutputChannel.ResponseReceiverId).Serialize <RpcMessage>(rpcRequest); AttachedDuplexOutputChannel.SendMessage(aSerializedMessage); // Wait for the response. if (!anRpcSyncContext.RpcCompleted.WaitOne((int)myRpcTimeout.TotalMilliseconds)) { throw new TimeoutException("Remote call has not returned within the specified timeout " + myRpcTimeout + "."); } if (anRpcSyncContext.Error != null) { throw anRpcSyncContext.Error; } return(anRpcSyncContext.SerializedReturnValue); } catch (Exception err) { EneterTrace.Error(TracedObject + "." + rpcRequest.OperationName + "(..) " + ErrorHandler.FailedToSendMessage, err); throw; } finally { using (ThreadLock.Lock(myPendingRemoteCalls)) { myPendingRemoteCalls.Remove(rpcRequest.Id); } } } }
public void SendMessage(string message) { using (EneterTrace.Entering()) { if (AttachedDuplexOutputChannel == null) { string anError = TracedObject + ErrorHandler.FailedToSendMessageBecauseNotAttached; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } try { AttachedDuplexOutputChannel.SendMessage(message); } catch (Exception err) { EneterTrace.Error(TracedObject + ErrorHandler.FailedToSendMessage, err); throw; } } }
public void SendRequestMessage(_RequestType message) { using (EneterTrace.Entering()) { if (AttachedDuplexOutputChannel == null) { string anError = TracedObject + ErrorHandler.FailedToSendMessageBecauseNotAttached; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } try { object aRequestMessage = mySerializer.ForResponseReceiver(AttachedDuplexOutputChannel.ResponseReceiverId).Serialize <_RequestType>(message); AttachedDuplexOutputChannel.SendMessage(aRequestMessage); } catch (Exception err) { EneterTrace.Error(TracedObject + ErrorHandler.FailedToSendMessage, err); throw; } } }
private void Send(BrokerMessage message) { using (EneterTrace.Entering()) { if (AttachedDuplexOutputChannel == null) { string anError = TracedObject + "failed to send the message because it is not attached to any duplex output channel."; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } try { object aSerializedMessage = mySerializer.ForResponseReceiver(AttachedDuplexOutputChannel.ResponseReceiverId).Serialize <BrokerMessage>(message); AttachedDuplexOutputChannel.SendMessage(aSerializedMessage); } catch (Exception err) { string anError = TracedObject + "failed to send a message to the Broker."; EneterTrace.Error(anError, err); throw; } } }