public MyServiceBase(string name, MainAction ma, LogAction la)
 {
     // InitializeComponent
     this.ServiceName = name;
     this.CbMain = ma;
     this.CbLog = la;
 }

 internal static void ParseWord(XDocument document, LogAction func)
 {
     XElement WordNode = new XElement("Word");
     (document.FirstNode as XElement).Add(WordNode);
     ParseWordTypes(WordNode, func);
     ParseWordEnums(WordNode, func);
     ParseWordTypesMembers(WordNode, func);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="LoggerBase" /> class.
        /// </summary>
        /// <param name="action">The action to use.</param>
        /// <param name="syncRoot">The custom object for thread safe operations.</param>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="action" /> is <see langword="null" />.
        /// </exception>
        public DelegateLogger(LogAction action, object syncRoot = null)
            : base(syncRoot: syncRoot)
        {
            if (action == null)
            {
                throw new ArgumentNullException("action");
            }

            _ACTION = action;
        }

        /// <summary>
        /// Log object constructor.
        /// </summary>
        /// <param name="type">The type of the event being logged.</param>
        /// <param name="function">The function executing when the event occured.</param>
        /// <param name="action">The action being performed when the event occured.</param>
        /// <param name="Message">A specific message associated with the event being logged.</param>
        /// <param name="user">The user of the system when the event occured.</param>
        /// <param name="timestamp">The date and time when the event was logged (set in DB).</param>
        public LogEntry(LogType type, LogFunction function, LogAction action, DateTime timestamp, long id, string message, Person user)
        {
            Type = type;
            Function = function;
            Action = action;

            ID = id;
            Timestamp = timestamp;
            Message = message;
            User = user;
        }

        /// <summary>
        /// Read all files in a directory and replace arg search with arg replace in file content(s)
        /// </summary>
        /// <param name="directoryName">target root directory</param>
        /// <param name="fileFilter">exclude filter as file extension</param>
        /// <param name="search">search expression</param>
        /// <param name="replace">replace value</param>
        /// <param name="func">log handler</param>
        public static void SearchAndReplace(string directoryName, string fileFilter, string search, string replace, LogAction func)
        {
            if (!Directory.Exists(directoryName))
                throw new DirectoryNotFoundException(directoryName);
            if (null == func || String.IsNullOrWhiteSpace(replace) || String.IsNullOrWhiteSpace(search) || String.IsNullOrWhiteSpace(fileFilter) || String.IsNullOrWhiteSpace(directoryName))
                throw new ArgumentNullException();

            string[] filterArray = BuildFilterArray(fileFilter);
            string[] searchArray = BuildSearchArray(search);
            string[] replaceArray = BuildReplaceArray(replace);
            if (searchArray.Length != replaceArray.Length)
                throw new FormatException("Search and Repleace terms count must equal");
            SearchAndReplace(directoryName, filterArray, searchArray, replaceArray, func);
        }

        internal static XDocument ParseReference(LogAction func)
        {
            func("Parse References ");
            XDocument document = new XDocument();
            document.Add(new XElement("NOBuildTools.ReferenceAnalyzer"));
            ParseExcel(document, func);
            ParseAccess(document, func);
            ParseOffice(document, func);
            ParseOutlook(document, func);
            ParsePowerPoint(document, func);
            ParseProject(document, func);
            ParseVisio(document, func);
            ParseWord(document, func);
            func("Done!");

            return document;
        }

        private static void ParseWordTypes(XElement excelNode, LogAction func)
        {
            func("Parse Word Types");

            XElement rootNode = new XElement("Types");
            excelNode.Add(rootNode);

            int counter = 0;
            string excelRootReferencePage = _rootAdress + _wordTypesRelative;
            using (var client = new System.Net.WebClient())
            {
                string pageContent = DownloadPage(client, excelRootReferencePage);
                HtmlDocument doc = new HtmlDocument();
                doc.LoadHtml(pageContent);
                var root = doc.DocumentNode;

                var divNodes = root.Descendants("div").ToList();
                foreach (var item in divNodes)
                {
                    string className = item.GetAttributeValue("class", null);
                    if (className == "toclevel2")
                    {
                        string href = item.FirstChild.NextSibling.GetAttributeValue("href", null);
                        string name = item.FirstChild.NextSibling.GetAttributeValue("title", null);
                        if (null != href && null != name)
                        {
                            if (name.EndsWith(" Object", StringComparison.InvariantCultureIgnoreCase))
                            {
                                name = name.Substring(0, name.Length - " Object".Length);
                                rootNode.Add(new XElement("Type", new XElement("Name", name), new XElement("Link", _rootAdress + href)));
                                counter++;
                            }
                        }
                    }

                }
            }

            func(String.Format("{0} Word Types recieved", counter));
        }

        private static bool DoSearchAndReplace(ref string fileContent, string[] searchArray, string[] replaceArray, LogAction func)
        {
            bool oneOrMoreReplaced = false;
            for (int i = 0; i < searchArray.Length; i++)
            {
                string search = searchArray[i];
                string replace = replaceArray[i];
                int cnt = 0;
                while (fileContent.IndexOf(search) > -1)
                {
                    fileContent = fileContent.Replace(search, replace);
                    cnt++;
                }
                if (cnt > 0)
                {
                    oneOrMoreReplaced = true;
                    func(String.Format("{0} entries of {1} replaced", cnt, search));
                }

            }

            return oneOrMoreReplaced;
        }

 public DataAdjusterWithLogging(IBuildRepository repository, LogAction log) : base(repository)
 {
     OnFoundInvalidData = data => log("-- Found invalid json-data in file: {0}", data.Source);
     OnFixedInvalidData = () => log("-- Successfully converted invalid json data to valid");
     OnCouldNotConvertData = e => log("-- Could not convert json-data : {0}", e.Message);
 }

 private static void ParsePowerPointTypeEvents(XElement propertiesNode, LogAction func)
 {
     using (var client = new System.Net.WebClient())
     {
         string pageLink = XmlConvert.DecodeName(propertiesNode.Attribute("Link").Value);
         string pageContent = DownloadPage(client, pageLink);
         HtmlDocument doc = new HtmlDocument();
         doc.LoadHtml(pageContent);
         var root = doc.DocumentNode;
         var divNodes = root.Descendants("div").ToList();
         foreach (var item in divNodes)
         {
             string className = item.GetAttributeValue("class", null);
             if (className == "toclevel2")
             {
                 string href = item.FirstChild.NextSibling.GetAttributeValue("href", null);
                 string name = item.FirstChild.NextSibling.GetAttributeValue("title", null);
                 if (null != href && null != name)
                 {
                     if (name.IndexOf(" ") > -1)
                         name = name.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries)[0];
                     propertiesNode.Add(new XElement("Event", new XElement("Name", name), new XElement("Link", _rootAdress + href)));
                     func("");
                 }
             }
         }
     }
 }

        private static void ParsePowerPointTypeMembers(XElement typeNode, LogAction func)
        {
            XElement propsNode = new XElement("Properties");
            XElement methodsNode = new XElement("Methods");
            XElement eventsNode = new XElement("Events");
            typeNode.Add(propsNode);
            typeNode.Add(methodsNode);
            typeNode.Add(eventsNode);

            using (var client = new System.Net.WebClient())
            {
                string pageLink = typeNode.Element("Link").Value;
                string pageContent = DownloadPage(client, pageLink);
                HtmlDocument doc = new HtmlDocument();
                doc.LoadHtml(pageContent);
                var root = doc.DocumentNode;

                var divNodes = root.Descendants("div").ToList();
                foreach (var item in divNodes)
                {
                    string className = item.GetAttributeValue("class", null);
                    if (className == "toclevel2")
                    {
                        string href = item.FirstChild.NextSibling.GetAttributeValue("href", null);
                        string name = item.FirstChild.NextSibling.GetAttributeValue("title", null);
                        if (null != href && null != name)
                        {
                            name = name.ToLower().Trim();
                            switch (name)
                            {
                                case "properties":
                                    propsNode.Add(new XAttribute("Link", XmlConvert.EncodeName(_rootAdress + href)));
                                    ParsePowerPointTypeProperties(propsNode, func);
                                    break;
                                case "methods":
                                    methodsNode.Add(new XAttribute("Link", XmlConvert.EncodeName(_rootAdress + href)));
                                    ParsePowerPointTypeMethods(methodsNode, func);
                                    break;
                                case "events":
                                    eventsNode.Add(new XAttribute("Link", XmlConvert.EncodeName(_rootAdress + href)));
                                    ParsePowerPointTypeEvents(eventsNode, func);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                }
            }
        }

 private static void ParsePowerPointTypesMembers(XElement typeNode, LogAction func)
 {
     func("Parse PowerPoint Type Members");
     foreach (XElement item in typeNode.Element("Types").Elements("Type"))
     {
         ParseOfficeTypeMembers(item, func);
     }
 }

 /// <summary>
 /// Update database
 /// </summary>
 /// <param name="device"></param>
 /// <param name="logAction"></param>
 /// <param name="logDetails"></param>
 private static void updateDatabase(DeviceView device, Power power, LogAction logAction, string logDetails)
 {
     device.Power = power;
       device.Save();
       new Log(LogType.Information, logAction, device.ToString() + " " + logDetails);
 }

 public void Log(Type classname, LoggingLevel level, LogAction action, string message)
 {
     _worker(classname, level, action, message);
 }

		public static bool Log(string message, LogAction action, string destination)
		{
			return Log(message, action, destination, null);
		}

 internal static void ParseVisio(XDocument document, LogAction func)
 {
     XElement VisioNode = new XElement("Visio");
     (document.FirstNode as XElement).Add(VisioNode);
     ParseVisioTypes(VisioNode, func);
     ParseVisioEnums(VisioNode, func);
     ParseVisioTypesMembers(VisioNode, func);
 }

    /**
     * There can only safely be one of these threads running
     */
    protected void AnnounceThread() {
      Brunet.Util.FuzzyEvent fe = null;
      try {
        int millisec_timeout = 5000; //log every 5 seconds.
        IAction queue_item = null;
        bool timedout = false;
        if( ProtocolLog.Monitor.Enabled ) {
          IAction log_act = new LogAction(_packet_queue);
          Action<DateTime> log_todo = delegate(DateTime dt) {
            EnqueueAction(log_act);
          };
          fe = Brunet.Util.FuzzyTimer.Instance.DoEvery(log_todo, millisec_timeout, millisec_timeout/2);
        }
        while( 1 == _running ) {
          queue_item = _packet_queue.Dequeue(millisec_timeout, out timedout);
          if (!timedout) {
            _current_action = queue_item;
            queue_item.Start();
          }
        }
      }
      catch(System.InvalidOperationException x) {
        //This is thrown when Dequeue is called on an empty queue
        //which happens when the BlockingQueue is closed, which
        //happens on Disconnect
        if(1 == _running) {
          ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
            "Running in AnnounceThread got Exception: {0}", x));
        }
      }
      catch(Exception x) {
        ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
        "ERROR: Exception in AnnounceThread: {0}", x));
      }
      finally {
        //Make sure we stop logging:
        if( fe != null ) { fe.TryCancel(); }
      }
      ProtocolLog.Write(ProtocolLog.Monitor,
                        String.Format("Node: {0} leaving AnnounceThread",
                                      this.Address));

    }

 private static void ParseAccessConstants(XElement excelNode, LogAction func)
 {
     func("Parse Access Constants");
     XElement constantNode = new XElement("OldConstants", _rootAdress + _accessConstantsRelative);
     excelNode.Add(constantNode);
     func(String.Format("{0} Access Contants recieved", 1));
 }

 internal static void ParseAccess(XDocument document, LogAction func)
 {
     XElement accessNode = new XElement("Access");
     (document.FirstNode as XElement).Add(accessNode);
     ParseAccessTypes(accessNode, func);
     ParseAccessEnums(accessNode, func);
     ParseAccessConstants(accessNode, func);
     ParseAccessTypesMembers(accessNode, func);
 }

 internal static void ParseExcel(XDocument document, LogAction func)
 {
     XElement excelNode = new XElement("Excel");
     (document.FirstNode as XElement).Add(excelNode);
     ParseExcelTypes(excelNode, func);
     ParseExcelEnums(excelNode, func);
     ParseExcelTypesMembers(excelNode, func);
 }