private void OnMessageAvailable(MessageAvailableEventArgs value)
{
using (var childServiceLocator = this.ServiceLocator.CreateNestedContainer())
{
var currentMessageContext = new MessageContext(
bus: this.Bus,
messageID: value.TransportMessage.MessageId,
headers: value.TransportMessage.Headers,
currentMessage: value.TransportMessage.DecodedMessage,
serviceLocator: childServiceLocator);
// register a bunch of things we might want to use during the message handling
childServiceLocator.RegisterSingleton <IBus>(this.Bus);
childServiceLocator.RegisterSingleton(this.MessageHandlers);
childServiceLocator.RegisterSingleton <IMessageMapper>(this.MessageMapper);
childServiceLocator.RegisterSingleton <MessageContext>(currentMessageContext);
try
{
var stopwatch = Stopwatch.StartNew();
var startTimestamp = DateTime.UtcNow;
compiledMessageHandlerPipeline(currentMessageContext);
stopwatch.Stop();
var endTimestamp = startTimestamp.AddTicks(stopwatch.ElapsedTicks);
OnMessageProcessed(new MessageProcessedEventArgs(currentMessageContext, startTimestamp, endTimestamp, stopwatch.Elapsed.TotalMilliseconds));
}
finally
{
currentMessageContext = null;
}
}
}
/// <summary>
/// Publish the Message Available Event.
/// </summary>
/// <param name="messageAvailable">Available message.</param>
private void PublishMessageAvailableEvent(MessageAvailableEventArgs messageAvailableEvent)
{
if (OnMessageAvailable != null)
{
OnMessageAvailable(this, messageAvailableEvent);
}
}
private void Sw_MessageAvailable(object sender, MessageAvailableEventArgs e)
{
if ((!backgroundWorker1.CancellationPending) && (backgroundWorker1.IsBusy))
{
backgroundWorker1.ReportProgress(0, e.MessageString);
}
}
protected void OnMessageAvailable(MessageAvailableEventArgs e)
{
var handler = MessageAvailable;
if (handler != null)
{
handler(this, e);
}
}
private void NewMessageTask(object obj, MessageAvailableEventArgs args)
{
MCPPacket packet = MCPPacket.Parse(args.Message);
if (packet.IpAddress.ToString() + ":" + packet.Port.ToString() != myIpAddress.ToString() + ":" + myPort.ToString())
{
AnalysePacket(packet);
}
}
/// <summary>
/// Only intereseted in Storage Commitment N-Event-Report Response messages.
/// Signal the local N-Event-Report Response semaphore on receipt of this message type.
/// </summary>
/// <param name="server">Event source.</param>
/// <param name="messageAvailableEvent">Message Available Event Details.</param>
private void HandleStorageCommitmentNEventReportResponse(object server, MessageAvailableEventArgs messageAvailableEvent)
{
if (messageAvailableEvent.Message.Message is DicomProtocolMessage)
{
DicomProtocolMessage dicomProtocolMessage = (DicomProtocolMessage)messageAvailableEvent.Message.Message;
if (dicomProtocolMessage is DvtkHighLevelInterface.Dicom.Messages.DicomMessage)
{
DvtkHighLevelInterface.Dicom.Messages.DicomMessage dicomMessage = (DvtkHighLevelInterface.Dicom.Messages.DicomMessage)dicomProtocolMessage;
if (dicomMessage.CommandSet.DimseCommand == DvtkData.Dimse.DimseCommand.NEVENTREPORTRSP)
{
if (_storageCommitmentNEventReportResponseSemaphore != null)
{
_storageCommitmentNEventReportResponseSemaphore.Signal();
}
}
}
}
}
/// <summary>
/// Message is available.
/// </summary>
/// <param name="server">Event source.</param>
/// <param name="messageAvailableEvent">Message Available Event Details.</param>
private void MessageIsAvailable(object server, MessageAvailableEventArgs messageAvailableEvent)
{
// Publish the event to any interested parties.
PublishMessageAvailableEvent(messageAvailableEvent);
}
private void DataAvailable(object obj, MessageAvailableEventArgs args)
{
byte[] decoded = codec.Decode(args.Message, 0, args.Message.Length);
AudioDataAvailableEvent?.Invoke(this, decoded);
}
