Wikipedia

Chain-of-responsibility pattern: Difference between revisions

Browse history interactively
← Previous editNext edit →
Content deleted Content added
VisualWikitext
m →C# example: file-scoped namespace
Line 125:
 
<syntaxhighlight lang="C#">
namespace ChainOfResponsibility;
 
[Flags]
public enum LogLevel
{
None = 0, // 0
[Flags]
Info = 1, // 1
public enum LogLevel
Debug = 2, // 10
Warning = 4, // 100
Error = 8, // 1000
FunctionalMessage = 16, // 10000
FunctionalError = 32, // 100000
All = 63 // 111111
}
 
/// <summary>
/// Abstract Handler in chain of responsibility pattern.
/// </summary>
public abstract class Logger
{
protected LogLevel logMask;
 
// The next Handler in the chain
protected Logger next;
 
public Logger(LogLevel mask)
{
Nonethis.logMask = 0, // 0mask;
Info = 1, // 1
Debug = 2, // 10
Warning = 4, // 100
Error = 8, // 1000
FunctionalMessage = 16, // 10000
FunctionalError = 32, // 100000
All = 63 // 111111
}
 
/// <summary>
/// AbstractSets Handlerthe inNext logger to make a list/chain of responsibility patternHandlers.
/// </summary>
public abstract classLogger SetNext(Logger nextlogger)
{
protectedLogger LogLevellastLogger logMask= this;
 
// Thewhile (lastLogger.next Handler in the!= chainnull)
protected Logger next;
public Logger(LogLevel mask)
{
this.logMasklastLogger = masklastLogger.next;
}
/// <summary>
/// Sets the Next logger to make a list/chain of Handlers.
/// </summary>
public Logger SetNext(Logger nextlogger)
{
Logger lastLogger = this;
 
while (lastLogger.next != null)nextlogger;
return {this;
}
lastLogger = lastLogger.next;
}
 
public void Message(string msg, LogLevel severity)
lastLogger.next = nextlogger;
{
return this;
if ((severity & logMask) != 0) // True only if any of the logMask bits are set in severity
{
WriteMessage(msg);
}
if (next != null)
public void Message(string msg, LogLevel severity)
{
next.Message(msg, severity);
if ((severity & logMask) != 0) // True only if any of the logMask bits are set in severity
{
WriteMessage(msg);
}
if (next != null)
{
next.Message(msg, severity);
}
}
abstract protected void WriteMessage(string msg);
}
 
abstract protected void WriteMessage(string msg);
public class ConsoleLogger : Logger
}
 
public class ConsoleLogger : Logger
{
public ConsoleLogger(LogLevel mask)
: base(mask)
{ }
 
protected override void WriteMessage(string msg)
{
Console.WriteLine("Writing to console: " + msg);
public ConsoleLogger(LogLevel mask)
: base(mask)
{ }
protected override void WriteMessage(string msg)
{
Console.WriteLine("Writing to console: " + msg);
}
}
}
 
public class EmailLogger : Logger
public class EmailLogger : Logger
{
public EmailLogger(LogLevel mask)
: base(mask)
{ }
 
protected override void WriteMessage(string msg)
{
// Placeholder for mail send logic, usually the email configurations are saved in config file.
public EmailLogger(LogLevel mask)
Console.WriteLine("Sending via email: " :+ base(maskmsg);
{ }
protected override void WriteMessage(string msg)
{
// Placeholder for mail send logic, usually the email configurations are saved in config file.
Console.WriteLine("Sending via email: " + msg);
}
}
}
 
class FileLogger : Logger
class FileLogger : Logger
{
public FileLogger(LogLevel mask)
: base(mask)
{ }
 
protected override void WriteMessage(string msg)
{
// Placeholder for File writing logic
public FileLogger(LogLevel mask)
Console.WriteLine("Writing to Log File: base(mask" + msg);
{ }
protected override void WriteMessage(string msg)
{
// Placeholder for File writing logic
Console.WriteLine("Writing to Log File: " + msg);
}
}
}
 
public class Program
public class Program
{
public static void Main(string[] args)
{
public// staticBuild voidthe Main(string[]chain args)of responsibility
{Logger logger;
logger = new ConsoleLogger(LogLevel.All)
// Build the chain of responsibility
.SetNext(new EmailLogger(LogLevel.FunctionalMessage | LogLevel.FunctionalError))
Logger logger;
logger = .SetNext(new ConsoleLoggerFileLogger(LogLevel.AllWarning | LogLevel.Error));
 
.SetNext(new EmailLogger(LogLevel.FunctionalMessage | LogLevel.FunctionalError))
// Handled by ConsoleLogger since the console has a loglevel of all
.SetNext(new FileLogger(LogLevel.Warning | LogLevel.Error));
logger.Message("Entering function ProcessOrder().", LogLevel.Debug);
logger.Message("Order record retrieved.", LogLevel.Info);
// Handled by ConsoleLogger since the console has a loglevel of all
 
logger.Message("Entering function ProcessOrder().", LogLevel.Debug);
// Handled by ConsoleLogger and FileLogger since filelogger implements Warning & Error
logger.Message("Order record retrieved.", LogLevel.Info);
logger.Message("Customer Address details missing in Branch DataBase.", LogLevel.Warning);
logger.Message("Customer Address details missing in Organization DataBase.", LogLevel.Error);
// Handled by ConsoleLogger and FileLogger since filelogger implements Warning & Error
 
logger.Message("Customer Address details missing in Branch DataBase.", LogLevel.Warning);
// Handled by ConsoleLogger and EmailLogger as it implements functional error
logger.Message("Customer Address details missing in Organization DataBase.", LogLevel.Error);
logger.Message("Unable to Process Order ORD1 Dated D1 For Customer C1.", LogLevel.FunctionalError);
 
// Handled by ConsoleLogger and EmailLogger as it implements functional error
// Handled by ConsoleLogger and EmailLogger
logger.Message("Unable to Process Order ORD1 Dated D1 For Customer C1.", LogLevel.FunctionalError);
logger.Message("Order Dispatched.", LogLevel.FunctionalMessage);
// Handled by ConsoleLogger and EmailLogger
logger.Message("Order Dispatched.", LogLevel.FunctionalMessage);
}
}
}
Retrieved from "https://en.wikipedia.org/wiki/Chain-of-responsibility_pattern"