• 考试的时候,会有一个倒计时的实现。一般我们会选择使用Timer控件来实现,几句代码就可以简单的实现了。从网上找到一种方法可以通过进程睡觉来实现倒计时。感兴趣的可以研究一下,下面的两种方法: 一、普通Timer...

          考试的时候,会有一个倒计时的实现。一般我们会选择使用Timer控件来实现,几句代码就可以简单的实现了。从网上找到一种方法可以通过进程睡觉来实现倒计时。感兴趣的可以研究一下,下面的两种方法:


    一、普通Timer控件实现倒计时:


         假设倒计时60分钟,如图一个label记录总的倒计时时间。





         插入一个timer控件,在timer1_Tick事件中进行编写。


       private void timer1_Tick(object sender, EventArgs e)
            {
                //倒计时
                if (Timecount >= 0)
                {
                    this.lbltime.Text = ((Timecount / 60000) % 60).ToString();
    
                    Timecount -= 1000;
                }
                if (Timecount == 0)
                {
                    //强制交卷的代码
                    MessageBox.Show("考试时间到");
                    this.Close();
                }
            }


    二、进程实现倒计时:


          前面用几个label显示数据,一个开始按钮,一个结束按钮。




    后台是这样编写的:


     public partial class Form2 : Form
        {
            public Form2()
            {
                InitializeComponent();
            }
            int Timecount = 0;//记录倒计时总毫秒数
            int isstop = 0;//标示是否启动/暂停的变量,0表示第一次初始化
            private void button1_Click(object sender, EventArgs e)
            {
                if (this.button1.Text == "开始计时" || this.button1.Text == "继续计时")
                {
                    this.button1.Text = "暂停计时";
                    if (isstop == 0)//第一次执行或者倒计时事件设置发生变化,则重新倒计时
                    {
                        Timecount = Convert.ToInt32(txtTotalmm.Text) * 60000;//毫秒
                        MessageBox.Show(Timecount.ToString());
                        Thread counter = new Thread(Counter);
                        counter.Start();
                        Control.CheckForIllegalCrossThreadCalls = false;//放弃捕获对错误线程的调用,否则在线程中无法调用控件名  
                    }
                    isstop = 1;//启动
                }
                else
                {
                    this.button1.Text = "继续计时";
                    isstop = 2;//暂停
                }
            }
            public void Counter()
            {
            
                    while (Timecount >= 0)
                    {
                        this.txthour.Text = (Timecount / 60/60/100).ToString();
                        this.txtmm.Text = ((Timecount / 60/1000) % 60).ToString();
                        this.txtss.Text = ((Timecount / 1000) % 60).ToString();
                        this.txtmss.Text = (Timecount % 1000).ToString();
                        //label1.Text = hour.ToString() + "时 " + minute.ToString() + "分 " + second.ToString() + "秒" + millsecond + "毫秒";
                        if (Timecount == 0)
                        {
                            this.button1.Text = "开始计时";
                            isstop = 0;
                          
                                Thread currthread = Thread.CurrentThread;
                                currthread.Abort();// 终止当前进程,会触发ThreadAbortException异常,从而终止进程,所以下面需要捕获该异常才能终止进程
    
                        }
                        if (isstop != 2)
                            Timecount -= 1;
                        Thread.Sleep(1);
                    }
            
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                this.txtTotalmm.Text = (Convert.ToInt32(this.txtTotalmm.Text) + 1).ToString();
            }

    三、Thread类常用方法:

    • Thread.Suspend()  //挂起线程(使线程暂时停止) 
    • Thread.Resume()   //使挂起的线程开始工作 
    • Thread.Abort()    //使线程永远的停止 
    • Thread.Join()     //线程之间的插入  
    • Thread.Start()  //开始执行线程 

    四、总结:



    1.倒计时如果是以秒为单位,可以选择Timer和线程来实现,如果以毫秒为单位,建议使用线程来实现。

    2.使用线程时,如果要暂停,需要使用Abort()方法终止线程,该方法是通过触发ThreadAbortException异常来实现对线程的终止的,所以需要捕获该异常,才能终止线程。


    展开全文
  • C# 的定时器的实现方法有 3 种: (1)使用 System.Windows.Forms.Timer (2)使用 System.Threading.Timer (3)使用 System.Timers.Timer 其中: System.Windows.Forms.Timer 只能在 WinForm 中使用,通过...

    C# 的定时器的实现方法有 3 种:

    (1)使用 System.Windows.Forms.Timer

    (2)使用 System.Threading.Timer

    (3)使用 System.Timers.Timer

    其中:

    System.Windows.Forms.Timer 只能在 WinForm 中使用,通过Windows消息机制实现的,类似于 VB 或 Delphi 中的 Timer 控件,内部使用 API  SetTimer 实现的。

    它的主要缺点是计时不精确,而且必须有消息循环,因此在 Console  Application (控制台应用程序)中无法使用。

    System.Timers.Timer 和 System.Threading.Timer 非常类似,它们是通过.NET  Thread  Pool实现的,轻量,计时精确,对应用程序、消息没有特别的要求。

    System.Timers.Timer 还可以应用于WinForm,完全取代上面的 Timer 控件。

    它们的缺点是不支持直接的拖放,需要手工编码。

     

    说明:在控制台下,如果要看得到 倒计时 的效果,需要在最后加一句 Console.ReadLine(); ,否则是看不到效果的(参下)。

     

    先讲讲

     System.Timers.Timer 的使用:

    MSDN 的示例:

    //Timer.cs
    using System;
    using System.Timers;
    
    public class Timer1
    {
        //定义一个 类级别 的 Timer
        private static System.Timers.Timer aTimer;
        //如果 不是 类级别 的 Timer,我们应该使用 GC.KeepAlive(aTimer); 来维持变量的存在。
        //一般建议定义成 类级别 的 Timer
    
        public static void Main()
        {
            //局部的 Timer
            //System.Timers.Timer aTimer;
    
            //初始化 aTimer ,间隔时间为 10s
            aTimer = new System.Timers.Timer(10000);
    
            //添加一个钩子:注册一个函数,在倒计时完成后调用
            aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
    
            //设置 倒计时 的时间为 2s
            aTimer.Interval = 2000;
    
            //设置 是否 循环执行:默认会循环执行
            aTimer.AutoReset = true;
    
            //开启 倒计时
            aTimer.Enabled = true;
    
            Console.WriteLine("按下回车结束程序");
            Console.ReadLine();
    
            //防止局部的 aTimer 被 自动垃圾回收
            //GC.KeepAlive(aTimer);
        }
    
        // Specify what you want to happen when the Elapsed event is 
        // raised.
        private static void OnTimedEvent(object source, ElapsedEventArgs e)
        {
            Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
        }
    }
    
    /* 大致输出结果如下:
    
    按下回车结束程序
    The Elapsed event was raised at 5/20/2007 8:42:27 PM
    The Elapsed event was raised at 5/20/2007 8:42:29 PM
    The Elapsed event was raised at 5/20/2007 8:42:31 PM
    ...
     */

    如果你启动多个线程,问题就来了,两个线程的变化是同步的,这不是我们要的,

    因此,我们给它加个线程锁:

    //Program.cs
    
    namespace CK
    {
        class Program
        {
            static void Main(string[] args)
            {
                Clock.GetTimerStart();
            }
        }
    }
    

    //Clock.cs
    using System;
    using System.Timers;
    
    namespace CK
    {
        class Clock
        {
            //用于设置 线程锁
            private static object lockClock = new Object();
    
            //定义 类级别 的 Timer
            private static Timer clockTimer = new Timer();
    
            //检查是否有锁
            private static bool check = false;
    
            internal static void GetTimerStart()
            {
                //设置间隔时间
                clockTimer.Interval = 6000;
                //添加钩子:注册一个函数,在倒计时完成后调用
                clockTimer.Elapsed += new ElapsedEventHandler(Update);
                //设置循环调用
                clockTimer.AutoReset = true;
                //开启 倒计时
                clockTimer.Enabled = true;
    
                Console.WriteLine("按下回车结束程序");
                Console.ReadLine();
            }
    
            private static void Update(object sender, ElapsedEventArgs e)
            {
                //此处语义:如果 lockClock 未上锁,则上锁并执行 代码
                lock (lockClock)
                {
                    if (check == false)
                    {
                        check = true;
                        Console.WriteLine(e.SignalTime);
                    }
                    else
                    {
                        //如果在此处无 return; 我们的代码就只能在 if 中调用
                        return;
                    }
                }
    
                //Console.WriteLine(e.SignalTime);
    
                //同样在 未上锁 时执行,之所以加 lock,是避免上面的代码未执行完毕就执行此处
                //虽然在本例子中 有无加 lock 没有差别
                lock (lockClock)
                {
                    check = false;
                }
            }
    
        }
    }
    



    展开全文
  • 使用Timer控件做一个倒计时器 可以根据输入的值来控制倒计时的事件。 假设输入的是180s 第一次点开始按钮是 180 179 178 ......正常的 点了重置按钮之后,第二次点开始按钮就是 180 178 176..... 再次重置...
  • C#线程(五)计时

    2018-05-12 13:23:14
    6. 计时器 计时器可以周期性的执行某个方法。6.1. System.Threading.Timer线程计时器利用了线程池,通过线程池定期执行某个方法,因此可以严格的定时执行某个方法。如果某个方法比较耗时,该计时器通过线程池技术...

    6. 计时器

     计时器可以周期性的执行某个方法。

    6.1. System.Threading.Timer

    线程计时器利用了线程池,通过线程池定期执行某个方法,因此可以严格的定时执行某个方法。如果某个方法比较耗时,该计时器通过线程池技术保证定时出发该方法,只不过通过不同的线程来执行。

    6.1.1. 常用方法

    构造方法

    public Timer (TimerCallback tick, object state, int dueTime , intperiod);

    tick:一个返回值为void,参数为object的委托,也是计时器执行的方法。

    state:计时器执行方法的的参数。

    dueTime:调用 callback 之前延迟的时间量(以毫秒为单位)。

    period:调用 callback 的时间间隔。

    Change方法

    bool Change (int dueTime, int period)

    用来改变调用方法之前延迟的时间量和调用时间间隔。

    Dispose方法

    void Dispose()

    用来关闭计时器,释放资源。

    6.1.2. 应用举例

     

    static void Main(string[] args)

    {          

         Timer t = new Timer(tick,null, 1000, 2000);

         Console.ReadKey();       

    }

     

    static void tick(object ob)

    {

        Console.WriteLine("Start");

         Thread.Sleep(5000);

        Console.WriteLine("End");

    }

     

    输出结果:

    Start

    Start

    Start

    End

    Start

    从上面的结果可以看出,定时器并没有阻塞在tick方法中。这是因为使用了线程池技术,从而保证在规定时间内定时执行时间。

    6.2. System.Timers.Timer

    System.Timers命名空间下的Timer类完全包装自System.Threading.Timer。

    定义一个System.Timers.Timer对象,然后绑定Elapsed事件,通过Start()方法来启动计时,通过Stop()方法或者Enable=false停止计时。AutoReset属性设置是否重复计时(设置为false只执行一次,设置为true可以多次执行)。

    6.2.1. 常用方法

    构造方法

    (1)public Timer()

    默认初始值:

    AutoReset:true

    Enabled:false

    Interval:100 毫秒

    (2)public Timer(double interval)

    参数代表设定间隔时间

    Dispose方法

    void Dispose()

    用来关闭计时器,释放资源。

    Start方法

    void Start()

    通过将 Enabled 设置为 true 开始引发 Elapsed 事件。

    Stop方法

    void Stop()

    通过将 Enabled 设置为 false 停止引发 Elapsed 事件。

     

     

    6.2.2. 常用属性

    AutoReset

    获取或设置一个布尔值,该值指示 Timer 是否应只引发一次 Elapsed 事件((false) 或重复 (true))。

     

    Enable

    获取或设置一个值,该值指示 Timer 是否应引发 Elapsed 事件。

     

    Interval

    获取或设置引发 Elapsed 事件的间隔(以毫秒为单位)。

    6.2.3. 事件

    Elapsed

    用于绑定需要定时执行的方法

     

    6.2.2. 应用举例

    static void Main(string[] args)

    {

         System.Timers.Timer t =new System.Timers.Timer(2000);

         t.AutoReset = true;

         t.Enabled = true;

         t.Elapsed += T_Elapsed;

         Console.ReadKey();       

    }

     

    private static void T_Elapsed(object sender,System.Timers.ElapsedEventArgs e)

    {

        Console.WriteLine("Start");

         Thread.Sleep(5000);

        Console.WriteLine("End");

    }

    输出结果:

    Start

    Start

    Start

    End

    Start

    从上面的结果可以看出,定时器并没有阻塞在tick方法中。这是因为使用了线程池技术,从而保证在规定时间内定时执行时间。

     

    6.3. System.Windows.Forms.Timer

    System.Windows.Forms.Timer用法类似于System.Timers.Timer,但功能特性上有根本的不同。

    System.Windows.Forms.Timer使用消息循环机制来取代线程池产生消息的机制。

    这意味着Tick事件总是在创建timer的那个线程上执行,同时也意味着如果上一次Tick消息还未被处理,即使时间超过了间隔时间也要等待上一次Tick执行完毕才能执行下一次Tick

    假定这是主线程——负责实例化所有Windows Forms程序中的forms和控件,计时器的事件能够操作forms和控件而不违反线程安全。它实质上是一个单线程timer

          Windows Forms计时器必须迅速地执行来更新用户接口。迅速地执行是非常重要的,因为Tick事件被主线程调用,如果它有阻塞,将使用户接口变的没有响应。

    展开全文
  • C#线程-倒计时

    2020-04-14 23:33:44
    该压缩包主要为大家展示C#版的倒计时,适用于刚接触C#新手,简单,易学。
  • C# 线程计时

    2016-03-18 12:27:10
    实现功能:(1)传入一个时间 HH:mm:ss 字符串 和 label控件对象 即可实现控件倒计时。三行代码即可运行,如下图效果:当然,每个项目需要的需求不同,这里只是抛砖引玉。下面贴出我的代码,欢迎讨论。完整代码:...

    原文地址:http://blog.csdn.net/andrew_wx/article/details/6659756


    该例子是一个封装的计时器类。

    实现功能:

    (1)传入一个时间 HH:mm:ss 字符串 和 label控件对象 即可实现控件倒计时。

    三行代码即可运行,如下图效果:

    当然,每个项目需要的需求不同,这里只是抛砖引玉。

    下面贴出我的代码,欢迎讨论。

    完整代码:

    namespace ThreadTime  
    {  
        public partial class Form1 : Form  
        {  
            public Form1()  
            {  
                InitializeComponent();  
            }  
    
            private void button1_Click(object sender, EventArgs e)  
            {  
                TimeSpan time = TimeSpan.Parse("01:00:00");  
                TimeHelper myTime = new TimeHelper(time, label1);  
                myTime.Open();  
            }  
    
            private void button2_Click(object sender, EventArgs e)  
            {  
                TimeSpan time = TimeSpan.Parse("01:00:00");  
                TimeHelper myTime = new TimeHelper(time, label2);  
                myTime.Open();  
            }  
    
            private void button3_Click(object sender, EventArgs e)  
            {  
                TimeSpan time = TimeSpan.Parse("00:00:05");  
                TimeHelper myTime = new TimeHelper(time, label3);  
                myTime.Open();  
            }  
    
        }  
    }  

    其实只有三行代码,因为有3个计时器。所以写了9行。。
    当然也可以写成两行代码,如下:

    TimeHelper myTime = new TimeHelper(TimeSpan.Parse("01:00:00"), label1);  
    myTime.Open();  

    这是主窗体的代码,下面贴出TimeHelper.cs 类的关键代码。

    TimeHelper完整代码:

    引入命名using System.Threading;
    using System.Windows.Forms; 码:

    namespace ThreadTime  
    {  
        class TimeHelper  
        {  
            Thread thread;  
            private TimeSpan time;  //计时时间  
            private TimeSpan endTime;   //到点时间  
            private Label lb;  
            private bool whereExit = true;  
    
            /// <summary>  
            /// 设定计时器计时的时间  
            /// </summary>  
            /// <param name="StartTime">计时器时间,如:01:00:00 既1小时</param>  
            public TimeHelper(TimeSpan StartTime,Label lb)  
            {  
                time = StartTime;  
                this.lb = lb;  
            }  
    
            public void ShowLabel()  
            {  
                lb.Text = time.ToString();  
            }  
    
            /// <summary>  
            /// 获取时间  
            /// </summary>  
            /// <returns></returns>  
            public TimeSpan GetTime()  
            {  
                return time;  
            }  
    
            /// <summary>  
            /// 开启计时器  
            /// </summary>  
            public void Open()  
            {  
                //计算到点时间  
                TimeSpan tsNow = TimeSpan.Parse(DateTime.Now.ToString("HH:mm:ss"));  
                TimeSpan tsAdd = time;  
                endTime = tsNow + tsAdd;  
                //线程开始  
                whereExit = false;  
                thread = new Thread(TimeThreadStart);  
                thread.IsBackground = true;  
                thread.Start();  
            }  
    
            /// <summary>  
            /// 关闭计时器  
            /// </summary>  
            public void Close()  
            {  
                whereExit = true;  
                thread.Join(1000);  
            }  
    
            private void TimeThreadStart()  
            {  
                while (!whereExit)  
                {  
                    RunTime();  
                    Thread.Sleep(1000);  
                }  
            }  
    
            private delegate void RunTimeDelegate();  
            private void RunTime()  
            {  
                if (lb.InvokeRequired)  
                {  
                    RunTimeDelegate d = RunTime;  
                    lb.Invoke(d);  
                }  
                else  
                {  
                    time = endTime - TimeSpan.Parse(DateTime.Now.ToString("HH:mm:ss"));  
                    lb.Text = time.ToString();  
                }  
            }  
        }  
    }  

    若编译有问题,可以下载我上传的完整项目包: http://download.csdn.net/source/3494587

    展开全文
  • C#线程 计时器 到计时 C#线程 计时器 到计时 C#线程 计时器 到计时 C#线程 计时器 到计时 C#线程 计时器 到计时
  • C#线程计时器类

    2014-08-27 22:22:19
    原文地址:http://blog.csdn.net/andrew_wx/article/details/6659756 很好的一片文章,

    原文地址:http://blog.csdn.net/andrew_wx/article/details/6659756

    很好的一片文章,推荐大家去看下。

    该例子是一个封装的计时器类。

    实现功能:

    (1)传入一个时间 HH:mm:ss 字符串 和 label控件对象 即可实现控件倒计时。


    三行代码即可运行,如下图效果:


    当然,每个项目需要的需求不同,这里只是抛砖引玉。


    下面贴出我的代码,欢迎讨论。

    完整代码:

    1. namespace ThreadTime  
    2. {  
    3.     public partial class Form1 : Form  
    4.     {  
    5.         public Form1()  
    6.         {  
    7.             InitializeComponent();  
    8.         }  
    9.   
    10.         private void button1_Click(object sender, EventArgs e)  
    11.         {  
    12.             TimeSpan time = TimeSpan.Parse("01:00:00");  
    13.             TimeHelper myTime = new TimeHelper(time, label1);  
    14.             myTime.Open();  
    15.         }  
    16.   
    17.         private void button2_Click(object sender, EventArgs e)  
    18.         {  
    19.             TimeSpan time = TimeSpan.Parse("01:00:00");  
    20.             TimeHelper myTime = new TimeHelper(time, label2);  
    21.             myTime.Open();  
    22.         }  
    23.   
    24.         private void button3_Click(object sender, EventArgs e)  
    25.         {  
    26.             TimeSpan time = TimeSpan.Parse("00:00:05");  
    27.             TimeHelper myTime = new TimeHelper(time, label3);  
    28.             myTime.Open();  
    29.         }  
    30.   
    31.     }  
    32. }  

    其实只有三行代码,因为有3个计时器。所以写了9行。。

    当然也可以写成两行代码,如下:

    1. TimeHelper myTime = new TimeHelper(TimeSpan.Parse("01:00:00"), label1);  
    2. myTime.Open();  

    这是主窗体的代码,下面贴出TimeHelper.cs 类的关键代码。


    TimeHelper完整代码:

    引入命名空间:

    1. using System.Threading;  
    2. using System.Windows.Forms;  

    完整代码:

    1. namespace ThreadTime  
    2. {  
    3.     class TimeHelper  
    4.     {  
    5.         Thread thread;  
    6.         private TimeSpan time;  //计时时间  
    7.         private TimeSpan endTime;   //到点时间  
    8.         private Label lb;  
    9.         private bool whereExit = true;  
    10.   
    11.         /// <summary>  
    12.         /// 设定计时器计时的时间  
    13.         /// </summary>  
    14.         /// <param name="StartTime">计时器时间,如:01:00:00 既1小时</param>  
    15.         public TimeHelper(TimeSpan StartTime,Label lb)  
    16.         {  
    17.             time = StartTime;  
    18.             this.lb = lb;  
    19.         }  
    20.   
    21.         public void ShowLabel()  
    22.         {  
    23.             lb.Text = time.ToString();  
    24.         }  
    25.   
    26.         /// <summary>  
    27.         /// 获取时间  
    28.         /// </summary>  
    29.         /// <returns></returns>  
    30.         public TimeSpan GetTime()  
    31.         {  
    32.             return time;  
    33.         }  
    34.   
    35.         /// <summary>  
    36.         /// 开启计时器  
    37.         /// </summary>  
    38.         public void Open()  
    39.         {  
    40.             //计算到点时间  
    41.             TimeSpan tsNow = TimeSpan.Parse(DateTime.Now.ToString("HH:mm:ss"));  
    42.             TimeSpan tsAdd = time;  
    43.             endTime = tsNow + tsAdd;  
    44.             //线程开始  
    45.             whereExit = false;  
    46.             thread = new Thread(TimeThreadStart);  
    47.             thread.IsBackground = true;  
    48.             thread.Start();  
    49.         }  
    50.   
    51.         /// <summary>  
    52.         /// 关闭计时器  
    53.         /// </summary>  
    54.         public void Close()  
    55.         {  
    56.             whereExit = true;  
    57.             thread.Join(1000);  
    58.         }  
    59.   
    60.         private void TimeThreadStart()  
    61.         {  
    62.             while (!whereExit)  
    63.             {  
    64.                 RunTime();  
    65.                 Thread.Sleep(1000);  
    66.             }  
    67.         }  
    68.   
    69.         private delegate void RunTimeDelegate();  
    70.         private void RunTime()  
    71.         {  
    72.             if (lb.InvokeRequired)  
    73.             {  
    74.                 RunTimeDelegate d = RunTime;  
    75.                 lb.Invoke(d);  
    76.             }  
    77.             else  
    78.             {  
    79.                 time = endTime - TimeSpan.Parse(DateTime.Now.ToString("HH:mm:ss"));  
    80.                 lb.Text = time.ToString();  
    81.             }  
    82.         }  
    83.     }  
    84. }  

    若编译有问题,可以下载我上传的完整项目包: http://download.csdn.net/source/3494587

    原文地址:http://blog.csdn.net/andrew_wx/article/details/6659756


    展开全文
  • C#简单的倒计时软件

    2020-05-17 19:07:26
    使用winform开发的一个简单的倒计时软件,可供学习的地方有:winfrom透明背景 窗体桌面置顶 无窗体边框 时间计算 多线程调用(使用多线程实现刷新秒数,避免窗体假死不会实时刷新)
  • C#实现倒计时功能

    2010-07-08 21:28:00
    (1) 首先创建两个窗体,在Form1窗体上添加一个Button按钮和一个timer组件,用来执行倒计时功能;在Form2中添加一个Label控件,用于显示倒计时。 (2) 在Form2窗体中定义一个公共变量curr_time,用于...
  • 废话不多说了,直接上效果图了! 代码,如下: namespace MyForm { public delegate void FlushTime();//定义时间刷新的委托 public partial class Form1 : Form { public Form1() ... InitializeComponent...
  • 下面的代码是关于C#实现的windows form 倒计时的代码。 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using ...
  • 倒计时:是运用线程的休眠方式来模拟倒计时的。 实现步骤: 获取当前时间并加上10秒(我是想让时间只倒计10秒) 获取当前时间的毫秒数(是加了10秒的当前时间) 循环打印时间(在打印时间为了打印的效果:引用...
  • 本章讲述:C#计时器的简单实现方法; 1、System.Threading.Timer 使用方法: //定义计时器 private System.Threading.Timer timerClose; //初始化计时器 timerClose = new System.Threading.Timer(new ...
  • c#毫秒级计时

    2017-10-10 15:10:07
    使用C#提供一个毫秒级的计时
  •   system.Timers命名空间下的Timer类,使用Elapsed事件另开一个线程。定义一个System.Timers.Timer对象,然后绑定Elapsed事件,通过Start()方法来启动计时,通过Stop()方法或者Enable=false停止计时; M...
  • C#线程计时器类。

    2018-12-31 23:43:14
    (1)传入一个时间 HH:mm:ss 字符串 和 label控件对象 即可实现控件倒计时。 三行代码即可运行,如下图效果: 当然,每个项目需要的需求不同,这里只是抛砖引玉。 下面贴出我的代码,欢迎讨论。 ...
  • C#实现微秒级计时

    2019-01-12 10:38:00
    自己写了一个类(传送门在文尾),调用这个类的方法和调用C#自带的System.Timers中的定时器差不多,但是考虑到当定时器用确实不太准,所以改成了计时器,下面演示示例用法: 有这样一个场景,我需要得到一个相机单次...
  • winfrom计时小程序,功能较为完善可以满足会议,演讲,个人计时等更能需求,设置简单快捷,主要包含以下功能,桌面倒计时,多时段个性化提醒,提示语个性化设置,桌面置顶,自动隐藏等功能特点,并且附有源码,欢迎...
1 2 3 4 5 ... 20
收藏数 822
精华内容 328