Calling a background worker thread multiple times?

I'm writing a Outlook plugin that transfers large files off to a web service to be copied, but when I have multiple attachments the loop is only sending one of them off to the web service. I can't seem to figure out what I exactly need to do to pass the code to multiple backgroundworkers without a hard limit of attachme开发者_开发知识库nts. Any ideas?

private BackgroundWorker bw = new BackgroundWorker();

    public string pubAttFullPath = null;
    public string pubAttFileName = null;
    public void SM_ItemSend(Object Item, ref bool Cancel)
    {
        Outlook.MailItem mailItem = Item as Outlook.MailItem;
        if (mailItem != null)
        {
            int minAttachSize = 40960000; //SM_GetMinSize();
            for (int i = 1; i<=mailItem.Attachments.Count; i++)
            {
                if (mailItem.Attachments[i].Size < minAttachSize)
                {
                    System.Windows.Forms.MessageBox.Show("This does NOT meet the minimum attachment size of " + minAttachSize);
                }
                else
                {
                    string attFullFilePath = System.IO.Path.GetFullPath(mailItem.Attachments[i].FileName);
                    pubAttFullPath = attFullFilePath;
                    pubAttFileName = mailItem.Attachments[i].FileName;

                    Guid smGuid;
                    smGuid = Guid.NewGuid();

                    bw.WorkerReportsProgress = true;
                    bw.WorkerSupportsCancellation = true;
                    bw.DoWork += new DoWorkEventHandler(bw_DoWork);
                    bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
                    bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);


                    if (bw.IsBusy != true)
                    {
                        bw.RunWorkerAsync();
                    }

                    mailItem.Attachments[i].Delete();       

                }  
            }                
        }
    }

 private void bw_DoWork(object sender, DoWorkEventArgs e)
   {
       System.Windows.Forms.Application.DoEvents();
       BackgroundWorker worker = sender as BackgroundWorker;
       if ((!worker.CancellationPending == true))
       {

       TransferFile.TransferFileSoapClient ws_TransferFile = new TransferFile.TransferFileSoapClient();

           bool transfercompleted = false;
           using (FileStream fs = new FileStream(
                pubAttFullPath,
                FileMode.Open,
                FileAccess.Read,
                FileShare.Read))
           {
               //Declare Buffers and Counts
               byte[] buffer = new byte[49152];
               long fileSize = fs.Length;
               long totalReadCount = 0;
               int readCount;
               //Loop and copy file until it changes to not exactly the same byte count as the buffer
               //which means the file is about to complete.
           while ((readCount =
                   fs.Read(buffer, 0, buffer.Length)) > 0)
               {             
                   if (!transfercompleted)
                   {
                       totalReadCount += readCount;
                       byte[] bytesToTransfer;

                       if (readCount == buffer.Length)
                       {
                           // Shortcut to not need to copy more bytes.
                           bytesToTransfer = buffer;
                           ws_TransferFile.WriteBinaryFile(bytesToTransfer, pubAttFileName);
                       }
                       else
                       {
                           // Only a part is requred to upload,
                           // copy that part.
                           List<byte> b = new List<byte>(buffer);

                           bytesToTransfer =
                               b.GetRange(0, readCount).ToArray();
                           ws_TransferFile.WriteBinaryFile(bytesToTransfer, pubAttFileName);

                           transfercompleted = true;
                           break;
                       }                         
                   }
               }
           }
       }
       //Cancel the job, cause for some reason it likes to loop twice and ruin your transfer
       e.Cancel = true;
       worker.CancelAsync();
   }

Take a look at the Task class, you can use it instead of the background worker. You can define a copy operation for one attachment as a task and depending on the number of attachments you would spawn several tasks simultaneously.