Multiple overloads for message handling
You are correct when you say that the MessageHandler class violates the Single Responsibility Principle. 

What you're looking for here is generics. First of all, you need to define a contract for messages and their respective handlers. This can be done with the following:

public interface IMessage
{
    // properties
}

public interface IMessageHandler&lt;in TMessage&gt;
    where TMessage : IMessage
{
    bool Handle(TMessage message);
}


So with the AlarmEventMessage, you can do this:

public class AlarmEventMessage : IMessage
{
    // properties
}

public class AlarmEventMessageHandler : IMessageHandler&lt;AlarmEventMessage&gt;
{
    public bool Handle(AlarmEventMessage message)
    {
        // stuff
    }
}


This design allows you to do some cool stuff with decorator chains, dispatching, registration by convention (if you're using an IoC container that supports it), among other things. For more information, check out the following two articles (they demonstrate how to implement the command/query pattern, but the design is identical):


Meanwhile... on the command side of my architecture
Meanwhile... on the query side of my architecture