Task的在主线程处理异常信息的Helper类

最近使用task时候需要把异常记录日志，直接注入非单例模式的实例进入异步线程，在高并发情况下会出现一些问题。

所以需要把异常反馈给主线程 ，并且不在主线程里进行等待，研究相关资料后，自己写了一个简单的helper类封装了下。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Xyfy.Helper
{
    /// <summary>
    /// 
    /// </summary>
    public class TaskHelper
    {
        /// <summary>
        /// 
        /// </summary>
        event EventHandler<AggregateExceptionArgs> AggregateExceptionCatched;

        private readonly TaskFactory factory;

        private readonly Action<Exception> logAction;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="errorLogAction"></param>
        public TaskHelper(Action<Exception> errorLogAction = null)
        {
            logAction = errorLogAction ?? Console.WriteLine;
            AggregateExceptionCatched += new EventHandler<AggregateExceptionArgs>(Program_AggregateExceptionCatched);
            factory = Task.Factory;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workAction"></param>
        /// <returns></returns>
        public Task StartNew(Action workAction)
        {
            return ContinueWith(factory.StartNew(workAction));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        private Task ContinueWith(Task task)
        {
            return task.ContinueWith(t =>
            {
                if (t.Exception != null)
                {
                    AggregateExceptionArgs errArgs = new AggregateExceptionArgs()
                    {
                        AggregateException = new AggregateException(t.Exception.InnerExceptions)
                    };
                    AggregateExceptionCatched(null, errArgs);
                }
            }, TaskContinuationOptions.OnlyOnFaulted);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="action"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public Task StartNew(Action action, CancellationToken cancellationToken)
        {
            return ContinueWith(factory.StartNew(action, cancellationToken));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="action"></param>
        /// <param name="creationOptions"></param>
        /// <returns></returns>
        public Task StartNew(Action action, TaskCreationOptions creationOptions)
        {
            return ContinueWith(factory.StartNew(action, creationOptions));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="action"></param>
        /// <param name="cancellationToken"></param>
        /// <param name="creationOptions"></param>
        /// <param name="scheduler"></param>
        /// <returns></returns>
        public Task StartNew(Action action, CancellationToken cancellationToken,
            TaskCreationOptions creationOptions, TaskScheduler scheduler)
        {
            return ContinueWith(factory.StartNew(action, cancellationToken, creationOptions, scheduler));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Program_AggregateExceptionCatched(object sender, AggregateExceptionArgs e)
        {
            foreach (Exception item in e.AggregateException.InnerExceptions)
            {
                logAction(item);
            }
        }

    }
}

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Xyfy.Helper
{
    /// <summary>
    /// 
    /// </summary>
    public class AggregateExceptionArgs : EventArgs
    {
        /// <summary>
        /// 
        /// </summary>
        public AggregateException AggregateException { get; set; }
    }
}