/// <summary> /// Handles the specified message. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="timeOut">The time out.</param> /// <param name="queueWait">The queue wait.</param> /// <returns></returns> /// <exception cref="System.TimeoutException"></exception> public IReceivedMessage <TReceivedMessage> Handle(IMessageId messageId, TimeSpan timeOut, IQueueWait queueWait) { Guard.NotNull(() => messageId, messageId); Guard.NotNull(() => queueWait, queueWait); //use a message context, and talk to the transport directly //we are not going to use the consumer queue, because we are going to re-use the calling thread for all of the work below using (var context = _messageContextFactory.Create()) { var recMessage = _receiveMessagesFactory.Create(); //set message Id on the context, so that the transport knows we want a particular message context.Set(_configurationReceive.HeaderNames.StandardHeaders.RpcContext, _rpcContextFactory.Create(messageId, timeOut)); //use a stop watch to determine when we have timed out var sw = new Stopwatch(); sw.Start(); while (true) { var messageRec = recMessage.ReceiveMessage(context); if (messageRec != null) { _commitMessage.Commit(context); return((IReceivedMessage <TReceivedMessage>)_messageHandler.GenerateMessage(messageRec)); } if (sw.ElapsedMilliseconds >= timeOut.TotalMilliseconds) { throw new TimeoutException(); } queueWait.Wait(); } } }
private async ValueTask FlushAndClean() { await Flush(); _lastCumulativeAck = (MessageId)IMessageId.Earliest; _pendingIndividualAcks.Clear(); }
public int CompareTo(IMessageId o) { if (o is BatchMessageId bm) { var ord = 0; var ledgercompare = _ledgerId.CompareTo(bm.LedgerId); if (ledgercompare != 0) { ord = ledgercompare; } var entryCompare = EntryId.CompareTo(bm.EntryId); if (entryCompare != 0 && ord == 0) { ord = entryCompare; } var partitionCompare = PartitionIndex.CompareTo(bm.PartitionIndex); if (partitionCompare != 0 && ord == 0) { ord = partitionCompare; } var result = ledgercompare == 0 && entryCompare == 0 && partitionCompare == 0; if (result && bm.BatchIndex > -1) { return(-1); } return(ord); } if (o is MessageId other) { var ledgerCompare = _ledgerId.CompareTo(other.LedgerId); if (ledgerCompare != 0) { return(ledgerCompare); } var entryCompare = _entryId.CompareTo(other.EntryId); if (entryCompare != 0) { return(entryCompare); } var partitionedCompare = _partitionIndex.CompareTo(other.PartitionIndex); if (partitionedCompare != 0) { return(partitionedCompare); } return(0); } if (o is TopicMessageId impl) { return(CompareTo(impl.InnerMessageId)); } throw new ArgumentException("expected MessageId object. Got instance of " + o.GetType().FullName); }
private void BuildCommandInternal(SqlCommand selectCommand, SqlTransaction transaction, IMessageId messageId, List <string> routes) { selectCommand.Transaction = transaction; if (messageId != null && messageId.HasValue) { selectCommand.CommandText = _createDequeueStatement.GetDeQueueCommand(true, routes); selectCommand.Parameters.Add("@QueueID", SqlDbType.BigInt); selectCommand.Parameters["@QueueID"].Value = messageId.Id.Value; } else { selectCommand.CommandText = _createDequeueStatement.GetDeQueueCommand(false, routes); } if (_options.Value.EnableRoute && routes != null && routes.Count > 0) { var routeCounter = 1; foreach (var route in routes) { selectCommand.Parameters.Add("@Route" + routeCounter, SqlDbType.VarChar); selectCommand.Parameters["@Route" + routeCounter].Value = route; routeCounter++; } } }
protected internal virtual void OnAcknowledgeCumulative(IMessageId messageId, Exception exception) { if (Interceptors != null) { Interceptors.OnAcknowledgeCumulative(Self, messageId, exception); } }
/// <summary> /// Returns the next message, if any. /// </summary> /// <param name="context">The context.</param> /// <returns> /// A message if one is found; null otherwise /// </returns> public async Task <IReceivedMessageInternal> GetMessageAsync(IMessageContext context) { //if stopping, exit now if (_cancelToken.Tokens.Any(t => t.IsCancellationRequested)) { return(null); } //check for a specific MessageID to pull IMessageId messageId = null; var rpc = context.Get(_configuration.HeaderNames.StandardHeaders.RpcContext); if (rpc?.MessageId != null && rpc.MessageId.HasValue) { messageId = rpc.MessageId; } //ask for the next message, or a specific message if we have a messageID var receivedTransportMessage = await _receiveMessageAsync.Handle(new ReceiveMessageQueryAsync <IDbConnection, IDbTransaction>(null, null, messageId, _configuration.Routes)).ConfigureAwait(false); //if no message (null) run the no message action and return if (receivedTransportMessage == null) { return(null); } //set the message ID on the context for later usage context.MessageId = receivedTransportMessage.MessageId; return(receivedTransportMessage); }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessageQuery"/> class. /// </summary> /// <param name="context">The context.</param> /// <param name="id">The identifier.</param> public ReceiveMessageQuery(IMessageContext context, IMessageId id) { Guard.NotNull(() => context, context); MessageContext = context; MessageId = id; }
protected internal virtual void OnSendAcknowledgement(IMessage <T> message, IMessageId msgId, Exception exception) { if (Interceptors != null && message != null) { Interceptors.OnSendAcknowledgement(Self, message, msgId, exception); } }
private int RemoveMessagesTill(IMessageId msgId) { try { var removed = 0; var iterator = MessageIdPartitionMap.Keys; foreach (var i in iterator) { var messageId = i; if (messageId.CompareTo(msgId) <= 0) { var exist = MessageIdPartitionMap[messageId]; exist?.Remove(messageId); MessageIdPartitionMap.Remove(i, out var remove); removed++; } } return(removed); } catch (Exception ex) { _log.Error(ex.ToString()); return(-1); } }
internal void BuildCommand(SQLiteCommand selectCommand, IMessageId messageId, CommandString commandString, SqLiteMessageQueueTransportOptions options, List<string> routes ) { if (messageId != null && messageId.HasValue) { selectCommand.CommandText = commandString.CommandText; selectCommand.Parameters.Add("@QueueID", DbType.Int64); selectCommand.Parameters.Add("@CurrentDateTime", DbType.Int64); selectCommand.Parameters["@QueueID"].Value = messageId.Id.Value; selectCommand.Parameters["@CurrentDateTime"].Value = _getTime.GetCurrentUtcDate().Ticks; } else { selectCommand.CommandText = commandString.CommandText; selectCommand.Parameters.Add("@CurrentDateTime", DbType.Int64); selectCommand.Parameters["@CurrentDateTime"].Value = _getTime.GetCurrentUtcDate().Ticks; } if (options.EnableRoute && routes != null && routes.Count > 0) { var routeCounter = 1; foreach (var route in routes) { selectCommand.Parameters.Add("@Route" + routeCounter.ToString(), DbType.AnsiString); selectCommand.Parameters["@Route" + routeCounter.ToString()].Value = route; routeCounter++; } } }
/// <summary> /// Initializes a new instance of the <see cref="ResponseId"/> class. /// </summary> /// <param name="messageId">The identifier.</param> /// <param name="timeOut">The time out.</param> public ResponseId(IMessageId messageId, TimeSpan timeOut) { Guard.NotNull(() => messageId, messageId); MessageId = messageId; TimeOut = timeOut; }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessageQuery{TConnection, TTransaction}" /> class. /// </summary> /// <param name="connection">The connection.</param> /// <param name="transaction">The transaction.</param> /// <param name="messageId">A specific message identifier to de-queue. If null, the first message found will be de-queued.</param> /// <param name="routes">The routes.</param> public ReceiveMessageQueryAsync(TConnection connection, TTransaction transaction, IMessageId messageId, List <string> routes) { Connection = connection; Transaction = transaction; MessageId = messageId; Routes = routes; }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessageQuery{TConnection, TTransaction}" /> class. /// </summary> /// <param name="messageId">A specific message identifier to de-queue. If null, the first message found will be de-queued.</param> /// <param name="routes">The routes.</param> public ReceiveMessageQueryAsync(IMessageId messageId, List <string> routes) { Connection = default(TConnection); Transaction = default(TTransaction); MessageId = messageId; Routes = routes; }
public AcknowledgeWithTxn(IMessageId messageId, IDictionary <string, long> properties, IActorRef txn) { MessageId = messageId; AckType = AckType.Individual; Properties = properties; Txn = txn; }
/// <summary> /// Adds the message identifier tag. /// </summary> /// <param name="span">The span.</param> /// <param name="id">The identifier.</param> public static void AddMessageIdTag(this ISpan span, IMessageId id) { if (id != null && id.HasValue) { span.SetTag("MessageId", id.Id.Value.ToString()); } }
/// <summary> /// Creates a new instance of <see cref="IReceivedMessageInternal"/> /// </summary> /// <param name="message">The message.</param> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> /// <returns></returns> public IReceivedMessageInternal Create(IMessage message, IMessageId messageId, ICorrelationId correlationId) { Guard.NotNull(() => messageId, messageId); Guard.NotNull(() => message, message); Guard.NotNull(() => correlationId, correlationId); return(new ReceivedMessageInternal(message, messageId, correlationId)); }
private void DoCumulativeAckAsync(MessageId msgId) { if (msgId.CompareTo(_lastCumulativeAck) > 0) { _lastCumulativeAck = msgId; _cumulativeAckFlushRequired = true; } }
/// <summary> /// Initializes a new instance of the <see cref="SentMessage"/> class. /// </summary> /// <param name="messageId">The identifier.</param> /// <param name="correlationId">The correlation identifier.</param> public SentMessage(IMessageId messageId, ICorrelationId correlationId) { //NOTE - null messageID's are allowed, as this indicates a failure by the transport to send Guard.NotNull(() => correlationId, correlationId); MessageId = messageId; CorrelationId = correlationId; }
public IEnumerable<IMessageId> GetChanges(IMessageId startId, long sinceSeq, out long lastSeq) { // Get changes after sinceSeq, and drop messages at or before _startId Replicate(); lastSeq = GetLastSeq(); return Enumerable.Range((int) sinceSeq + 1, (int) (lastSeq - sinceSeq)).Select(seqId => MessageIdManager.Create(_docInfos[seqId].DocId)). OrderBy(mId => mId).SkipWhile(mId => mId.CompareTo(startId) <= 0); }
/// <inheritdoc /> public IDictionary <string, object> GetHeaders(IMessageId id) { if (id != null && id.HasValue) { return(_commandHandler.Handle(new GetHeaderQuery((long)id.Id.Value))); } return(null); }
/// <summary> /// Creates a new instance of <see cref="IReceivedMessageInternal"/> /// </summary> /// <param name="message">The message.</param> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> /// <returns></returns> public IReceivedMessageInternal Create(IMessage message, IMessageId messageId, ICorrelationId correlationId) { Guard.NotNull(() => messageId, messageId); Guard.NotNull(() => message, message); Guard.NotNull(() => correlationId, correlationId); return new ReceivedMessageInternal(message, messageId, correlationId); }
/// <summary> /// Gets the headers for the specified message if possible /// </summary> /// <param name="id">The identifier.</param> /// <returns> /// null if the headers could not be obtained; otherwise a collection with 0 or more records /// </returns> public IDictionary <string, object> GetHeaders(IMessageId id) { if (id != null && id.HasValue) { return(_dataStorage.GetHeaders((Guid)id.Id.Value)); } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="ResetHeartBeatOutput"/> class. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="headers">The headers.</param> /// <param name="approximateResetTimeStart">The approximate reset time start.</param> /// <param name="approximateResetTimeEnd">The approximate reset time end.</param> public ResetHeartBeatOutput(IMessageId messageId, IReadOnlyDictionary <string, object> headers, DateTime approximateResetTimeStart, DateTime approximateResetTimeEnd) { MessageId = messageId; Headers = headers; ApproximateResetTimeStart = approximateResetTimeStart; ApproximateResetTimeEnd = approximateResetTimeEnd; }
public async ValueTask AcknowledgeAsync(IMessageId messageId) { var ask = await _consumerActor.Ask <AskResponse>(new AcknowledgeMessageId(messageId)).ConfigureAwait(false); if (ask.Failed) { throw ask.Exception; } }
public void Send(IMessageId msg, string name, params object[] args) { Node.Send(new RpcMail{ To = Remote, From = Id, MessageId = msg.As<MessageId>(), Message = new FunctionCall(name, args), }); }
/// <summary> /// Creates new instance of <see cref="IRedisQueueWorkSub" /> that will only respond if the specified ID is sent /// </summary> /// <param name="id">The identifier.</param> /// <returns></returns> public IRedisQueueWorkSub Create(IMessageId id) { if (id == null || !id.HasValue) { return Create(); } //return a new instance return new RedisQueueWorkSubRpc(_connection, _redisNames, _cancelWork, id); }
/// <inheritdoc /> public IRedisQueueWorkSub Create(IMessageId id) { if (id == null || !id.HasValue) { return(Create()); } //return a new instance return(new RedisQueueWorkSubRpc(_connection, _redisNames, _cancelWork, id)); }
public int CompareTo(IMessageId o) { var m = InnerMessageId as BatchMessageId; if (m != null) { return(m.CompareTo(o)); } return(((MessageId)InnerMessageId).CompareTo(o)); }
/// <inheritdoc /> public RemoveMessageStatus Remove(IMessageId id, RemoveMessageReason reason) { if (id == null || !id.HasValue) { return(RemoveMessageStatus.NotFound); } var result = _deleteMessage.Handle(new DeleteMessageCommand <string>(id.Id.Value.ToString())); return(result ? RemoveMessageStatus.Removed : RemoveMessageStatus.NotFound); }
/// <inheritdoc /> public RemoveMessageStatus Remove(IMessageId id, RemoveMessageReason reason) { if (id == null || !id.HasValue) { return(RemoveMessageStatus.NotFound); } var result = _deleteMessage.Handle(new DeleteMessageCommand((RedisQueueId)id)); return(result ? RemoveMessageStatus.Removed : RemoveMessageStatus.NotFound); }
/// <summary> /// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class. /// </summary> /// <param name="message">The message.</param> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> public ReceivedMessageInternal(IMessage message, IMessageId messageId, ICorrelationId correlationId) { Guard.NotNull(() => message, message); Guard.NotNull(() => messageId, messageId); Guard.NotNull(() => correlationId, correlationId); Body = message.Body; MessageId = messageId; CorrelationId = correlationId; Headers = new ReadOnlyDictionary <string, object>(message.Headers.ToDictionary(entry => entry.Key, entry => entry.Value)); }
/// <summary> /// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class. /// </summary> /// <param name="message">The message.</param> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> public ReceivedMessageInternal(IMessage message, IMessageId messageId, ICorrelationId correlationId) { Guard.NotNull(() => message, message); Guard.NotNull(() => messageId, messageId); Guard.NotNull(() => correlationId, correlationId); Body = message.Body; MesssageId = messageId; CorrelationId = correlationId; Headers = new ReadOnlyDictionary<string, object>(message.Headers.ToDictionary(entry => entry.Key, entry => entry.Value)); }
/// <inheritdoc /> public RemoveMessageStatus Remove(IMessageId id, RemoveMessageReason reason) { if (id != null && id.HasValue) { var result = _deleteMessageCommandHandler.Handle(new DeleteMessageCommand((long)id.Id.Value)); if (result > 0) { return(RemoveMessageStatus.Removed); } } return(RemoveMessageStatus.NotFound); }
public static long GetOffset(IMessageId messageId) { var msgId = (MessageId)messageId; var ledgerId = msgId.LedgerId; var entryId = msgId.EntryId; // Combine ledger id and entry id to form offset // Use less than 32 bits to represent entry id since it will get // rolled over way before overflowing the max int range var offset = (ledgerId << 28) | entryId; return(offset); }
// If all messageId in map are same Size, and all bigger/smaller than the other, return valid value. public int CompareTo(IMessageId o) { if (!(o is MultiMessageId)) { throw new ArgumentException("expected MultiMessageId object. Got instance of " + o.GetType().FullName); } var other = (MultiMessageId)o; var otherMap = other.Map; if ((Map == null || Map.Count == 0) && (otherMap == null || otherMap.Count == 0)) { return(0); } if (otherMap == null || Map == null || otherMap.Count != Map.Count) { throw new ArgumentException("Current Size and other Size not equals"); } var result = 0; foreach (var entry in HashMapHelper.SetOfKeyValuePairs(Map)) { if (!otherMap.TryGetValue(entry.Key, out var otherMessage)) { throw new ArgumentException("Other MessageId not have topic " + entry.Key); } var currentResult = entry.Value.CompareTo(otherMessage); if (result == 0) { result = currentResult; } else if (currentResult == 0) { continue; } else if (result != currentResult) { throw new ArgumentException("Different MessageId in Map get different compare result"); } else { continue; } } return(result); }
public IEnumerable<IMessageId> GetChanges(IMessageId startId, long sinceSeq, out long lastSeq) { // Get changes after sinceSeq, throw out non-messages e.g. design doc updates, and drop messages at or before _startId // Loveseat doesn't have a _changes call, so it has to be done like this. var changes = _db.GetDocument(string.Format("_changes?since={0}&filter=filters/nodeletions", sinceSeq)); // Changes are returned as // {"results":[{"seq":28312,"id":"04b8dbf49b5d2603","changes":[{"rev":"1-ea426b58321d93c39a3486cc4d55abe2"}]}, // ... // {"seq":28313,"id":"_design/mce","changes":[{"rev":"9-4d4ec5b438064ab0d602f2ed2ea9ac34"}]} // ], // "last_seq":28313} lastSeq = (long) changes["last_seq"]; return changes["results"].Select(jObj => (string) jObj["id"]).Where(MessageIdManager.IsMessageId).Select(MessageIdManager.Create) .OrderBy(mId => mId).SkipWhile(mId => mId.CompareTo(startId) <= 0); }
/// <summary> /// Initializes a new instance of the <see cref="RedisQueueWorkSubRpc"/> class. /// </summary> /// <param name="connection">The connection.</param> /// <param name="redisNames">The redis names.</param> /// <param name="cancelWork">The cancel work.</param> /// <param name="messageId">The message identifier.</param> public RedisQueueWorkSubRpc(IRedisConnection connection, RedisNames redisNames, IQueueCancelWork cancelWork, IMessageId messageId) { Guard.NotNull(() => connection, connection); Guard.NotNull(() => redisNames, redisNames); Guard.NotNull(() => cancelWork, cancelWork); _connection = connection; _redisNames = redisNames; _cancelWork = cancelWork; _messageId = messageId; _waitHandle = new ManualResetEventSlim(false); _waitHandle.Set(); }
private object GetReturnValue(MethodInfo method, IMessageId msg) { if (method.ReturnType == typeof(void)) return null; if (method.IsGenericMethod && typeof(Task).IsAssignableFrom(method.ReturnType)) { return TaskEx.New(() => { var mail = Remote.Receive(msg); var returnType = method.ReturnType.GetGenericArguments()[0]; return mail.As<RpcMail>().Message.Args[0].Convert(returnType); }, method.ReturnType); } else { var mail = Remote.Receive(msg).Result; if (!mail.HasValue || mail.Value.As<RpcMail>().Message.Args.Length == 0) { if (method.ReturnType.IsClass) return null; return method.ReturnType.CreateInstance(); } return mail.Value.As<RpcMail>().Message.Args[0].Convert(method.ReturnType); } }
/// <summary> /// Initializes a new instance of the <see cref="MessageException"/> class. /// </summary> /// <param name="message">The message.</param> /// <param name="inner">The inner.</param> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> public MessageException(string message, Exception inner, IMessageId messageId, ICorrelationId correlationId) : base(message, inner) { MessageId = messageId; CorrelationId = correlationId; }
/// <summary> /// Creates a new instance of <see cref="IResponseId" /> /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="timeOut">The time out.</param> /// <returns></returns> public IResponseId Create(IMessageId messageId, TimeSpan timeOut) { Guard.NotNull(() => messageId, messageId); return new ResponseId(messageId, timeOut); }
/// <summary> /// Creates new instance of <see cref="IRpcContext" /> /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="timeout">The timeout.</param> /// <returns></returns> public IRpcContext Create(IMessageId messageId, TimeSpan? timeout) { Guard.NotNull(() => messageId, messageId); return new RpcContext(messageId, timeout); }
/// <summary> /// Initializes a new instance of the <see cref="RpcContext"/> class. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="timeOut">The time out.</param> public RpcContext(IMessageId messageId, TimeSpan? timeOut) { Guard.NotNull(() => messageId, messageId); MessageId = messageId; Timeout = timeOut; }
/// <summary> /// Initializes a new instance of the <see cref="HeartBeatStatus"/> class. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="lastHeartBeatTime">The last heart beat time.</param> public HeartBeatStatus(IMessageId messageId, DateTime? lastHeartBeatTime) { Guard.NotNull(() => messageId, messageId); MessageId = messageId; LastHeartBeatTime = lastHeartBeatTime; }
/// <summary> /// Initializes a new instance of the <see cref="MessageException"/> class. /// </summary> /// <param name="message">The message.</param> /// <param name="inner">The inner.</param> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> /// <param name="messagePayload">The raw message payload.</param> /// <param name="headerPayload">The raw header payload.</param> public PoisonMessageException(string message, Exception inner, IMessageId messageId, ICorrelationId correlationId, byte[] messagePayload, byte[] headerPayload) : base(message, inner, messageId, correlationId) { MessagePayload = messagePayload; HeaderPayload = headerPayload; }
public bool Equals(IMessageId other) { var utcOther = (UtcIdMessageId) other; return _timeBits == utcOther._timeBits && _suffix == utcOther._suffix; }
public void Reply(IActorId to, IMessageId msg, string name, params object[] args) { node.Reply(to, id, msg, name, args); }
/// <summary> /// Gets the next message from the queue /// </summary> /// <param name="context">The context.</param> /// <param name="messageId">The message identifier.</param> /// <returns></returns> private RedisMessage GetMessage(IMessageContext context, IMessageId messageId) { var message = _receiveMessage.Handle(new ReceiveMessageQuery(context, messageId)); if (message == null) return null; if (!message.Expired) { context.MessageId = message.Message.MesssageId; } return message; }
/// <summary> /// Gets the next message from the queue /// </summary> /// <param name="context">The context.</param> /// <param name="messageId">The message identifier.</param> /// <returns></returns> private async Task<RedisMessage> GetMessageAsync(IMessageContext context, IMessageId messageId) { var message = await _receiveMessageAsync.Handle(new ReceiveMessageQueryAsync(context, messageId)).ConfigureAwait(false); if (message == null) return null; if (!message.Expired) { context.MessageId = message.Message.MesssageId; } return message; }
/// <summary> /// Initializes a new instance of the <see cref="MessageException"/> class. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> /// <param name="format">The format.</param> /// <param name="args">The arguments.</param> public MessageException(IMessageId messageId, ICorrelationId correlationId, string format, params object[] args) : base(string.Format(format, args)) { MessageId = messageId; CorrelationId = correlationId; }
public bool Equals(IMessageId other) { if(other == null || other.GetType() != GetType()) return false; return ((MessageId)other).id == id; }
public int CompareTo(IMessageId other) { var utcOther = (UtcIdMessageId) other; var highCompare = _timeBits.CompareTo(utcOther._timeBits); return highCompare == 0 ? String.Compare(_suffix, utcOther._suffix, StringComparison.Ordinal) : highCompare; }
/// <summary> /// Initializes a new instance of the <see cref="MessageException"/> class. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="correlationId">The correlation identifier.</param> /// <param name="messagePayload">The raw message payload.</param> /// <param name="headerPayload">The raw header payload.</param> /// <param name="format">The format.</param> /// <param name="args">The arguments.</param> public PoisonMessageException(IMessageId messageId, ICorrelationId correlationId, byte[] messagePayload, byte[] headerPayload, string format, params object[] args) : base(string.Format(format, args), messageId, correlationId) { MessagePayload = messagePayload; HeaderPayload = headerPayload; }