Create a text file, type in the following lines and save it as addprompt.reg.
Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\Directory\shell\Command]
@="Command Prompt:"
[HKEY_CLASSES_ROOT\Directory\shell\Command\Command]
@="cmd.exe /k cd %1"
Save this out and double click the file.
[NonSerialized] private static readonly IDictionary loggers = new Dictionary();
static Logger()
{
loggers.Add(LoggingLevel.DEBUG, LogManager.GetLogger(LoggingLevel.DEBUG));
loggers.Add(LoggingLevel.INFO, LogManager.GetLogger(LoggingLevel.INFO));
loggers.Add(LoggingLevel.ERROR, LogManager.GetLogger(LoggingLevel.ERROR));
loggers.Add(LoggingLevel.FATAL, LogManager.GetLogger(LoggingLevel.FATAL));
log4net.Config.XmlConfigurator.ConfigureAndWatch(new FileInfo("log4net.config"));
}
public static string FormatErrorMessage(Exception ex)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat("Error message: {0} \n Stack trace: {1}", CompleteExceptionMessage(ex),
CompleteStackTrace(ex));
return stringBuilder.ToString();
}
public static void Debug(string message)
{
loggers[LoggingLevel.DEBUG].Debug(message);
}
public static class CommonLogManager
{
private static readonly WrapperMap s_wrapperMap =
new WrapperMap(WrapperCreationHandler);
public static CommonLogImpl GetLogger(string name)
{
return WrapLogger(LoggerManager.GetLogger(Assembly.GetCallingAssembly(), name));
}
private static CommonLogImpl WrapLogger(ILogger logger)
{
return (CommonLogImpl) s_wrapperMap.GetWrapper(logger);
}
private static ILoggerWrapper WrapperCreationHandler(ILogger logger)
{
return new CommonLogImpl(logger);
}
}
public class Logger
{
[NonSerialized] private static IDictionary loggers = new Dictionary();
static Logger()
{
loggers.Add(LoggingLevel.DEBUG, CommonLogManager.GetLogger(LoggingLevel.DEBUG));
loggers.Add(LoggingLevel.INFO, CommonLogManager.GetLogger(LoggingLevel.INFO));
loggers.Add(LoggingLevel.ERROR, CommonLogManager.GetLogger(LoggingLevel.ERROR));
loggers.Add(LoggingLevel.FATAL, CommonLogManager.GetLogger(LoggingLevel.FATAL));
XmlConfigurator.ConfigureAndWatch(new FileInfo("log4net.config"));
}
protected static IDictionary Loggers
{
get { return loggers; }
set { loggers = value; }
}
[TestFixture]
public class DemoLoggingTest
{
#region Setup/Teardown
[SetUp]
public void Setup()
{
request = new request();
request.operand1 = 10;
request.operand2 = 0;
request.secretpassword = "password";
demoLogging = new DemoLibrary();
mockRepository = new MockRepository();
}
#endregion
private request request;
private DemoLibrary demoLogging;
private MockRepository mockRepository;
private void CreatemockLogger(ILog mockCommonLogger)
{
var loggerStub = new LoggerStub();
var logs = new Dictionary();
logs.Add("DEBUG", mockCommonLogger);
logs.Add("ERROR", mockCommonLogger);
loggerStub.injectLoggers(logs);
}
[Test]
[ExpectedException(typeof (DivideByZeroException))]
public void ShouldLogDebugLogs()
{
var mockCommonLogger = (ILog) mockRepository.CreateMock(typeof (ILog));
CreatemockLogger(mockCommonLogger);
mockCommonLogger.Debug(request);
mockCommonLogger.Error(null);
LastCall.On(mockCommonLogger).IgnoreArguments();
mockRepository.ReplayAll();
demoLogging.Divide(request);
mockRepository.VerifyAll();
}
[TearDown]
public void TearDown()
{
request = null;
demoLogging = null;
mockRepository = null;
}
}
internal class LoggerStub : Logger
{
public void injectLoggers(IDictionary dictionary)
{
Loggers = dictionary;
}
}
public class SerializingRollingFileAppenderAppender : RollingFileAppender
{
protected override void Append(LoggingEvent loggingEvent)
{
LoggingEventData data = loggingEvent.GetLoggingEventData();
data.Message = LogMessageHelper.FormatMessageBeforeLogging(loggingEvent);
base.Append(new LoggingEvent(data));
}
}
public class LogMessageHelper
{
private static string SerializeMessage(object message)
{
if (message is string) return (string) message;
using (var writer = new StringWriter())
{
SerializeMessage(message, writer);
return writer.ToString();
}
}
private static void SerializeMessage(object message, TextWriter writer)
{
new XmlSerializer(message.GetType()).Serialize(writer, message);
}
public static string GetThreadId()
{
return "Thread Id: " + Thread.CurrentThread.ManagedThreadId;
}
public static string FormatMessageBeforeLogging(LoggingEvent loggingEvent)
{
var sb = new StringBuilder();
sb.Append(" ");
sb.Append(GetThreadId());
string data = SerializeMessage(loggingEvent.MessageObject);
sb.Append(data);
sb.Append(Environment.NewLine);
return sb.ToString();
}
}
public class SerializingRollingFileAppenderAppender : RollingFileAppender
{
private readonly List RegexFilterPatterns = new List();
public string RegexFilterPattern
{
set { RegexFilterPatterns.Add(value); }
}
protected override void Append(LoggingEvent loggingEvent)
{
LoggingEventData data = loggingEvent.GetLoggingEventData();
data.Message = LogMessageHelper.FormatMessageBeforeLogging(loggingEvent,RegexFilterPatterns);
base.Append(new LoggingEvent(data));
}
}
So here was the code:
public class ModuleCatalogue
{
private static volatile ModuleCatalogue _moduleCatalogue;
private static object syncRoot = new object();
private ModuleCatalogue
{}
public static ModuleCatalogue instance
{
get
{
if (_moduleCatalogue == null)
{
lock (syncRoot)
{
if (_moduleCatalogue == null)
_moduleCatalogue = new ModuleCatalogue()
}
}
return _moduleCatalogue;
}
}
}
So why do we need to make _moduleCatalogue volatile. This is mainly because our compiler tries to be smart and tries to do some optimization by caching the value. So we use the keyword “volatile” to make sure it does not do any optimization on that memory location.And thus making sure that the thread retrieves the most up to date value. It is also said that the compiler optimizes some section of the code as well. This might affect our value in case of muti-threaded environment.
There are several benefits that one could see from an approach like this:
There are at least three things we need to write the test for:
