So we have a base interface:

        public interface IMessage
        { 
            //Some properties
        }

then we have derived messages that implement this interface such as:

        public class AlarmEventMessage: IMessage 
        {   //Some properties  }

Now, these messages get routed to a message handler that receives them. So we have multiple overloads for this Handle(IMessage message) to handle the specific derived messages.

        public class MessageHandler
        {
             public bool Handle(IMessage message)
             {
                 if (message is AlarmEventMessage)
                 {
                     return Handle(message as AlarmEventMessage);
                 }
                 // some more message routing here
             }

             public bool Handle(AlarmEventMessage message)
             {
                 // Some business logic here
             }

             //Handle more messages here
        }

I believe it violates the Single-Responsibility Principle. This class constantly keeps changing because of new messages being added and also the business logic that relates with this new message.

Any other SOLID principles it violates? Does it look like an Anti-Pattern?

We have a base interface:

        public interface IMessage
        { 
            //Some properties
        }

then we have derived messages that implement this interface such as:

        public class AlarmEventMessage: IMessage 
        {   //Some properties  }

Now, these messages get routed to a message handler that receives them. So we have multiple overloads for this Handle(IMessage message) to handle the specific derived messages.

        public class MessageHandler
        {
             public bool Handle(IMessage message)
             {
                 if (message is AlarmEventMessage)
                 {
                     return Handle(message as AlarmEventMessage);
                 }
                 // some more message routing here
             }

             public bool Handle(AlarmEventMessage message)
             {
                 // Some business logic here
             }

             //Handle more messages here
        }

I believe it violates the Single-Responsibility Principle. This class constantly keeps changing because of new messages being added and also the business logic that relates with this new message.

Are there any other SOLID principles it violates? Does it look like an Anti-Pattern?