Question

In a WPF application, I have a 3rd party library that is publishing messages.

The messages are like :

public class DialectMessage
{
    public string PathAndQuery { get; private set; }

    public byte[] Body { get; private set; }

    public DialectMessage(string pathAndQuery, byte[] body)
    {
        this.PathAndQuery = pathAndQuery;
        this.Body = body;
    }
}

And I setup the external message source from my app.cs file :

public partial class App : Application
{
    static App()
    {
        MyComponent.MessageReceived += MessageReceived;
        MyComponent.Start();
    }

    private static void MessageReceived(Message message)
    {
        //handle message
    }

}

These messages can be publishing from multiple thread at a time, making possible to call the event handler multiple times at once.

I have a service object that have to parse the incoming messages. This service implements the following interface :

internal interface IDialectService
{
    void Parse(Message message);
}

And I have a default static instance in my app.cs file :

    private readonly static IDialectService g_DialectService = new DialectService();

In order to simplify the code of the parser, I would like to ensure only one message at a time is parsed.

I also want to avoid locking in my event handler, as I don’t want to block the 3rd party object.

Because of this requirements, I cannot directly call g_DialectService.Parse from my message event handler

What is the correct way to ensure this single threaded execution?

My first though is to wrap my parsing operations in a Produce/Consumer pattern. In order to reach this goal, I’ve try the following :

1. Declare a BlockingCollection in my app.cs :

   private readonly static BlockingCollection<Message> g_ParseOperations = new BlockingCollection<Message>();
   

2. Change the body of my event handler to add an operation :

   private static void MessageReceived(Message message)
   {
       g_ParseOperations.Add(message);
   }
   

3. Create a new thread that pump the collection from my app constructor :

   static App()
   {
       MyComponent.MessageReceived += MessageReceived;
       MyComponent.Start();
   
       Task.Factory.StartNew(() =>
       {
           Message message;
           while (g_ParseOperations.TryTake(out message))
           {
               g_DialectService.Parse(message);
           }
       });
   }
   

However, this code does not seems to work. The service Parse method is never called.

Moreover, I’m not sure if this pattern will allow me to properly shutdown the application.

What have I to change in my code to ensure everything is working?

PS: I’m targeting .Net 4.5

[Edit] After some search, and the answer of ken2k, i can see that I was wrongly calling trytake in place of take.

My updated code is now :

    private readonly static CancellationTokenSource g_ShutdownToken = new CancellationTokenSource();

    private static void MessageReceived(Message message)
    {
        g_ParseOperations.Add(message, g_ShutdownToken.Token);
    }

    static App()
    {
        MyComponent.MessageReceived += MessageReceived;
        MyComponent.Start();

        Task.Factory.StartNew(() =>
        {
            while (!g_ShutdownToken.IsCancellationRequested)
            {
                var message = g_ParseOperations.Take(g_ShutdownToken.Token);
                g_DialectService.Parse(message);
            }
        });
    }

    protected override void OnExit(ExitEventArgs e)
    {
        g_ShutdownToken.Cancel();
        base.OnExit(e);
    }

This code acts as expected. Messages are processed in the correct order. However, as soon I exit the application, I get a “CancelledException” on the Take method, even if I just test the IsCancellationRequested right before.

Answer 1

The documentation says about BlockingCollection.TryTake(out T item):

If the collection is empty, this method immediately returns false.

So basically your loop exits immediately. What you may want is to call the TryTake method with a timeout parameter instead, and exit your loop when a mustStop variable becomes true:

bool mustStop = false;  // Must be set to true on somewhere else when you exit your program
...
while (!mustStop)
{
    Message yourMessage;

    // Waits 500ms if there's nothing in the collection. Avoid to consume 100% CPU
    // for nothing in the while loop when the collection is empty.
    if (yourCollection.TryTake(out yourMessage, 500))
    {
        // Parses yourMessage here
    }
}

---

For your edited question: if you mean you received a OperationCanceledException, that’s OK, it’s exactly how methods that take a CancellationToken object as parameter must behave 🙂 Just catch the exception and exit gracefully.