XmlMessageFormatter is generating messages with all zeros in the body

Question

Simple implementation; single process writing (although multiple tasks may write asynchronously) single process reading.

Most of the time it seems to be working fine, but every once in a while we get a message where the Body size is reasonable, but if you look at it in the Computer Management tool, it's nothing but '0's. This causes the XmlMessageFormatter on the reader to fail.

We added code that'll let us handle poisoned messages better, but we need the messages, so that alone is not acceptable.

Object:

public class SubscriptionData
{
  public Guid SubscriptionInstanceId { get; set; }
  public SubscriptionEntityTypes SubscriptionEntityType { get; set; }
  public List<int> Positions { get; set; }
  public List<EventInformation> Events { get; set; }
  public int SubscriptionId { get; set; }

  public SubscriptionData() { }

  public SubscriptionData(SubscriptionEntityTypes entityType, List<int> positions, List<EventInformation> events, int subscriptionId)
  {
    SubscriptionEntityType = entityType;
    Positions = positions;
    Events = events;
    SubscriptionId = subscriptionId;
    SubscriptionInstanceId = Guid.NewGuid();
  }

  public override string ToString()
  {
    return $"Entity Type: {SubscriptionEntityType}, Instance Id: {SubscriptionInstanceId}, Events: {string.Join("/", Events)}, SubsId: {SubscriptionId}";
  }
}

Writer:

private static void ConstructMessageQueue()
{
  _messageQueue = MessageQueue.Exists(Queue) ?
    new MessageQueue(Queue) : MessageQueue.Create(Queue);
  _messageQueue.Label = QueueName;
}

private static void EnqueueSubscriptionData(SubscriptionEntityTypes entityType, List<int> positions, List<EventInformation> events, int subscriptionId)
{
  Task.Run(() =>
   {
     var subsData = new SubscriptionData(entityType, positions, events, subscriptionId);
     _logger.Info(ErrorLevel.Normal, $"Enqueuing subscription: {subsData}");
     _messageQueue.Send(subsData);
   });
}

Reader:

private void HandleNotifications()
    {
        var mq = new MessageQueue(Queue);
        mq.Formatter = new XmlMessageFormatter(new Type[] { typeof(SubscriptionData) });

        while (!_cancellationToken.IsCancellationRequested)
        {
            Message message = null;
            try
            {
                message = mq.Peek(TimeSpan.FromSeconds(5));

                if (message != null)
                {
                    var subsData = message.Body as SubscriptionData;
                    if (subsData == null)
                        continue;
                    _logger.Info(ErrorLevel.Normal, $"Processing subscription: {subsData}");

                    //  Process the notification here

                    mq.Receive();
                }
            }
            catch (MessageQueueException t) when (t.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout)
            {
                _logger.Info(ErrorLevel.Normal, $"Message Queue Peek Timeout");
                continue;
            }
            catch (MessageQueueException t)
            {
                _logger.Exception(t, "MessageQueueException while processing message queue for notifications");
                throw;
            }
            catch (Exception t)
            {
                _logger.Exception(t, "Exception while processing message queue for notifications");
            }
        }
    }

If you're curious, I'm told that we peek and only receive after success so that we don't lose the message, but in reading up on this to try and help my coworker it looks like there are transactions.

The bad messages we get look like this.

Answer 1

It seems that Send method is not thread safe, you should not share MessageQueue object (your _messageQueue static variable) between multiple threads. It's discussed here:

Is MSMQ thread safe?