Passo a passo: usar um fluxo de dados em um aplicativo do Windows Forms

Este artigo demonstra como criar uma rede de blocos de fluxo de dados que executam o processamento de imagens em um aplicativo do Windows Forms.

Este exemplo carrega arquivos de imagem da pasta especificada, cria uma imagem composta e exibe o resultado. O exemplo usa o modelo de fluxo de dados para encaminhar imagens por meio da rede. No modelo de fluxo de dados, componentes independentes de um programa se comunicam uns com os outros enviando mensagens. Quando um componente recebe uma mensagem, ele executa uma ação e, depois, passa o resultado para outro componente. Compare isso com o modelo de fluxo de controle, em que um aplicativo usa estruturas de controle, por exemplo, instruções condicionais, loops e assim por diante, para controlar a ordem das operações em um programa.

Pré-requisitos

Leia sobre o Fluxo de dados antes de iniciar essa explicação passo a passo.

Observação

A Biblioteca de Fluxo de Dados TPL (o namespace System.Threading.Tasks.Dataflow) não é distribuída com o .NET. Para instalar o namespace System.Threading.Tasks.Dataflow no Visual Studio, abra o projeto, escolha Gerenciar Pacotes NuGet no menu Projeto e pesquise online o pacote System.Threading.Tasks.Dataflow. Como alternativa, instale-o usando a CLI do .NET Core e execute dotnet add package System.Threading.Tasks.Dataflow.

Seções

Este passo a passo contém as seguintes seções:

• Criar o aplicativo do Windows Forms

• Criar a rede de fluxo de dados

• Conectar a rede de fluxo de dados à interface do usuário

• O exemplo completo

Criar o aplicativo do Windows Forms

Esta seção descreve como criar o aplicativo básico do Windows Forms e adicionar controles ao formulário principal.

Para criar o aplicativo do Windows Forms

1. No Visual Studio, crie um projeto de aplicativo do Windows Forms do Visual Basic ou do Visual C#. Neste documento, o projeto é chamado CompositeImages.

2. No designer de formulários do formulário principal, Form1.cs (Form1.vb para Visual Basic), adicione um controle ToolStrip.

3. Adicione um controle ToolStripButton ao controle ToolStrip. Defina a propriedade DisplayStyle como Text e a propriedade Text como Escolher Pasta.

4. Adicione um segundo controle ToolStripButton ao controle ToolStrip. Defina a propriedade DisplayStyle como Text, a propriedade Text como Cancelar e a propriedade Enabled como False.

5. Adicione um objeto PictureBox ao formulário principal. Defina a propriedade Dock como Fill.

Criar a rede de fluxo de dados

Esta seção descreve como criar a rede de fluxo de dados que executa o processamento de imagem.

Para criar a rede de fluxo de dados

1. Adicione uma referência a System.Threading.Tasks.Dataflow.dll ao seu projeto.

2. Verifique se o Form1.cs (Form1.vb para Visual Basic) contém as seguintes instruções using (Using em Visual Basic):

   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. Adicione os membros de dados a seguir à classe Form1:

   // The head of the dataflow network.
   ITargetBlock<string> headBlock = null;
   
   // Enables the user interface to signal cancellation to the network.
   CancellationTokenSource cancellationTokenSource;
   

4. Adicione o seguinte método, CreateImageProcessingNetwork, à classe Form1. Esse método cria a rede de processamento de imagem.

   // 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. Implementar o método de 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. Implementar o método de 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;
   }
   

   Observação

   A versão em C# do método CreateCompositeBitmap usa ponteiros para habilitar o processamento eficiente dos objetos System.Drawing.Bitmap. Portanto, você deve habilitar a opção Permitir código não gerenciado em seu projeto para usar a palavra-chave unsafe. Para obter mais informações de como habilitar o código não seguro em um projeto em Visual C#, confira Página Build, Designer de Projeto (C#).

A tabela a seguir descreve os membros da rede.

Membro	Type	Descrição
loadBitmaps	TransformBlock<TInput,TOutput>	Usa um caminho de pasta como entrada e produz uma coleção de objetos Bitmap como saída.
createCompositeBitmap	TransformBlock<TInput,TOutput>	Usa uma coleção de objetos Bitmap como entrada e produz um bitmap composto como saída.
displayCompositeBitmap	ActionBlock<TInput>	Exibe o bitmap composto no formulário.
operationCancelled	ActionBlock<TInput>	Exibe uma imagem para indicar que a operação foi cancelada e permite que o usuário selecione outra pasta.

Para conectar os blocos de fluxo de dados para formar uma rede, este exemplo usa o método LinkTo. O método LinkTo contém uma versão sobrecarregada que usa um objeto Predicate<T> que determina se o bloco de destino aceita ou rejeita uma mensagem. Esse mecanismo de filtragem permite que os blocos de mensagens recebam apenas determinados valores. Neste exemplo, a rede pode ser ramificada usando uma de duas maneiras. A ramificação principal carrega as imagens do disco, cria a imagem composta e exibe essa imagem no formulário. A ramificação alternativa cancela a operação atual. Os objetos Predicate<T> permitem que os blocos de fluxo de dados ao longo da ramificação principal alternem para a ramificação alternativa rejeitando determinadas mensagens. Por exemplo, se o usuário cancelar a operação, o bloco de fluxo de dados createCompositeBitmap produzirá null (Nothing em Visual Basic) como sua saída. O bloco de fluxo de dados displayCompositeBitmap rejeita valores de entrada null e, portanto, a mensagem é oferecida para operationCancelled. O bloco de fluxo de dados operationCancelled aceita todas as mensagens e, portanto, exibe uma imagem para indicar que a operação foi cancelada.

A seguinte ilustração mostra a rede de processamento de imagem:

Como os blocos de fluxo de dados displayCompositeBitmap e operationCancelled atuam na interface do usuário, é importante que essas ações ocorram no thread da interface do usuário. Para isso, durante a construção, cada um desses objetos fornece um objeto ExecutionDataflowBlockOptions que tem a propriedade TaskScheduler definida como TaskScheduler.FromCurrentSynchronizationContext. O método TaskScheduler.FromCurrentSynchronizationContext cria um objeto TaskScheduler que executa o trabalho no contexto de sincronização atual. Como o método CreateImageProcessingNetwork é chamado do manipulador do botão Escolher Pasta, executado no thread da interface de usuário, as ações para os blocos de fluxo de dados displayCompositeBitmap e operationCancelled também são executadas no thread da interface do usuário.

Este exemplo usa um token de cancelamento compartilhado em vez de configurar a propriedade CancellationToken, pois a propriedade CancellationToken cancela permanentemente a execução do bloco de fluxo de dados. Um token de cancelamento permite que esse exemplo reutilize a mesma rede de fluxo de dados várias vezes, mesmo quando o usuário cancela uma ou mais operações. Para obter um exemplo que usa CancellationToken para cancelar permanentemente a execução de um bloco de fluxo de dados, confira Como cancelar um bloco de fluxo de dados.

Conectar a rede de fluxo de dados à interface do usuário

Esta seção descreve como conectar a rede de fluxo de dados à interface do usuário. A criação de uma imagem composta e o cancelamento da operação começa com os botões Escolher Pasta e Cancelar. Quando o usuário escolhe um desses botões, a ação apropriada é iniciada de maneira assíncrona.

Para conectar a rede de fluxo de dados à interface do usuário

1. No designer de formulários, do formulário principal, crie um manipulador de eventos para o evento Click para o botão Escolher Pasta.

2. Implemente o evento Click para o botão Escolher Pasta.

   // 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. No designer de formulários, para o formulário principal, crie um manipulador de eventos para o evento Click para o botão Cancelar.

4. Implante o evento Click para o botão Cancelar.

   // 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();
   }
   

O Exemplo Completo

O exemplo a seguir mostra o código completo dessa explicação passo a passo.

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();
      }
   }
}

A ilustração a seguir mostra a saída típica para a pasta \Sample Pictures\ comum.

Confira também

• Fluxo de dados