// Create a BufferBlock<int> object.
var bufferBlock = new BufferBlock<int>();

// Post several messages to the block.
for (int i = 0; i < 3; i++)
{
   bufferBlock.Post(i);
}

// Receive the messages back from the block.
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(bufferBlock.Receive());
}

// Post more messages to the block.
for (int i = 0; i < 3; i++)
{
   bufferBlock.Post(i);
}

// Receive the messages back from the block.
int value;
while (bufferBlock.TryReceive(out value))
{
   Console.WriteLine(value);
}

// Write to and read from the message block concurrently. 
var post01 = Task.Run(() =>
   {
      bufferBlock.Post(0);
      bufferBlock.Post(1);
   });
var receive = Task.Run(() => 
   {
     for (int i = 0; i < 3; i++)
     {
        Console.WriteLine(bufferBlock.Receive());
     }
   });
var post2 = Task.Run(() => 
   {
     bufferBlock.Post(2);
   });
Task.WaitAll(post01, receive, post2);

// Post more messages to the block asynchronously. 
for (int i = 0; i < 3; i++)
{
   await bufferBlock.SendAsync(i);
}

// Asynchronously receive the messages back from the block. 
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(await bufferBlock.ReceiveAsync());
}

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

// Demonstrates a how to write to and read from a dataflow block. 
class DataflowReadWrite
{
   // Demonstrates asynchronous dataflow operations. 
   static async Task AsyncSendReceive(BufferBlock<int> bufferBlock)
   {
      // Post more messages to the block asynchronously. 
      for (int i = 0; i < 3; i++)
      {
        await bufferBlock.SendAsync(i);
      }

      // Asynchronously receive the messages back from the block. 
      for (int i = 0; i < 3; i++)
      {
        Console.WriteLine(await bufferBlock.ReceiveAsync());
      }
          
          /*Output:
             0
             1
             2
           */
     }

       static void Main(string[] args)
       {
          // Create a BufferBlock<int> object. 
          var bufferBlock = new BufferBlock<int>();

          // Post several messages to the block. 
          for (int i = 0; i < 3; i++)
          {
             bufferBlock.Post(i);
          }

          // Receive the messages back from the block. 
          for (int i = 0; i < 3; i++)
          {
             Console.WriteLine(bufferBlock.Receive());
          }

          /* Output:
             0
             1
             2
           */ 

          // Post more messages to the block. 
          for (int i = 0; i < 3; i++)
          {
             bufferBlock.Post(i);
          }

          // Receive the messages back from the block. 
          int value;
          while (bufferBlock.TryReceive(out value))
          {
             Console.WriteLine(value);
          }

          /* Output:
             0
             1
             2
           */ 

          // Write to and read from the message block concurrently. 
          var post01 = Task.Run(() =>
             {
                bufferBlock.Post(0);
                bufferBlock.Post(1);
             });
          var receive = Task.Run(() => 
             {
                for (int i = 0; i < 3; i++)
                {
                   Console.WriteLine(bufferBlock.Receive());
                }
             });
          var post2 = Task.Run(() => 
             {
                bufferBlock.Post(2);
             });
          Task.WaitAll(post01, receive, post2);


          // Demonstrate asynchronous dataflow operations.
          AsyncSendReceive(bufferBlock).Wait();
       }
    }

// Create a BroadcastBlock<double> object.
var broadcastBlock = new BroadcastBlock<double>(null);

// Post a message to the block.
broadcastBlock.Post(Math.PI);

// Receive the messages back from the block several times.
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(broadcastBlock.Receive());
}

// Create a WriteOnceBlock<string> object.
var writeOnceBlock = new WriteOnceBlock<string>(null);

// Post several messages to the block in parallel. The first 
// message to be received is written to the block. 
// Subsequent messages are discarded.
Parallel.Invoke(
   () => writeOnceBlock.Post("Message 1"),
   () => writeOnceBlock.Post("Message 2"),
   () => writeOnceBlock.Post("Message 3"));

// Receive the message from the block.
Console.WriteLine(writeOnceBlock.Receive());

// Performs several computations by using dataflow and returns the elapsed
// time required to perform the computations.
static TimeSpan TimeDataflowComputations(int maxDegreeOfParallelism,
   int messageCount)
{
   var workerBlock = new ActionBlock<int>(
      millisecondsTimeout => Thread.Sleep(millisecondsTimeout),

      // 몇개를 병렬로 실행할지 정한다.
      new ExecutionDataflowBlockOptions
      {
         MaxDegreeOfParallelism = maxDegreeOfParallelism
      });


   Stopwatch stopwatch = new Stopwatch();
   stopwatch.Start();

   for (int i = 0; i < messageCount; i++)
   {
      // 처리할 작업을 요청한다. ActionBlock을 생성할 때 인자로 넣은 함수가 실행된다.
      workerBlock.Post(1000);
   }
   // 더 이상 처리할 작업을 받지 않음을 통보
   workerBlock.Complete();

   // Completion 멤버는 Task를 반환한다. task가 완료될 때까지 대기한다
   workerBlock.Completion.Wait();

   // Stop the timer and return the elapsed number of milliseconds.
   stopwatch.Stop();
   return stopwatch.Elapsed;
}

static void Main(string[] args)
{
  int processorCount = Environment.ProcessorCount;
  int messageCount = processorCount;

  // Print the number of processors on this computer.
  Console.WriteLine("Processor count = {0}.", processorCount);

  TimeSpan elapsed;

  // Perform two dataflow computations and print the elapsed
  // time required for each.

  // This call specifies a maximum degree of parallelism of 1.
  // This causes the dataflow block to process messages serially.
  elapsed = TimeDataflowComputations(1, messageCount);
  Console.WriteLine("Degree of parallelism = {0}; message count = {1}; " +
     "elapsed time = {2}ms.", 1, messageCount, (int)elapsed.TotalMilliseconds);

  // Perform the computations again. This time, specify the number of 
  // processors as the maximum degree of parallelism. This causes
  // multiple messages to be processed in parallel.
  elapsed = TimeDataflowComputations(processorCount, messageCount);
  Console.WriteLine("Degree of parallelism = {0}; message count = {1}; " +
     "elapsed time = {2}ms.", processorCount, messageCount, (int)elapsed.TotalMilliseconds);
}

// Create an ActionBlock<int> object that prints its input
// and throws ArgumentOutOfRangeException if the input
// is less than zero.
var throwIfNegative = new ActionBlock<int>(n =>
{
   Console.WriteLine("n = {0}", n);
   if (n < 0)
   {
      throw new ArgumentOutOfRangeException();
   }
});

// Post values to the block.
throwIfNegative.Post(0);
throwIfNegative.Post(-1);
throwIfNegative.Post(1);
throwIfNegative.Post(-2);
throwIfNegative.Complete();

// Wait for completion in a try/catch block.
try
{
   throwIfNegative.Completion.Wait();
}
catch (AggregateException ae)
{
   // If an unhandled exception occurs during dataflow processing, all
   // exceptions are propagated through an AggregateException object.
   ae.Handle(e =>
   {
      Console.WriteLine("Encountered {0}: {1}", 
         e.GetType().Name, e.Message);
      return true;
   });
}

// Create an ActionBlock<int> object that prints its input
// and throws ArgumentOutOfRangeException if the input
// is less than zero.
var throwIfNegative = new ActionBlock<int>(n =>
{
   Console.WriteLine("n = {0}", n);
   if (n < 0)
   {
      throw new ArgumentOutOfRangeException();
   }
});

// Create a continuation task that prints the overall 
// task status to the console when the block finishes.
throwIfNegative.Completion.ContinueWith(task =>
{
   Console.WriteLine("The status of the completion task is '{0}'.", 
      task.Status);
});

// Post values to the block.
throwIfNegative.Post(0);
throwIfNegative.Post(-1);
throwIfNegative.Post(1);
throwIfNegative.Post(-2);
throwIfNegative.Complete();

// Wait for completion in a try/catch block.
try
{
   throwIfNegative.Completion.Wait();
}
catch (AggregateException ae)
{
   // If an unhandled exception occurs during dataflow processing, all
   // exceptions are propagated through an AggregateException object.
   ae.Handle(e =>
   {
      Console.WriteLine("Encountered {0}: {1}",
         e.GetType().Name, e.Message);
      return true;
   });
}

// Create a TransformBlock<int, double> object that 
// computes the square root of its input.
var transformBlock = new TransformBlock<int, double>(n => Math.Sqrt(n));

// Post several messages to the block.
transformBlock.Post(10);
transformBlock.Post(20);
transformBlock.Post(30);

// Read the output messages from the block.
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(transformBlock.Receive());
}

// Create a TransformManyBlock<string, char> object that splits
// a string into its individual characters.
var transformManyBlock = new TransformManyBlock<string, char>(
   s => s.ToCharArray());

// Post two messages to the first block.
transformManyBlock.Post("Hello");
transformManyBlock.Post("World");

// Receive all output values from the block.
for (int i = 0; i < ("Hello" + "World").Length; i++)
{
   Console.WriteLine(transformManyBlock.Receive());
}

// Create a BatchBlock<int> object that holds ten
// elements per batch.
var batchBlock = new BatchBlock<int>(10);

// Post several values to the block.
for (int i = 0; i < 13; i++)
{
   batchBlock.Post(i);
}
// Set the block to the completed state. This causes
// the block to propagate out any any remaining
// values as a final batch.
batchBlock.Complete();

// Print the sum of both batches.

Console.WriteLine("The sum of the elements in batch 1 is {0}.",
   batchBlock.Receive().Sum());

// 위에서 공간은 10개를 잡았는데 13개를 입력해서 여기서는 위에서 처리하지 못한 나머지 3개를 처리한다
Console.WriteLine("The sum of the elements in batch 2 is {0}.",
   batchBlock.Receive().Sum());

// Create a JoinBlock<int, int, char> object that requires
// two numbers and an operator.
var joinBlock = new JoinBlock<int, int, char>();

// Post two values to each target of the join.

joinBlock.Target1.Post(3);
joinBlock.Target1.Post(6);

joinBlock.Target2.Post(5);
joinBlock.Target2.Post(4);

joinBlock.Target3.Post('+');
joinBlock.Target3.Post('-');

// Receive each group of values and apply the operator part
// to the number parts.

for (int i = 0; i < 2; i++)
{
   var data = joinBlock.Receive();
   switch (data.Item3)
   {
      case '+':
         Console.WriteLine("{0} + {1} = {2}",
            data.Item1, data.Item2, data.Item1 + data.Item2);
         break;
      case '-':
         Console.WriteLine("{0} - {1} = {2}",
            data.Item1, data.Item2, data.Item1 - data.Item2);
         break;
      default:
         Console.WriteLine("Unknown operator '{0}'.", data.Item3);
         break;
   }
}

// For demonstration, create a Func<int, int> that  
// returns its argument, or throws ArgumentOutOfRangeException 
// if the argument is less than zero.
Func<int, int> DoWork = n =>
{
   if (n < 0)
      throw new ArgumentOutOfRangeException();
   return n;
};

// Create a BatchedJoinBlock<int, Exception> object that holds  
// seven elements per batch. 
var batchedJoinBlock = new BatchedJoinBlock<int, Exception>(7);

// Post several items to the block. 
foreach (int i in new int[] { 5, 6, -7, -22, 13, 55, 0 })
{
   try
   {
      // Post the result of the worker to the  
      // first target of the block.
      batchedJoinBlock.Target1.Post(DoWork(i));
   }
   catch (ArgumentOutOfRangeException e) 
   {
      // If an error occurred, post the Exception to the  
      // second target of the block.
      batchedJoinBlock.Target2.Post(e); 
   }
}

// Read the results from the block. 
var results = batchedJoinBlock.Receive();

// Print the results to the console. 

// Print the results. 
foreach (int n in results.Item1)
{
   Console.WriteLine(n);
}
// Print failures. 
foreach (Exception e in results.Item2)
{
   Console.WriteLine(e.Message);
}

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

// Demonstrates a basic producer and consumer pattern that uses dataflow. 
class DataflowProducerConsumer
{
   // Demonstrates the production end of the producer and consumer pattern. 
   static void Produce(ITargetBlock<byte[]> target)
   {
      // Create a Random object to generate random data.
      Random rand = new Random();

      // In a loop, fill a buffer with random data and 
      // post the buffer to the target block. 
      for (int i = 0; i < 100; i++)
      {
         // Create an array to hold random byte data. 
         byte[] buffer = new byte[1024];

         // Fill the buffer with random bytes.
         rand.NextBytes(buffer);

         // Post the result to the message block.
         target.Post(buffer);
      }

      // Set the target to the completed state to signal to the consumer 
      // that no more data will be available.
      target.Complete();
   }

   // Demonstrates the consumption end of the producer and consumer pattern. 
   static async Task<int> ConsumeAsync(ISourceBlock<byte[]> source)
   {
      // Initialize a counter to track the number of bytes that are processed. 
      int bytesProcessed = 0;

      // Read from the source buffer until the source buffer has no  
      // available output data. 
      while (await source.OutputAvailableAsync())
      {
         byte[] data = source.Receive();

         // Increment the count of bytes received.
         bytesProcessed += data.Length;
      }

      return bytesProcessed;
   }

   static void Main(string[] args)
   {
      // Create a BufferBlock<byte[]> object. This object serves as the  
      // target block for the producer and the source block for the consumer. 
      var buffer = new BufferBlock<byte[]>();

      // Start the consumer. The Consume method runs asynchronously.  
      var consumer = ConsumeAsync(buffer);

      // Post source data to the dataflow block.
      Produce(buffer);

      // Wait for the consumer to process all data.
      consumer.Wait();

      // Print the count of bytes processed to the console.
      Console.WriteLine("Processed {0} bytes.", consumer.Result);
   }
}

// Demonstrates the consumption end of the producer and consumer pattern.
static async Task<int> ConsumeAsync(IReceivableSourceBlock<byte[]> source)
{
   // Initialize a counter to track the number of bytes that are processed.
   int bytesProcessed = 0;

   // Read from the source buffer until the source buffer has no 
   // available output data.
   while (await source.OutputAvailableAsync())
   {
      byte[] data;
      while (source.TryReceive(out data))
      {
         // Increment the count of bytes received.
         bytesProcessed += data.Length;
      }
   }

   return bytesProcessed;
}

using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

// Demonstrates how to provide delegates to exectution dataflow blocks. 
class DataflowExecutionBlocks
{
   // Computes the number of zero bytes that the provided file 
   // contains. 
   static int CountBytes(string path)
   {
      byte[] buffer = new byte[1024];
      int totalZeroBytesRead = 0;
      using (var fileStream = File.OpenRead(path))
      {
         int bytesRead = 0;
         do
         {
            bytesRead = fileStream.Read(buffer, 0, buffer.Length);
            totalZeroBytesRead += buffer.Count(b => b == 0);
         } while (bytesRead > 0);
      }

      return totalZeroBytesRead;
   }

   static void Main(string[] args)
   {
      // Create a temporary file on disk. 
      string tempFile = Path.GetTempFileName();

      // Write random data to the temporary file. 
      using (var fileStream = File.OpenWrite(tempFile))
      {
         Random rand = new Random();
         byte[] buffer = new byte[1024];
         for (int i = 0; i < 512; i++)
         {
            rand.NextBytes(buffer);
            fileStream.Write(buffer, 0, buffer.Length);
         }
      }

      // Create an ActionBlock<int> object that prints to the console  
      // the number of bytes read. 
      var printResult = new ActionBlock<int>(zeroBytesRead =>
      {
         Console.WriteLine("{0} contains {1} zero bytes.",
            Path.GetFileName(tempFile), zeroBytesRead);
      });

      // Create a TransformBlock<string, int> object that calls the  
      // CountBytes function and returns its result. 
      var countBytes = new TransformBlock<string, int>(
         new Func<string, int>(CountBytes));

      // Link the TransformBlock<string, int> object to the  
      // ActionBlock<int> object.
      countBytes.LinkTo(printResult);

      // Create a continuation task that completes the ActionBlock<int> 
      // object when the TransformBlock<string, int> finishes.
      countBytes.Completion.ContinueWith(delegate { printResult.Complete(); });

      // Post the path to the temporary file to the  
      // TransformBlock<string, int> object.
      countBytes.Post(tempFile);

      // Requests completion of the TransformBlock<string, int> object.
      countBytes.Complete();

      // Wait for the ActionBlock<int> object to print the message.
      printResult.Completion.Wait();

      // Delete the temporary file.
      File.Delete(tempFile);
   }
}

// Asynchronously computes the number of zero bytes that the provided file  
// contains. 
static async Task<int> CountBytesAsync(string path)
{
   byte[] buffer = new byte[1024];
   int totalZeroBytesRead = 0;
   using (var fileStream = new FileStream(
      path, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, true))
   {
      int bytesRead = 0;
      do
      {
         // Asynchronously read from the file stream.
         bytesRead = await fileStream.ReadAsync(buffer, 0, buffer.Length);
         totalZeroBytesRead += buffer.Count(b => b == 0);
      } while (bytesRead > 0);
   }

   return totalZeroBytesRead;
}

// Create a TransformBlock<string, int> object that calls the  
// CountBytes function and returns its result. 
var countBytesAsync = new TransformBlock<string, int>(async path =>
{
   byte[] buffer = new byte[1024];
   int totalZeroBytesRead = 0;
   using (var fileStream = new FileStream(
      path, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, true))
   {
      int bytesRead = 0;
      do
      {
         // Asynchronously read from the file stream.
         bytesRead = await fileStream.ReadAsync(buffer, 0, buffer.Length);
         totalZeroBytesRead += buffer.Count(b => b == 0);
      } while (bytesRead > 0);
   }

   return totalZeroBytesRead;
});

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks.Dataflow;

// Demonstrates how to specify the maximum degree of parallelism  
// when using dataflow. 
class Program
{
   // Performs several computations by using dataflow and returns the elapsed 
   // time required to perform the computations. 
   static TimeSpan TimeDataflowComputations(int maxDegreeOfParallelism,
      int messageCount)
   {
      // Create an ActionBlock<int> that performs some work. 
      var workerBlock = new ActionBlock<int>(
         // Simulate work by suspending the current thread.
         millisecondsTimeout => Thread.Sleep(millisecondsTimeout),
         // Specify a maximum degree of parallelism. 
         new ExecutionDataflowBlockOptions
         {
            MaxDegreeOfParallelism = maxDegreeOfParallelism
         });

      // Compute the time that it takes for several messages to  
      // flow through the dataflow block.

      Stopwatch stopwatch = new Stopwatch();
      stopwatch.Start();

      for (int i = 0; i < messageCount; i++)
      {
         workerBlock.Post(1000);
      }
      workerBlock.Complete();

      // Wait for all messages to propagate through the network.
      workerBlock.Completion.Wait();

      // Stop the timer and return the elapsed number of milliseconds.
      stopwatch.Stop();
      return stopwatch.Elapsed;
   }
   static void Main(string[] args)
   {
      int processorCount = Environment.ProcessorCount;
      int messageCount = processorCount;

      // Print the number of processors on this computer.
      Console.WriteLine("Processor count = {0}.", processorCount);

      TimeSpan elapsed;

      // Perform two dataflow computations and print the elapsed 
      // time required for each. 

      // This call specifies a maximum degree of parallelism of 1. 
      // This causes the dataflow block to process messages serially.
      elapsed = TimeDataflowComputations(1, messageCount);
      Console.WriteLine("Degree of parallelism = {0}; message count = {1}; " +
         "elapsed time = {2}ms.", 1, messageCount, (int)elapsed.TotalMilliseconds);

      // Perform the computations again. This time, specify the number of  
      // processors as the maximum degree of parallelism. This causes 
      // multiple messages to be processed in parallel.
      elapsed = TimeDataflowComputations(processorCount, messageCount);
      Console.WriteLine("Degree of parallelism = {0}; message count = {1}; " +
         "elapsed time = {2}ms.", processorCount, messageCount, (int)elapsed.TotalMilliseconds);
   }
}

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
using System.Windows.Forms;

namespace WriterReadersWinForms
{
   public partial class Form1 : Form
   {
      // Broadcasts values to an ActionBlock<int> object that is associated 
      // with each check box.
      BroadcastBlock<int> broadcaster = new BroadcastBlock<int>(null);

      public Form1()
      {         
         InitializeComponent();


         // Create an ActionBlock<CheckBox> object that toggles the state 
         // of CheckBox objects. 
         // Specifying the current synchronization context enables the  
         // action to run on the user-interface thread. 
         var toggleCheckBox = new ActionBlock<CheckBox>(checkBox =>
         {
            checkBox.Checked = !checkBox.Checked;
         }, 
         new ExecutionDataflowBlockOptions
         {
            TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext()  // UI 스레드에서 ActionBlock을 실행되도록 설정
         });

         // Create a ConcurrentExclusiveSchedulerPair object. 
         // Readers will run on the concurrent part of the scheduler pair. 
         // The writer will run on the exclusive part of the scheduler pair. 
         var taskSchedulerPair = new ConcurrentExclusiveSchedulerPair();

         // Create an ActionBlock<int> object for each reader CheckBox object. 
         // Each ActionBlock<int> object represents an action that can read  
         // from a resource in parallel to other readers. 
         // Specifying the concurrent part of the scheduler pair enables the  
         // reader to run in parallel to other actions that are managed by  
         // that scheduler. 
         var readerActions = 
            from checkBox in new CheckBox[] {checkBox1, checkBox2, checkBox3}
            select new ActionBlock<int>(milliseconds =>
            {
               // Toggle the check box to the checked state.
               toggleCheckBox.Post(checkBox);

               // Perform the read action. For demonstration, suspend the current 
               // thread to simulate a lengthy read operation.
               Thread.Sleep(milliseconds);

               // Toggle the check box to the unchecked state.
               toggleCheckBox.Post(checkBox);
            },
            new ExecutionDataflowBlockOptions
            {
               TaskScheduler = taskSchedulerPair.ConcurrentScheduler  // 현재의 스레드에서 실행되도록
            });

         // Create an ActionBlock<int> object for the writer CheckBox object. 
         // This ActionBlock<int> object represents an action that writes to  
         // a resource, but cannot run in parallel to readers. 
         // Specifying the exclusive part of the scheduler pair enables the  
         // writer to run in exclusively with respect to other actions that are  
         // managed by the scheduler pair. 
         var writerAction = new ActionBlock<int>(milliseconds =>
         {
            // Toggle the check box to the checked state.
            toggleCheckBox.Post(checkBox4);

            // Perform the write action. For demonstration, suspend the current 
            // thread to simulate a lengthy write operation.
            Thread.Sleep(milliseconds);

            // Toggle the check box to the unchecked state.
            toggleCheckBox.Post(checkBox4);
         },
         new ExecutionDataflowBlockOptions
         {
            TaskScheduler = taskSchedulerPair.ExclusiveScheduler  // 다른 스레드에서 실행되도록 
         });

         // Link the broadcaster to each reader and writer block. 
         // The BroadcastBlock<T> class propagates values that it  
         // receives to all connected targets. 
         foreach (var readerAction in readerActions)
         {
            broadcaster.LinkTo(readerAction);
         }
         broadcaster.LinkTo(writerAction);

         // Start the timer.
         timer1.Start();
      }

      // Event handler for the timer. 
      private void timer1_Tick(object sender, EventArgs e)
      {
         // Post a value to the broadcaster. The broadcaster 
         // sends this message to each target. 
         broadcaster.Post(1000);
      }
   }
}

static TimeSpan TimeDataflowComputations(int maxDegreeOfParallelism, int messageCount)
{
    var workerBlock = new ActionBlock<int>(
       millisecondsTimeout => { Thread.Sleep(millisecondsTimeout); 
                                 Console.WriteLine("process workerBlock      : {0}.", DateTime.Now.Ticks); },

       // 몇개를 병렬로 실행할지 정한다.
       new ExecutionDataflowBlockOptions
       {
           MaxDegreeOfParallelism = maxDegreeOfParallelism
       });


    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();

    for (int i = 0; i < messageCount; i++)
    {
        // 처리할 작업을 요청한다. ActionBlock을 생성할 때 인자로 넣은 함수가 실행된다.
        Console.WriteLine("Call workerBlock.Post       : {0}.", DateTime.Now.Ticks);
        workerBlock.Post(1000);
    }

    int DelayMillisecond = 2000;
    Console.WriteLine("딜레이 {0}밀리세컨드       : {1}.", DelayMillisecond, DateTime.Now.Ticks);
    Thread.Sleep(DelayMillisecond);

    // 더 이상 처리할 작업을 받지 않음을 통보
    Console.WriteLine("Call workerBlock.Complete   : {0}.", DateTime.Now.Ticks);
    workerBlock.Complete();

    // Completion 멤버는 Task를 반환한다. task가 완료될 때까지 대기한다
    Console.WriteLine("Call workerBlock.Completion : {0}.", DateTime.Now.Ticks);
    workerBlock.Completion.Wait();

    // Stop the timer and return the elapsed number of milliseconds.
    stopwatch.Stop();
    return stopwatch.Elapsed;
}

static void Main(string[] args)
{
    int processorCount = Environment.ProcessorCount;
    int messageCount = processorCount;

    Console.WriteLine("Processor count = {0}.", processorCount);

    TimeSpan elapsed;

    elapsed = TimeDataflowComputations(1, messageCount);
    Console.WriteLine("Degree of parallelism = {0}; message count = {1}; " +
       "elapsed time = {2}ms.", 1, messageCount, (int)elapsed.TotalMilliseconds);
}

static TimeSpan TimeDataflowComputations(int maxDegreeOfParallelism, int messageCount)
{
    var workerBlock = new ActionBlock<int>(
       millisecondsTimeout => { Thread.Sleep(millisecondsTimeout); 
                                 Console.WriteLine("process workerBlock      : {0}.", DateTime.Now.Ticks); },

       // 몇개를 병렬로 실행할지 정한다.
       new ExecutionDataflowBlockOptions
       {
           MaxDegreeOfParallelism = maxDegreeOfParallelism
       });


    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();

    for (int i = 0; i < messageCount; i++)
    {
        var bResult = workerBlock.Post(1000);
        Console.WriteLine("Call workerBlock.Post       : {0}, Result:{1}", DateTime.Now.Ticks, bResult);
    }

    int DelayMillisecond = 2000;
    Console.WriteLine("딜레이 {0}밀리세컨드       : {1}.", DelayMillisecond, DateTime.Now.Ticks);
    Thread.Sleep(DelayMillisecond);

    // 더 이상 처리할 작업을 받지 않음을 통보
    Console.WriteLine("Call workerBlock.Complete   : {0}.", DateTime.Now.Ticks);
    workerBlock.Complete();

    // Completion 멤버는 Task를 반환한다. task가 완료될 때까지 대기한다
    Console.WriteLine("Call workerBlock.Completion : {0}.", DateTime.Now.Ticks);
    workerBlock.Completion.Wait();
    Console.WriteLine("End workerBlock.Completion : {0}.", DateTime.Now.Ticks);


    // 다시 한번 더
    Console.WriteLine("");
    Console.WriteLine("다시 한번 더 !!!       : {0}.", DateTime.Now.Ticks);

    for (int i = 0; i < messageCount; i++)
    {
        var bResult = workerBlock.Post(1000);
        Console.WriteLine("Call workerBlock.Post       : {0}, Result:{1}", DateTime.Now.Ticks, bResult);
    }

    DelayMillisecond = 2000;
    Console.WriteLine("딜레이 {0}밀리세컨드       : {1}.", DelayMillisecond, DateTime.Now.Ticks);
    Thread.Sleep(DelayMillisecond);

    // 더 이상 처리할 작업을 받지 않음을 통보
    Console.WriteLine("Call workerBlock.Complete   : {0}.", DateTime.Now.Ticks);
    workerBlock.Complete();

    // Completion 멤버는 Task를 반환한다. task가 완료될 때까지 대기한다
    Console.WriteLine("Call workerBlock.Completion : {0}.", DateTime.Now.Ticks);
    workerBlock.Completion.Wait();
    Console.WriteLine("End workerBlock.Completion : {0}.", DateTime.Now.Ticks);

    stopwatch.Stop();
    return stopwatch.Elapsed;
}

static void Main(string[] args)
{
    int processorCount = Environment.ProcessorCount;
    int messageCount = processorCount;

    Console.WriteLine("Processor count = {0}.", processorCount);

    TimeSpan elapsed;

    elapsed = TimeDataflowComputations(1, messageCount);
    Console.WriteLine("Degree of parallelism = {0}; message count = {1}; " +
       "elapsed time = {2}ms.", 1, messageCount, (int)elapsed.TotalMilliseconds);
}