Procédure pas à pas : utilisation d’un dataflow dans une application Windows Forms

Cet article montre comment créer un réseau de blocs de flux de données qui effectuent un traitement des images dans une application Windows Forms.

Dans cet exemple, on charge des fichiers image à partir du dossier spécifié, on crée une image composite, et on affiche le résultat. L’exemple utilise le modèle de flux de données pour acheminer les images via le réseau. Dans le modèle de flux de données, les composants indépendants d’un programme communiquent entre eux en envoyant des messages. Lorsqu’un composant reçoit un message, il effectue une action, puis transmet le résultat à un autre composant. Comparez cela avec le modèle de flux de contrôle, dans lequel une application utilise des structures de contrôle (par exemple, des instructions conditionnelles, des boucles, etc.) pour contrôler l’ordre des opérations dans un programme.

Prérequis

Lisez la rubrique Flux de données avant de démarrer cette procédure pas à pas.

Sections

Cette procédure pas à pas contient les sections suivantes :

• Création de l’application Windows Forms

• Création du réseau de flux de données

• Connexion du réseau de flux de données à l’interface utilisateur

• Exemple complet

Création de l’application Windows Forms

Cette section décrit comment créer l’application Windows Forms de base et ajouter des contrôles au formulaire principal.

Pour créer une Application Windows Forms

1. Dans Visual Studio, créez un projet Application Windows Forms en Visual C# ou en Visual Basic. Dans ce document, le projet est nommé CompositeImages.

2. Dans le concepteur de formulaires pour le formulaire principal, Form1.cs (Form1.vb pour Visual Basic), ajoutez un contrôle ToolStrip.

3. Ajoutez un contrôle ToolStripButton au contrôle ToolStrip. Définissez la propriété DisplayStyle sur Text et la propriété Text sur Choisir un dossier.

4. Ajoutez un deuxième contrôle ToolStripButton au contrôle ToolStrip. Définissez la propriété DisplayStyle sur Text, la propriété Text sur Annuler et la propriété Enabled sur False.

5. Ajoutez un objet PictureBox au formulaire principal. Définissez la propriété Dock sur Fill.

Création du réseau de flux de données

Cette section décrit comment créer le réseau de flux de données qui effectue le traitement des images.

Pour créer le réseau de flux de données

1. Dans votre projet, ajoutez une référence à System.Threading.Tasks.Dataflow.dll.

2. Vérifiez que Form1.cs (Form1.vb pour Visual Basic) contient les instructions using suivantes (Usingen 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. Ajoutez les membres de données suivants à la 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. Ajoutez la méthode suivante, CreateImageProcessingNetwork, à la classe Form1. Cette méthode crée le réseau de traitement des images.

   // 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. Implémentez la méthode 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. Implémentez la méthode 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;
   }
   

   Notes

   La version C# de la méthode CreateCompositeBitmap utilise des pointeurs pour permettre un traitement efficace des objets System.Drawing.Bitmap. Par conséquent, vous devez activer l’option Autoriser les blocs de code unsafe dans votre projet pour pouvoir utiliser le mot-clé unsafe. Pour plus d’informations sur l’activation de code unsafe dans un projet Visual C#, consultez Générer, page du Concepteur de projets (C#).

Le tableau ci-dessous décrit les membres du réseau.

Pour connecter les blocs de flux de données afin de former un réseau, cet exemple utilise la méthode LinkTo. LinkTo Celle-ci contient une version surchargée qui prend un objet Predicate<T> définissant si le bloc cible accepte ou rejette un message. Ce mécanisme de filtrage permet aux blocs de messages de ne recevoir que certaines valeurs. Dans cet exemple, le réseau peut créer une branche de deux manières. La branche principale charge les images à partir du disque, crée l’image composite et affiche cette image sur le formulaire. L’autre branche annule l’opération en cours. Les objets Predicate<T> permettent aux blocs de flux de données de la branche principale de basculer vers l’autre branche en rejetant certains messages. Par exemple, si l’utilisateur annule l’opération, le bloc de flux de données createCompositeBitmap produit null (Nothing en Visual Basic) comme sortie. Le bloc de flux de données displayCompositeBitmap rejette les valeurs d’entrée null. Par conséquent, le message est proposé aux operationCancelled. Le bloc de flux de données operationCancelled accepte tous les messages. Par conséquent, il affiche une image pour indiquer que l’opération est annulée.

L’illustration suivante montre le réseau de traitement des images :

Étant donné que les blocs de flux de données displayCompositeBitmap et operationCancelled agissent sur l’interface utilisateur, il est important que ces actions se produisent sur le thread de l’interface utilisateur. Pour cela, chacun de ces objets fournit lors de la construction un objet ExecutionDataflowBlockOptions dont la propriété TaskScheduler est définie sur TaskScheduler.FromCurrentSynchronizationContext. La méthode TaskScheduler.FromCurrentSynchronizationContext crée un objet TaskScheduler qui effectue le travail dans le contexte actuel de synchronisation. Étant donné que la méthode CreateImageProcessingNetwork est appelée à partir du gestionnaire du bouton Choisir le dossier, qui est exécuté sur le thread de l’interface utilisateur, les actions des blocs de flux de données displayCompositeBitmap et operationCancelled sont également exécutées sur le thread de l’interface utilisateur.

Cet exemple utilise un jeton d’annulation partagé au lieu de définir la propriété CancellationToken, car cette dernière annule définitivement l’exécution du bloc de flux de donnéesCancellationToken. Cet exemple explique comment un jeton d’annulation permet de réutiliser un réseau de flux de données plusieurs fois, même lorsque l’utilisateur annule une ou plusieurs opérations. Vous trouverez un exemple utilisant CancellationToken pour annuler définitivement l’exécution d’un bloc de flux de données sur la page Guide pratique : annuler un bloc de flux de données.

Connexion du réseau de flux de données à l’interface utilisateur

Cette section décrit comment connecter le réseau de flux de données à l’interface utilisateur. La création de l’image composite et l’annulation de l’opération sont lancées à partir des boutons Choisir le dossier et Annuler. Lorsque l’utilisateur clique sur l’un de ces boutons, l’action appropriée est lancée de manière asynchrone.

Connecter le réseau de flux de données à l’interface utilisateur

1. Dans le concepteur de formulaires du formulaire principal, créez un gestionnaire d'événements pour l'événement Click du bouton Annuler.

2. Implémentez l’événement Click pour le bouton Choisir un dossier.

   // 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. Dans le concepteur de formulaires du formulaire principal, créez un gestionnaire d'événements pour l’événement Click du bouton Annuler.

4. Implémentez l’événement Click pour le bouton Annuler.

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

Exemple complet

L'exemple suivant présente le code complet pour cette visite.

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

L’illustration suivante montre une sortie type du dossier \Échantillons d'images\.

Voir aussi

• Dataflow