static int _pcount = 0;
      static object _lock = new object();
      static SemaphoreSlim _semaphore;

      static int PCount
      {
         get
         {
            lock (_lock)
            {
               return ++_pcount;
            }
         }
      }

      class PTaskTestItem
      {
         public int OrderNum;
         public int SleepSec;
         public int RunNum;

         public PTaskTestItem(int orderNum, int sleepSec)
         {
            OrderNum = orderNum;
            SleepSec = sleepSec;
            RunNum = -1;
         }

         public override string ToString()
         {
            return string.Format("{0} - {1} [{2}]", OrderNum, RunNum, SleepSec);
         }
      }


     public void Test3()
      {
         var taskList = new List<PTaskTestItem>()
         {
            new PTaskTestItem(1, 10),
            new PTaskTestItem(2, 5),
            new PTaskTestItem(3, 3),
            new PTaskTestItem(4, 8),
            new PTaskTestItem(5, 12),
            new PTaskTestItem(6, 7),
            new PTaskTestItem(7, 10),
            new PTaskTestItem(8, 8),
            new PTaskTestItem(9, 10),
            new PTaskTestItem(10, 4),
            new PTaskTestItem(11, 1),
            new PTaskTestItem(12, 3),
            new PTaskTestItem(13, 10),
            new PTaskTestItem(14, 12),
            new PTaskTestItem(15, 11),
            new PTaskTestItem(16, 4),
            new PTaskTestItem(17, 7),
            new PTaskTestItem(18, 6),
            new PTaskTestItem(19, 10),
            new PTaskTestItem(20, 14),
         };
         var po = new ParallelOptions() { MaxDegreeOfParallelism = 4 };
         _semaphore = new SemaphoreSlim(0, po.MaxDegreeOfParallelism);
         /*
         //1
         var pTaskList = taskList.ToArray().
                  AsParallel().
                  AsOrdered().
                  Select(x =>
                  {
                     x.RunNum = PCount;
                     Thread.Sleep(x.SleepSec * 1000);
                     return x;
                  });
         foreach (var res in pTaskList) // Выполнение 
         {
            Debug.WriteLine(res.ToString());
         }
         */
         //2
         //Parallel.ForEach(taskList, po, (x) =>
         //{
         //   x.RunNum = PCount;
         //   Thread.Sleep(x.SleepSec * 1000);
         //   Debug.WriteLine(x.ToString());
         //});

         //3


         var tasks = new Task[taskList.Count];
         for (int i = 0; i < taskList.Count; i++)
         {
            tasks[i] = Task.Run(() =>
            {
               _semaphore.Wait();
               var n = PCount;
               var x = taskList.FirstOrDefault(f => f.OrderNum == n);               
               x.RunNum = n;
               Thread.Sleep(x.SleepSec * 1000);
               Debug.WriteLine(x.ToString());
               _semaphore.Release();
            });
         }
         _semaphore.Release(po.MaxDegreeOfParallelism);
         Task.WaitAll(tasks);
}