/// <summary>
/// Stops the watching.
/// </summary>
public void StopWatching()
{
lock (this)
{
foreach (FileSystemWatcher watcher in this.watchers)
{
InternalLogger.Info("Stopping file watching for path '{0}' filter '{1}'", watcher.Path, watcher.Filter);
watcher.EnableRaisingEvents = false;
watcher.Dispose();
}
this.watchers.Clear();
}
}
protected ObjectHandleSerializer(SerializationInfo info, StreamingContext context)
{
Type type = null;
try
{
type = (Type)info.GetValue("wrappedtype", typeof(Type));
_wrapped = info.GetValue("wrappedvalue", type);
}
catch (Exception ex)
{
_wrapped = string.Empty; // Type cannot be resolved in this AppDomain
InternalLogger.Info(ex, "ObjectHandleSerializer failed to deserialize object: {0}", type);
}
}
public void Watch(string fileName)
{
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = Path.GetDirectoryName(fileName);
watcher.Filter = Path.GetFileName(fileName);
watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.CreationTime | NotifyFilters.Size | NotifyFilters.Security | NotifyFilters.Attributes;
watcher.Created += new FileSystemEventHandler(this.OnWatcherChanged);
watcher.Changed += new FileSystemEventHandler(this.OnWatcherChanged);
watcher.Deleted += new FileSystemEventHandler(this.OnWatcherChanged);
watcher.EnableRaisingEvents = true;
InternalLogger.Info("Watching path '{0}' filter '{1}' for changes.", watcher.Path, watcher.Filter);
lock (this)
{
_watchers.Add(watcher);
}
}
/// <summary>
/// Load from url
/// </summary>
/// <param name="assemblyName">name without .dll</param>
/// <returns></returns>
public static Assembly LoadFromName(string assemblyName)
{
InternalLogger.Info("Loading assembly: {0}", assemblyName);
#if NETSTANDARD1_0 || WINDOWS_PHONE
var name = new AssemblyName(assemblyName);
return(Assembly.Load(name));
#elif SILVERLIGHT && !WINDOWS_PHONE
//as embedded resource
var assemblyFile = assemblyName + ".dll";
var stream = Application.GetResourceStream(new Uri(assemblyFile, UriKind.Relative));
var assemblyPart = new AssemblyPart();
Assembly assembly = assemblyPart.Load(stream.Stream);
return(assembly);
#else
Assembly assembly = Assembly.Load(assemblyName);
return(assembly);
#endif
}
private static bool IncludeConfigurationItem(object item, Type itemType, int level)
{
try
{
if (itemType == null)
{
return(false);
}
if (item is NLog.LayoutRenderers.LayoutRenderer)
{
return(true);
}
if (item is NLog.Layouts.Layout)
{
return(true);
}
if (item is NLog.Targets.Target)
{
return(true);
}
if (item is LoggingRule)
{
return(true);
}
if (itemType.IsDefined(typeof(NLogConfigurationItemAttribute), true))
{
return(true);
}
}
catch (System.Exception ex)
{
InternalLogger.Info(ex, "{0}Type reflection not possible for: {1}. Maybe because of .NET Native.", new string(' ', level), item.ToString());
}
return(false);
}
private static object GetConfigurationPropertyValue(object o, PropertyInfo prop, int level)
{
if (prop == null || prop.PropertyType == null || prop.PropertyType.IsPrimitive() || prop.PropertyType.IsEnum() || prop.PropertyType == typeof(string))
{
return(null);
}
try
{
if (prop.IsDefined(typeof(NLogConfigurationIgnorePropertyAttribute), true))
{
return(null);
}
}
catch (System.Exception ex)
{
InternalLogger.Info(ex, "{0}Type reflection not possible for property {1}. Maybe because of .NET Native.", new string(' ', level + 1), prop.Name);
return(null);
}
return(prop.GetValue(o, null));
}
/// <summary>
/// Load from url
/// </summary>
/// <param name="assemblyFileName">file or path, including .dll</param>
/// <param name="baseDirectory">basepath, optional</param>
/// <returns></returns>
public static Assembly LoadFromPath(string assemblyFileName, string baseDirectory = null)
{
string fullFileName = baseDirectory == null ? assemblyFileName : Path.Combine(baseDirectory, assemblyFileName);
InternalLogger.Info("Loading assembly file: {0}", fullFileName);
#if NETSTANDARD1_5
try
{
var assemblyName = System.Runtime.Loader.AssemblyLoadContext.GetAssemblyName(fullFileName);
return(Assembly.Load(assemblyName));
}
catch (Exception ex)
{
// this doesn't usually work
InternalLogger.Warn(ex, "Fallback to AssemblyLoadContext.Default.LoadFromAssemblyPath for file: {0}", fullFileName);
return(System.Runtime.Loader.AssemblyLoadContext.Default.LoadFromAssemblyPath(fullFileName));
}
#else
Assembly asm = Assembly.LoadFrom(fullFileName);
return(asm);
#endif
}
internal void Watch(string fileName)
{
var directory = Path.GetDirectoryName(fileName);
if (!Directory.Exists(directory))
{
InternalLogger.Warn("Cannot watch {0} for changes as it doesn't exist", directory);
return;
}
lock (this)
{
if (this.watcherMap.ContainsKey(fileName))
{
return;
}
var watcher = new FileSystemWatcher
{
Path = directory,
Filter = Path.GetFileName(fileName),
NotifyFilter = NotifyFilters
};
watcher.Created += OnFileChanged;
watcher.Changed += OnFileChanged;
watcher.Deleted += OnFileChanged;
watcher.Renamed += OnFileChanged;
watcher.Error += OnWatcherError;
watcher.EnableRaisingEvents = true;
InternalLogger.Info("Watching path '{0}' filter '{1}' for changes.", watcher.Path, watcher.Filter);
this.watcherMap.Add(fileName, watcher);
}
}
/// <summary>
/// Load from url
/// </summary>
/// <param name="assemblyName">name without .dll</param>
/// <returns></returns>
public static Assembly LoadFromName(string assemblyName)
{
InternalLogger.Info("Loading assembly: {0}", assemblyName);
#if NETSTANDARD1_0 || WINDOWS_PHONE
var name = new AssemblyName(assemblyName);
return(Assembly.Load(name));
#elif SILVERLIGHT && !WINDOWS_PHONE
//as embedded resource
var assemblyFile = assemblyName + ".dll";
var stream = Application.GetResourceStream(new Uri(assemblyFile, UriKind.Relative));
var assemblyPart = new AssemblyPart();
Assembly assembly = assemblyPart.Load(stream.Stream);
return(assembly);
#else
try
{
Assembly assembly = Assembly.Load(assemblyName);
return(assembly);
}
catch (FileNotFoundException)
{
var name = new AssemblyName(assemblyName);
InternalLogger.Trace("Try find '{0}' in current domain", assemblyName);
var loadedAssembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(domainAssembly => IsAssemblyMatch(name, domainAssembly.GetName()));
if (loadedAssembly != null)
{
InternalLogger.Trace("Found '{0}' in current domain", assemblyName);
return(loadedAssembly);
}
InternalLogger.Trace("Haven't found' '{0}' in current domain", assemblyName);
throw;
}
#endif
}
private void StopWatching(FileSystemWatcher watcher)
{
InternalLogger.Info("Stopping file watching for path '{0}' filter '{1}'", watcher.Path, watcher.Filter);
watcher.EnableRaisingEvents = false;
watcher.Dispose();
}
/// <remarks>ISet is not there in .net35, so using HashSet</remarks>
private static void ScanProperties <T>(bool aggressiveSearch, List <T> result, object o, int level, HashSet <object> visitedObjects)
where T : class
{
if (o == null)
{
return;
}
var type = o.GetType();
try
{
if (type == null || !type.IsDefined(typeof(NLogConfigurationItemAttribute), true))
{
return;
}
}
catch (System.Exception ex)
{
InternalLogger.Info(ex, "{0}Type reflection not possible for: {1}. Maybe because of .NET Native.", new string(' ', level), o.ToString());
return;
}
if (visitedObjects.Contains(o))
{
return;
}
visitedObjects.Add(o);
if (InternalLogger.IsTraceEnabled)
{
InternalLogger.Trace("{0}Scanning {1} '{2}'", new string(' ', level), type.Name, o);
}
var t = o as T;
if (t != null)
{
result.Add(t);
if (!aggressiveSearch)
{
return;
}
}
foreach (PropertyInfo prop in PropertyHelper.GetAllReadableProperties(type))
{
if (prop == null || prop.PropertyType == null || prop.PropertyType.IsPrimitive() || prop.PropertyType.IsEnum() || prop.PropertyType == typeof(string))
{
continue;
}
try
{
if (prop.IsDefined(typeof(NLogConfigurationIgnorePropertyAttribute), true))
{
continue;
}
}
catch (System.Exception ex)
{
InternalLogger.Info(ex, "{0}Type reflection not possible for property {1}. Maybe because of .NET Native.", new string(' ', level + 1), prop.Name);
continue;
}
object value = prop.GetValue(o, null);
if (value == null)
{
continue;
}
if (InternalLogger.IsTraceEnabled)
{
InternalLogger.Trace("{0}Scanning Property {1} '{2}' {3}", new string(' ', level + 1), prop.Name, value.ToString(), prop.PropertyType.Namespace);
}
var list = value as IList;
if (list != null)
{
//try first icollection for syncroot
List <object> elements;
lock (list.SyncRoot)
{
elements = new List <object>(list.Count);
//no foreach. Even .Cast can lead to Collection was modified after the enumerator was instantiated.
for (int i = 0; i < list.Count; i++)
{
var item = list[i];
elements.Add(item);
}
}
ScanPropertiesList(aggressiveSearch, result, elements, level + 1, visitedObjects);
}
else
{
var enumerable = value as IEnumerable;
if (enumerable != null)
{
//new list to prevent: Collection was modified after the enumerator was instantiated.
var elements = enumerable as IList <object> ?? enumerable.Cast <object>().ToList();
//note .Cast is tread-unsafe! But at least it isn't a ICollection / IList
ScanPropertiesList(aggressiveSearch, result, elements, level + 1, visitedObjects);
}
else
{
#if NETSTANDARD
if (!prop.PropertyType.IsDefined(typeof(NLogConfigurationItemAttribute), true))
{
continue; // .NET native doesn't always allow reflection of System-types (Ex. Encoding)
}
#endif
ScanProperties(aggressiveSearch, result, value, level + 1, visitedObjects);
}
}
}
}