When ever you encounter multiple conditions that you see growing, that should be a clear indication that a strategy pattern could help. You start by doing the following.
Create a simple enum for your status codes.
public enum MessageStatusCodes{
case12= 12,
case13= 13,
case22 = 22,
case120 = 120
}
Create your interface that will instruct your concrete strategy classes how to handle your messages
public interface IMessageStrategy{
void Process(Message);
}
Here your Message class will become your context object.
public class Message
{
public Guid ID { get; private set; }
public string MessageIn { get; private set; }
public string MessageOut { get; private set; }
public MessageStatusCodes StatusCode { get; set; } //EDIT could be changed during message lifecycle
public Message(Guid id, string messageIn, string messageOut, MessageStatusCodes statusCode){
ID=id;
MessageIn=messageIn;
MessageOut=messageOut;
StatusCode = statusCode;
LoadStrategies();
}
private static Dictionary<MessageStatusCodes, IMessageStrategy> messageStrategies;
private void LoadStrategies()
{
messageStrategies = new Dictionary<MessageStatusCodes,IMessageStrategy>();
messageStrategies.Add(MessageStatusCodes.case12, new DeleteMessageStrategy() );
}
public void Process()
{
return messageStrategies[StatusCode].Process(this);
}
}
Then you start by creating your concrete classes that implement the different actions or strategies that you want to perform for each condition. For example, the Delete message action could be a strategy.
public class DeleteMessageStrategy : IMessageStrategy {
public void Process(Message){
//do something based on delete status code
}
}
Then you call your Message like so
Message message = new Message(....);
message.Process();
And then your code will process the message with respect to the status code passed in.
When you're ready to expand, you implement new strategies and add those new strategies to your Message class so its aware of them.
You can really expand on this template I have shown here. Take a look at my post, I did something very similar and had questions and came to codereview for answers
When ever you encounter multiple conditions that you see growing, that should be a clear indication that a strategy pattern could help. You start by doing the following.
Create a simple enum for your status codes.
public enum MessageStatusCodes{
case12= 12,
case13= 13,
case22 = 22,
case120 = 120
}
Create your interface that will instruct your concrete strategy classes how to handle your messages
public interface IMessageStrategy{
void Process(Message);
}
Here your Message class will become your context object.
public class Message
{
public Guid ID { get; private set; }
public string MessageIn { get; private set; }
public string MessageOut { get; private set; }
public MessageStatusCodes StatusCode { get; set; } //EDIT could be changed during message lifecycle
public Message(Guid id, string messageIn, string messageOut, MessageStatusCodes statusCode){
ID=id;
MessageIn=messageIn;
MessageOut=messageOut;
StatusCode = statusCode;
LoadStrategies();
}
private static Dictionary<MessageStatusCodes, IMessageStrategy> messageStrategies;
private void LoadStrategies()
{
messageStrategies = new Dictionary<MessageStatusCodes,IMessageStrategy>();
messageStrategies.Add(MessageStatusCodes.case12, new DeleteMessageStrategy() );
}
public void Process()
{
return messageStrategies[StatusCode].Process(this);
}
}
Then you start by creating your concrete classes that implement the different actions or strategies that you want to perform for each condition. For example, the Delete message action could be a strategy.
public class DeleteMessageStrategy : IMessageStrategy {
public void Process(Message){
//do something based on delete status code
}
}
Then you call your Message like so
Message message = new Message(....);
message.Process();
And then your code will process the message with respect to the status code passed in.
When you're ready to expand, you implement new strategies and add those new strategies to your Message class so its aware of them.
You can really expand on this template I have shown here. Take a look at my post, I did something very similar and had questions and came to codereview for answers
When ever you encounter multiple conditions that you see growing, that should be a clear indication that a strategy pattern could help. You start by doing the following.
Create a simple enum for your status codes.
public enum MessageStatusCodes{
case12= 12,
case13= 13,
case22 = 22,
case120 = 120
}
Create your interface that will instruct your concrete strategy classes how to handle your messages
public interface IMessageStrategy{
void Process(Message);
}
Here your Message class will become your context object.
public class Message
{
public Guid ID { get; private set; }
public string MessageIn { get; private set; }
public string MessageOut { get; private set; }
public MessageStatusCodes StatusCode { get; set; } //EDIT could be changed during message lifecycle
public Message(Guid id, string messageIn, string messageOut, MessageStatusCodes statusCode){
ID=id;
MessageIn=messageIn;
MessageOut=messageOut;
StatusCode = statusCode;
LoadStrategies();
}
private static Dictionary<MessageStatusCodes, IMessageStrategy> messageStrategies;
private void LoadStrategies()
{
messageStrategies = new Dictionary<MessageStatusCodes,IMessageStrategy>();
messageStrategies.Add(MessageStatusCodes.case12, new DeleteMessageStrategy() );
}
public void Process()
{
return messageStrategies[StatusCode].Process(this);
}
}
Then you start by creating your concrete classes that implement the different actions or strategies that you want to perform for each condition. For example, the Delete message action could be a strategy.
public class DeleteMessageStrategy : IMessageStrategy {
public void Process(Message){
//do something based on delete status code
}
}
Then you call your Message like so
Message message = new Message(....);
message.Process();
And then your code will process the message with respect to the status code passed in.
When you're ready to expand, you implement new strategies and add those new strategies to your Message class so its aware of them.
You can really expand on this template I have shown here. Take a look at my post, I did something very similar and had questions and came to codereview for answers
When ever you encounter multiple conditions that you see growing, that should be a clear indication that a strategy pattern could help. You start by doing the following.
Create a simple enum for your status codes.
public enum MessageStatusCodes{
case12= 12,
case13= 13,
case22 = 22,
case120 = 120
}
Create your interface that will instruct your concrete strategy classes how to handle your messages
public interface IMessageStrategy{
void Process(Message);
}
Here your Message class will become your context object.
public class Message
{
public Guid ID { get; private set; }
public string MessageIn { get; private set; }
public string MessageOut { get; private set; }
public MessageStatusCodes StatusCode { get; set; } //EDIT could be changed during message lifecycle
public Message(Guid id, string messageIn, string messageOut, MessageStatusCodes statusCode){
ID=id;
MessageIn=messageIn;
MessageOut=messageOut;
StatusCode = statusCode;
LoadStrategies();
}
private static Dictionary<MessageStatusCodes, IMessageStrategy> messageStrategies;
private void LoadStrategies()
{
messageStrategies = new Dictionary<MessageStatusCodes,IMessageStrategy>();
messageStrategies.Add(MessageStatusCodes.case12, new DeleteMessageStrategy() );
}
public void Process()
{
return messageStrategies[StatusCode].Process(this);
}
}
Then you start by creating your concrete classes that implement the different actions or strategies that you want to perform for each condition. For example, the Delete message action could be a strategy.
public class DeleteMessageStrategy : IMessageStrategy {
public void Process(Message){
//do something based on delete status code
}
}
Then you call your Message like so
Message message = new Message(....);
message.Process();
And then your code will process the message with respect to the status code passed in.
When you're ready to expand, you implement new strategies and add those new strategies to your Message class so its aware of them.
You can really expand on this template I have shown here. Take a look at my post, I did something very similar and had questions and came to codereview for answers