using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    /// <summary>
    /// 超时类,可设置执行方法超时时间
    /// 目前没有添加取消方法,如有需要,可添加取消功能
    /// </summary>
    public class OutTimeClass
    {
        #region delegate
        /// <summary>
        /// 无参数,无反回值方法
        /// </summary>
        public delegate void NotParamDelegate();
        /// <summary>
        /// 有参数,无反回值方法
        /// </summary>
        /// <param name="Params"></param>
        public delegate void SomeParamsDelegate(object Params);
        /// <summary>
        /// 无参数,带返回值方法
        /// </summary>
        /// <returns></returns>
        public delegate object NotParamReturnDelegate();
        /// <summary>
        /// 有参数,有反回值方法
        /// </summary>
        /// <param name="Params"></param>
        /// <returns></returns>
        public delegate object SomeParamsReturnDelegate(object Params);
        #endregion

        #region 超时方法
        /// <summary>
        /// 无参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTimeMilliseconds">超时时间(毫秒)</param>
        public static void OutTimeNotParam(NotParamDelegate Method, int OutTimeMilliseconds)
        {
            OutTimeNotParam(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds));
        }

        /// <summary>
        /// 无参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        public static void OutTimeNotParam(NotParamDelegate Method, TimeSpan OutTime)
        {
            OutTimeNotParam(Method, OutTime, null);
        }

        /// <summary>
        /// 无参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="cancelEvent">取消信号</param>
        public static void OutTimeNotParam(NotParamDelegate Method, TimeSpan OutTime, WaitHandle cancelEvent)
        {
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate () { Method(); are.Set(); });
            t.IsBackground = true;
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
        }

        /// <summary>
        /// 有参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTimeMilliseconds">超时时间(毫秒)</param>
        /// <param name="Param">参数</param>
        public static void OutTimeSomeParem(SomeParamsDelegate Method, int OutTimeMilliseconds, object Param)
        {
            OutTimeSomeParem(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds), Param);
        }

        /// <summary>
        /// 有参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Param">参数</param>
        public static void OutTimeSomeParem(SomeParamsDelegate Method, TimeSpan OutTime, object Param)
        {
            OutTimeSomeParem(Method, OutTime, Param, null);
        }

        /// <summary>
        /// 有参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="cancelEvent">取消信号</param>
        /// <param name="Params">参数</param>
        public static void OutTimeSomeParem(SomeParamsDelegate Method, TimeSpan OutTime, object Param, WaitHandle cancelEvent)
        {
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate () { Method(Param); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
        }

        /// <summary>
        /// 没参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTimeMilliseconds">超时时间(毫秒)</param>
        /// <returns>反回object类型对象</returns>
        public static object OutTimeNotParamReturn(NotParamReturnDelegate Method, int OutTimeMilliseconds)
        {
            return OutTimeNotParamReturn(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds));
        }

        /// <summary>
        /// 没参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <returns>反回object类型对象</returns>
        public static object OutTimeNotParamReturn(NotParamReturnDelegate Method, TimeSpan OutTime)
        {
            return OutTimeNotParamReturn(Method, OutTime, null);
        }

        /// <summary>
        /// 没参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="cancelEvent">取消信号</param>
        /// <returns>反回object类型对象</returns>
        public static object OutTimeNotParamReturn(NotParamReturnDelegate Method, TimeSpan OutTime, WaitHandle cancelEvent)
        {
            object obj = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate () { obj = Method(); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
            return obj;
        }

        /// <summary>
        /// 有参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Params">执行参数</param>
        /// <returns>反回一个object类型方法</returns>
        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, int OutTimeMilliseconds, object Param)
        {
            return OutTimeSomeParemReturn(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds), Param);
        }

        /// <summary>
        /// 有参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Params">执行参数</param>
        /// <returns>反回一个object类型方法</returns>
        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, TimeSpan OutTime, object Param)
        {
            return OutTimeSomeParemReturn(Method, OutTime, Param, null);
        }

        /// <summary>
        /// 有参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Params">执行参数</param>
        /// <param name="cancelEvent">取消信号</param>
        /// <returns>反回一个object类型方法</returns>
        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, TimeSpan OutTime, object Param, WaitHandle cancelEvent)
        {
            object obj = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate () { obj = Method(Param); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
            return obj;
        }

        /// <summary>
        /// 等待方法执行完成,或超时
        /// </summary>
        /// <param name="t"></param>
        /// <param name="OutTime"></param>
        /// <param name="ares"></param>
        private static void Wait(Thread t, TimeSpan OutTime, WaitHandle are, WaitHandle cancelEvent)
        {
            WaitHandle[] ares;
            if (cancelEvent == null)
                ares = new WaitHandle[] { are };
            else
                ares = new WaitHandle[] { are, cancelEvent };
            int index = WaitHandle.WaitAny(ares, OutTime);
            if ((index != 0) && t.IsAlive)//如果不是执行完成的信号,并且,线程还在执行,那么,结束这个线程
            {
                //t.Abort();//不支持
                t.Interrupt();
                t = null;
            }
        }
        #endregion
    }

    public class ThreadHelper
    {
        static CancellationTokenSource _cancelSource01 = new CancellationTokenSource();
        static CancellationTokenSource _cancelSource02 = new CancellationTokenSource();
        public static void TaskThread(Action methodName, int timeout = 0)
        {
            var task = Task.Factory.StartNew(() =>
            {
                methodName();
            }, _cancelSource01.Token);

            if (timeout > 0)
            {
                task.Wait(timeout);
                _cancelSource01.Cancel();
            }
        }

        public static void TaskThread(Action<object> methodName, object param, int timeout = 0)
        {
            var task = Task.Factory.StartNew(() =>
            {
                methodName(param);
            }, _cancelSource02.Token);

            if (timeout > 0)
            {
                task.Wait(timeout);
                _cancelSource02.Cancel();
            }
        }

        //public static object TaskThread(Func<object> methodName)
        //{
        //    var result = Task.Factory.StartNew(() =>
        //    {
        //        return methodName();
        //    });
        //    return result;
        //}
        //public static object TaskThread(Func<object,object> methodName,object param)
        //{
        //    var result = Task.Factory.StartNew(() =>
        //    {
        //        return methodName(param);
        //    });
        //    return result;
        //}
    }
}