Passo a passo: usando o 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 imagem 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 rotear imagens pela 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 alguma ação e passa o resultado para outro componente. Compare isso com o modelo de fluxo de controle, no qual 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 o fluxo de dados antes de iniciar este passo a passo.

Observação

A biblioteca de fluxo de dados TPL (o System.Threading.Tasks.Dataflow namespace) está incluída no .NET 6 e versões posteriores. Para projetos .NET Framework e .NET Standard, você precisa instalar o 📦 pacote NuGet System.Threading.Tasks.Dataflow.

Seções

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

• Criando o aplicativo windows forms

• Criando a rede de fluxo de dados

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

• O exemplo completo

Criando o aplicativo 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 de Windows Forms

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

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

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

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

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

Criando 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 Form1.cs (Form1.vb para Visual Basic) contém as seguintes using instruções (Using no 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 seguintes membros de dados à Form1 classe:

   // 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 C# do CreateCompositeBitmap método usa ponteiros para habilitar o processamento eficiente dos System.Drawing.Bitmap objetos. Portanto, você deve habilitar a opção Permitir código não seguro em seu projeto para usar a palavra-chave não segura . Para obter mais informações sobre como habilitar código não seguro em um projeto do Visual C#, consulte Página de Build, Designer de Projeto (C#).

A tabela a seguir descreve os membros da rede.

Membro	Tipo	Description
loadBitmaps	TransformBlock<TInput,TOutput>	Usa um caminho de pasta como entrada e produz uma coleção de Bitmap objetos como saída.
createCompositeBitmap	TransformBlock<TInput,TOutput>	Usa uma coleção de Bitmap objetos 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 LinkTo método. O LinkTo método contém uma versão sobrecarregada que usa um Predicate<T> objeto 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 ramificar de duas maneiras. O branch 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 Predicate<T> objetos permitem que os blocos de fluxo de dados ao longo do branch principal mudem para o branch alternativo por meio da rejeição de determinadas mensagens. Por exemplo, se o usuário cancelar a operação, o bloco de fluxo de dados createCompositeBitmap produzirá null como saída (Nothing no Visual Basic). O bloco displayCompositeBitmap de fluxo de dados rejeita valores de entrada e, portanto, a mensagem é oferecida para operationCancelled. O bloco operationCancelled de fluxo de dados 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 de execução da interface do usuário. Para fazer isso, durante a construção, cada um desses objetos fornece um ExecutionDataflowBlockOptions objeto que tem a TaskScheduler propriedade definida como TaskScheduler.FromCurrentSynchronizationContext. O TaskScheduler.FromCurrentSynchronizationContext método cria um TaskScheduler objeto que executa o trabalho no contexto de sincronização atual. Como o método CreateImageProcessingNetwork é chamado do manipulador do botão Escolher Pasta, que é executado no thread de interface do usuário, as ações para os blocos de fluxo de dados displayCompositeBitmap e operationCancelled também são executadas no thread de interface do usuário.

Este exemplo usa um token de cancelamento compartilhado em vez de definir a propriedade CancellationToken, porque a propriedade CancellationToken cancela permanentemente a execução do bloco de dados. Um token de cancelamento permite que este 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, consulte Como cancelar um bloco de fluxo de dados.

Conectando 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 da imagem composta e o cancelamento da operação são iniciados nos 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ário para o formulário principal, crie um manipulador de eventos para o evento Click para o botão Escolher Pasta.

2. Implemente o Click evento 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ário para o formulário principal, crie um manipulador de eventos para o evento do botão Cancelar.

4. Implemente o Click evento 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 para este 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 uma saída típica para a pasta comum \Sample Pictures\.

Consulte também

• Fluxo