다음을 통해 공유

연습: Windows Forms 애플리케이션에서 데이터 흐름 사용

이 문서에서는 Windows Forms 애플리케이션에서 이미지 처리를 수행하는 데이터 흐름 블록 네트워크를 만드는 방법을 보여 줍니다.

이 예제는 지정된 폴더에서 이미지 파일을 로드하고 합성 이미지를 만들어 결과를 표시합니다. 이 예제에서는 네트워크를 통해 이미지를 라우팅하는 데 데이터 흐름 모델을 사용합니다. 데이터 흐름 모델에서는, 프로그램의 개별 구성 요소가 메시지를 전달하여 서로 통신합니다. 구성 요소가 메시지를 받으면 어떤 작업을 수행한 후 결과를 다른 구성 요소에 전달합니다. 이를 애플리케이션에서 제어 구조(예 : 조건 문, 루프 등)를 사용하는 제어 흐름 모델과 비교하여 프로그램에서 작업 순서를 제어합니다.

사전 요구 사항

이 연습을 시작하기 전에 데이터 흐름을 읽어 보세요.

참고

TPL 데이터 흐름 라이브러리(System.Threading.Tasks.Dataflow 네임스페이스)는 .NET과 함께 배포되지 않습니다. Visual Studio에서 System.Threading.Tasks.Dataflow 네임스페이스를 설치하려면 프로젝트를 열고, 프로젝트 메뉴에서 NuGet 패키지 관리를 선택한 후, System.Threading.Tasks.Dataflow 패키지를 온라인으로 검색합니다. 또는 .NET Core CLI를 사용하여 설치하려면 dotnet add package System.Threading.Tasks.Dataflow를 실행합니다.

섹션

이 연습에는 다음과 같은 섹션이 있습니다.

Windows Forms 애플리케이션 만들기

이 섹션에서는 기본 Windows Forms 애플리케이션을 만들고 기본 폼에 컨트롤을 추가하는 방법을 설명합니다.

Windows Forms 애플리케이션을 만들려면

  1. Visual Studio에서 Visual C# 또는 Visual Basic Windows Forms 애플리케이션 프로젝트를 만듭니다. 이 문서에서 프로젝트 이름은 CompositeImages입니다.

  2. 기본 폼인 Form1.cs(Visual Basic에서는 Form1.vb)의 폼 디자이너에서 ToolStrip 컨트롤을 추가합니다.

  3. ToolStripButton 컨트롤을 ToolStrip 컨트롤에 추가합니다. DisplayStyle 속성을 Text로 설정하고 Text 속성을 폴더 선택으로 설정합니다.

  4. 두 번째 ToolStripButton 컨트롤을 ToolStrip 컨트롤에 추가합니다. DisplayStyle 속성을 Text로 설정하고, Text 속성을 취소로 설정하고, Enabled 속성을 False로 설정합니다.

  5. 기본 폼에 PictureBox 개체를 추가합니다. Dock 속성을 Fill로 설정합니다.

데이터 흐름 네트워크 만들기

이 섹션에서는 이미지 처리를 수행하는 데이터 흐름 네트워크를 만드는 방법을 설명합니다.

데이터 흐름 네트워크를 만들려면

  1. 프로젝트에 System.Threading.Tasks.Dataflow.dll에 대한 참조를 추가합니다.

  2. Form1.cs(Visual Basic에서는 Form1.vb)에 다음 using(Visual Basic에서는 Using) 명령문이 포함되어 있는지 확인합니다.

    using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
using System.Windows.Forms;

  3. Form1 클래스에 다음 데이터 멤버를 추가합니다.

    // The head of the dataflow network.
ITargetBlock<string> headBlock = null;

// Enables the user interface to signal cancellation to the network.
CancellationTokenSource cancellationTokenSource;

  4. 다음 CreateImageProcessingNetwork 메서드를 Form1 클래스에 추가합니다. 이 메서드는 이미지 처리 네트워크를 만듭니다.

    // Creates the image processing dataflow network and returns the
// head node of the network.
ITargetBlock<string> CreateImageProcessingNetwork()
{
   //
   // Create the dataflow blocks that form the network.
   //

   // Create a dataflow block that takes a folder path as input
   // and returns a collection of Bitmap objects.
   var loadBitmaps = new TransformBlock<string, IEnumerable<Bitmap>>(path =>
      {
         try
         {
            return LoadBitmaps(path);
         }
         catch (OperationCanceledException)
         {
            // Handle cancellation by passing the empty collection
            // to the next stage of the network.
            return Enumerable.Empty<Bitmap>();
         }
      });

   // Create a dataflow block that takes a collection of Bitmap objects
   // and returns a single composite bitmap.
   var createCompositeBitmap = new TransformBlock<IEnumerable<Bitmap>, Bitmap>(bitmaps =>
      {
         try
         {
            return CreateCompositeBitmap(bitmaps);
         }
         catch (OperationCanceledException)
         {
            // Handle cancellation by passing null to the next stage
            // of the network.
            return null;
         }
      });

   // Create a dataflow block that displays the provided bitmap on the form.
   var displayCompositeBitmap = new ActionBlock<Bitmap>(bitmap =>
      {
         // Display the bitmap.
         pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
         pictureBox1.Image = bitmap;

         // Enable the user to select another folder.
         toolStripButton1.Enabled = true;
         toolStripButton2.Enabled = false;
         Cursor = DefaultCursor;
      },
      // Specify a task scheduler from the current synchronization context
      // so that the action runs on the UI thread.
      new ExecutionDataflowBlockOptions
      {
          TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext()
      });

   // Create a dataflow block that responds to a cancellation request by
   // displaying an image to indicate that the operation is cancelled and
   // enables the user to select another folder.
   var operationCancelled = new ActionBlock<object>(delegate
      {
         // Display the error image to indicate that the operation
         // was cancelled.
         pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
         pictureBox1.Image = pictureBox1.ErrorImage;

         // Enable the user to select another folder.
         toolStripButton1.Enabled = true;
         toolStripButton2.Enabled = false;
         Cursor = DefaultCursor;
      },
      // Specify a task scheduler from the current synchronization context
      // so that the action runs on the UI thread.
      new ExecutionDataflowBlockOptions
      {
         TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext()
      });

   //
   // Connect the network.
   //

   // Link loadBitmaps to createCompositeBitmap.
   // The provided predicate ensures that createCompositeBitmap accepts the
   // collection of bitmaps only if that collection has at least one member.
   loadBitmaps.LinkTo(createCompositeBitmap, bitmaps => bitmaps.Count() > 0);

   // Also link loadBitmaps to operationCancelled.
   // When createCompositeBitmap rejects the message, loadBitmaps
   // offers the message to operationCancelled.
   // operationCancelled accepts all messages because we do not provide a
   // predicate.
   loadBitmaps.LinkTo(operationCancelled);

   // Link createCompositeBitmap to displayCompositeBitmap.
   // The provided predicate ensures that displayCompositeBitmap accepts the
   // bitmap only if it is non-null.
   createCompositeBitmap.LinkTo(displayCompositeBitmap, bitmap => bitmap != null);

   // Also link createCompositeBitmap to operationCancelled.
   // When displayCompositeBitmap rejects the message, createCompositeBitmap
   // offers the message to operationCancelled.
   // operationCancelled accepts all messages because we do not provide a
   // predicate.
   createCompositeBitmap.LinkTo(operationCancelled);

   // Return the head of the network.
   return loadBitmaps;
}

  5. LoadBitmaps 메서드를 구현합니다.

    // Loads all bitmap files that exist at the provided path.
IEnumerable<Bitmap> LoadBitmaps(string path)
{
   List<Bitmap> bitmaps = new List<Bitmap>();

   // Load a variety of image types.
   foreach (string bitmapType in
      new string[] { "*.bmp", "*.gif", "*.jpg", "*.png", "*.tif" })
   {
      // Load each bitmap for the current extension.
      foreach (string fileName in Directory.GetFiles(path, bitmapType))
      {
         // Throw OperationCanceledException if cancellation is requested.
         cancellationTokenSource.Token.ThrowIfCancellationRequested();

         try
         {
            // Add the Bitmap object to the collection.
            bitmaps.Add(new Bitmap(fileName));
         }
         catch (Exception)
         {
            // TODO: A complete application might handle the error.
         }
      }
   }
   return bitmaps;
}

  6. CreateCompositeBitmap 메서드를 구현합니다.

    // Creates a composite bitmap from the provided collection of Bitmap objects.
// This method computes the average color of each pixel among all bitmaps
// to create the composite image.
Bitmap CreateCompositeBitmap(IEnumerable<Bitmap> bitmaps)
{
   Bitmap[] bitmapArray = bitmaps.ToArray();

   // Compute the maximum width and height components of all
   // bitmaps in the collection.
   Rectangle largest = new Rectangle();
   foreach (var bitmap in bitmapArray)
   {
      if (bitmap.Width > largest.Width)
         largest.Width = bitmap.Width;
      if (bitmap.Height > largest.Height)
         largest.Height = bitmap.Height;
   }

   // Create a 32-bit Bitmap object with the greatest dimensions.
   Bitmap result = new Bitmap(largest.Width, largest.Height,
      PixelFormat.Format32bppArgb);

   // Lock the result Bitmap.
   var resultBitmapData = result.LockBits(
      new Rectangle(new Point(), result.Size), ImageLockMode.WriteOnly,
      result.PixelFormat);

   // Lock each source bitmap to create a parallel list of BitmapData objects.
   var bitmapDataList = (from bitmap in bitmapArray
                         select bitmap.LockBits(
                           new Rectangle(new Point(), bitmap.Size),
                           ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb))
                        .ToList();

   // Compute each column in parallel.
   Parallel.For(0, largest.Width, new ParallelOptions
   {
      CancellationToken = cancellationTokenSource.Token
   },
   i =>
   {
      // Compute each row.
      for (int j = 0; j < largest.Height; j++)
      {
         // Counts the number of bitmaps whose dimensions
         // contain the current location.
         int count = 0;

         // The sum of all alpha, red, green, and blue components.
         int a = 0, r = 0, g = 0, b = 0;

         // For each bitmap, compute the sum of all color components.
         foreach (var bitmapData in bitmapDataList)
         {
            // Ensure that we stay within the bounds of the image.
            if (bitmapData.Width > i && bitmapData.Height > j)
            {
               unsafe
               {
                  byte* row = (byte*)(bitmapData.Scan0 + (j * bitmapData.Stride));
                  byte* pix = (byte*)(row + (4 * i));
                  a += *pix; pix++;
                  r += *pix; pix++;
                  g += *pix; pix++;
                  b += *pix;
               }
               count++;
            }
         }

         //prevent divide by zero in bottom right pixelless corner
         if (count == 0)
             break;

         unsafe
         {
            // Compute the average of each color component.
            a /= count;
            r /= count;
            g /= count;
            b /= count;

            // Set the result pixel.
            byte* row = (byte*)(resultBitmapData.Scan0 + (j * resultBitmapData.Stride));
            byte* pix = (byte*)(row + (4 * i));
            *pix = (byte)a; pix++;
            *pix = (byte)r; pix++;
            *pix = (byte)g; pix++;
            *pix = (byte)b;
         }
      }
   });

   // Unlock the source bitmaps.
   for (int i = 0; i < bitmapArray.Length; i++)
   {
      bitmapArray[i].UnlockBits(bitmapDataList[i]);
   }

   // Unlock the result bitmap.
   result.UnlockBits(resultBitmapData);

   // Return the result.
   return result;
}

    참고

    CreateCompositeBitmap 메서드의 C# 버전에서는 포인터를 사용하여 System.Drawing.Bitmap 개체를 효율적으로 처리할 수 있습니다. 따라서 unsafe 키워드를 사용하려면 프로젝트에서 안전하지 않은 코드 허용 옵션을 사용하도록 설정해야 합니다. Visual C# 프로젝트에서 안전하지 않은 코드를 사용하는 방법에 대한 자세한 내용은 빌드 페이지, 프로젝트 디자이너(C#)를 참조하세요.

다음 표에서는 네트워크의 멤버를 설명합니다.

멤버 형식 Description
loadBitmaps TransformBlock<TInput,TOutput> 폴더 경로를 입력으로 사용하고 Bitmap 개체 컬렉션을 출력으로 생성합니다.
createCompositeBitmap TransformBlock<TInput,TOutput> Bitmap 개체 컬렉션을 입력으로 사용하고 복합 비트맵을 출력으로 생성합니다.
displayCompositeBitmap ActionBlock<TInput> 폼에 복합 비트맵을 표시합니다.
operationCancelled ActionBlock<TInput> 작업이 취소되었고 사용자가 다른 폴더를 선택할 수 있음을 나타내는 이미지를 표시합니다.

이 예제에서는 데이터 흐름 블록을 폼에 연결하기 위해 네트워크가 LinkTo 메서드를 사용합니다. LinkTo 메서드에는 대상 블록이 메시지를 허용 또는 거부하는지 여부를 결정하는 Predicate<T> 개체를 사용하는 오버로드된 버전이 포함되어 있습니다. 이 필터링 메커니즘을 통해 메시지 블록은 특정 값만 받을 수 있습니다. 이 예제에서는 네트워크가 두 방법 중 하나로 분기할 수 있습니다. 주 분기에서는 디스크에서 이미지를 로드하고 복합 이미지를 만들고 폼에 이미지를 표시합니다. 대체 분기는 현재 작업을 취소합니다. Predicate<T> 개체를 사용하면 주 분기를 따르는 데이터 흐름 블록이 특정 메시지를 거부하여 대체 분기로 전환할 수 있습니다. 예를 들어 사용자가 작업을 취소하면 데이터 흐름 블록 createCompositeBitmap은 출력으로 null(Visual Basic에서는 Nothing)을 생성합니다. 데이터 흐름 블록 displayCompositeBitmap은 null 입력 값을 거부하므로 메시지가 operationCancelled에 제공됩니다. 데이터 흐름 블록 operationCancelled은 모든 메시지를 수락하므로 작업이 취소됨을 나타내는 이미지를 표시합니다.

다음 그림에서는 이미지 처리 네트워크를 보여줍니다.

이미지 처리 네트워크를 보여주는 그림

displayCompositeBitmap 및 operationCancelled 데이터 흐름 블록이 사용자 인터페이스에서 동작하기 때문에 이러한 작업은 사용자 인터페이스 스레드에서 발생해야 합니다. 이를 위해 생성 중에 이러한 개체는 각각 속성이 로 ExecutionDataflowBlockOptions 설정된 개체를 TaskSchedulerTaskScheduler.FromCurrentSynchronizationContext제공합니다. TaskScheduler.FromCurrentSynchronizationContext 메서드는 현재 동기화 컨텍스트에서 작업을 수행하는 TaskScheduler 개체를 만듭니다. CreateImageProcessingNetwork 메서드가 사용자 인터페이스 스레드에서 실행되는 폴더 선택 단추 처리기에서 호출되기 때문에 displayCompositeBitmap 및 operationCancelled 데이터 흐름 블록에 대한 작업도 사용자 인터페이스 스레드에서 실행됩니다.

이 예제에서는 CancellationToken 속성이 데이터 흐름 블록 실행을 영구적으로 취소하므로 CancellationToken 속성을 설정하는 대신, 공유된 취소 토큰을 사용합니다. 이 예제에서는 취소 토큰을 통해 사용자가 하나 이상의 작업을 취소한 경우에도, 동일한 데이터 흐름 네트워크를 여러 번 재사용할 수 있습니다. CancellationToken를 사용하여 데이터 흐름 블록 실행을 영구적으로 취소하는 예제를 보려면 방법: 데이터 흐름 블록 취소를 참조하세요.

사용자 인터페이스에 데이터 흐름 네트워크 연결

이 섹션에서는 사용자 인터페이스에 데이터 흐름 네트워크를 연결하는 방법에 대해 설명합니다. 복합 이미지 생성 및 작업 취소는 폴더 선택 및 취소 단추에서 시작됩니다. 사용자가 이러한 단추 중 하나를 선택하면 해당 작업이 비동기식으로 시작됩니다.

사용자 인터페이스에 데이터 흐름 네트워크를 연결하려면

  1. 기본 폼의 폼 디자이너에서 폴더 선택 단추에 대한 Click 이벤트의 이벤트 처리기를 만듭니다.

  2. 폴더 선택 단추에 대한 Click 이벤트를 구현합니다.

    // Event handler for the Choose Folder button.
private void toolStripButton1_Click(object sender, EventArgs e)
{
   // Create a FolderBrowserDialog object to enable the user to
   // select a folder.
   FolderBrowserDialog dlg = new FolderBrowserDialog
   {
      ShowNewFolderButton = false
   };

   // Set the selected path to the common Sample Pictures folder
   // if it exists.
   string initialDirectory = Path.Combine(
      Environment.GetFolderPath(Environment.SpecialFolder.CommonPictures),
      "Sample Pictures");
   if (Directory.Exists(initialDirectory))
   {
      dlg.SelectedPath = initialDirectory;
   }

   // Show the dialog and process the dataflow network.
   if (dlg.ShowDialog() == DialogResult.OK)
   {
      // Create a new CancellationTokenSource object to enable
      // cancellation.
      cancellationTokenSource = new CancellationTokenSource();

      // Create the image processing network if needed.
      headBlock ??= CreateImageProcessingNetwork();

      // Post the selected path to the network.
      headBlock.Post(dlg.SelectedPath);

      // Enable the Cancel button and disable the Choose Folder button.
      toolStripButton1.Enabled = false;
      toolStripButton2.Enabled = true;

      // Show a wait cursor.
      Cursor = Cursors.WaitCursor;
   }
}

  3. 기본 폼의 폼 디자이너에서 취소 단추에 대한 Click 이벤트의 이벤트 처리기를 만듭니다.

  4. 취소 단추에 대한 Click 이벤트를 구현합니다.

    // Event handler for the Cancel button.
private void toolStripButton2_Click(object sender, EventArgs e)
{
   // Signal the request for cancellation. The current component of
   // the dataflow network will respond to the cancellation request.
   cancellationTokenSource.Cancel();
}

전체 예제

다음 예제에서는 이 연습의 전체 코드를 보여 줍니다.

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
using System.Windows.Forms;

namespace CompositeImages
{
   public partial class Form1 : Form
   {
      // The head of the dataflow network.
      ITargetBlock<string> headBlock = null;

      // Enables the user interface to signal cancellation to the network.
      CancellationTokenSource cancellationTokenSource;

      public Form1()
      {
         InitializeComponent();
      }

      // Creates the image processing dataflow network and returns the
      // head node of the network.
      ITargetBlock<string> CreateImageProcessingNetwork()
      {
         //
         // Create the dataflow blocks that form the network.
         //

         // Create a dataflow block that takes a folder path as input
         // and returns a collection of Bitmap objects.
         var loadBitmaps = new TransformBlock<string, IEnumerable<Bitmap>>(path =>
            {
               try
               {
                  return LoadBitmaps(path);
               }
               catch (OperationCanceledException)
               {
                  // Handle cancellation by passing the empty collection
                  // to the next stage of the network.
                  return Enumerable.Empty<Bitmap>();
               }
            });

         // Create a dataflow block that takes a collection of Bitmap objects
         // and returns a single composite bitmap.
         var createCompositeBitmap = new TransformBlock<IEnumerable<Bitmap>, Bitmap>(bitmaps =>
            {
               try
               {
                  return CreateCompositeBitmap(bitmaps);
               }
               catch (OperationCanceledException)
               {
                  // Handle cancellation by passing null to the next stage
                  // of the network.
                  return null;
               }
            });

         // Create a dataflow block that displays the provided bitmap on the form.
         var displayCompositeBitmap = new ActionBlock<Bitmap>(bitmap =>
            {
               // Display the bitmap.
               pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
               pictureBox1.Image = bitmap;

               // Enable the user to select another folder.
               toolStripButton1.Enabled = true;
               toolStripButton2.Enabled = false;
               Cursor = DefaultCursor;
            },
            // Specify a task scheduler from the current synchronization context
            // so that the action runs on the UI thread.
            new ExecutionDataflowBlockOptions
            {
                TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext()
            });

         // Create a dataflow block that responds to a cancellation request by
         // displaying an image to indicate that the operation is cancelled and
         // enables the user to select another folder.
         var operationCancelled = new ActionBlock<object>(delegate
            {
               // Display the error image to indicate that the operation
               // was cancelled.
               pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
               pictureBox1.Image = pictureBox1.ErrorImage;

               // Enable the user to select another folder.
               toolStripButton1.Enabled = true;
               toolStripButton2.Enabled = false;
               Cursor = DefaultCursor;
            },
            // Specify a task scheduler from the current synchronization context
            // so that the action runs on the UI thread.
            new ExecutionDataflowBlockOptions
            {
               TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext()
            });

         //
         // Connect the network.
         //

         // Link loadBitmaps to createCompositeBitmap.
         // The provided predicate ensures that createCompositeBitmap accepts the
         // collection of bitmaps only if that collection has at least one member.
         loadBitmaps.LinkTo(createCompositeBitmap, bitmaps => bitmaps.Count() > 0);

         // Also link loadBitmaps to operationCancelled.
         // When createCompositeBitmap rejects the message, loadBitmaps
         // offers the message to operationCancelled.
         // operationCancelled accepts all messages because we do not provide a
         // predicate.
         loadBitmaps.LinkTo(operationCancelled);

         // Link createCompositeBitmap to displayCompositeBitmap.
         // The provided predicate ensures that displayCompositeBitmap accepts the
         // bitmap only if it is non-null.
         createCompositeBitmap.LinkTo(displayCompositeBitmap, bitmap => bitmap != null);

         // Also link createCompositeBitmap to operationCancelled.
         // When displayCompositeBitmap rejects the message, createCompositeBitmap
         // offers the message to operationCancelled.
         // operationCancelled accepts all messages because we do not provide a
         // predicate.
         createCompositeBitmap.LinkTo(operationCancelled);

         // Return the head of the network.
         return loadBitmaps;
      }

      // Loads all bitmap files that exist at the provided path.
      IEnumerable<Bitmap> LoadBitmaps(string path)
      {
         List<Bitmap> bitmaps = new List<Bitmap>();

         // Load a variety of image types.
         foreach (string bitmapType in
            new string[] { "*.bmp", "*.gif", "*.jpg", "*.png", "*.tif" })
         {
            // Load each bitmap for the current extension.
            foreach (string fileName in Directory.GetFiles(path, bitmapType))
            {
               // Throw OperationCanceledException if cancellation is requested.
               cancellationTokenSource.Token.ThrowIfCancellationRequested();

               try
               {
                  // Add the Bitmap object to the collection.
                  bitmaps.Add(new Bitmap(fileName));
               }
               catch (Exception)
               {
                  // TODO: A complete application might handle the error.
               }
            }
         }
         return bitmaps;
      }

      // Creates a composite bitmap from the provided collection of Bitmap objects.
      // This method computes the average color of each pixel among all bitmaps
      // to create the composite image.
      Bitmap CreateCompositeBitmap(IEnumerable<Bitmap> bitmaps)
      {
         Bitmap[] bitmapArray = bitmaps.ToArray();

         // Compute the maximum width and height components of all
         // bitmaps in the collection.
         Rectangle largest = new Rectangle();
         foreach (var bitmap in bitmapArray)
         {
            if (bitmap.Width > largest.Width)
               largest.Width = bitmap.Width;
            if (bitmap.Height > largest.Height)
               largest.Height = bitmap.Height;
         }

         // Create a 32-bit Bitmap object with the greatest dimensions.
         Bitmap result = new Bitmap(largest.Width, largest.Height,
            PixelFormat.Format32bppArgb);

         // Lock the result Bitmap.
         var resultBitmapData = result.LockBits(
            new Rectangle(new Point(), result.Size), ImageLockMode.WriteOnly,
            result.PixelFormat);

         // Lock each source bitmap to create a parallel list of BitmapData objects.
         var bitmapDataList = (from bitmap in bitmapArray
                               select bitmap.LockBits(
                                 new Rectangle(new Point(), bitmap.Size),
                                 ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb))
                              .ToList();

         // Compute each column in parallel.
         Parallel.For(0, largest.Width, new ParallelOptions
         {
            CancellationToken = cancellationTokenSource.Token
         },
         i =>
         {
            // Compute each row.
            for (int j = 0; j < largest.Height; j++)
            {
               // Counts the number of bitmaps whose dimensions
               // contain the current location.
               int count = 0;

               // The sum of all alpha, red, green, and blue components.
               int a = 0, r = 0, g = 0, b = 0;

               // For each bitmap, compute the sum of all color components.
               foreach (var bitmapData in bitmapDataList)
               {
                  // Ensure that we stay within the bounds of the image.
                  if (bitmapData.Width > i && bitmapData.Height > j)
                  {
                     unsafe
                     {
                        byte* row = (byte*)(bitmapData.Scan0 + (j * bitmapData.Stride));
                        byte* pix = (byte*)(row + (4 * i));
                        a += *pix; pix++;
                        r += *pix; pix++;
                        g += *pix; pix++;
                        b += *pix;
                     }
                     count++;
                  }
               }

               //prevent divide by zero in bottom right pixelless corner
               if (count == 0)
                   break;

               unsafe
               {
                  // Compute the average of each color component.
                  a /= count;
                  r /= count;
                  g /= count;
                  b /= count;

                  // Set the result pixel.
                  byte* row = (byte*)(resultBitmapData.Scan0 + (j * resultBitmapData.Stride));
                  byte* pix = (byte*)(row + (4 * i));
                  *pix = (byte)a; pix++;
                  *pix = (byte)r; pix++;
                  *pix = (byte)g; pix++;
                  *pix = (byte)b;
               }
            }
         });

         // Unlock the source bitmaps.
         for (int i = 0; i < bitmapArray.Length; i++)
         {
            bitmapArray[i].UnlockBits(bitmapDataList[i]);
         }

         // Unlock the result bitmap.
         result.UnlockBits(resultBitmapData);

         // Return the result.
         return result;
      }

      // Event handler for the Choose Folder button.
      private void toolStripButton1_Click(object sender, EventArgs e)
      {
         // Create a FolderBrowserDialog object to enable the user to
         // select a folder.
         FolderBrowserDialog dlg = new FolderBrowserDialog
         {
            ShowNewFolderButton = false
         };

         // Set the selected path to the common Sample Pictures folder
         // if it exists.
         string initialDirectory = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.CommonPictures),
            "Sample Pictures");
         if (Directory.Exists(initialDirectory))
         {
            dlg.SelectedPath = initialDirectory;
         }

         // Show the dialog and process the dataflow network.
         if (dlg.ShowDialog() == DialogResult.OK)
         {
            // Create a new CancellationTokenSource object to enable
            // cancellation.
            cancellationTokenSource = new CancellationTokenSource();

            // Create the image processing network if needed.
            headBlock ??= CreateImageProcessingNetwork();

            // Post the selected path to the network.
            headBlock.Post(dlg.SelectedPath);

            // Enable the Cancel button and disable the Choose Folder button.
            toolStripButton1.Enabled = false;
            toolStripButton2.Enabled = true;

            // Show a wait cursor.
            Cursor = Cursors.WaitCursor;
         }
      }

      // Event handler for the Cancel button.
      private void toolStripButton2_Click(object sender, EventArgs e)
      {
         // Signal the request for cancellation. The current component of
         // the dataflow network will respond to the cancellation request.
         cancellationTokenSource.Cancel();
      }

      ~Form1()
      {
         cancellationTokenSource.Dispose();
      }
   }
}

다음 그림에서는 \Sample Pictures\ 공통 폴더에 대한 일반적인 출력을 보여 줍니다.

Windows Forms 애플리케이션

참조