void adb_OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (this.InvokeRequired)
         this.Invoke(new Action<object, DataReceivedEventArgs>(adb_OutputDataReceived), sender, e);
     else
         textAdb.AppendText(filterData(e.Data));
 }

 void Convert__OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (!String.IsNullOrEmpty(e.Data))
     {
         _sbOutput.AppendLine(e.Data);
     }
 }

 public static void OutputReceivedDataEventHandler(Object Sender, DataReceivedEventArgs Line)
 {
     if ((Line != null) && (Line.Data != null))
     {
         Log.TraceInformation(Line.Data);
     }
 }

        /// <summary>
        /// Handles the ErrorDataReceived event of the vlc process.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Diagnostics.DataReceivedEventArgs" /> instance containing the event data.</param>
        private void OnVlcErrorDataReceived(object sender, DataReceivedEventArgs e)
        {
            if (e == null)
                return;

            Trace.TraceError(e.Data);
        }

        private static void OnErrorDataReceived(object sender, DataReceivedEventArgs e)
        {
            if (e == null || String.IsNullOrWhiteSpace(e.Data))
                return;

            IISLogger.Error(e.Data);
        }

 private void AppendErrorData(object sender, DataReceivedEventArgs e)
 {
     if (e.Data == null)
         errorWaitHandle.Set();
     else
         errorOuput.AppendLine(e.Data);
 }

 private void process_OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (e.Data != null)
     {
         this.logOutputBuffer.AppendLine(e.Data);
     }
 }

        private void FaacProcess_OutputDataReceived(object sender, DataReceivedEventArgs e)
        {
            if (e.Data != null && e.Data.Length > 0)
            {
                Regex R = new Regex(@"\(\s*(\d+)%\)");
                Match M = R.Match(e.Data);
                if (M.Success)
                {
                    int NewProgress = Convert.ToInt32(M.Groups[1].Value);

                    if (NewProgress != Progress && !_cancelling)
                    {
                        Progress = NewProgress;
                        // raise the progress changed event
                        ExternalProcessProgressChangedEventArgs eArgs = new ExternalProcessProgressChangedEventArgs(
                          Progress, 1, 1, "Encoding", null, null);
                        async.Post(delegate(object ea)
                        { OnTaskProgressChanged((ExternalProcessProgressChangedEventArgs)ea); },
                          eArgs);
                    }
                    //Console.CursorLeft = 0;
                    //Console.Write(e.Data);
                }
                else
                {
                    //Console.WriteLine(e.Data);
                }
            }
        }

 private void cmd_ErrorDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (e.Data != null)
     {
         //MessageBox.Show(e.Data, "错误");
     }
 }

 private void ProcessOnErrorDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (!string.IsNullOrEmpty(e.Data))
     {
         output.Add(e.Data);
     }
 }

 private void Error(object sender,DataReceivedEventArgs e)
 {
     if (e.Data == null)
         Process.ErrorDataReceived -= Error;
     else
         Core.Log(this, e.Data);
 }

 /// <summary>
 /// The output data received.
 /// </summary>
 /// <param name="sender">
 /// The sender.
 /// </param>
 /// <param name="e">
 /// The e.
 /// </param>
 private void OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (e != null && e.Data != null)
     {
         this.Result = e.Data;
     }
 }

        public static void printData(object sender, DataReceivedEventArgs e)
        {
            // Critical section
            int pId = ((Process)sender).Id;

            if (!colors.ContainsKey(pId))
            {
                lock (lockObject)
                {
                    if (!colors.ContainsKey(pId))
                    {
                        colors.Add(pId, getColor());
                    }
                }
            }

            Console.ForegroundColor = colors[pId];
            if (String.IsNullOrEmpty(e.Data))
            {
                Console.WriteLine("Process " + (int)colors[pId] + " exited.");
            }
            else
            {
                Console.WriteLine((int)colors[pId] + " " + e.Data);
            }
            Console.ResetColor();
        }

 public void proc_DataReceived(object sender, DataReceivedEventArgs e)
 {
     if (!String.IsNullOrEmpty(e.Data))
     {
         this.Srv_Output.Invoke(new UpdateOutputCallback(this.updateoutput), new object[] { e.Data });
     }
 }

 void OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (!string.IsNullOrEmpty(e.Data))
     {
         Host.UI.WriteLine(e.Data);
     }
 }

 public void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     if (string.IsNullOrEmpty(e.Data)) {
     return;
       }
       txtConsoleOutput.AppendText(e.Data + "\n");
 }

 private void ProcessOnErrorDataReceived(object sender, DataReceivedEventArgs dataReceivedEventArgs)
 {
     if (!string.IsNullOrEmpty(dataReceivedEventArgs.Data)) // happened often and added unnecessary blank line to output
     {
         logger.WriteLine(LogKind.Default, dataReceivedEventArgs.Data); // warnings also comes as errors so Default log kind is used to avoid red output for things that are just warnings
     }
 }

 private static void ErrorHandler(object sendingProcess, DataReceivedEventArgs outLine)
 {
     if (outLine.Data != null)
     {
         Console.WriteLine("Error:" + outLine.Data);
     }
 }

        private static void VBusMonitorOnDataReceived(object sender, DataReceivedEventArgs e)
        {
            //Receives this:
            // LPDU: BC 00 01 08 06 F1 00 81 3C :L_Data low from 0.0.1 to 1/0/6 hops: 07 T_DATA_XXX_REQ A_GroupValue_Write (small) 01

            if (!e.Data.Contains("A_GroupValue_Write"))
                return;

            string address = string.Empty;
            string value = string.Empty;

            Regex regex = new Regex(Regex1);
            Match match = regex.Match(e.Data);

            if (match.Success)
                address = match.Groups[1].Value;

            regex = new Regex(Regex2);
            match = regex.Match(e.Data);

            if (match.Success)
                value = match.Groups[1].Value;

            if (string.IsNullOrWhiteSpace(address) || string.IsNullOrWhiteSpace(value))
                return;

            //TODO: check how it works if value received is more than 1 byte

            if (GroupWrite.IsGroupWriteAvailable())
                GroupWrite.Send(address, value);
        }

 private void ReadOutputLine(object sender, DataReceivedEventArgs e)
 {
   if (!string.IsNullOrEmpty(e.Data))
   {
     Log.Debug($"{this.LogPrefix} {e.Data}", this);
   }
 }