void CustomEvent(object sender, CustomBuildEventArgs e)
 {
     //Do nothing, really a place holder for sub-classes
 }

		// Raises a custom event to all registered loggers.
		public void LogCustomEvent (CustomBuildEventArgs e)
		{
			engine.EventSource.FireCustomEventRaised (this, e);
		}

 /// <summary>
 /// This is the delegate for CustomHandler events.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="buildEvent"></param>
 protected virtual void CustomHandler(object sender, CustomBuildEventArgs buildEvent)
 {
     // NOTE: This may run on a background thread!
     QueueOutputEvent(MessageImportance.High, buildEvent);
 }

 /// <summary>
 /// Raises a custom event to all registered loggers.
 /// </summary>
 /// <param name="e">The event data.</param>
 public void LogCustomEvent(CustomBuildEventArgs e)
 {
     this.context.Information(e.Message);
 }

		/// <summary>
		/// This is the delegate for CustomHandler events.
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="buildEvent"></param>
		private void CustomHandler(object sender, CustomBuildEventArgs buildEvent)
		{
            try
            {
                LogEvent(sender, buildEvent);
            }
            catch (Exception e)
            {
                Debug.Assert(false, "Problem logging custom event: " + e.Message + " at " + e.TargetSite);
                // swallow the exception
            }
		}

 /// <summary>
 /// Log and record the number of custom build events.
 /// </summary>
 internal void MyCustomBuildHandler(object s, CustomBuildEventArgs e)
 {
     _numberOfCustom++;
     _lastCustom = e;
     if (e.Message != null)
     {
         Console.Out.WriteLine("CustomEvent:" + e.Message.ToString());
     }
 }

 public void LogCustomEvent(CustomBuildEventArgs e)
 {
     _log.LogMessage(e.Message);
 }

        /// <summary>
        /// Raises a custom event to all registered loggers.
        /// </summary>
        /// <param name="sender">sender of the event</param>
        /// <param name="buildEvent">CustomBuildEventArgs</param>
        /// <exception cref="LoggerException">When EventHandler raises an logger exception the LoggerException is rethrown</exception>
        /// <exception cref="InternalLoggerException">Any exceptions which are not LoggerExceptions are wrapped in an InternalLoggerException</exception>
        /// <exception cref="Exception">ExceptionHandling.IsCriticalException exceptions will not be wrapped</exception>
        private void RaiseCustomEvent(object sender, CustomBuildEventArgs buildEvent)
        {
            if (CustomEventRaised != null)
            {
                try
                {
                    CustomEventRaised(sender, buildEvent);
                }
                catch (LoggerException)
                {
                    // if a logger has failed politely, abort immediately
                    // first unregister all loggers, since other loggers may receive remaining events in unexpected orderings
                    // if a fellow logger is throwing in an event handler.
                    this.UnregisterAllEventHandlers();
                    throw;
                }
                catch (Exception exception)
                {
                    // first unregister all loggers, since other loggers may receive remaining events in unexpected orderings
                    // if a fellow logger is throwing in an event handler.
                    this.UnregisterAllEventHandlers();

                    if (ExceptionHandling.IsCriticalException(exception))
                    {
                        throw;
                    }

                    InternalLoggerException.Throw(exception, buildEvent, "FatalErrorWhileLogging", false);
                }
            }

            RaiseAnyEvent(sender, buildEvent);
        }

 private void CustomBuildEventRaised(object sender, CustomBuildEventArgs e)
 {
     this.LogMessage("custom", e.Message, MessageImportance.Normal);
 }

        /// <summary>
        /// Prints a custom event
        /// </summary>
        public void CustomEventHandler(object sender, CustomBuildEventArgs e)
        {
            InitializeBaseConsoleLogger(); // for compat: see DDB#136924

            _consoleLogger.CustomEventHandler(sender, e);
        }

 public virtual void LogCustomEvent(CustomBuildEventArgs e)
 {
   throw new Exception("The method or operation is not implemented.");
 }

 /// <summary>
 /// Allows tasks to raise custom events to all registered loggers.
 /// The build engine may perform some filtering or
 /// pre-processing on the events, before dispatching them.
 /// </summary>
 /// <param name="e">Details of event to raise.</param>
 public void LogCustomEvent(CustomBuildEventArgs e)
 {
     OnLogBuildEvent(e);
 }

 /// <summary>
 /// Prints a custom event
 /// </summary>
 public override void CustomEventHandler(object sender, CustomBuildEventArgs e)
 {
     // if verbosity is detailed or diagnostic
     if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
     {
         // ignore custom events with null messages -- some other
         // logger will handle them appropriately
         if (e.Message != null)
         {
             ShowDeferredMessages();
             WriteLinePretty(e.Message);
         }
     }
 }

 /// <summary>
 /// Unused.
 /// </summary>
 public void LogCustomEvent(CustomBuildEventArgs e)
 {
     throw new NotImplementedException();
 }

		public void LogCustomEvent (CustomBuildEventArgs e)
		{
			event_source.FireCustomEventRaised (this, e);
		}

			public void LogCustomEvent(CustomBuildEventArgs e)
			{
				LoggedMessages.Add(e.Message);
			}

		public void LogCustomEvent(CustomBuildEventArgs e)
		{
		}

 public void LogCustomEvent(CustomBuildEventArgs e)
 {
     log.Info(e.Message);
 }

 /// <summary>
 /// This is the delegate for CustomHandler events.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="buildEvent"></param>
 private void CustomHandler(object sender, CustomBuildEventArgs buildEvent)
 {
     LogEvent(sender, buildEvent);
 }

 /// <summary>
 /// Handle a custom event, these are mostly user created events
 /// </summary>
 /// <param name="sender">Who sent the event</param>
 /// <param name="e">Event raised on the event source</param>
 private void Source_CustomEventRaised(object sender, CustomBuildEventArgs e)
 {
     HandleEvent(e);
 }