Index: src/Appender/AsyncAppender.cs
===================================================================
--- src/Appender/AsyncAppender.cs	(revision 0)
+++ src/Appender/AsyncAppender.cs	(revision 0)
@@ -0,0 +1,408 @@
+using System;
+using System.Threading;
+using log4net.Core;
+
+namespace log4net.Appender
+{
+    /// <summary>
+    /// A forwarding appender that queues the events first. And then forward
+    /// to the attached appenders asynchronously.
+    /// </summary>
+    public class AsyncAppender : ForwardingAppender
+    {
+        /// <summary>
+        /// The default event queue capacity.
+        /// </summary>
+        /// <seealso cref="QueueCapacity"/>
+        public const int DEFAULT_QUEUE_CAPACITY = 8192; //64K buffer
+
+        /// <summary>
+        /// The default event batch size
+        /// </summary>
+        /// <seealso cref="ForwardingBatchSize"/>
+        public const int DEFAULT_BATCH_SIZE = 256;
+
+        /// <summary>
+        /// The default batch wait time.
+        /// </summary>
+        /// <seealso cref="BatchWaitTimeout"/>
+        public static readonly TimeSpan DEFAULT_BATCH_WAIT_TIMEOUT = TimeSpan.FromSeconds(5);
+
+        /// <summary>
+        /// The minimal accaptable queue capacity.
+        /// </summary>
+        public const int MIN_QUEUE_CAPACITY = 32;
+
+        /// <summary>
+        /// The minimal allowed queue capacity to batch size ratio.
+        /// </summary>
+        public const int MIN_CAPACITY_TO_BATCH_RATIO = 4;
+
+        private FixFlags _fixFlags = FixFlags.All;
+
+        private int _queueCapacity = DEFAULT_QUEUE_CAPACITY;
+
+        private readonly object _queueLock = new object();
+        private LoggingEvent[] _queue;
+        private int _head = 0, _tail = 0;
+        private int _size = 0;
+        private TimeSpan _batchWait = DEFAULT_BATCH_WAIT_TIMEOUT;
+        private int _batchSize = DEFAULT_BATCH_SIZE;
+        private bool _isShutDown = false;
+
+        private Thread _asyncThread;
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets or sets a the fields that will be fixed in the event
+        /// </summary>
+        /// <value>
+        /// The event fields that will be fixed before the event is queued.
+        /// </value>
+        /// <remarks>
+        /// <para>
+        /// The logging event needs to have certain thread specific values 
+        /// captured before it can be queue for async logging. See 
+        /// <see cref="LoggingEvent.Fix"/> for details.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="LoggingEvent.Fix"/>
+        virtual public FixFlags Fix
+        {
+            get { return _fixFlags; }
+            set { _fixFlags = value; }
+        }
+
+        private int _tempBatchSize = DEFAULT_BATCH_SIZE;
+        /// <summary>
+        /// Gets and sets the number of events to forward to the attached 
+        /// appenders in batch.
+        /// </summary>
+        public int ForwardingBatchSize
+        {
+            get { return _tempBatchSize; }
+            set { _tempBatchSize = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the seconds to wait for the events to fill the batch
+        /// size. <see cref="AsyncAppender"/> will strat to forward to the 
+        /// attached appenders after the given time lapse regardless if the 
+        /// number of events has reached the required batch size .
+        /// </summary>
+        public double BatchWaitTimeout
+        {
+            get { return _batchWait.TotalSeconds; }
+            set { _batchWait = TimeSpan.FromSeconds(value); }
+        }
+
+        private int _tempQueueCapacity = DEFAULT_QUEUE_CAPACITY;
+        /// <summary>
+        /// Gets and sets the event queue capacity. Once the this limit
+        /// is reached. Events will be discarded.
+        /// </summary>
+        public int QueueCapacity
+        {
+            get { return _tempQueueCapacity; }
+            set { _tempQueueCapacity = value; }
+        }
+
+        #endregion
+
+        #region Method Overrides
+
+        ///<summary>
+        ///
+        ///            Initialize the appender based on the options set
+        ///            
+        ///</summary>
+        ///
+        ///<remarks>
+        ///
+        ///<para>
+        ///
+        ///            This is part of the <see cref="T:log4net.Core.IOptionHandler" /> delayed object
+        ///            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions" /> method must 
+        ///            be called on this object after the configuration properties have
+        ///            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions" /> is called this
+        ///            object is in an undefined state and must not be used. 
+        ///            
+        ///</para>
+        ///
+        ///<para>
+        ///
+        ///            If any of the configuration properties are modified then 
+        ///            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions" /> must be called again.
+        ///            
+        ///</para>
+        ///
+        ///</remarks>
+        ///
+        public override void ActivateOptions()
+        {
+            lock (this)
+            {
+                base.ActivateOptions();
+                lock (_queueLock)
+                    try
+                    {
+                        if (_tempQueueCapacity < MIN_QUEUE_CAPACITY)
+                        {
+                            _tempQueueCapacity = MIN_QUEUE_CAPACITY;
+                        }
+
+                        // This is important to avoid unnecessary pulse in Append
+                        if (_tempBatchSize <= 1) _tempBatchSize = 0;
+
+                        if (_tempBatchSize > 1 && (_queueCapacity/_tempBatchSize) < MIN_CAPACITY_TO_BATCH_RATIO)
+                        {
+                            _tempBatchSize = _queueCapacity/MIN_CAPACITY_TO_BATCH_RATIO;
+                        }
+
+                        if (_queue == null)
+                        {
+                            _queue = new LoggingEvent[_tempQueueCapacity];
+                        }
+                        else if (_tempQueueCapacity != _queueCapacity)
+                        {
+                            while (_tempQueueCapacity < _size) Monitor.Wait(_queueLock);
+
+                            LoggingEvent[] newQueue = new LoggingEvent[_tempQueueCapacity];
+                            for (int i = 0; i < _size; i++)
+                            {
+                                newQueue[i] = _queue[(_head + i)%_queueCapacity];
+                            }
+                            _queue = newQueue;
+                            _head = 0;
+                            _tail = _size % _tempQueueCapacity;
+                        }
+                        _queueCapacity = _tempQueueCapacity;
+                        _batchSize = _tempBatchSize;
+                    }
+                    finally
+                    {
+                        Monitor.Pulse(_queueLock);
+                    }
+
+                if (_asyncThread == null && !_isShutDown)
+                {
+                    _asyncThread = new Thread(AsyncAppend);
+                    _asyncThread.IsBackground = true;
+                    _asyncThread.Name = typeof (AsyncAppender).FullName;
+                    _asyncThread.Start();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Always return true;
+        /// </summary>
+        /// <returns>Always return true.</returns>
+        protected override bool PreAppendCheck()
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Add the <paramref name="loggingEvent"/> to the queue. If queue is
+        /// full, error is reported and it waits for the queue to be available.
+        /// </summary>
+        /// <param name="loggingEvent">Event to log.</param>
+        protected override void Append(LoggingEvent loggingEvent)
+        {
+            if (_fixFlags != FixFlags.None) loggingEvent.Fix = _fixFlags;
+
+            lock (_queueLock)
+            {
+                if (_size >= _queueCapacity)
+                {
+                    ErrorHandler.Error("AsyncAppender: Queue is full.");
+                    Monitor.Wait(_queueLock);
+                }
+                if (_size == 0) Monitor.Pulse(_queueLock);
+                Enqueue(loggingEvent);
+                if (_size >= _batchSize) Monitor.Pulse(_queueLock);
+            }
+        }
+
+        /// <summary>
+        /// Add all the events in <paramref name="loggingEvents"/> to the 
+        /// queue. If queue doesn't have enough free capacity to hold all
+        /// those events, error is reported and it waits for the queue to 
+        /// be available.
+        /// </summary>
+        /// <param name="loggingEvents">Evnets to log.</param>
+        protected override void Append(LoggingEvent[] loggingEvents)
+        {
+            if (_fixFlags != FixFlags.None)
+            {
+                foreach (LoggingEvent loggingEvent in loggingEvents)
+                {
+                    loggingEvent.Fix = _fixFlags;
+                }
+            }
+            lock (_queueLock)
+            {
+                if (_size + loggingEvents.Length > _queueCapacity)
+                {
+                    ErrorHandler.Error("AsyncAppender: Queue is full.");
+                    Monitor.Wait(_queueLock);
+                }
+                // Must pulse before we add to queue so wakeup is guaranteed
+                // and only when queue is empty to avoid unnecessary wakeup.
+                if (_size == 0) Monitor.Pulse(_queueLock);
+                try
+                {
+                    foreach (LoggingEvent loggingEvent in loggingEvents)
+                    {
+                        Enqueue(loggingEvent);
+                    }
+                }
+                finally
+                {
+                    if (_size >= _batchSize) Monitor.Pulse(_queueLock);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Inform and wait for the asynchronous thread to end.
+        /// </summary>
+        protected override void OnClose()
+        {
+            Thread worker;
+
+            // Tell async thread we are shutting down
+            lock(_queueLock)
+            {
+                _isShutDown = true;
+                Monitor.Pulse(_queueLock);
+                worker = _asyncThread;
+            }
+
+            if (worker != null)
+            {
+                // Wait for the async thread to exit.
+                Monitor.Wait(this);
+                worker.Join();
+            }
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        private void AsyncAppend()
+        {
+            // this is to handle the case when the batch size changes after
+            // worker thread started.
+            while (_batchSize > 1 ? AsyncAppendBatch(_batchSize) : AsyncAppendSingle())
+            {
+            }
+
+            // Async thread exiting, let's close all attached appenders.
+            lock (this)
+            {
+                base.OnClose();
+                Monitor.Pulse(this);                
+            }
+        }
+
+        private bool AsyncAppendSingle()
+        {
+            // start the looping to wait for the events in the queue and send
+            // then to the attached appenders when available.
+            for (; ; )
+            {
+                LoggingEvent loggingEvent;
+                lock (_queueLock)
+                {
+                    if (_batchSize > 1) return true;
+                    while (_size == 0)
+                    {
+                        if (_isShutDown) return false;
+                        // Nothing to log, let's wait for it
+                        try { Monitor.Wait(_queueLock); }
+                        catch(Exception e)
+                        {
+                            ErrorHandler.Error("AsyncAppender: async thread exception " + e.Message, e);
+                        }
+                    }
+                    loggingEvent = Dequeue();
+
+                    // Wake up one waiting appender if any.
+                    Monitor.Pulse(_queueLock);
+                }
+                base.Append(loggingEvent);
+            }
+        }
+
+        private bool AsyncAppendBatch(int count)
+        {
+            for (; ; )
+            {
+                LoggingEvent[] loggingEvents;
+                lock (_queueLock)
+                {
+                    if (_batchSize <= 1) return true;
+                    while (_size == 0)
+                    {
+                        if (_isShutDown) return false;
+                        // Nothing to log, let's wait for it
+                        try { Monitor.Wait(_queueLock); }
+                        catch (Exception e)
+                        {
+                            ErrorHandler.Error("AsyncAppender: async thread exception " + e.Message, e);
+                        }
+                    }
+                    DateTime now = DateTime.Now;
+                    DateTime releaseTime = now + _batchWait;
+                    while (!_isShutDown && _size < count && releaseTime > now)
+                    {
+                        // Let's wait for the queue to be filled with required 
+                        // batch size. But not later then releaseTime.
+                        try { Monitor.Wait(_queueLock, releaseTime - now); }
+                        catch (Exception e)
+                        {
+                            ErrorHandler.Error("AsyncAppender: async thread exception " + e.Message, e);
+                        }
+                        
+                        now = DateTime.Now;
+                    }
+
+                    // wake up all appending thread so they can try again as 
+                    // soon as we release the lock.
+                    Monitor.PulseAll(_queueLock); 
+
+                    int batch = _size < count ? _size : count;
+                    loggingEvents = new LoggingEvent[batch];
+                    for (int i = 0; i < batch; i++)
+                    {
+                        loggingEvents[i] = Dequeue();
+                    }
+                }
+                base.Append(loggingEvents);
+            }
+        }
+
+        private LoggingEvent Dequeue()
+        {
+            LoggingEvent loggingEvent = _queue[_head];
+            _queue[_head++] = null;
+            if (_head == _queueCapacity) _head = 0;
+            _size--;
+            return loggingEvent;
+        }
+
+        private void Enqueue(LoggingEvent loggingEvent)
+        {
+            _queue[_tail++] = loggingEvent;
+            if (_tail == _queueCapacity) _tail = 0;
+            _size++;
+        }
+
+        #endregion
+
+    }
+}
Index: src/Appender/BufferingAppenderSkeleton.cs
===================================================================
--- src/Appender/BufferingAppenderSkeleton.cs	(revision 727418)
+++ src/Appender/BufferingAppenderSkeleton.cs	(working copy)
@@ -516,6 +516,39 @@
 			}
 		}
 
+        ///<summary>
+        /// This method is called by the <see cref="AppenderSkeleton.DoAppend(LoggingEvent[])"/> method. 
+        ///</summary>
+        ///<param name="loggingEvents">the array of logging events</param>
+        ///<remarks>
+        ///<para>
+        /// When buffering is disabled and not in lossy mode, the bulk array of events 
+        /// are forwarded directly to <see cref="SendBuffer(LoggingEvent[])"/> for better
+        /// performance. Otherwise, delegate the call to base class.
+        ///</para>
+        ///</remarks>
+        ///
+        protected override void Append(LoggingEvent[] loggingEvents)
+        {
+            if (m_bufferSize > 1 || m_lossy)
+            {
+                base.Append(loggingEvents);
+            }
+            else
+            {
+                if (m_eventMustBeFixed)
+                {
+                    // Derive class expects fixed events
+                    foreach (LoggingEvent loggingEvent in loggingEvents)
+                    {
+                        loggingEvent.Fix = this.Fix;
+                    }
+                }
+
+                SendBuffer(loggingEvents);
+            }
+        }
+
 		#endregion Override implementation of AppenderSkeleton
 
 		#region Protected Instance Methods
Index: src/log4net.vs2005.csproj
===================================================================
--- src/log4net.vs2005.csproj	(revision 727418)
+++ src/log4net.vs2005.csproj	(working copy)
@@ -95,6 +95,7 @@
     <Compile Include="Appender\AspNetTraceAppender.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Appender\AsyncAppender.cs" />
     <Compile Include="Appender\BufferingAppenderSkeleton.cs">
       <SubType>Code</SubType>
     </Compile>
Index: tests/src/Appender/AsyncAppenderTest.cs
===================================================================
--- tests/src/Appender/AsyncAppenderTest.cs	(revision 0)
+++ tests/src/Appender/AsyncAppenderTest.cs	(revision 0)
@@ -0,0 +1,416 @@
+using System;
+using System.Threading;
+using log4net.Appender;
+using log4net.Core;
+using NUnit.Framework;
+
+namespace log4net.Tests.Appender
+{
+    /// <summary>
+    /// Test cases for <see cref="AsyncAppender"/>
+    /// </summary>
+    [TestFixture]
+    public class AsyncAppenderTest
+    {
+        private AsyncAppender _asyncAppender;
+        private MockAppender _mockAppender;
+        private volatile bool _isReleased;
+
+        [SetUp] public void Setup()
+        {
+            _mockAppender = new MockAppender();
+            _asyncAppender = new AsyncAppender();
+            _asyncAppender.AddAppender(_mockAppender);
+        }
+
+        [TearDown] public void TearDown()
+        {
+            _asyncAppender.Close();
+        }
+
+        [Test] public void FixProperty()
+        {
+            Assert.AreEqual(FixFlags.All, _asyncAppender.Fix);
+            FixFlags fix = FixFlags.Partial;
+            _asyncAppender.Fix = fix;
+            Assert.AreEqual(fix, _asyncAppender.Fix);
+        }
+
+        [Test] public void SingleEventMustBeFixed()
+        {
+            LoggingEvent e = new LoggingEvent(null, null, new LoggingEventData(), FixFlags.None);
+            Assert.AreEqual(FixFlags.None, e.Fix);
+
+            _asyncAppender.Fix = FixFlags.Partial;
+            _asyncAppender.ActivateOptions();
+            _asyncAppender.DoAppend(e);
+            _asyncAppender.Close();
+            Assert.AreEqual(FixFlags.Partial, e.Fix);
+        }
+
+        [Test]
+        public void MultiEventMustBeFixed()
+        {
+            FixFlags fix = FixFlags.None;
+            LoggingEvent[] events =
+                new LoggingEvent[]
+                    {
+                        new LoggingEvent(null, null, new LoggingEventData(), FixFlags.None),
+                        new LoggingEvent(null, null, new LoggingEventData(), FixFlags.None),
+                    };
+            _asyncAppender.Fix = FixFlags.Partial;
+            _asyncAppender.ActivateOptions();
+            _asyncAppender.DoAppend(events);
+            _asyncAppender.Close();
+            Assert.AreEqual(FixFlags.Partial, events[0].Fix);
+            Assert.AreEqual(FixFlags.Partial, events[1].Fix);
+        }
+
+        [Test] public void QueueCapacityProperty()
+        {
+            int capacity = AsyncAppender.MIN_QUEUE_CAPACITY*2;
+            _asyncAppender.QueueCapacity = capacity;
+            Assert.AreEqual(capacity, _asyncAppender.QueueCapacity);
+            _asyncAppender.ActivateOptions();
+            Assert.AreEqual(capacity, _asyncAppender.QueueCapacity);
+        }
+
+        [Test] public void QueueCapacityNotLowerThenMinimal()
+        {
+            int capacity = AsyncAppender.MIN_QUEUE_CAPACITY - 1;
+            _asyncAppender.QueueCapacity = capacity;
+            Assert.AreEqual(capacity, _asyncAppender.QueueCapacity);
+            _asyncAppender.ActivateOptions();
+            Assert.AreEqual(AsyncAppender.MIN_QUEUE_CAPACITY, _asyncAppender.QueueCapacity);
+        }
+
+        [Test] public void ForwardingBatchSizeProperty()
+        {
+            int size = AsyncAppender.DEFAULT_BATCH_SIZE - 1;
+            _asyncAppender.ForwardingBatchSize = size;
+            Assert.AreEqual(size, _asyncAppender.ForwardingBatchSize);
+            _asyncAppender.ActivateOptions();
+            Assert.AreEqual(size, _asyncAppender.ForwardingBatchSize);
+        }
+
+        [Test] public void ForwardingBatchSizeNotLowerThenMinimal()
+        {
+            int size = _asyncAppender.QueueCapacity / 2;
+            _asyncAppender.ForwardingBatchSize = size;
+            Assert.AreEqual(size, _asyncAppender.ForwardingBatchSize);
+            _asyncAppender.ActivateOptions();
+            Assert.AreEqual(
+                _asyncAppender.QueueCapacity / AsyncAppender.MIN_CAPACITY_TO_BATCH_RATIO,
+                _asyncAppender.ForwardingBatchSize);
+        }
+
+        [Test] public void BatchWaitTimeProperty()
+        {
+            Assert.AreEqual(AsyncAppender.DEFAULT_BATCH_WAIT_TIMEOUT.TotalSeconds, _asyncAppender.BatchWaitTimeout);
+            double t = AsyncAppender.DEFAULT_BATCH_WAIT_TIMEOUT.TotalSeconds * 2;
+            _asyncAppender.BatchWaitTimeout = t;
+            Assert.AreEqual(t, _asyncAppender.BatchWaitTimeout);
+        }
+
+        [Test] public void SingleEventInBatchModeShouldReleaseAfterTimeOut()
+        {
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            _asyncAppender.BatchWaitTimeout = 1;
+            _isReleased = false;
+            _mockAppender.OnAppend +=
+                delegate(LoggingEvent e1)
+                    {
+                        Assert.AreEqual(e, e1);
+                        _isReleased = true;
+                    };
+            _asyncAppender.ActivateOptions();
+            _asyncAppender.DoAppend(e);
+            Thread.Sleep(500);
+            Assert.IsFalse(_isReleased, "Should not release the event in batch mode before timeout.");
+            Thread.Sleep(700);
+            Assert.IsTrue(_isReleased, "Should have released the event in batch mode after timeout.");
+        }
+
+        [Test] public void MultipleEventInBatchModeShouldReleaseAfterTimeOut()
+        {
+            int count = 3;
+            LoggingEvent[] e = new LoggingEvent[count];
+            for (int i = 0; i < count; i++)
+            {
+                e[i] = new LoggingEvent(new LoggingEventData());
+            }
+            _asyncAppender.BatchWaitTimeout = 1;
+            _isReleased = false;
+            _mockAppender.OnBulkAppend +=
+                delegate(LoggingEvent[] loggingEvents)
+                    {
+                        Assert.AreEqual(count, loggingEvents.Length);
+                        for(int i=0; i<count; i++)
+                        {
+                            Assert.AreEqual(e[i], loggingEvents[i], "Event {0} is not matching", i);
+                        }
+                        _isReleased = true;
+                    };
+            _asyncAppender.ActivateOptions();
+            for (int i = 0; i < count; i++)
+            {
+                _asyncAppender.DoAppend(e[i]);
+            }
+            Thread.Sleep(500);
+            Assert.IsFalse(_isReleased, "Should not release the event in batch mode before timeout.");
+            Thread.Sleep(700);
+            Assert.IsTrue(_isReleased, "Should have released the event in batch mode after timeout.");
+        }
+
+        [Test] public void BulkEventInBatchModeShouldReleaseAfterTimeOut()
+        {
+            int count = 3;
+            LoggingEvent[] e = new LoggingEvent[count];
+            for (int i = 0; i < count; i++)
+            {
+                e[i] = new LoggingEvent(new LoggingEventData());
+            }
+            _asyncAppender.BatchWaitTimeout = 1;
+            _isReleased = false;
+            _mockAppender.OnBulkAppend +=
+                delegate(LoggingEvent[] loggingEvents)
+                    {
+                        Assert.AreEqual(count, loggingEvents.Length);
+                        for (int i = 0; i < count; i++)
+                        {
+                            Assert.AreEqual(e[i], loggingEvents[i], "Event {0} is not matching", i);
+                        }
+                        _isReleased = true;
+                    };
+            _asyncAppender.ActivateOptions();
+            _asyncAppender.DoAppend(e);
+            Thread.Sleep(500);
+            Assert.IsFalse(_isReleased, "Should not release the event in batch mode before timeout.");
+            Thread.Sleep(700);
+            Assert.IsTrue(_isReleased, "Should have released the event in batch mode after timeout.");
+        }
+
+        [Test] public void ShouldReleaseEventWhenReachesBatchSize1()
+        {
+            int batchSize = 3;
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            LoggingEvent[] events = new LoggingEvent[batchSize];
+            for (int i = 0; i < batchSize; i++)
+            {
+                events[i] = e;
+            }
+            _asyncAppender.BatchWaitTimeout = 5;
+            _asyncAppender.ForwardingBatchSize = batchSize;
+            _mockAppender.OnBulkAppend +=
+                delegate(LoggingEvent[] loggingEvents)
+                    {
+                        Assert.AreEqual(batchSize, loggingEvents.Length);
+                        _isReleased = true;
+                    };
+            _asyncAppender.ActivateOptions();
+
+            _isReleased = false;
+            for (int i = 0; i < batchSize - 1; i++ )
+            {
+                _asyncAppender.DoAppend(e);
+            }
+            Thread.Sleep(500);
+            Assert.IsFalse(_isReleased, "Should not release the events before reaches batch size.");
+
+            _asyncAppender.DoAppend(e);
+            Thread.Sleep(500);
+            Assert.IsTrue(_isReleased, "Should have released the event after reaches batch size.");
+        }
+
+        [Test] public void ShouldReleaseEventWhenReachesBatchSize2()
+        {
+            int batchSize = 4;
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            LoggingEvent[] events = new LoggingEvent[batchSize];
+            for (int i = 0; i < batchSize; i++)
+            {
+                events[i] = e;
+            }
+            _asyncAppender.BatchWaitTimeout = 5;
+            _asyncAppender.ForwardingBatchSize = batchSize;
+            BulkAppendDelegate bulkAppendDelegate =
+                delegate(LoggingEvent[] loggingEvents)
+                    {
+                        Assert.AreEqual(batchSize, loggingEvents.Length);
+                        _isReleased = true;
+                    };
+            _mockAppender.OnBulkAppend += bulkAppendDelegate;
+            _asyncAppender.ActivateOptions();
+
+            _isReleased = false;
+            for (int i = 0; i < batchSize/2; i++)
+            {
+                _asyncAppender.DoAppend(e);
+            }
+            Thread.Sleep(500);
+            Assert.IsFalse(_isReleased, "Should not release the events before reaches batch size.");
+
+            _asyncAppender.DoAppend(events);
+            Thread.Sleep(500);
+            Assert.IsTrue(_isReleased, "Should have released the event after reaches batch size.");
+            _mockAppender.OnBulkAppend -= bulkAppendDelegate;
+        }
+
+        [Test] public void SingleEventReleaseImmediatelyWhenNotInBatchMode()
+        {
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            _asyncAppender.ForwardingBatchSize = 0;
+            _isReleased = false;
+            _mockAppender.OnAppend +=
+                delegate(LoggingEvent e1)
+                    {
+                        Assert.AreEqual(e, e1);
+                        _isReleased = true;
+                    };
+            _asyncAppender.ActivateOptions();
+            _asyncAppender.DoAppend(e);
+            Thread.Sleep(500);
+            Assert.IsTrue(_isReleased, "Should release the event in non batch mode.");
+        }
+
+        [Test] public void NonBatchQueueCycle()
+        {
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            _asyncAppender.ForwardingBatchSize = 0;
+            _asyncAppender.QueueCapacity = AsyncAppender.MIN_QUEUE_CAPACITY;
+            long count = 0, total = AsyncAppender.MIN_QUEUE_CAPACITY * 3;
+            Random r = new Random();
+            _mockAppender.OnAppend +=
+                delegate(LoggingEvent e1)
+                    {
+                        Interlocked.Increment(ref count);
+                    };
+            _asyncAppender.ActivateOptions();
+
+            for (int i = 0; i < total; i++)
+            {
+                _asyncAppender.DoAppend(e);
+                Thread.Sleep(r.Next(10) * r.Next(10));
+            }
+            Thread.Sleep(500);
+            Assert.AreEqual(total, Interlocked.Read(ref count), "All event should be released.");
+        }
+
+        [Test] public void BatchQueueCycle()
+        {
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            LoggingEvent[] events = new LoggingEvent[] {e,e,e};
+            long count = 0, total = AsyncAppender.DEFAULT_QUEUE_CAPACITY * 2 / events.Length;
+            Random r = new Random();
+            _mockAppender.OnBulkAppend +=
+                delegate(LoggingEvent[] e1)
+                    {
+                        count += e1.Length;
+                        Thread.Sleep(5);
+                    };
+            _asyncAppender.ActivateOptions();
+
+            for (int i = 0; i < total; i++)
+            {
+                _asyncAppender.DoAppend(events);
+            }
+            _asyncAppender.Close();
+            Assert.AreEqual(total * events.Length, count, "All event should be released.");
+        }
+
+        [Test] public void DynamicConfigurationChange()
+        {
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            long countBulk = 0, countSingle = 0, total = AsyncAppender.DEFAULT_QUEUE_CAPACITY * 3;
+            _mockAppender.OnBulkAppend +=
+                delegate(LoggingEvent[] e1)
+                    {
+                        countBulk += e1.Length;
+                        Thread.Sleep(5);
+                    };
+            _mockAppender.OnAppend +=
+                delegate(LoggingEvent e1)
+                    {
+                        countSingle++;
+                        if(countSingle % AsyncAppender.DEFAULT_BATCH_SIZE == 0) Thread.Sleep(5);
+                    };
+
+            _asyncAppender.ActivateOptions();
+
+            for (int i = 0; i < total; i++)
+            {
+                _asyncAppender.DoAppend(e);
+            }
+
+            _asyncAppender.QueueCapacity = AsyncAppender.DEFAULT_QUEUE_CAPACITY / 2;
+            _asyncAppender.ForwardingBatchSize = 0;
+            _asyncAppender.ActivateOptions();
+
+            for (int i = 0; i < total; i++)
+            {
+                _asyncAppender.DoAppend(e);
+            }
+
+            _asyncAppender.QueueCapacity = AsyncAppender.DEFAULT_QUEUE_CAPACITY;
+            _asyncAppender.ForwardingBatchSize = AsyncAppender.DEFAULT_BATCH_SIZE;
+            _asyncAppender.ActivateOptions();
+
+            for (int i = 0; i < total; i++)
+            {
+                _asyncAppender.DoAppend(e);
+            }
+            _asyncAppender.Close();
+
+            Assert.Greater(countBulk, 0);
+            Assert.Greater(countSingle, 0);
+            Assert.AreEqual(total*3, countBulk + countSingle, "All event should be released.");
+        }
+
+        [Test] public void PerformanceOverhead()
+        {
+            LoggingEvent e = new LoggingEvent(new LoggingEventData());
+            int total = 1000000;
+
+            _asyncAppender.ActivateOptions();
+
+            DateTime start = DateTime.Now;
+            for (int i = 0; i < total; i++)
+            {
+                _asyncAppender.DoAppend(e);
+            }
+            _asyncAppender.Close();
+            TimeSpan span = DateTime.Now - start;
+            Console.Out.WriteLine("Async " + total + " events:" + span);
+
+            MockAppender mock = new MockAppender();
+            start = DateTime.Now;
+            for (int i = 0; i < total; i++)
+            {
+                mock.DoAppend(e);
+            }
+            span = DateTime.Now - start;
+            Console.Out.WriteLine("Mock  " + total + " events:" + span);
+        }
+
+        private delegate void AppendDelegate(LoggingEvent loggingEvent);
+        private delegate void BulkAppendDelegate(LoggingEvent[] loggingEvents);
+
+        private class MockAppender : AppenderSkeleton
+        {
+            public event AppendDelegate OnAppend;
+            public event BulkAppendDelegate OnBulkAppend;
+
+            protected override void Append(LoggingEvent loggingEvent)
+            {
+                AppendDelegate onAppend = OnAppend;
+                if (onAppend != null) onAppend(loggingEvent);
+            }
+
+            protected override void Append(LoggingEvent[] loggingEvents)
+            {
+                BulkAppendDelegate onBulkAppend = OnBulkAppend;
+                if (onBulkAppend != null) onBulkAppend(loggingEvents);
+            }
+        }
+    }
+}
\ No newline at end of file

Property changes on: tests\src\Appender\AsyncAppenderTest.cs
___________________________________________________________________
Added: svn:mergeinfo

Index: tests/src/log4net.Tests.vs2005.csproj
===================================================================
--- tests/src/log4net.Tests.vs2005.csproj	(revision 727418)
+++ tests/src/log4net.Tests.vs2005.csproj	(working copy)
@@ -91,6 +91,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Appender\AdoNetAppenderTest.cs" />
+    <Compile Include="Appender\AsyncAppenderTest.cs" />
     <Compile Include="Appender\AdoNet\Log4NetCommand.cs" />
     <Compile Include="Appender\AdoNet\Log4NetConnection.cs" />
     <Compile Include="Appender\AdoNet\Log4NetParameter.cs" />