关键词搜索

源码搜索 ×
×

C#PDA智能程序图片动态变化进度条设计及实现

发布2014-05-05浏览3015次

详情内容

    前言：SmartProject 项目是C#桌面程序的精简版，很多属性和事件可能都没有设置进SDK中。在最近的PDA程序中，我没用使用进度条。为了防止用户乱点，最开始想使用windows提供的进度条，但是觉得又不适合，所以就试图用图片切换的方式来实现。

   原理：开启线程切换图片实现显示（子线程不影响主线程而继续往下执行）。

1、进度界面设计效果


2、界面切换效果


点击质检按钮后跳转（during the new thread running the UI will be changed）：


等待业务线程（任务查询）执行完毕后，关闭进度界面。


2、关键实现代码片段

2-1、UI界面类

  1. using System;
  2. using System.Linq;
  3. using System.Collections.Generic;
  4. using System.ComponentModel;
  5. using System.Data;
  6. using System.Drawing;
  7. using System.Text;
  8. using System.Threading;
  9. using SmartDeviceProjectWtms.Domain;
  10. using SmartDeviceProjectWtms.Repository;
  11. using System.Windows.Forms;
  12.  
  13. namespace SmartDeviceProjectWtms.Forms
  14. {
  15.     public partial class FrmProcessModel : Form
  16.     {
  17.         public FrmProcessModel()
  18.         {
  19.             InitializeComponent();
  20.         }
  21.  
  22.  
  23.  
  24.         // 线程执行业务类型
  25.  
  26.         // 0-钻井任务下载入库，1-质检任务下载入库
  27.         public int PROCESS_TYPE { get; set; }
  28.  
  29.         // 线程执行业务数据
  30.         private string PROCESS_DATA { get; set; }
  31.  
  32.         // 声明一个委托
  33.         private delegate void NewDelegate();
  34.        
  35.         // 创建一个 Service新线程的方法
  36.         public void runCurrentThread()
  37.         {
  38.             Thread thread;
  39.             ThreadStart threadstart = new ThreadStart(startCase);
  40.             thread = new Thread(threadstart);
  41.             thread.Start();
  42.         }
  43.  
  44.         // 创建一个 UI新线程的方法
  45.         public void runCurrentUIThread()
  46.         {
  47.             Thread thread;
  48.             ThreadStart threadstart = new ThreadStart(startUiCase);
  49.             thread = new Thread(threadstart);
  50.             thread.Start();
  51.         }
  52.  
  53.         // 【UI处理】解决Control.Invoke 必须用于与在独立线程上创建的控件交互
  54.         private void startUiCase() 
  55.         {
  56.             if (InvokeRequired)
  57.             {
  58.                 // 要 努力 工作的 方法
  59.                 BeginInvoke(new NewDelegate(changeUI));
  60.  
  61.             }
  62.         }
  63.  
  64.         // 【远程处理】解决Control.Invoke 必须用于与在独立线程上创建的控件交互
  65.         private void startCase()
  66.         {
  67.             if (InvokeRequired)
  68.             {
  69.                 // 要 努力 工作的 方法
  70.                 if (this.PROCESS_TYPE == 0)
  71.                 {
  72.                     BeginInvoke(new NewDelegate(SaveRemoteDrillingTasks));
  73.                 }
  74.                 else if (this.PROCESS_TYPE == 1)
  75.                 {
  76.                     BeginInvoke(new NewDelegate(SaveRemoteQualityTasks));
  77.                 }
  78.                
  79.             }
  80.         }
  81.  
  82.      
  83.         /// <summary>
  84.         /// 【UI动态改变】随机切换显示图片
  85.         /// </summary>
  86.         private void doChangePictures() 
  87.         {
  88.             Image imageA = pictureBox0.Image;
  89.             Image imageB = pictureBox1.Image;
  90.             //实例化随机数产生器random；
  91.             Random rad = new Random();
  92.             // 生成大于0小于11的随机数
  93.             int value = rad.Next(0, 11);
  94.             if (value % 2 == 0)
  95.             {
  96.                 pictureBox0.Image = imageA; pictureBox2.Image = imageA;
  97.                 pictureBox4.Image = imageA; pictureBox6.Image = imageA;
  98.                 pictureBox1.Image = imageB; pictureBox3.Image = imageB;
  99.                 pictureBox5.Image = imageB; pictureBox7.Image = imageB;
  100.             }
  101.             else 
  102.             {
  103.                 pictureBox0.Image = imageB; pictureBox2.Image = imageB;
  104.                 pictureBox4.Image = imageB; pictureBox6.Image = imageB;
  105.                 pictureBox7.Image = imageA; pictureBox1.Image = imageA;
  106.                 pictureBox3.Image = imageA; pictureBox5.Image = imageA;
  107.             }
  108.         }
  109.  
  110.         // 【UI处理显示】改变UI图片循环展示
  111.         private void changeUI() 
  112.         {
  113.             int index = 0;
  114.             while (Global.QUEST_STATUS && index <= Global.PROCESS_LOOP_COUNT)
  115.             {
  116.                 Thread.Sleep(Global.PROCESS_LOOP_FEQUENCE);
  117.                 doChangePictures();
  118.                 Application.DoEvents();
  119.                 index++;
  120.             }
  121.             // 关闭此窗口
  122.             this.Close();
  123.            
  124.         }
  125.  
  126.         /// <summary>
  127.         /// 【UI切换&业务处理】启动并执行相应的操作类型
  128.         /// </summary>
  129.         public void toStartUI()
  130.         {
  131.             // 允许发起请求
  132.             Global.QUEST_STATUS = true;
  133.  
  134.             // 执行UI线程
  135.             this.runCurrentUIThread();
  136.  
  137.             // 执行业务线程
  138.             //this.runCurrentThread();
  139.  
  140.            
  141.         }
  142.  
  143.         /******************************线程处理业务*******************************/
  144.  
  145.         private readonly DrillingTaskRepository drillingTaskDao = new DrillingTaskRepository();
  146.  
  147.         private static QualityTaskRepository qualityTaskDao = new QualityTaskRepository();
  148.  
  149.  
  150.         /// <summary>
  151.         /// 【钻井任务】添加到本地数据库
  152.         /// </summary>
  153.         /// <returns></returns>
  154.         public void SaveRemoteDrillingTasks()
  155.         {
  156.             //获取服务器任务数据
  157.             List<DrillingTaskModel> modelList = RemoteDataService.GetRemoteToLocalDrillingTasksByJson();
  158.  
  159.             if (modelList != null)
  160.             {
  161.                 foreach (DrillingTaskModel model in modelList)
  162.                 {
  163.                     if (model != null)
  164.                     {
  165.                         // 添加任务到本地暂存SDF数据库
  166.                         DrillingTask task = new DrillingTask(Convert.ToString(model.id), Convert.ToString(model.projectId), model.measureLineNo, model.wellsNo, model.wellsName, model.wellsLocation, Convert.ToString(model.latlngNorth), Convert.ToString(model.latlngEast), Convert.ToString(model.elevation), model.processStatus, model.planStartDate, model.taskEidtDate, model.captainName, model.areaName, model.projectCode);
  167.                         try
  168.                         {
  169.                             drillingTaskDao.AddDrillingTask(task);
  170.                         }
  171.                         catch (Exception ex)
  172.                         {
  173.                             MessageBox.Show("钻井任务入库异常：" + ex.Message);
  174.                             continue;
  175.                         }
  176.                         // 更新任务状态下载状态
  177.                         int flag = 1;
  178.                         flag = RemoteDataService.UpdateDrillingTasksDownloadStatus(task, flag);
  179.                         if (flag == 0)
  180.                         {
  181.                             //更新失败删除本地数据库任务
  182.                             try
  183.                             {
  184.                                 drillingTaskDao.DeleteDrillingTaskByTaskId(task.TaskId);
  185.                             }
  186.                             catch (Exception ex)
  187.                             {
  188.                                 MessageBox.Show("本地任务删除异常：" + ex.Message);
  189.                                 continue;
  190.                             }
  191.                         }
  192.  
  193.                     }
  194.                 }
  195.             }
  196.             // 终止线程
  197.             Global.QUEST_STATUS = false;
  198.             ProcessThread.UN_QUIT_THREAD = false;
  199.         }
  200.  
  201.         /// <summary>
  202.         /// 【质检任务】添加到本地数据库
  203.         /// </summary>
  204.         /// <returns></returns>
  205.         public void SaveRemoteQualityTasks()
  206.         {
  207.             //获取服务器任务数据
  208.             List<QualityTaskModel> modelList = RemoteDataService.GetRemoteToLocalQualityTasksByJson();
  209.  
  210.             if (modelList != null)
  211.             {
  212.                 foreach (QualityTaskModel model in modelList)
  213.                 {
  214.                     if (model != null)
  215.                     {
  216.                         // 添加任务到本地暂存SDF数据库
  217.                         QualityTask task = new QualityTask(Convert.ToString(model.id), Convert.ToString(model.projectId), model.measureLineNo, model.wellsNo, model.processStatus, model.planEndDate, model.taskEidtDate, model.checker, model.areaName, model.projectCode);
  218.                         try
  219.                         {
  220.                             qualityTaskDao.AddQualityTask(task);
  221.                         }
  222.                         catch (Exception ex)
  223.                         {
  224.                             MessageBox.Show("钻井任务入库异常：" + ex.Message);
  225.                             continue;
  226.                         }
  227.                         // 更新任务下载状态
  228.                         int flag = RemoteDataService.UpdateQualityTasksDownloadStatus(task.TaskId);
  229.                         if (flag == 0)
  230.                         {
  231.                             //更新失败删除本地数据库任务
  232.                             try
  233.                             {
  234.                                 qualityTaskDao.DeleteQualityTaskByTaskId(task.TaskId);
  235.                             }
  236.                             catch (Exception ex)
  237.                             {
  238.                                 MessageBox.Show("本地任务删除异常：" + ex.Message);
  239.                                 continue;
  240.                             }
  241.                         }
  242.  
  243.                     }
  244.                 }
  245.             }
  246.             // 终止线程
  247.            Global.QUEST_STATUS = false;
  248.            ProcessThread.UN_QUIT_THREAD = false;
  249.         }
  250.  
  251.         // 窗体活动事件
  252.         private void FrmProcessModel_Activated(object sender, EventArgs e)
  253.         {
  254.             this.toStartUI();
  255.         }
  256.  
  257.         /// <summary>
  258.         /// 【钻井任务】查询远程数据库任务情况
  259.         /// </summary>
  260.         public void SearchDrillingList(string queryMeasureNo, string queryWellsNo, int queryProcess) 
  261.         {
  262.             // 执行远程数据访问
  263.  
  264.             Global.TEMP_DATA = RemoteDataService.GetRemoteDrillingTasksJsonByQueryParams(Global.DEVICE_CODE, queryMeasureNo, queryWellsNo, queryProcess);
  265.  
  266.             // 终止线程
  267.  
  268.             Global.QUEST_STATUS = false;
  269.             ProcessThread.UN_QUIT_THREAD = false;
  270.         }
  271.  
  272.         /// <summary>
  273.         /// 【质检任务】查询远程数据库任务情况
  274.         /// </summary>
  275.         public void SearchQualityList(string queryMeasureNo, string queryWellsNo, int queryProcess)
  276.         {
  277.             // 执行远程数据访问
  278.  
  279.             Global.TEMP_DATA = RemoteDataService.GetRemoteQualityTasksJsonByQueryParams(Global.DEVICE_CODE, queryMeasureNo, queryWellsNo, queryProcess);
  280.  
  281.             // 终止线程
  282.  
  283.             Global.QUEST_STATUS = false;
  284.             ProcessThread.UN_QUIT_THREAD = false;
  285.         } 
  286.     }
  287. }

2-2、UI线程委托

  1. using System;
  2. using System.Linq;
  3. using System.Collections.Generic;
  4. using System.Text;
  5. using System.Windows.Forms;
  6. using System.Threading;
  7. using SmartDeviceProjectWtms.Forms;
  8.  
  9. namespace SmartDeviceProjectWtms
  10. {
  11.     public class ProcessThread
  12.     {
  13.         public static bool UN_QUIT_THREAD = true;
  14.  
  15.         private static ProcessThread _instance;
  16.  
  17.         private static readonly Object syncLock = new Object();
  18.  
  19.         public static ProcessThread Instance
  20.         {
  21.             get 
  22.             {
  23.                 if (ProcessThread._instance == null)
  24.                 {
  25.                     lock (syncLock)
  26.                     {
  27.                         if (ProcessThread._instance == null)
  28.                         {
  29.                             ProcessThread._instance = new ProcessThread();
  30.                         }
  31.                     }
  32.                 }
  33.                 return ProcessThread._instance;
  34.             }
  35.         }
  36.  
  37.         private ProcessThread()
  38.         {
  39.             
  40.         }
  41.  
  42.         private Thread waitingThread;
  43.  
  44.         private FrmProcessModel waitingForm;
  45.  
  46.         public void CreateForm()
  47.         {
  48.             if (waitingThread != null && waitingForm != null)
  49.             {
  50.                 try
  51.                 {
  52.                     waitingThread.Abort();
  53.                 }
  54.                 catch (Exception)
  55.                 {
  56.                 }
  57.             }
  58.  
  59.             waitingThread = new Thread(new ThreadStart(delegate()
  60.             {
  61.                 waitingForm = new FrmProcessModel();
  62.                 Application.Run(waitingForm);
  63.             }));
  64.             waitingThread.Start();
  65.         }
  66.  
  67.         public FrmProcessModel GetForm() 
  68.         {
  69.             return waitingForm;
  70.         }
  71.  
  72.  
  73.         public void CloseForm()
  74.         {
  75.             if (waitingThread != null)
  76.             {
  77.                 try
  78.                 {
  79.                     waitingThread.Abort();
  80.                 }
  81.                 catch (Exception)
  82.                 {
  83.                 }
  84.             }
  85.       
  86.         }
  87.         
  88.     }
  89. }

2-3、主线程调用 

  1.   private void funcQualityBtn_Click(object sender, EventArgs e)
  2.         {
  3.             string message = "";
  4.             ProcessThread.UN_QUIT_THREAD = true;
  5.             switch (Global.DEVICE_STATUS)
  6.             {
  7.                 case 0:
  8.                     message = "禁用";
  9.                     break;
  10.                 case 1:
  11.  
  12.                     // 打开处理进度条
  13.                     this.operateType = 1;
  14.  
  15.                     ProcessThread processThread = ProcessThread.Instance;
  16.  
  17.                     processThread.CreateForm();
  18.  
  19.                     // 睡眠一会儿等待创建进度显示窗口
  20.                     Thread.Sleep(300);
  21.                
  22.                     // 远程数据处理
  23.                     while (ProcessThread.UN_QUIT_THREAD)
  24.                     {
  25.                         processThread.GetForm().SaveRemoteQualityTasks();
  26.  
  27.                         Application.DoEvents();
  28.  
  29.                         processThread.CloseForm();
  30.  
  31.                         // 打开质检窗口主页
  32.                         FrmQualityMain frmQualityMain = new FrmQualityMain();
  33.                         frmQualityMain.Show();
  34.                     }
  35.                     return;
  36.                 case 2:
  37.                     message = "归还";
  38.                     break;
  39.                 case 3:
  40.                     message = "损坏";
  41.                     break;
  42.             }
  43.  
  44.             MessageBox.Show("设备已【" + message + "】,操作无效!");
  45.  
  46.         }

注意：调用时Thread.sleep(300);的位置。设置此休眠是因为：在while之前窗体还没有被创建，所以为了防止空引用故设置之。如果将Thread.sleep(300);放在while循环内第一行，webservice就会陷入无休止的循环请求中，所以要放置在外面。


相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载