private void InitAppenders(IAppender[] appenders)
 {
     for (int i = 0; i < appenders.Length; i++)
     {
         this.appenders[i] = appenders[i];
     }
 }

		/// <summary>
		/// Add an appender to a logger.
		/// </summary>
		/// <param name="loggerName">Name of the logger.</param>
		/// <param name="appender">The appender.</param>
		public static void AddAppender( string loggerName, IAppender appender )
		{
			ILog log = LogManager.GetLogger( loggerName );
			var l = (Logger)log.Logger;

			l.AddAppender( appender );
		}

        public void AddAppender(IAppender appender)
        {
            Hierarchy hierarchy =
                    (Hierarchy)LogManager.GetRepository();

            hierarchy.Root.AddAppender(appender);
        }

        /// <summary>
        /// Configures logging to a specified level, optionally directing log output to a particular
        /// IAppender instance.
        /// </summary>
        /// <param name="verbose">If true, informational messages should be logged.</param>
        /// <param name="debug">If true, diagnostic and trace-level messages should be logged.</param>
        /// <param name="appender">An IAppender to which log traffic should be directed. If absent, a default
        /// is used.</param>
        public static void Configure(bool verbose, bool debug, IAppender appender = null)
        {
            if (appender != null)
            {
                BasicConfigurator.Configure(appender);
            }
            else
            {
                // Just take the default
                BasicConfigurator.Configure();
            }

            var hierarchy = log4net.LogManager.GetRepository() as log4net.Repository.Hierarchy.Hierarchy;

            if (debug)
            {
                hierarchy.Root.Level = log4net.Core.Level.Debug;
            }
            else if (verbose)
            {
                hierarchy.Root.Level = log4net.Core.Level.Info;
            }
            else
            {
                hierarchy.Root.Level = log4net.Core.Level.Error;
            }
        }

 private void AddAppenders(IAppender[] appenders)
 {
     foreach (IAppender appender in appenders)
     {
         this.Appenders.Add(appender);
     }
 }

 public Logger(IAppender appender, IAppender appenderTwo, IAppender appenderThree)
 {
     this.appenders = new List<IAppender>();
     this.Appenders = appender;
     this.Appenders = appenderTwo;
     this.Appenders = appenderThree;
 }

        /*
        public static ILog MyLogger {
            get {
                return LogManager.GetLogger(MyLoggerName);
            }
        }
        */

        private static void AddAppender(string loggerName, IAppender appender) {
            var log = LogManager.GetLogger(loggerName);
            var logger = (Logger)log.Logger;

            logger.AddAppender(appender);
            logger.Repository.Configured = true;
        }

 private void SetAppenderFixFlags(IAppender appender)
 {
     var bufferingAppender = appender as BufferingAppenderSkeleton;
     if (bufferingAppender != null)
     {
         bufferingAppender.Fix = Fix;
     }
 }

 public static void AddAppender(IAppender initAppender)
 {
     appender.Add(initAppender);
     foreach (ILog aLog in log)
     {
         ((Log)aLog).AddAppender(initAppender);
     }
 }

 public Logger(IAppender baseapender, params IAppender[] moreappenders)
 {
     this.Appenders = new List<IAppender>();
     this.Appenders.Add(baseapender);
     foreach (var appender in moreappenders)
     {
         this.Appenders.Add(appender);
     }
 }

        public FallbackAppenderProxyBase(IAppender appenderToWrap)
        {
            var convertedAppender = appenderToWrap as AppenderSkeleton;
            if (convertedAppender == null)
                throw new InvalidOperationException("cannot use IndefiniteAppenderProxy with an appender that does not inherit from AppenderSkeleton as it needs to hook into the IErrorHandler, to gather errors.");

            innerAppender = convertedAppender;
            errorHandler = new RecordingErrorHandler(GetType().Name);
            convertedAppender.ErrorHandler = errorHandler;
        }

        public void AddAppender(IAppender appender)
        {
            int size = this.Appenders.Length;
            int newSize = size + 1;

            IAppender[] tmp = new IAppender[newSize];
            Array.Copy(this.Appenders, 0, tmp, 0, size);

            this.Appenders = tmp;

            this.Appenders[newSize - 1] = appender;
        }

        public static void addLogAppender(IAppender appender)
        {
            if (appender == null)
            {
                string msg = UException.getExceptionMessage("AppGlobal", "addLogAppender", "An IAppender object is required");

                logAndThrowException(new ArgumentNullException(msg), msg);
            }

            loadLoggers();

            log4net.Repository.Hierarchy.Logger log = (log4net.Repository.Hierarchy.Logger)logger.Logger;

            log.AddAppender(appender);
        }

        protected virtual void AddAppender(IAppender profilerAppender, IAppenderAttachable logger)
        {
            IAppender appender;
            do {
                appender = logger.GetAppender(profilerAppender.Name);
                if (appender != null) {
                    try {
                        logger.RemoveAppender(appender);
                    }
                    catch (Exception) { }
                }
            }
            while (appender != null);

            logger.AddAppender(profilerAppender);
        }

		/// <summary>
		/// Attaches an appender.
		/// </summary>
		/// <param name="newAppender">The appender to add.</param>
		/// <remarks>
		/// If the appender is already in the list it won't be added again.
		/// </remarks>
		public void AddAppender(IAppender newAppender) 
		{
			// Null values for newAppender parameter are strictly forbidden.
			if (newAppender == null)
			{
				throw new ArgumentNullException("newAppender");
			}
	
			if (m_appenderList == null) 
			{
				m_appenderList = new AppenderCollection(1);
			}
			if (!m_appenderList.Contains(newAppender))
			{
				m_appenderList.Add(newAppender);
			}
		}

 public CommandManager(IPerformanceDatabase database, IAppender appender)
 {
     this.database = database;
     this.appender = appender;
 }

		/// <summary>
		/// Remove the appender passed as parameter form the list of appenders.
		/// </summary>
		/// <param name="appender">The appender to remove</param>
		/// <returns>The appender removed from the list</returns>
		/// <remarks>
		/// <para>
		/// Remove the appender passed as parameter form the list of appenders.
		/// The appender removed is not closed.
		/// If you are discarding the appender you must call
		/// <see cref="IAppender.Close"/> on the appender removed.
		/// </para>
		/// </remarks>
		virtual public IAppender RemoveAppender(IAppender appender) 
		{
			m_appenderLock.AcquireWriterLock();
			try
			{
				if (appender != null && m_appenderAttachedImpl != null) 
				{
					return m_appenderAttachedImpl.RemoveAppender(appender);
				}
			}
			finally
			{
				m_appenderLock.ReleaseWriterLock();
			}
			return null;
		}

		/// <summary>
		/// Add <paramref name="newAppender"/> to the list of appenders of this
		/// Logger instance.
		/// </summary>
		/// <param name="newAppender">An appender to add to this logger</param>
		/// <remarks>
		/// <para>
		/// Add <paramref name="newAppender"/> to the list of appenders of this
		/// Logger instance.
		/// </para>
		/// <para>
		/// If <paramref name="newAppender"/> is already in the list of
		/// appenders, then it won't be added again.
		/// </para>
		/// </remarks>
		virtual public void AddAppender(IAppender newAppender) 
		{
			if (newAppender == null)
			{
				throw new ArgumentNullException("newAppender");
			}

			m_appenderLock.AcquireWriterLock();
			try
			{
				if (m_appenderAttachedImpl == null) 
				{
					m_appenderAttachedImpl = new log4net.Util.AppenderAttachedImpl();
				}
				m_appenderAttachedImpl.AddAppender(newAppender);
			}
			finally
			{
				m_appenderLock.ReleaseWriterLock();
			}
		}

		/// <summary>
		/// Removes the specified appender from the list of appenders.
		/// </summary>
		/// <param name="appender">The appender to remove.</param>
		/// <returns>The appender removed from the list</returns>
		/// <remarks>
		/// The appender removed is not closed.
		/// If you are discarding the appender you must call
		/// <see cref="IAppender.Close"/> on the appender removed.
		/// </remarks>
		virtual public IAppender RemoveAppender(IAppender appender) 
		{
			lock(this)
			{
				if (appender != null && m_appenderAttachedImpl != null) 
				{
					return m_appenderAttachedImpl.RemoveAppender(appender);
				}
			}
			return null;
		}

		/// <summary>
		/// Adds an <see cref="IAppender" /> to the list of appenders of this
		/// instance.
		/// </summary>
		/// <param name="newAppender">The <see cref="IAppender" /> to add to this appender.</param>
		/// <remarks>
		/// <para>
		/// If the specified <see cref="IAppender" /> is already in the list of
		/// appenders, then it won't be added again.
		/// </para>
		/// </remarks>
		virtual public void AddAppender(IAppender newAppender) 
		{
			if (newAppender == null)
			{
				throw new ArgumentNullException("newAppender");
			}
			lock(this)
			{
				if (m_appenderAttachedImpl == null) 
				{
					m_appenderAttachedImpl = new log4net.Util.AppenderAttachedImpl();
				}
				m_appenderAttachedImpl.AddAppender(newAppender);
			}
		}