/// <summary>
        /// Load LogWriters from an Assembly
        /// </summary>
        /// <param name="assembly">the Assembly containing LogWriters</param>
        /// <returns>true if successfulr</returns>
        public bool LoadFromAssembly(Assembly assembly)
        {
            bool hasLoaded = false;

            try
            {
                var types = assembly.GetExportedTypes()
                            .Where(t => t.IsClass &&
                                   !t.IsAbstract &&
                                   t.IsDefined(typeof(LogDataWriterAttribute)) &&
                                   typeof(IWriteLogData <T>).IsAssignableFrom(t));

                foreach (var type in types)
                {
                    IWriteLogData <T> activatedObject;
                    if (ActivateType(type, out activatedObject))
                    {
                        AddWriter(activatedObject);
                        hasLoaded = true;
                    }
                }
            }
            catch (Exception ex)
            {
                LoadExceptionOccurred?.Invoke(this, new ExceptionEventArgs(ex));
            }

            return(hasLoaded);
        }
        /// <summary>
        /// Load Log Writers from files in a path
        /// </summary>
        /// <param name="path">the path to the Log Writers</param>
        /// <param name="recurseSubPaths">true to load Writers from sub paths</param>
        public void LoadFromPath(string path, bool recurseSubPaths = true)
        {
            try
            {
                string   dllFileFilter = "*.dll";
                string[] dllFiles      = Directory.GetFiles(path, dllFileFilter, SearchOption.TopDirectoryOnly);
                foreach (var file in dllFiles)
                {
                    LoadFromAssemblyFileName(file);
                }

                string   exeFileFilter = "*.exe";
                string[] exeFiles      = Directory.GetFiles(path, exeFileFilter, SearchOption.TopDirectoryOnly);
                foreach (var file in exeFiles)
                {
                    LoadFromAssemblyFileName(file);
                }

                if (recurseSubPaths)
                {
                    string[] dirs = Directory.GetDirectories(path);
                    foreach (string dir in dirs)
                    {
                        LoadFromPath(dir);
                    }
                }
            }
            catch (Exception ex)
            {
                LoadExceptionOccurred?.Invoke(this, new ExceptionEventArgs(ex));
            }
        }
        /// <summary>
        /// Load Writers from Assembly by filename
        /// </summary>
        /// <param name="filename">the filename of the assembly to contain LogWriters</param>
        /// <returns>true if successful, false otherwise</returns>
        public bool LoadFromAssemblyFileName(string filename)
        {
            try
            {
                Assembly tempAssembly = Assembly.LoadFile(filename);

                return(LoadFromAssembly(tempAssembly));
            }
            catch (Exception ex)
            {
                LoadExceptionOccurred?.Invoke(this, new ExceptionEventArgs(ex));
                return(false);
            }
        }