C#开发WinForm进度条开发

刺骨的言语ヽ痛彻心扉 2022-04-12 03:19 524阅读 0赞

C#开发WinForm进度条开发

文章目录

    • C#开发WinForm进度条开发
  • 前言
  • 实现
  • 结果
    • 补充
  • BackgroundWorker方式

前言

开发windows窗体组件，由于业务复杂需要进度条，使用ProgressBar控件。
winForm弹出窗口有两种方式：非模态窗口方式和模态窗口方式。
Show():非模态窗口方式(可以跟其他界面自由切换，而且不阻塞代码)
ShowDialog():模态窗口(必须关闭了该窗口，后面的代码才会执行，并且不能跟其他界面自由切换)。
这里面的进度条和我们开发web前端还不一样。我们知道js里，当我们弹出个进度框后，后面代码是可以执行的。在这里不行。
如果我们想用模态方式弹出框，同时还想执行后面代码。这种想法是实现不了了。只有一种办法（至少我这么认为）。将逻辑部份和组件放在一起，同时使用线程去更新UI。

实现

这里以下载文件，同时显示进度条的功能为例。

新建一个windows窗体组件,名字为DownLoadingForm
拖Label和ProgressBar组件到窗体里。如下

在这里插入图片描述

去掉头部的按钮（包括最大/最小/关闭按钮）：将窗体的FormBorderStyle设为None。
代码如下:

  1. using DongliCAD.utils;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.ComponentModel;
  5. using System.Data;
  6. using System.Drawing;
  7. using System.Linq;
  8. using System.Text;
  9. using System.Threading;
  10. using System.Threading.Tasks;
  11. using System.Windows.Forms;
  13. namespace DongliCAD.component.common
  14. {
  15.     public partial class DownLoadingForm : Form
  16.     {
  17.         private string downUrl;
  18.         private string savePath;
  19.         /// <summary>
  20.         /// 
  21.         /// </summary>
  22.         /// <param name="downUrl">下载url</param>
  23.         /// <param name="savePath">本地保存路径</param>
  24.         public DownLoadingForm(string downUrl, string savePath)
  25.         {
  26.             this.downUrl = downUrl;
  27.             this.savePath = savePath;
  28.             InitializeComponent();
  29.         }
  31.         /// <summary>
  32.         /// 启动线程
  33.         /// </summary>
  34.         private void startThread()
  35.         {
  36.             //重新开一个线程用于更新UI
  37.             ThreadStart ts = new ThreadStart(startTime);
  38.             Thread thread = new Thread(ts);
  39.             thread.Name = "startTime";
  40.             thread.Start();
  41.         }
  43.         private System.Timers.Timer aTimer;
  44.         /// <summary>
  45.         /// 定时器
  46.         /// </summary>
  47.         private void startTime()
  48.         {
  49.             aTimer = new System.Timers.Timer();
  50.             aTimer.Elapsed += new System.Timers.ElapsedEventHandler(aTimer_Elapsed);
  51.             // 设置引发时间的时间间隔 此处设置为１秒
  52.             aTimer.Interval = 1000;
  53.             aTimer.Enabled = true;
  55.             //HttpDownUtil是我的下载类。
  56.             string resultPath = HttpDownUtil.HttpDownloadFile(downUrl, savePath);
  57.             if (!string.IsNullOrEmpty(resultPath))
  58.             {
  59.                 CloseTime();
  60.             }
  61.         }
  63.         private delegate void SetProgressBarC(string str);
  64.         private void aTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
  65.         {
  66.             progressBar.Invoke(new EventHandler(delegate {
  67.                 if (null != progressBar)
  68.                 {
  69.                     int currentValue = progressBar.Value;
  70.                     currentValue += NumberUtil.getRandNum();
  71.                     currentValue = currentValue >= 98 ? 98 : currentValue;
  72.                     progressBar.Value = currentValue;
  73.                     progressLbl.Text = "下载CAD文件进度：" + currentValue + "%";
  74.                     if (progressBar.Value >= 100)
  75.                     {
  76.                         if(null != aTimer) {
  77.                             aTimer.Enabled = false;
  78.                             aTimer.Close();
  79.                         }
  80.                     }
  81.                 }
  82.             }
  83.             ));
  84.         }
  86.         public void CloseTime()
  87.         {
  88.             if (null != aTimer)
  89.             {
  90.                 aTimer.Enabled = false;
  91.                 aTimer.Close();
  92.             }
  93.             progressBar.Invoke(new EventHandler(delegate {
  94.                 if (null != progressBar)
  95.                 {
  96.                     int currentValue = 100;
  97.                     progressBar.Value = currentValue;
  98.                     progressLbl.Text = "下载CAD文件进度：" + currentValue + "%";
  99.                     Thread.Sleep(1000);
  100.                     this.Close();
  101.                 }
  102.             }
  103.             ));
  104.         }
  106.         private void DownLoadingForm_Load(object sender, EventArgs e)
  107.         {
  108.             //组件初始化完成，启动线程
  109.             startThread();
  110.         }
  111.     }
  112. }

其中注意下载方法HttpDownUtil.HttpDownloadFile也必需放在新线程里执行。这里我只用了假的进度条，真实的太复杂。

HttpDownUtil.cs里HttpDownloadFile方法：

  1. /// <summary>
  2.         /// 同步下载
  3.         /// Http下载文件
  4.         /// </summary>
  5.         public static string HttpDownloadFile(string url, string path)
  6.         {
  7.             // 设置参数
  8.             HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
  9.             if (GlobalData.Authorization.Length > 0)
  10.             {
  11.                 request.Headers.Add("Authorization", GlobalData.Authorization);
  12.             }
  13.             //发送请求并获取相应回应数据
  14.             HttpWebResponse response = request.GetResponse() as HttpWebResponse;
  15.             //直到request.GetResponse()程序才开始向目标网页发送Post请求
  16.             Stream responseStream = response.GetResponseStream();
  17.             //创建本地文件写入流
  18.             Stream stream = new FileStream(path, FileMode.Create);
  19.             byte[] bArr = new byte[1024];
  20.             int size = responseStream.Read(bArr, 0, (int)bArr.Length);
  21.             while (size > 0)
  22.             {
  23.                 stream.Write(bArr, 0, size);
  24.                 size = responseStream.Read(bArr, 0, (int)bArr.Length);
  25.             }
  26.             stream.Close();
  27.             responseStream.Close();
  28.             return path;
  29.         }

结果

结果如下：
在这里插入图片描述

补充

上面的下载是同步下载，如果在实时显示下载进度需要异常下载。下面代码是实时显示下载进度的代码。

  1. /// <summary>
  2.     /// 下载请求信息
  3.     /// </summary>
  4.     public class DownloadTmp
  5.     {
  6.         /// <summary>
  7.         /// 文件名
  8.         /// </summary>
  9.         public string fileName;
  10.         /// <summary>
  11.         /// 下载路径
  12.         /// </summary>
  13.         public string filePath;
  14.         /// <summary>
  15.         /// 下载进度回调
  16.         /// </summary>
  17.         public Action<int> loadingCallback;
  18.         /// <summary>
  19.         /// 完成回调
  20.         /// </summary>
  21.         public Action succeedCallback;
  22.         /// <summary>
  23.         /// 失败回调
  24.         /// </summary>
  25.         public Action failedCallback;
  26.         /// <summary>
  27.         /// webRequest
  28.         /// </summary>
  29.         public HttpWebRequest webRequest;
  31.         public long AllContentLength;
  33.         public long currentContentLength;
  34.     }
  36. using DongliCAD.utils;
  37. using System;
  38. using System.Collections.Generic;
  39. using System.ComponentModel;
  40. using System.Data;
  41. using System.Diagnostics;
  42. using System.Drawing;
  43. using System.IO;
  44. using System.Linq;
  45. using System.Net;
  46. using System.Text;
  47. using System.Threading;
  48. using System.Threading.Tasks;
  49. using System.Windows.Forms;
  51. namespace DongliCAD.component.common
  52. {
  53.     public partial class DownLoadingForm : Form
  54.     {
  55.         private string downUrl;
  56.         private string savePath;
  57.         private DownloadTmp downloadTmp;
  58.         /// <summary>
  59.         /// 
  60.         /// </summary>
  61.         /// <param name="downUrl">下载url</param>
  62.         /// <param name="savePath">本地保存路径</param>
  63.         public DownLoadingForm(string downUrl, string savePath)
  64.         {
  65.             this.downUrl = downUrl;
  66.             this.savePath = savePath;
  67.             InitializeComponent();
  68.         }
  70.         /// <summary>
  71.         /// 启动线程
  72.         /// </summary>
  73.         private void startThread()
  74.         {
  75.             downloadTmp = new DownloadTmp();
  76.             downloadTmp.filePath = savePath;
  77.             HttpDownloadZip(downUrl, ref downloadTmp);
  78.             //HttpDownUtil.HttpDownloadFile("http://192.168.1.243:85/api/files/download/516610289672650758", savePath);
  79.         }
  82.         private void DownLoadingForm_Load(object sender, EventArgs e)
  83.         {
  84.             //组件初始化完成，启动线程
  85.             startThread();
  86.         }
  88.         private void updateProgressBar(long allContentLength, long currentContentLength)
  89.         {
  90.             Debug.Write("allContentLength: " + allContentLength + ",currentContentLength: " + currentContentLength);
  91.             progressBar.Invoke(new EventHandler(delegate {
  92.                 if (null != progressBar)
  93.                 {
  94.                     int step = Convert.ToInt32(currentContentLength * 100 / allContentLength);
  95.                     progressBar.Value = step;
  96.                     progressLbl.Text = "下载CAD文件进度：" + step + "%";
  97.                 }
  98.             }
  99.             ));
  100.         }
  102.         /// <summary>
  103.         /// 异步回调
  104.         /// </summary>
  105.         /// <param name="result">Result.</param>
  106.         private void BeginResponseCallback(IAsyncResult result)
  107.         {
  108.             DownloadTmp downloadInfo = (DownloadTmp)result.AsyncState;
  109.             HttpWebRequest Request = downloadInfo.webRequest;
  110.             HttpWebResponse Response = (HttpWebResponse)Request.EndGetResponse(result);
  112.             if (Response.StatusCode == HttpStatusCode.OK || Response.StatusCode == HttpStatusCode.Created)
  113.             {
  114.                 string filePath = downloadInfo.filePath;
  117.                 if (File.Exists(filePath))
  118.                 {
  119.                     File.Delete(filePath);
  120.                 }
  121.                 //FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write);
  122.                 FileStream fs = File.OpenWrite(filePath);
  124.                 Stream stream = Response.GetResponseStream();
  126.                 int count = 0;
  127.                 int num = 0;
  128.                 long AllContentLength = Response.ContentLength;
  129.                 long currentContentLength = 0;
  130.                 if (Response.ContentLength > 0)
  131.                 {
  132.                     var buffer = new byte[2048 * 100];
  133.                     do
  134.                     {
  135.                         num++;
  136.                         count = stream.Read(buffer, 0, buffer.Length);
  137.                         currentContentLength += count;
  139.                         updateProgressBar(AllContentLength, currentContentLength);
  140.                         fs.Write(buffer, 0, count);
  141.                         if (downloadInfo.loadingCallback != null)
  142.                         {
  143.                             float pro = (float)fs.Length / Response.ContentLength * 100;
  144.                             downloadInfo.loadingCallback((int)pro);
  145.                         }
  146.                     } while (count > 0);
  147.                 }
  148.                 fs.Close();
  149.                 Response.Close();
  150.                 if (downloadInfo.succeedCallback != null)
  151.                 {
  152.                     downloadInfo.succeedCallback();
  153.                 }
  154.                 progressBar.Invoke(new EventHandler(delegate {
  155.                     this.Close();
  156.                     this.DialogResult = DialogResult.OK;
  157.                 }));
  158.             }
  159.             else
  160.             {
  161.                 Response.Close();
  162.                 if (downloadInfo.failedCallback != null)
  163.                 {
  164.                     downloadInfo.failedCallback();
  165.                 }
  166.                 progressBar.Invoke(new EventHandler(delegate {
  167.                     this.Close();
  168.                     this.DialogResult = DialogResult.Cancel;
  169.                 }));
  170.             }
  171.         }
  173.         /// <summary>
  174.         /// 下载文件，异步
  175.         /// </summary>
  176.         /// <param name="URL">下载路径</param>
  177.         /// <param name="downloadPath">文件下载路径</param>
  178.         /// <returns></returns>
  179.         public void HttpDownloadZip(string URL, ref DownloadTmp downloadInfo)
  180.         {
  181.             HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URL);
  182.             if (GlobalData.Authorization.Length > 0)
  183.             {
  184.                 request.Headers.Add("Authorization", GlobalData.Authorization);
  185.             }
  186.             downloadInfo.webRequest = request;
  187.             request.BeginGetResponse(BeginResponseCallback, downloadInfo);
  188.         }
  189.     }
  190. }

-———————补充2019-01-22————————-

BackgroundWorker方式

使用BackgroundWorker做成一个上传进度条，外部传入进度值显示，对，就是和你心里想的一样的进度条。

  1. 拖拽一个BackgroundWorker到需要弹出进度条框的窗体上。
    添加代码如下

    private void BackgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

    1.     {
    2.         if (e.Error != null)
    3.         {
    4.             MessageBox.Show(e.Error.Message);
    5.         }
    6.         else if (e.Cancelled)
    7.         {
    9.         }
    10.         else
    11.         {
    13.         }
    14.     }
    16.     private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    17.     {
    18.         startAssembly();
    19.     }
    21.     private void startAssembly()
    22.     {
    23.         //导出pdf
    24.         this.backgroundWorker1.ReportProgress(20, "正在导出PDF...(1/6)");
    25.         this.xExportPDF(this);
    26.         Boolean result = false;
    27.         this.backgroundWorker1.ReportProgress(30, "正在签出...(2/6)");
    28.         result = this.CheckOut();
    29.         this.backgroundWorker1.ReportProgress(40, "正在保存图纸...(3/6)");
    30.         result = this.DoSaveTitleWBaseInfo();
    31.         if (!result)
    32.         {
    33.             return;
    34.         }
    35.         this.SaveWorkspaceCadInfoVo();
    36.         this.backgroundWorker1.ReportProgress(60, "正在保存BOM...(4/6)");
    37.         result = this.SaveBom();
    38.         if (!result)
    39.         {
    40.             return;
    41.         }
    42.         this.backgroundWorker1.ReportProgress(80, "正在签入...(5/6)");
    43.         this.CheckIn();
    44.         closeTimeout();
    45.         this.backgroundWorker1.ReportProgress(100, "保存成功...(6/6)");
    46.     }

  2. 新建一个进度条窗体，包括一个ProgressBar和一个显示文件Label，代码如下

    public partial class UploadLoadingWorkerForm : Form

    1. {
    2.     private BackgroundWorker backgroundWorker;
    3.     /// <summary>
    4.     /// 
    5.     /// </summary>
    6.     public UploadLoadingWorkerForm(BackgroundWorker backgroundWorker)
    7.     {
    8.         InitializeComponent();
    9.         GlobalData.SetAutoScaleMode(this);
    10.         this.backgroundWorker = backgroundWorker;
    11.         this.backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);
    12.         this.backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
    13.     }
    15.     private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    16.     {
    17.         this.DialogResult = DialogResult.OK;
    18.         this.Close();//执行完之后，直接关闭页面
    19.     }
    21.     private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
    22.     {
    23.         this.progressBar.Value = e.ProgressPercentage;
    24.         this.progressLbl.Text = e.UserState.ToString();
    25.     }

最主要的是backgroundWorker1_ProgressChanged事件处理函数，外部通过 this.backgroundWorker1.ReportProgress(30, “正在签出…(2/6)”);传值，事件处理函数负责接收并显示进度和文本。

  1. 弹出进度条

    UploadLoadingWorkerForm uploadLoadingForm = new UploadLoadingWorkerForm ();
    this.backgroundWorker1.RunWorkerAsync(); // 运行 backgroundWorker 组件
    uploadLoadingForm = new UploadLoadingWorkerForm(this.backgroundWorker1);

发表评论

表情：
评论列表 （有 0 条评论，524人围观）

还没有评论，来说两句吧...

相关阅读