The code samples show a simple project that manages cache entries. Several cache entries can exist in a cache session, and cache sessions are managed by a cache manager. The project was created with Visual Studio 2010. My Visual Studio 2010 has applied a color scheme from http://studiostyles.info/ to make it more attractive.

Some notes about the coding style I’m using:

• Use precompiled header with default VS settings (StdAfx).
• Use STL. All include statements for STL files are in StdAfx.h (the precompiled header)

// stdafx.h
#pragma once
#include "targetver.h"

#include <map>
#include <memory>
#include <string>
#include <vector>
…

• Never include using in header files.
• Declare all members as private and use properties for accessing them. Private member names start with prefix p.

Coming from a C# background, I came to appreciate the syntactic sugar that lets you write less code and helps with project readability. One of these features is the syntactic sugar for getter and setter accessors of object properties. Well, nothing is lost in C++: a property can be easily defined using __declspec. You can read more about this in this blog post. The properties look like this (snippet from CacheManager.h):

__declspec(property(get=get_Owner)) std::wstring const & Owner;
std::wstring const & get_Owner() const { return pOwner; }

• Use typedef whenever needed to make the code easier to read and understand. Example:

typedef std::map<std::wstring, CacheEntry<std::wstring>> StringCacheEntryMap;

• Use explicit whenever the constructor has one parameter to avoid implicit type conversion. Example:

explicit CacheManager(std::wstring const & owner);

• Prefer passing arguments by reference if at all possible to avoid copy unnecessary operations. Exception: fundamental types and small structures, for which copy is inexpensive.

void Add(StringCacheEntry const & entry);

• Always use Resource Acquisition Is Initialization (RAII). Avoid using raw pointers, wrap them in unique_ptr or shared_ptr to avoid memory leaks/corruption.
• Whenever possible, use move constructors for expensive objects.

In interest of space, the code pasted in the blog entries may be compacted, in which case some of the rules may be abolished.

Here are some resources I used to get back to native code (as you noticed, I haven’t use the keyword “unmanaged”: a lot of C++ users consider the term “unmanaged” degrading, because it somewhat implies that unmanaged is somewhat inferior to managed or developed after managed code):

1. Effective C++ – Scott Meyers
2. More Effective C++ – Scott Meyers
3. Effective STL - Scott Meyers 
4. Windows via C/C++ (Pro - Developer) - Jeffrey M. Richter
5. C++ Coding Standards: 101 Rules, Guidelines, and Best Practices - Herb Sutter
6. C++ Templates: The Complete Guide - David Vandevoorde and Nicolai M. Josuttis

These books helped me refresh my C++ memory. On top of this, I had to get familiar with the new 0x features: lambdas (unnamed function objects), auto (automatic type deduction), static_assert (trigger compiler errors with custom error messages), RValue references (move semantics and perfect forwarding) and decltype. Here are the articles I recommend from the Visual C++ team blog:

1. http://blogs.msdn.com/b/vcblog/archive/2008/10/28/lambdas-auto-and-static-assert-c-0x-features-in-vc10-part-1.aspx 
2. http://blogs.msdn.com/b/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx
3. http://blogs.msdn.com/b/vcblog/archive/2009/04/22/decltype-c-0x-features-in-vc10-part-3.aspx

Other materials:

1. Stroustrup C++ language reference
2. The Design and Evolution of C++ – Stroustrup
3. The C++ Standard Library: A Tutorial and Reference by Nicolai M. Josuttis.
4. STL Tutorial and Reference – Musser

As in any process of learning, I made mistakes and I learned from them. Some mistakes were due to faulty expectations coming from the C# world – like C++ scoped static initialization is not thread-safe, on purpose!. I’m still learning, and I’m still making mistakes. In future blogs I will share with you some of these mistakes.

Inside a program, the code paths that are executed most often belong to the hot path (with the remaining code paths being on the cold path). One can look at this at multiple levels: instruction, language statements, features. Over the years, multiple studies have shown how to optimize software for the hot path execution.

Here, I want to focus on the developer that’s writing the code. From the start, the developer can easily identify some cold code (for example, the exception handling code). Keeping in mind the usage pattern, the developer can improve the program so it runs faster most of the times.

Here is an example: let’s say that your application (called CalculatorService) keeps track of the number of Add or Subtract operations by incrementing performance counters. It expects that a performance counter category called CalculatorService already exists (for example, the installer of the service creates it). This is a requirement because it runs as Network Service, while creating the category takes Administrator privileges. Inside CalculatorService category we have 2 counters, AddCounter and SubtractCounter. If the category is not installed, CalculatorService must not throw – it just won’t save the counters.

You decide to create a class PerfCounterPublisher that deal with the performance counters. The service class keeps an instance of PerfCounterPublisher and calls methods on it when Add/Subtract operations are executed.

class CalculatorService
{
    PerfCounterPublisher publisher;

    public CalculatorService()
    {
        this.publisher = new PerfCounterPublisher("CalculatorService");
    }

    public int Add(int a, int b)
    {
        this.publisher.IncrementCounter("AddCounter");
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        this.publisher.IncrementCounter("SubtractCounter");
        return a - b;
    }
}

A simple implementation of the PerfCounterPublisher can look like this:

class PerfCounterPublisher
{
    string categoryName;

    public PerfCounterPublisher(string categoryName)
    {
        this.categoryName = categoryName;
    }

    public bool IncrementCounter(string counterName)
    {
        if (PerformanceCounterCategory.Exists(this.categoryName))
        {
            PerformanceCounter counter = new PerformanceCounter(
                this.categoryName,
                counterName,
                false);
            counter.Increment();
            return true;
        }

        return false;
    }
}

So, if the category is installed, we increment the counter; otherwise, we just return false, letting the user know that the counter wasn’t incremented.

This code can be improved. PerformanceCounterCategory.Exists is a rather expensive operation. If we look at usage pattern, most of the time the counters are installed. So we penalize most of the scenarios by adding the check.

How can we optimize the code for the hot path?

Since we expect the category to exist, we will try to create the counter without the check; in the rare cases where the category doesn’t exist, creating the counter will throw InvalidOperationException – in this case, we catch the exception and return false (counters not incremented). IncrementCounter looks like this:

public bool IncrementCounter(string counterName)
{
    try
    {
        PerformanceCounter counter = new PerformanceCounter(
            this.categoryName,
            counterName,
            false);
        counter.Increment();
        return true;
    }
    catch (InvalidOperationException)
    {
        return false;
    }
}

Depending on the application scenario, we can make further improvements. For example, if we don’t expect the category is installed after the service has been started, we can check if the category exists in the constructor and set a flag to disabled if it doesn’t. Or we can postpone the check to the first time a call to IncrementCounter is done and set the flag there. If the flag has been set, future IncrementCounter become NoOp.

This is a very simple example, but I hope it expresses what I tried to convey. When writing code, make sure you understand how it’s going to be used, identify the how path based on this and always optimize for the hot path.

- The distributed system encounters a problem and you have a retry logic in place (eg. the network goes down and you need to retry until it comes up again). In order to avoid hammering the system with the retry logic, you decide to add a small delay between consecutive retries.

- You know a critical operation is taking place and you want to wait for it to finish, either because the resources are shared or it has a higher priority etc (eg. Updates are installed every night at 2 PM or trace data is collected every 4 hours, and your client operations can wait until that is done).

To implement the delay, all the threads of the application need to sleep for a period of time (that can be determined at runtime, eg. choose a random delay in order to avoid all requests to execute at the same time).

Consider an app that starts a number of parallel operations that need to sleep. You can implement this in a sync or async fashion.

1. Sync sleep – Create all the threads and set the work to include sleeping

Thread[] clients = new Thread[this.ParallelOperations];
for (int i = 0; i < this.ParallelOperations; i++)
{
    clients[i] = new Thread(new ThreadStart(
        // We need a method void () target; 
        // for simplicity, inline it here
        () =>
        {
            // ... Previous operations 
            Stopwatch watch = new Stopwatch();
            watch.Start();
            Thread.Sleep(SleepTime);
            watch.Stop();
            Console.WriteLine("Elapsed time: {0} msec", 
                watch.ElapsedMilliseconds);
            // ... Subsequent operations 
        }));
}

// Start all clients
for (int i = 0; i < this.ParallelOperations; i++)
{
    clients[i].Start();
}

// Wait for all clients to finish
for (int i = 0; i < this.ParallelOperations; i++)
{
    clients[i].Join();
}

This implementation manually creates as many threads as the number of operations that should be ran and calls Sleep (if you need to sleep on a thread that has STAThreadAttribute, but you want to perform standard COM and SendMessage pumping, consider using one of the overloads of the Join method that specifies a timeout interval - Thread.CurrentThread.Join).

Another option is to use the CLR threadpool instead. To wait for the threads, we can use an event that we signal when all operations are done.

int clientsDone = 0;
ManualResetEvent waitEvent = new ManualResetEvent(false);

for (int i = 0; i < this.ParallelOperations; i++)
{
    ThreadPool.QueueUserWorkItem(new WaitCallback(o =>
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        Thread.Sleep(SleepTime);
        watch.Stop();
        Console.WriteLine("Elapsed time: {0} msec", watch.ElapsedMilliseconds);
        if (Interlocked.Increment(ref clientsDone) >= this.ParallelOperations)
        {
            waitEvent.Set();
        }
    }));
}

waitEvent.WaitOne(TimeSpan.FromSeconds(WaitTime));

// dispose of the timer and async event

The sync version has one huge problem: it doesn’t scale. If you look on msdn, it is clearly stated that “the thread will not be scheduled for execution by the operating system for the amount of time specified”. With another words, we are sitting on the current thread without doing any useful work. If the system has many clients, it’s a high possibility that we will eventually run out of threads because operations come in faster than the rate at which we finish them.

2. Async sleep – The alternative is for the operation to start the Sleep and leave the thread to do other, useful work; when the wait is done, the app will be notified and another thread will continue the execution.

To implement the sleep async, we use a Timer – when the callback is triggered, the sleep is done.

int clientsDone = 0;
ManualResetEvent waitEvent = new ManualResetEvent(false);

Timer t;
Stopwatch watch;
TimerCallback callback;
for (int i = 0; i < ParallelOperations; i++)
{
    callback = new TimerCallback(
        o =>
        {
            Stopwatch passedWatch = (Stopwatch)o;
            passedWatch.Stop();
            Console.WriteLine("Elapsed time: {0} msec", 
                passedWatch.ElapsedMilliseconds);
            if (Interlocked.Increment(ref clientsDone) >= this.ParallelOperations)
            {
                waitEvent.Set();
            }
        });

    watch = new Stopwatch();
    watch.Start();
    t = new Timer(callback, watch, SleepTime, TimeSpan.FromMilliseconds(-1));
}

waitEvent.WaitOne(TimeSpan.FromSeconds(50));
// dispose of the timer and async event

Running this code with 10 operations and a sleep of 10 sec leads to this output:

Elapsed time: 10010 msec
Elapsed time: 10009 msec
Elapsed time: 10010 msec
Elapsed time: 10009 msec
Elapsed time: 10011 msec
Elapsed time: 10011 msec
Elapsed time: 10011 msec
Elapsed time: 10011 msec
Elapsed time: 10011 msec
Elapsed time: 10011 msec

(notice how the actual time is not 10 sec, but it differs slightly. If the system is in an overloaded state, the difference will be much higher. The same is true for the sync case).

This works, but let’s rewrite to be more in sync with the .NET FX Asynchronous Programming model. From msdn:

An asynchronous operation that uses the IAsyncResult design pattern is implemented as two methods named BeginOperationName and EndOperationName that begin and end the asynchronous operation OperationName respectively. For example, the FileStream class provides the BeginRead and EndRead methods to asynchronously read bytes from a file. These methods implement the asynchronous version of the Read method.

After calling BeginOperationName, an application can continue executing instructions on the calling thread while the asynchronous operation takes place on a different thread. For each call to BeginOperationName, the application should also call EndOperationName to get the results of the operation.

We can change our code to implement this pattern by defining an async result. To make my job easier, I took the abstract class AsyncResult.cs from one of the WCF MSDN Samples (download the samples, then go to the directory you saved them and look for WCFWFCardSpace\WCF\Basic\Contract\Service\Asynchronous\CS\library). This class implements the IAsyncResult interface.

Using this base class, I defined SleepAsyncResult to start the timer and complete the operation in callback (for simplicity, I always set completedAsync flag to true, this should be set accordingly in practice).

class SleepAsyncResult : AsyncResult
{
    Timer t;
    readonly TimeSpan sleepTime;

    public SleepAsyncResult(TimeSpan sleepTime, AsyncCallback callback, object state)
        : base(callback, state)
    {
        this.sleepTime = sleepTime;
        this.Start();
    }

    public void Start()
    {
        Stopwatch watch = new Stopwatch();
        TimerCallback cb = new TimerCallback(
           o =>
           {
               watch.Stop();
               Console.WriteLine("Elapsed time: {0} msec",
                   watch.ElapsedMilliseconds);
               this.Complete(false);
               t.Dispose();
           });

        watch.Start();
        t = new Timer(cb, null, this.sleepTime, TimeSpan.FromMilliseconds(-1));
    }

    public static void End(IAsyncResult result)
    {
        AsyncResult.End<SleepAsyncResult>(result);
    }
}

Then we write the Begin/End methods using this async result:

int clientsDone = 0;
ManualResetEvent waitEvent = new ManualResetEvent(false);

IAsyncResult BeginSleep()
{
    return new SleepAsyncResult(SleepTime, EndSleep, null); 
}

void EndSleep(IAsyncResult result)
{
    SleepAsyncResult.End(result);
    if (Interlocked.Increment(ref this.clientsDone) >= this.ParallelOperations)
    {
        this.waitEvent.Set();
    }
}

Implementing the Sleep becomes dead simple.

for (int i = 0; i < ParallelOperations; i++)
{
    this.BeginSleep();
}

waitEvent.WaitOne(TimeSpan.FromSeconds(50));

Et voila! We are now sleeping asynchronously!

Note:

The code presented is just for demo purposes and I don’t recommend using it in production. Distributed code should be very careful with exception handling, multithreading issues, sharing resources, leaking resources etc.

I recently tried to install Live Writer on my newest Win7 box and I had a most unpleasant experience.

First, the installer told me there are a couple of programs that should be closed in order for the installation to proceed. It also offered me the option to ignore them – which I gladly chose. After trying really hard for a couple of minutes, it went belly up with the error code 0x80070643 (very helpful!)

So I try again. This time I ignore the “ignore” option. The other option: the installer gracefully offers to close some programs that are in the way for me. Cool, says I, go right ahead (I hate when installers give you a list of programs and it’s your business to go through it and kill them – what a waste of time!). So the installer starts bringing down programs – there goes my music, there goes this, there goes that, and … surprise, surprise … there goes Explorer. Which means no Start button, no task bar no nothing. Now, looking back, I must admit that I didn’t pay any attention to the list of programs the installer “needed” to close, but at a backward glance it was huge (check the picture). As my excuse, I usually go very fast through these installation steps – aka I don’t read them.

So here I am, no Explorer in sight (Explorer is a Windows process that starts at startup and remains up). How do I bring it back? With a command prompt open, piece of cake: go though the open programs using Alt+Tab until I land on the Command Prompt and then start explorer with the command “explorer.exe”.

As it was, I didn’t have a command prompt open. Next option: task manager. To open task manager, use the shortcut Ctrl+Shift+Escape (I prefer it to Alt+Ctrl+Delete –> open Task Manger). In task manager go to File –>  New Task and create a new task for Explorer.exe. Et voila! The task bar, the start button are all back. This method is useful any time when Explorer crashes (as an alternative for reboot).

So what about my Live Writer installation? I hate to admit, but I gave up for now. I’ll try again tomorrow, maybe the Live gods are on my side. All in all, bad mark for the Windows Live user experience.

At any given point in time, the communication objects find themselves in a CommunicationState. Here is a diagram with the states and the transitions:

When we look at a communication object in a debugger, we see something like this (some columns and internal objects removed for brevity reasons):

Name: System.ServiceModel.Channels.ServiceChannel

Fields:

public enum CommunicationState
{
    Created = 0,
    Opening = 1,
    Opened = 2,
    Closing = 3,
    Closed = 4,
    Faulted = 5
}

So in our case, the ServiceChannel is Opened. We could identify the state by looking at the other variable – if close called or aborted was called, we can only by in state 4 or 5 and so on. But the cheat sheet makes it simple.

Hope you find it useful!

This year's theme was “Opportunity In Change”. The planning team was formed by volunteers that did a great job – the organization was really well planned, the sessions and the speakers well chosen and from registration to food and networking events everything went flawlessly.

And I want to share with you some of the things I learned. The conference took 2 days and a half. In the 2 full days, there were a couple of sessions going in parallel. Of course, I chose the sessions that seemed more interesting to me. But I learned that the content and the speaker are not enough to make it a good presentation; in order to inspire you, the information and the delivery must match some internal struggle you are dealing with. There were sessions contained the right info, where the speaker did all the right things to attract and connect to the audience, but that didn’t honestly impress me. And sessions that I found heart reaching did nothing for other women.

The session I liked most was one by Nancy D. Solomon, talking about impact. As a writer, speaker, facilitator and executive coach, Nancy has built her career around one simple question: “What did you come here to do, and are you getting it done?” In this session, she gave us the definition of impact -  impact is the fingerprint, not the finger that left the print. Put it simply, it's the consequence of what you do/say/think that matters and not the action/word/thought per se. This was a good point for me, as I have the tendency to look at actions instead of the impact of those actions.

Another good point: people usually don't know what they want, because nobody asked them and, more importantly, they never asked themselves. This is quite applicable inside Microsoft. I know people that do things because they think that that is what they should be doing: I'll take this job because I'll be better positioned for the next , I'll do this because it will increase my visibility, etc. Very few ask: what do I really want? She told us about a study that looks at how engaged the employees are. I believe I found the study, and it says:

The Gallup Management Journal publishes a semi-annual Employee Engagement Index. Recent results for the U.S. indicated that:

•    Only 29% of employees are actively engaged in their jobs and feel a passion for their work and a connection to their company.
•    Over half of employees (54%) are not engaged in their work and have essentially “checked out.” They are going through the motions; putting in their time and keeping busy but not working with passion.
•    The remaining employees, 17%, are actively disengaged. Such employees act on their unhappiness and undermine the work their engaged co-workers are trying to accomplish.

When it comes to career progress, Nancy sais a lot of people think that personal satisfaction and achievement are on the same axis, and therefore in order to get one, the other will be neglected, Instead, she argues that people move an 2 axes, so it's possible to move to accomplish both if you do what you like.

Another session I liked was Bonnie St John’s one, about achieving peak performance in spite of the fact that life is sometimes tough. This was a very inspiring story: Bonnie had a most interesting life:

Due to a condition called pre-femoral focal disorder, Bonnie had her right leg amputated above the knee when she was only 5 years old. Despite this challenge, she went on to excel as an athlete, a scholar, a mother, and a businesswoman. After graduating Magna Cum Laude from Harvard University in 1986, Bonnie won a Rhodes Scholarship to Oxford University where she earned her M.Litt. Degree in Economics in 1990. She worked in the White House during the Clinton administration as a Director for the National Economic Council, and is currently CEO of Courageous Spirit, Inc. Bonnie provides inspirational and motivational keynote speeches to dozens of business organizations annually, touching literally tens of thousands of lives each year with her messages of strength and courage.

The most important take away from her presentation was that if people often compare life with sports, nowadays, companies are better compared with disabilities sports (due to the economic situation that’s not quite pink – in case you haven’t noticed). Companies need to thrive despite their disabilities; same for people. About the people she competed with at Paralympics, she said: "what they don't have doesn't matter". What matters is to do the best with what you have.

Instead of playing it safe to stay up all the time, it's more important to learn how to get up fast after you fall.

Now, most of the sessions touched upon some common themes:

• Be yourself, and be the best you can be.
• Take risks, get out of your comfort zone.
• Enjoy the small moments of life, take time regularly to feel joy and delight.
• Find and follow your purpose in life to be more efficient.
• Soft skills impact business performance. A study shows that people give in average 85% off what they could be giving on the job; they put in more depending on the direct manager’s soft skills and the soft skills of people around them.

I also loved the quote Mitch Shepard shared with us at her session about Emotional Intelligence: The cure for exertion is not rest, it’s living wholeheartedly. I believe I’ll make this my motto.

Hope this gives you an idea of what happened at the Microsoft conference. Like Lisa Brummel, Microsoft’s senior VP for HR said at the conference, there are a lot of opportunities for personal development and learning activities in Microsoft; if people don’t know about them, it’s management’s fault; if they know and don’t take advantage of them, it’s their own fault. The women’s conference is an opportunity for women to network and connect with other women, learn and get inspired by different opinions, opportunities, and a variety of experiences. If your company organizes something similar, I highly recommend going.

“a general-purpose, high-speed tracing facility provided by the operating system. Using a buffering and logging mechanism implemented in the kernel, ETW provides a tracing mechanism for events raised by both user-mode applications and kernel-mode device drivers. Additionally, ETW gives you the ability to enable and disable logging dynamically, making it easy to perform detailed tracing in production environments without requiring reboots or application restarts. The logging mechanism uses per-processor buffers that are written to disk by an asynchronous writer thread. This allows large-scale server applications to write events with minimum disturbance.”

The article above explains the ETW architecture (that suffered great improvements since Windows Vista), explaining events and sessions, event providers and event consumers. As a quick overview: an event provider writes events to ETW sessions (it can be any user-mode application, managed application, driver etc). When events are written, ETW adds more info about the time it took place, process and thread ID that generated it, processor number, and CPU usage data of the logging thread. This info is used by the event consumers - application that reads log files or listens to a session for real time events and processes them. More about providers at ETW Trace Providers - When to use what.

Since Windows Vista, the event provider APIs are simpler to use and offer richer functionality (like same way to use trace and event logs). To register as an ETW provider, software components need to provide a GUID as a unique identifier and a callback that will be invoked when notifications are enabled. When enabling a provider, a controller can specify

- a level (1-byte integer) – used to show the severity or verbosity of events (eg. verbose, info, error, critical)

- keywords (8-byte bit masks) – indicate subcomponents in a provider, so subcomponents can be enabled separately.

.Net Framework offers a managed ETW provider API (see System.Diagnostics.Eventing Namespace).

Once a provider is installed, users can collect events from the provider using the logman tool or Reliability and Performance Monitor (Perfmon in Vista and above). The Event Viewer offers another means for collecting and viewing events. Logman is a controller that offers the following options:

logman create - Create a counter, trace, configuration data collector, or API.

logman query - Query data collector properties.

logman start | stop - Start or stop data collection.

logman delete - Delete an existing data collector.

logman update - Update the properties of an existing data collector.

logman import | export - Import a data collector set from an XML file or export a data collector set to an XML file.

To read more about logman, try Two Minute Drill: LOGMAN.EXE.

Tracerpt can be used to process event trace logs or real-time data from instrumented event trace providers. It generates trace analysis reports and CSV (comma-delimited) files for the events generated. LogParser 2.2 also knows to parse ETW events.

There are other tools that can help with event logging information, like Event trace and ETW Trace Viewer.

To see an example of how to use ETW, read Capturing and analyzing an ETW Trace article.

The tools I mentioned so far are useful to get and analyze the traces. From a developer point of view, if you want to generate traces for your software application, you can create a trace source and then write events to it. Using an ETW listener offers huge performance improvements over other trace listeners. For a managed application that uses the existing trace listeners or other custom listeners, the only change is to switch to the EventProviderTraceListener (a configuration change). For a provider with GUID 4a632b62-b345-42d4-56dc-g1sac9hfjr14 (generated and installed by you), the config file can look like this:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.diagnostics>
    <sources>
      <source name="MySourceName" switchName="mySwitch" 
              switchType="System.Diagnostics.SourceSwitch">
        <listeners>
          <remove name="Default" />
          <add name="MyEventProviderTraceListener"
               type="System.Diagnostics.Eventing.EventProviderTraceListener, 
               System.Core, Version=3.5.0.0, Culture=neutral, 
               PublicKeyToken=b77a5c561934e089"
               initializeData="4a632b62-b345-42d4-56dc-g1sac9hfjr14" />
        </listeners>
      </source>
    </sources>
    <trace autoflush="true" indentsize="4"/>
  </system.diagnostics>
</configuration>

But more about this in a future post. Stay tuned!

Let’s take a concrete example: the class ProjectProgressTracker keeps track of a project progress – this is the Events Generator; when a task is added, completed or blocked (all internal states that the user doesn’t have access to), it needs to let a monitor system know – the Events Consumer.

// generates events when a task is added, completed, blocked etc
class ProjectProgressTracker {
    static Random r = new Random((int)DateTime.Now.Ticks);
    List<Task> tasks;

    public ProjectProgressTracker(string[] initialTasks) {
        this.tasks = new List<Task>();
        if (initialTasks != null)
            foreach (string s in initialTasks)
                this.tasks.Add(new Task(s));
    }

    public void NextAction() {
        int randomNumber = r.Next(10);
        if (randomNumber < 3)
            // a new task was added
        else if (randomNumber > 6)
            // a task is blocked
        else
            // the task is done
    }

    class Task {
        string name;
        public Task(string name)
            this.name = name;
        // other properties & methods
    }
}

This monitor system – StatusUpdatePublisher, sends mails and updates calendars.

// the class that reacts to events generated by ProjectProgressTracker
class StatusUpdatePublisher {
    public void OnTaskAdded(string taskName) {
        this.UpdateCalendar(true);
        this.SendMail(taskName, "added");
    }
    public void OnTaskBlocked(string taskName) {
        this.SendMail(taskName, "blocked");
    }
    public void OnTaskCompleted(string taskName) {
        this.UpdateCalendar(false);
        this.SendMail(taskName, "completed");
    }

    void SendMail(string taskName, string action) {
        Console.WriteLine("Task {0} was {1}", taskName, action);
    }
    void UpdateCalendar(bool taskAdded) {
        Console.WriteLine("Task was {0}", taskAdded ? "added" : "removed");
    }
}

The 2 functionalities (generator / consumer) are completely separate.

1. One way to implement this is to pass an Events Consumer object when constructing the Events Generator; then the generator class simply uses the consumer instance to call the desired methods.

class ProjectProgressTracker {
    static Random r = new Random((int)DateTime.Now.Ticks);
    List<Task> tasks;
    readonly StatusUpdatePublisher publisher;

    public ProjectProgressTracker(
        string[] initialTasks, StatusUpdatePublisher publisher) {
        this.publisher = publisher;
        // other functionality, see above
    }

    public void NextAction() {
        // This should be replaced with the actual logic
        int randomNumber = r.Next(10);
        if (randomNumber < 3)
            publisher.OnTaskAdded(randomNumber.ToString());
        else if (randomNumber > 6)
            publisher.OnTaskBlocked(randomNumber.ToString());
        else
            publisher.OnTaskCompleted(randomNumber.ToString());
    }

    // other methods & classes
}

This works, but makes the events generator class tightly coupled with the events consumer. Consider now that we want to add another monitor system that generates documentation tasks. If we follow the style above, we should pass it too inside the events generator class so it can call the correct methods. Of course, this model doesn’t scale very well.

2. Another option is to raise some events at the correct time.

class TaskEventArgs : EventArgs {
    public TaskEventArgs(string taskName) {
        this.TaskName = taskName;
    }
    public string TaskName { get; private set; }
}

delegate void TaskEventHandler(object sender, TaskEventArgs e);

The events generator class has 3 events – for tasks added, completed and blocked.

class ProjectProgressTracker {
    public event TaskEventHandler OnTaskAdded;
    public event TaskEventHandler OnTaskCompleted;
    public event TaskEventHandler OnTaskBlocked;

    public void NextAction() {
        // This should be replaced with the actual logic
        int randomNumber = r.Next(10);
        TaskEventArgs eventArgs = new TaskEventArgs(
            randomNumber.ToString());
        if (randomNumber < 3)
            this.OnTaskAdded(this, eventArgs);
        else if (randomNumber > 6)
            this.OnTaskBlocked(this, eventArgs);
        else
            this.OnTaskCompleted(this, eventArgs);
    }

    // other methods & classes
}

Then the user of the class needs to hook up the events to the correct methods in the consumer class.

ProjectProgressTracker tracker = new ProjectProgressTracker(
    new string[] {"Gather requirements", "Prototype"});
tracker.OnTaskAdded += 
    (object o, TaskEventArgs e) => publisher.OnTaskAdded(e.TaskName);
tracker.OnTaskCompleted += 
    (object o, TaskEventArgs e) => publisher.OnTaskCompleted(e.TaskName);
tracker.OnTaskBlocked += 
    (object o, TaskEventArgs e) => publisher.OnTaskBlocked(e.TaskName); 

The benefit of this approach is that the generator class is not modified, no matter how many consumer classes we want to add to it. The disadvantage is that the user class needs to hook up all events to the correct implementation in consumers.

3. Another solution is to use the Observable/Observer pattern. The Observer-Observable design pattern is a a very useful pattern for maintaining one-way communication between one object and a set of other objects. The observers receive communications from the Observable. Observers do not have a reference back to the Observable, so the communication is strictly from the Observable to the Observers. The observable is the object the Observers are "watching". The Observable maintains some sort of  list of references to Observers. That way, the Observable can send a message to all the Observers by calling each of their update methods.

This is a known pattern, but since it’s not implemented in .Net Framework 3.5, I am just going to define some interfaces that suit my needs.

Here, the class that generates events is the IObservable<T> and the class that consumes events in IObserver<T>:

interface IObservable<T> {
    void Subscribe(IObserver<T> observer);
    bool Unsubscribe(IObserver<T> observer);
}

interface IObserver<T> {
    void OnNext(T value);
}

In our case, T is a class that contains the state of the task – the name of the task and the action that was taken:

enum TaskAction { Added, Completed, Blocked }
class TaskState {
    public TaskState(string taskName, TaskAction taskAction) {
        this.TaskAction = taskAction;
        this.TaskName = taskName;
    }
    public string TaskName { get; private set; }
    public TaskAction TaskAction { get; private set; }
}

So our classes change accordingly: the ProjectProgressTracker implements the IObservable interface, and the status update class implements the IObserver interface.

class ProjectProgressTracker : IObservable<TaskState> {
    List<IObserver<TaskState>> observers = 
        new List<IObserver<TaskState>>();

    public void Subscribe(IObserver<TaskState> observer) {
        this.observers.Add(observer);
    }
    public bool Unsubscribe(IObserver<TaskState> observer) {
        return this.observers.Remove(observer);
    }

    public void NextAction() {
        // This should be replaced with the actual logic
        int randomNumber = r.Next(10);
        TaskEventArgs eventArgs = new TaskEventArgs(
            randomNumber.ToString());
        if (randomNumber < 3)
            foreach (IObserver<TaskState> observer in this.observers)
                observer.OnNext(
                    new TaskState(randomNumber.ToString(), TaskAction.Added));
        else if (randomNumber > 6)
            foreach (IObserver<TaskState> observer in this.observers)
                observer.OnNext(
                    new TaskState(randomNumber.ToString(), TaskAction.Blocked));
        else
            foreach (IObserver<TaskState> observer in this.observers)
                observer.OnNext(
                    new TaskState(randomNumber.ToString(), TaskAction.Completed));
    }

    // other methods & classes
}

class StatusUpdatePublisher : IObserver<TaskState> {
    public void OnNext(TaskState state) {
        switch (state.TaskAction) {
            case TaskAction.Added:
                this.OnTaskAdded(state.TaskName); break;
            case TaskAction.Blocked:
                this.OnTaskBlocked(state.TaskName); break;
            case TaskAction.Completed:
                this.OnTaskCompleted(state.TaskName); break;
        }
    }

    // the other methods
}

Now the user just constructs the classes and registers the desired consumers:

StatusUpdatePublisher publisher = new StatusUpdatePublisher();
ProjectProgressTracker tracker = new ProjectProgressTracker(
    new string[] {"Gather requirements", "Prototype"});
tracker.Subscribe(publisher);

This pattern has a couple of advantages:

• Multiple consumers can be added easily
• The events generator doesn’t need to know anything about the consumers; no change in the generator is needed when one or more of the consumers is changed.

But we pay the penalty of wrapping the state in a class and then analyzing it in the Observer to see what concrete method to implement.

4. Another possible implementation is the IRegistrar pattern (Disclaimer: I’m not aware of a pattern with this name described. The name is something I came up with). This is somewhat similar with the IObservable pattern, but instead of a class that wraps the state when the event occurs, we specify an interface for the type of events.

interface IProjectEvents {
    void OnTaskAdded(string taskName);
    void OnTaskBlocked(string taskName);
    void OnTaskCompleted(string taskName);
}

interface IRegistrar<T> {
    void Subscribe(T consumer);
    bool Unsubscribe(T consumer);
}

The events consumers implement this interface:

class StatusUpdatePublisher : IProjectEvents {
    // the original methods
}

The generator class can register consumers that know to consume events of type T (IProjectEvents in our case).

class ProjectProgressTracker : IRegistrar<IProjectEvents> {
    List<IProjectEvents> consumers = new List<IProjectEvents>();

    public void Subscribe(IProjectEvents consumer) {
        this.consumers.Add(consumer);
    }
    public bool Unsubscribe(IProjectEvents consumer) {
        return this.consumers.Remove(consumer);
    }

    public void NextAction() {
        // This should be replaced with the actual logic
        int randomNumber = r.Next(10);
        TaskEventArgs eventArgs = new TaskEventArgs(
            randomNumber.ToString());
        if (randomNumber < 3)
            foreach (IProjectEvents consumer in this.consumers)
                consumer.OnTaskAdded(randomNumber.ToString());
        else if (randomNumber > 6)
            foreach (IProjectEvents consumer in this.consumers)
                consumer.OnTaskBlocked(randomNumber.ToString());
        else
            foreach (IProjectEvents consumer in this.consumers)
                consumer.OnTaskCompleted(randomNumber.ToString());
    }

    // other methods & classes
}

The usage is just as the one for the IObservable pattern.

In our case, it seems that this pattern works the best, because we get all the previous advantages plus strongly typing when calling consumer methods.

Depending on your project requirements, you may choose one of these solutions or look for a better one. Some requirements may be:

• Loosely coupling between the events generator and the consumers
  • Changing the consumer doesn’t affect the generator
• One or more consumers can be added
• Producers can have inner producers and the consumers must be propagated
• Etc… who knows?

On the Communications front, Windows Communication Foundation has 3 major new features: support for WS-Discovery, standard endpoints (pre-defined endpoints with some of the properties fixed) and workflow services (messaging activities make the implementation of workflows very easy).

I am really excited with the support for the WS-Discovery protocol. From the msdn documentation:

“The Service Discovery feature enables client applications to dynamically discover service addresses at run time in an interoperable way using WS-Discovery. The WS-Discovery specification outlines the message-exchange patterns (MEPs) required for performing lightweight discovery of services, both by multicast (ad hoc) and unicast (using a network resource).”

To learn more about Discovery, take a at the Discovery MSDN SDK samples. Plus, the Discovery team is blogging, so go to the Discovery team’s blog. Or start with the Channel9 Discovery video: