Coding A AOP Logger

Look at the following points

• Create a new project (I created a Console Application).
• Add NuGet package Castle.Core, Castle.Windsor and Log4Net.
• Castle.Core: Allow we to use Proxy

Proxy objects can assist in building a flexible application architecture because it allows functionality to be transparently added to code without modifying it. For example, a class could be proxied to add logging or security checking without making the code aware this functionality has been added.

• Implementing a simple calculator to logger their operations:
  
  1. public interface ICalculator
  2. {
  3. double Add(double x, double y);
  4. double Divide(double x, double y);
  5. }
  6. public class Calculator: ICalculator
  7. {
  8. public double Add(double x, double y)
  9. {
  10. return x + y;
  11. }
  12. public double Divide(double x, double y)
  13. {
  14. return x / y;
  15. }
  16. }

• Now we can proceed to coding our logger. We want to log every call function including their parameters and the return value.
  
  
• Let’s create a simple Class Calculator to be logged as follows.
  
  
• Now we need to configure log4net,
  
  Open the AssemblyInfo.cs and insert the follow line:
  
  [assembly: log4net.Config.XmlConfigurator(Watch = true)]
  
  Configure the application config (app.config) as follows:
  
  
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3. <configSections>
  4. <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" /> </configSections>
  5. <startup>
  6. <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /> </startup>
  7. <log4net>
  8. <appender name="MyLogger" type="log4net.Appender.RollingFileAppender">
  9. <file type="log4net.Util.PatternString" value="MyLog.txt" />
  10. <appendToFile value="true" />
  11. <rollingStyle value="Size" />
  12. <maxSizeRollBackups value="20" />
  13. <maximumFileSize value="1000KB" />
  14. <layout type="log4net.Layout.PatternLayout">
  15. <param name="ConversionPattern" value="%date [%thread] %-5level %logger [%ndc] - %message%newline" /> </layout>
  16. </appender>
  17. <root>
  18. <level value="DEBUG" />
  19. <appender-ref ref="MyLogger" /> </root>
  20. </log4net>
  21. </configuration>

• Now we need to create an Interceptor to be invoked in every method call to create our log.
  
  
  1. public class LogInterceptor: IInterceptor
  2. {
  3. void IInterceptor.Intercept(IInvocation invocation)
  4. {
  5. var logger = LogManager.GetLogger(invocation.TargetType);
  6. try
  7. {
  8. StringBuilder sb = null;
  9. if (logger.IsDebugEnabled)
  10. {
  11. sb = new StringBuilder(invocation.TargetType.FullName).Append(".").Append(invocation.Method).Append("("); //getting method name
  12. //getting parameters
  13. for (int i = 0; i < invocation.Arguments.Length; i++)
  14. {
  15. if (i > 0) sb.Append(", ");
  16. sb.Append(invocation.Arguments[i]);
  17. }
  18. sb.Append(")");
  19. logger.Debug(sb);
  20. }
  21. invocation.Proceed();
  22. if (logger.IsDebugEnabled)
  23. {
  24. //getting return
  25. logger.Debug("Return of " + sb + " is: " + invocation.ReturnValue);
  26. }
  27. }
  28. catch (Exception e)
  29. {
  30. logger.Error(e);
  31. throw;
  32. }
  33. }
  34. }

• Now we need to test our Logger.
  
  At my console application main I have the following code:
  
  
  1. class Program
  2. {
  3. static void Main(string[] args)
  4. {
  5. InitCalc();
  6. }
  7. private static void InitCalc()
  8. {
  9. //A little of IoC here
  10. //Here I put our LogInterceptor into my Calculator
  11. var container = new WindsorContainer().Register(Component.For < LogInterceptor > (), Component.For < ICalculator > ().ImplementedBy < Calculator > ().Interceptors(new InterceptorReference(typeof (LogInterceptor))).First);
  12. BasicConfigurator.Configure(); // configure log4net
  13. //Create my ICalculator Object to be able to log method calls
  14. var c = container.Resolve < ICalculator > ();
  15. try
  16. {
  17. c.Add(1, 2);
  18. c.Divide(1, 2);
  19. c.Divide(1, 0);
  20. }
  21. catch (Exception)
  22. {}
  23. Console.ReadKey();
  24. }
  25. }

• Check the MyLog.txt at bin folder:
  
  
  1. 2015 - 10 - 28 16: 30: 07, 455[10] DEBUG LoggerAOP.Calculator[(null)] - LoggerAOP.Calculator.Double Add(Double, Double)(1, 2)
  2. 2015 - 10 - 28 16: 30: 07, 529[10] DEBUG LoggerAOP.Calculator[(null)] - Return of LoggerAOP.Calculator.Double Add(Double, Double)(1, 2) is: 3
  3. 2015 - 10 - 28 16: 30: 07, 530[10] DEBUG LoggerAOP.Calculator[(null)] - LoggerAOP.Calculator.Double Divide(Double, Double)(1, 2)
  4. 2015 - 10 - 28 16: 30: 07, 530[10] DEBUG LoggerAOP.Calculator[(null)] - Return of LoggerAOP.Calculator.Double Divide(Double, Double)(1, 2) is: 0, 5
  5. 2015 - 10 - 28 16: 30: 07, 531[10] DEBUG LoggerAOP.Calculator[(null)] - LoggerAOP.Calculator.Double Divide(Double, Double)(1, 0)
  6. 2015 - 10 - 28 16: 30: 07, 531[10] DEBUG LoggerAOP.Calculator[(null)] - Return of LoggerAOP.Calculator.Double Divide(Double, Double)(1, 0) is: +Infinito

References

• DynamicProxy
• Introducing Castle - Part I
• Logging the AOP Way
• Aspect-oriented programming