private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this)
{
Logger l;
if (_loggerCache.TryGetValue(cacheKey, out l))
{
return(l);
}
//Activator.CreateInstance(cacheKey.ConcreteType);
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, GetConfigurationForLogger(cacheKey.Name, Configuration), this);
}
_loggerCache.Add(cacheKey, newLogger);
return(newLogger);
}
}
private static Logger CreateDefaultLogger(ref LoggerCacheKey cacheKey)
{
cacheKey = new LoggerCacheKey(cacheKey.Name, typeof(Logger));
var newLogger = new Logger();
return(newLogger);
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this)
{
WeakReference l;
if (this.loggerCache.TryGetValue(cacheKey, out l))
{
Logger existingLogger = l.Target as Logger;
if (existingLogger != null)
{
// logger in the cache and still referenced
return(existingLogger);
}
}
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
try
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
if (ThrowExceptions)
{
throw;
}
InternalLogger.Error("Cannot create instance of specified type. Proceeding with default type instance. Exception : {0}", exception);
//Creating default instance of logger if instance of specified type cannot be created.
cacheKey = new LoggerCacheKey(typeof(Logger), cacheKey.Name);
newLogger = new Logger();
}
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
this.loggerCache[cacheKey] = new WeakReference(newLogger);
return(newLogger);
}
}
public Logger Retrieve(LoggerCacheKey loggerCacheKey)
{
if (_loggerCache.TryGetValue(loggerCacheKey, out var loggerReference))
{
return(loggerReference.Target as Logger);
}
return(null);
}
public Logger Retrieve(LoggerCacheKey cacheKey)
{
if (_loggerCache.TryGetValue(cacheKey, out var loggerReference))
{
// logger in the cache and still referenced
return(loggerReference.Target as Logger);
}
return(null);
}
public override bool Equals(object o)
{
LoggerCacheKey lck2 = (LoggerCacheKey)o;
if (lck2 == null)
{
return(false);
}
return((ConcreteType == lck2.ConcreteType) && (lck2.Name == Name));
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this.syncRoot)
{
Logger existingLogger = loggerCache.Retrieve(cacheKey);
if (existingLogger != null)
{
// Logger is still in cache and referenced.
return(existingLogger);
}
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
try
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
catch (Exception ex)
{
if (ex.MustBeRethrown() || ThrowExceptions)
{
throw;
}
InternalLogger.Error("Cannot create instance of specified type. Proceeding with default type instance. Exception : {0}", ex);
// Creating default instance of logger if instance of specified type cannot be created.
cacheKey = new LoggerCacheKey(cacheKey.Name, typeof(Logger));
newLogger = new Logger();
}
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
// TODO: Clarify what is the intention when cacheKey.ConcreteType = null.
// At the moment, a logger typeof(Logger) will be created but the ConcreteType
// will remain null and inserted into the cache.
// Should we set cacheKey.ConcreteType = typeof(Logger) for default loggers?
loggerCache.InsertOrUpdate(cacheKey, newLogger);
return(newLogger);
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this)
{
WeakReference l;
if (this.loggerCache.TryGetValue(cacheKey, out l))
{
Logger existingLogger = l.Target as Logger;
if (existingLogger != null)
{
// logger in the cache and still referenced
return(existingLogger);
}
}
// Activator.CreateInstance(cacheKey.ConcreteType);
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
this.loggerCache[cacheKey] = new WeakReference(newLogger);
return(newLogger);
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock(this)
{
Logger l;
if(_loggerCache.TryGetValue(cacheKey, out l))
return l;
//Activator.CreateInstance(cacheKey.ConcreteType);
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
else
newLogger = new Logger();
if (cacheKey.ConcreteType != null)
newLogger.Initialize(cacheKey.Name, GetConfigurationForLogger(cacheKey.Name, Configuration), this);
_loggerCache.Add(cacheKey, newLogger);
return newLogger;
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this)
{
WeakReference l;
if (this.loggerCache.TryGetValue(cacheKey, out l))
{
Logger existingLogger = l.Target as Logger;
if (existingLogger != null)
{
// logger in the cache and still referenced
return existingLogger;
}
}
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
try
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
catch(Exception exception)
{
if(exception.MustBeRethrown())
{
throw;
}
if(ThrowExceptions)
{
throw;
}
InternalLogger.Error("Cannot create instance of specified type. Proceeding with default type instance. Exception : {0}",exception);
//Creating default instance of logger if instance of specified type cannot be created.
cacheKey = new LoggerCacheKey(typeof(Logger),cacheKey.Name);
newLogger = new Logger();
}
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
this.loggerCache[cacheKey] = new WeakReference(newLogger);
return newLogger;
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this.syncRoot)
{
Logger existingLogger = loggerCache.Retrieve(cacheKey);
if (existingLogger != null)
{
// Logger is still in cache and referenced.
return(existingLogger);
}
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
var fullName = cacheKey.ConcreteType.FullName;
try
{
//creating instance of static class isn't possible, and also not wanted (it cannot inherited from Logger)
if (cacheKey.ConcreteType.IsStaticClass())
{
var errorMessage = string.Format("GetLogger / GetCurrentClassLogger is '{0}' as loggerType can be a static class and should inherit from Logger",
fullName);
InternalLogger.Error(errorMessage);
if (ThrowExceptions)
{
throw new NLogRuntimeException(errorMessage);
}
newLogger = CreateDefaultLogger(ref cacheKey);
}
else
{
var instance = FactoryHelper.CreateInstance(cacheKey.ConcreteType);
newLogger = instance as Logger;
if (newLogger == null)
{
//well, it's not a Logger, and we should return a Logger.
var errorMessage = string.Format("GetLogger / GetCurrentClassLogger got '{0}' as loggerType which doesn't inherit from Logger", fullName);
InternalLogger.Error(errorMessage);
if (ThrowExceptions)
{
throw new NLogRuntimeException(errorMessage);
}
// Creating default instance of logger if instance of specified type cannot be created.
newLogger = CreateDefaultLogger(ref cacheKey);
}
}
}
catch (Exception ex)
{
InternalLogger.Error(ex, "GetLogger / GetCurrentClassLogger. Cannot create instance of type '{0}'. It should have an default contructor. ", fullName);
if (ex.MustBeRethrown())
{
throw;
}
// Creating default instance of logger if instance of specified type cannot be created.
newLogger = CreateDefaultLogger(ref cacheKey);
}
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this, this.Configuration);
}
// TODO: Clarify what is the intention when cacheKey.ConcreteType = null.
// At the moment, a logger typeof(Logger) will be created but the ConcreteType
// will remain null and inserted into the cache.
// Should we set cacheKey.ConcreteType = typeof(Logger) for default loggers?
loggerCache.InsertOrUpdate(cacheKey, newLogger);
return(newLogger);
}
}
/// <summary>
/// Inserts or updates.
/// </summary>
/// <param name="cacheKey"></param>
/// <param name="logger"></param>
public void InsertOrUpdate(LoggerCacheKey cacheKey, Logger logger)
{
loggerCache[cacheKey] = new WeakReference(logger);
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this)
{
WeakReference l;
if (this.loggerCache.TryGetValue(cacheKey, out l))
{
Logger existingLogger = l.Target as Logger;
if (existingLogger != null)
{
// logger in the cache and still referenced
return existingLogger;
}
}
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
this.loggerCache[cacheKey] = new WeakReference(newLogger);
return newLogger;
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (_syncRoot)
{
Logger existingLogger = _loggerCache.Retrieve(cacheKey);
if (existingLogger != null)
{
return(existingLogger);
}
Logger newLogger;
//构建Logger对象
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
var fullName = cacheKey.ConcreteType.FullName;
try
{
if (cacheKey.ConcreteType.IsStaticClass())
{
var errorMessage =
$"创建一个静态类 '{fullName}' 的实例是不可能的,它也不应该继承Logger ";
if (ThrowExceptions)
{
throw new CLogRuntimeException(errorMessage);
}
newLogger = CreateDefaultLogger(ref cacheKey);
}
else
{
var instance = FactoryHelper.CreateInstance(cacheKey.ConcreteType);
newLogger = instance as Logger;
if (newLogger == null)
{
var errorMessage =
$"不能创建类型为'{fullName}'的实例。它应该有一个默认的构造函数。";
if (ThrowExceptions)
{
throw new CLogRuntimeException(errorMessage);
}
//如果无法创建指定类型的实例，则创建logger的默认实例。
newLogger = CreateDefaultLogger(ref cacheKey);
}
}
} catch (Exception ex)
{
if (ex.MustBeRethrown())
{
throw;
}
//如果无法创建指定类型的实例，则创建logger的默认实例。
newLogger = CreateDefaultLogger(ref cacheKey);
}
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, GetConfigurationForLogger(cacheKey.Name, Configuration), this);
}
return(newLogger);
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this)
{
Logger l;
if (this.loggerCache.TryGetValue(cacheKey, out l))
{
return l;
}
// Activator.CreateInstance(cacheKey.ConcreteType);
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
newLogger = (Logger)FactoryHelper.CreateInstance(cacheKey.ConcreteType);
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
this.loggerCache[cacheKey] = newLogger;
return newLogger;
}
}
