Ejemplo n.º 1
0
        /// <summary>
        /// 并发处理任务(阻塞请求线程)
        /// </summary>
        /// <param name="tasks">并发任务集合</param>
        /// <param name="concurrentOptions">并发项</param>
        /// <returns></returns>
        public static void Processing(List <Func <Task> > tasks,
                                      ConcurrentOptions concurrentOptions = default)
        {
            tasks ??= new List <Func <Task> >();
            tasks = tasks.Where(taskFunc => taskFunc != null).ToList();
            if (tasks.Count <= 0)
            {
                return;
            }

            concurrentOptions ??= new ConcurrentOptions();

            var semaphoreSlim = new SemaphoreSlim(concurrentOptions.MaxConcurrentCount);
            var taskList      = new List <Task>();

            foreach (var taskItem in tasks)
            {
                semaphoreSlim.Wait(concurrentOptions.SecondsTimeout * 1000);

                var task = taskItem()
                           .ContinueWith(t =>
                {
                    semaphoreSlim.Release();
                });

                taskList.Add(task);
            }
            Task.WaitAll(taskList.ToArray());
        }
Ejemplo n.º 2
0
        /// <summary>
        /// 并发处理任务(不阻塞请求线程)
        /// </summary>
        /// <param name="taskName">任务名称</param>
        /// <param name="tasks">并发任务集合</param>
        /// <param name="concurrentOptions">并发项</param>
        /// <returns></returns>
        public static async Task ProcessingAsync(string taskName,
                                                 List <Func <Task> > tasks,
                                                 ConcurrentOptions concurrentOptions = default)
        {
            if (string.IsNullOrEmpty(taskName))
            {
                throw new ArgumentNullException(nameof(taskName));
            }

            tasks ??= new List <Func <Task> >();
            tasks = tasks.Where(taskFunc => taskFunc != null).ToList();
            if (tasks.Count <= 0)
            {
                return;
            }

            await Task.Yield();

            concurrentOptions ??= new ConcurrentOptions();

            var concurrentResultNew = new ConcurrentResult(taskName, tasks.Count, concurrentOptions.LifeTime);

            TryRemoveValue(taskName, out _);
            TryAddValue(taskName, concurrentResultNew);

            var semaphoreSlim = new SemaphoreSlim(concurrentOptions.MaxConcurrentCount);
            var taskList      = new List <Task>();

            foreach (var taskItem in tasks)
            {
                await semaphoreSlim.WaitAsync(concurrentOptions.SecondsTimeout * 1000);

                var task = taskItem()
                           .ContinueWith(t =>
                {
                    semaphoreSlim.Release();
                });

                taskList.Add(task);
                concurrentResultNew.ExecuteTaskList = taskList;
            }
            await Task.WhenAll(taskList);

            concurrentResultNew.Completed = true;
            concurrentResultNew.StartExpiryTimer(ExpiryTimer_Tick);
        }