C#定时器与延时操作的使用

引言

在 c# 开发的广袤领域中，定时器与延时机制宛如隐匿在幕后的精密齿轮，悄无声息却又至关重要地推动着程序的高效运转。它们是构建复杂逻辑和实现特定功能的基石，为开发者提供了对程序执行时间的精准把控。

定时器，如同一位不知疲倦的时间管家，按照预设的时间间隔准时触发事件，执行特定的代码块。在数据处理中，我们常常需要定时从数据库中获取最新数据，进行实时分析与展示；在网络通信中，定时发送心跳包以维持连接的稳定性，确保信息的顺畅传输。这些场景都离不开定时器的助力，它让程序能够有条不紊地按照既定节奏工作，实现各种自动化任务。

而延时，则像是为程序执行流程按下了 “暂停键”，让特定的操作在经过一段指定的时间后再执行。当我们启动一个程序时，可能需要延时片刻，等待系统资源的初始化和加载，确保程序后续的稳定运行；在用户交互过程中，为了避免频繁操作导致的系统压力，也会设置一定的延时，提升用户体验。

无论是定时器还是延时，它们都在 c# 开发中扮演着不可或缺的角色，帮助开发者实现定时任务、控制程序执行节奏、优化用户体验等。接下来，就让我们一同深入探索 c# 定时器与延时的奇妙世界，揭开它们神秘的面纱，学习如何在实际项目中巧妙运用它们。

c# 定时器详解

常见定时器类介绍

在 c# 的庞大类库中，为我们提供了多种定时器类，以满足不同场景下的定时需求。其中，较为常见的有 system.windows.forms.timer、system.threading.timer 和 system.timers.timer，它们各自有着独特的特点和适用场景。

• system.windows.forms.timer：主要应用于 windows 窗体应用程序中，它运行在 ui 线程上，通过 tick 事件来触发定时操作。这使得它在更新 ui 元素时非常便捷，因为可以直接在 tick 事件处理程序中操作 ui 控件，而无需担心线程安全问题。不过，由于它依赖于 windows 消息循环，所以不适用于控制台应用程序等非 ui 环境，并且其时间精度相对较低，大约在 10 - 30 毫秒左右。
• system.threading.timer：基于线程池来工作，是一种轻量级的定时器。它以回调的方式实现定时任务，具有较高的执行效率，适用于对性能要求较高、无需频繁操作 ui 的后台任务场景。它的启动和停止操作相对灵活，并且可以通过构造函数的参数来精确控制首次执行时间和执行间隔。但需要注意的是，在操作 ui 时，由于它不在 ui 线程上运行，所以需要进行跨线程操作的处理。
• system.timers.timer：可以在多线程或单线程环境中使用，通过 elapsed 事件触发定时操作。它适用于对时间精度要求较高的场景，并且支持线程同步。在使用时，可以通过设置 autoreset 属性来决定事件触发后是否自动重置定时器，以实现单次触发或循环触发的功能。不过，在操作 ui 时同样需要注意跨线程的问题。

system.windows.forms.timer 使用示例

接下来，我们通过一个简单的 winforms 项目来演示 system.windows.forms.timer 的使用。首先，打开 visual studio，创建一个新的 windows forms 应用程序项目。

在设计视图中，从工具箱中找到 timer 控件，并将其拖放到窗体上。此时，在窗体下方的组件栏中会出现一个 timer 图标，选中它，在属性窗口中设置 interval 属性为 1000，表示时间间隔为 1 秒；设置 enabled 属性为 false，初始状态下不启动定时器。

然后，双击 timer 控件，自动生成 tick 事件处理程序。在事件处理程序中，我们可以编写定时执行的代码。例如，我们要实现一个每秒更新一次 label 显示当前时间的功能，代码如下：

private void timer1_tick(object sender, eventargs e)
{
    label1.text = datetime.now.tostring("hh:mm:ss");
}

在上述代码中，当 timer 的 tick 事件触发时，会将当前时间以 “hh:mm:ss” 的格式赋值给 label1 的 text 属性，从而实现每秒更新一次时间显示的效果。

最后，我们可以在窗体的 load 事件或某个按钮的 click 事件中启动定时器，例如：

private void form1_load(object sender, eventargs e)
{
    timer1.enabled = true;
}

这样，当窗体加载完成后，定时器就会开始工作，每秒触发一次 tick 事件，更新 label 的显示内容。

system.threading.timer 使用示例

system.threading.timer 的使用方式与 system.windows.forms.timer 有所不同。下面是一个简单的代码示例，展示如何使用 system.threading.timer 来实现定时任务：

using system;
using system.threading;
class program
{
    private static timer timer;
    static void main()
    {
        // 定义回调函数
        timercallback callback = new timercallback(timertask);
        // 创建timer实例，设置启动时间为0，间隔时间为1000毫秒（1秒）
        timer = new system.threading.timer(callback, null, 0, 1000);
        console.writeline("按任意键停止定时器...");
        console.readkey();
        // 停止定时器
        timer.dispose();
        console.writeline("定时器已停止");
    }
    // 回调函数
    private static void timertask(object state)
    {
        console.writeline("定时器回调执行于：" + datetime.now);
    }
}

在上述代码中，首先定义了一个 timercallback 类型的回调函数 timertask，该函数会在定时器触发时执行。然后，通过 timer 的构造函数创建了一个定时器实例，传入回调函数、状态对象（这里为 null）、首次执行的延迟时间（0 毫秒，表示立即执行）和执行间隔时间（1000 毫秒）。在 main 方法中，等待用户按下任意键后，调用 timer.dispose () 方法停止并释放定时器资源。

需要注意的是，由于 system.threading.timer 基于线程池工作，其回调函数不在 ui 线程上执行，所以在回调函数中不能直接操作 ui 控件。如果需要操作 ui，需要使用 invoke 或 begininvoke 方法来切换到 ui 线程。例如，在 winforms 应用中，如果要在回调函数中更新 label 的文本，可以这样实现：

using system;
using system.threading;
using system.windows.forms;
namespace threadingtimerexample
{
    public partial class form1 : form
    {
        private static timer timer;
        public form1()
        {
            initializecomponent();
        }
        private void form1_load(object sender, eventargs e)
        {
            // 定义回调函数
            timercallback callback = new timercallback(timertask);
            // 创建timer实例，设置启动时间为0，间隔时间为1000毫秒（1秒）
            timer = new system.threading.timer(callback, null, 0, 1000);
        }
        // 回调函数
        private static void timertask(object state)
        {
            form1 form = (form1)state;
            form.invoke((methodinvoker)delegate
            {
                form.label1.text = datetime.now.tostring("hh:mm:ss");
            });
        }
        private void form1_formclosed(object sender, formclosedeventargs e)
        {
            // 停止定时器
            timer.dispose();
        }
    }
}

在这个示例中，将 form1 实例作为状态对象传递给定时器，在回调函数中通过 invoke 方法将更新 label 文本的操作切换到 ui 线程上执行，以确保线程安全。

system.timers.timer 使用示例

system.timers.timer 的使用方式也有其特点，以下是一个使用 system.timers.timer 的示例代码：

using system;
using system.timers;

class program
{
    private static timer timer;

    static void main()
    {
        // 创建timer对象
        timer = new system.timers.timer();

        // 设置间隔时间为1000毫秒（1秒）
        timer.interval = 1000;

        // 设置autoreset属性为true，表示事件关联的方法会一直执行
        timer.autoreset = true;

        // 绑定elapsed事件
        timer.elapsed += new system.timers.elapsedeventhandler(ontimedevent);

        // 启用定时器
        timer.enabled = true;

        console.writeline("按enter键退出程序...");
        console.readline();

        // 停止定时器
        timer.stop();
        timer.dispose();
    }

    // elapsed事件处理函数
    private static void ontimedevent(object source, system.timers.elapsedeventargs e)
    {
        console.writeline("elapsed事件于 {0:hh:mm:ss.fff} 触发", e.signaltime);
    }
}

在这段代码中，首先创建了一个 system.timers.timer 对象，设置其 interval 属性为 1 秒，autoreset 属性为 true，这样定时器会在每次到达时间间隔时自动重置并再次触发 elapsed 事件。然后，通过 += 运算符将 ontimedevent 方法绑定到 elapsed 事件上，当事件触发时，会执行 ontimedevent 方法，在控制台输出事件触发的时间。最后，在程序结束时，调用 timer.stop () 方法停止定时器，并调用 timer.dispose () 方法释放资源。

同样，如果在 winforms 应用中使用 system.timers.timer 并需要操作 ui，也需要注意跨线程问题。可以通过设置 synchronizingobject 属性将定时器的操作同步到 ui 线程上，例如：

using system;
using system.timers;
using system.windows.forms;

namespace timerstimerexample
{
    public partial class form1 : form
    {
        private system.timers.timer timer;

        public form1()
        {
            initializecomponent();

            // 创建timer对象
            timer = new system.timers.timer();

            // 设置间隔时间为1000毫秒（1秒）
            timer.interval = 1000;

            // 设置autoreset属性为true，表示事件关联的方法会一直执行
            timer.autoreset = true;

            // 绑定elapsed事件
            timer.elapsed += new system.timers.elapsedeventhandler(ontimedevent);

            // 将定时器的操作同步到ui线程
            timer.synchronizingobject = this;

            // 启用定时器
            timer.enabled = true;
        }

        // elapsed事件处理函数
        private void ontimedevent(object source, system.timers.elapsedeventargs e)
        {
            label1.text = datetime.now.tostring("hh:mm:ss");
        }

        private void form1_formclosed(object sender, formclosedeventargs e)
        {
            // 停止定时器
            timer.stop();
            timer.dispose();
        }
    }
}

在这个示例中，通过设置 timer.synchronizingobject = this，将定时器的操作同步到当前窗体的 ui 线程上，这样在 elapsed 事件处理函数中就可以直接操作 ui 控件，而无需额外的跨线程处理。

定时器应用场景举例

在实际项目开发中，定时器有着广泛的应用场景，以下是一些常见的例子：

• 定时数据备份：在数据库管理系统中，为了保证数据的安全性和完整性，常常需要定时对数据库进行备份操作。通过使用定时器，可以设置每天、每周或每月的特定时间点自动执行备份任务，将数据库中的数据复制到安全的存储位置，以防止数据丢失或损坏。例如，在一个企业级的财务管理系统中，每天凌晨 2 点定时备份财务数据，确保数据的实时性和可恢复性。
• 轮询服务状态：在分布式系统中，各个服务之间相互协作，为了确保系统的稳定性和可靠性，需要实时监控各个服务的运行状态。定时器可以定时向各个服务发送心跳请求，检测服务是否正常响应。如果某个服务在规定时间内没有响应，系统可以及时发出警报，并采取相应的措施，如自动重启服务或进行故障转移。比如，在一个电商平台的微服务架构中，定时轮询订单服务、支付服务等的状态，确保用户的购物流程不受影响。
• 定时更新缓存：在 web 应用程序中，为了提高数据的访问速度，常常使用缓存技术。然而，缓存中的数据需要与数据库中的实时数据保持一致，因此需要定时更新缓存。定时器可以按照设定的时间间隔，从数据库中获取最新的数据，并更新到缓存中，以保证用户获取到的数据是最新的。例如，在一个新闻资讯网站中，每 10 分钟定时更新缓存中的热门新闻列表，为用户提供最新的新闻内容。
• 自动化任务调度：在一些需要定期执行的任务中，如生成报表、发送邮件、清理临时文件等，定时器可以发挥重要作用。通过设置定时器的触发时间和执行间隔，实现任务的自动化调度，减少人工干预，提高工作效率。比如，在一个企业的办公自动化系统中，每周一早上 9 点定时生成上周的工作报表，并自动发送给相关部门的负责人。

c# 延时实现方式

thread.sleep 方法

在 c# 中，thread.sleep方法是一种简单直接的实现延时的方式。它的作用是使当前线程暂停执行指定的时间，参数为毫秒数。例如，thread.sleep(1000)表示让当前线程休眠 1000 毫秒，即 1 秒。

using system;
using system.threading;

class program
{
    static void main()
    {
        console.writeline("开始延时...");
        thread.sleep(3000); // 延时3秒
        console.writeline("延时结束");
    }
}

上述代码中，当执行到thread.sleep(3000)时，主线程会被阻塞，暂停执行 3 秒，在此期间，线程不会执行任何其他操作，3 秒后线程才会恢复执行后续代码。然而，由于thread.sleep会阻塞当前线程，如果在 ui 线程中使用，会导致界面无响应，出现卡顿甚至假死的情况，所以它不适合在需要保持界面交互性的 ui 线程中使用。但在一些简单的控制台应用程序、测试代码或者对线程执行顺序有严格要求且不需要线程在延时期间执行其他任务的场景中，thread.sleep方法还是非常实用的。

task.delay 方法

task.delay方法是基于异步编程模型的延时实现方式，它具有异步特性，不会阻塞当前线程。task.delay方法返回一个task对象，表示在指定的时间间隔后完成的异步操作。通常，它会配合async/await关键字一起使用，以实现异步延时的效果。

using system;
using system.threading.tasks;

class program
{
    static async task main()
    {
        console.writeline("开始异步延时...");
        await task.delay(2000); // 异步延时2秒
        console.writeline("异步延时结束");
    }
}

在上述代码中，await task.delay(2000)会启动一个异步任务，该任务会在 2 秒后完成。当执行到这一行代码时，方法会暂停执行，但当前线程不会被阻塞，而是将控制权返回给调用者，调用者可以继续执行其他任务。2 秒后，task.delay任务完成，程序从await之后的代码继续执行。

在 ui 应用中，task.delay的优势尤为明显。例如，在一个 winforms 应用程序中，当用户点击按钮时，如果使用thread.sleep进行延时操作，界面会在延时期间冻结，无法响应用户的任何操作；而使用task.delay，界面则可以保持响应，用户可以继续进行其他交互，极大地提升了用户体验。此外，在需要处理高并发的服务器应用或者其他异步操作场景中，task.delay也能充分发挥其非阻塞的优势，提高系统资源的利用率和程序的整体性能。

使用 timer 实现延时

除了上述两种方式，还可以利用定时器来实现延时效果。以system.timers.timer为例，通过设置其interval属性和autoreset属性，可以实现单次触发的延时操作。

using system;
using system.timers;

class program
{
    private static timer timer;

    static void main()
    {
        // 创建timer对象
        timer = new system.timers.timer();

        // 设置间隔时间为3000毫秒（3秒）
        timer.interval = 3000;

        // 设置autoreset属性为false，表示只执行一次
        timer.autoreset = false;

        // 绑定elapsed事件
        timer.elapsed += new system.timers.elapsedeventhandler(ontimedevent);

        // 启用定时器
        timer.enabled = true;

        console.writeline("启动定时器，开始延时...");

        console.writeline("按enter键退出程序...");
        console.readline();

        // 停止定时器
        timer.stop();
        timer.dispose();
    }

    // elapsed事件处理函数
    private static void ontimedevent(object source, system.timers.elapsedeventargs e)
    {
        console.writeline("延时结束，定时器触发于：" + e.signaltime);
    }
}

在这段代码中，创建了一个system.timers.timer对象，设置其interval为 3 秒，autoreset为false，这样定时器只会触发一次。当定时器启动后，经过 3 秒，会触发elapsed事件，执行ontimedevent方法中的代码，实现了延时 3 秒后执行特定操作的效果。

各种延时方法对比与选择

从是否阻塞线程的角度来看，thread.sleep会阻塞当前线程，在延时期间线程无法执行其他任务；而task.delay和利用定时器实现的延时不会阻塞线程，线程可以在延时期间继续执行其他操作。

在是否适用于 ui 方面，thread.sleep不适合在 ui 线程中使用，否则会导致界面卡顿；task.delay则非常适合在 ui 应用中实现延时操作，能够保持界面的响应性；使用定时器实现延时，如果需要操作 ui，需要注意跨线程问题，可通过设置synchronizingobject属性等方式来确保线程安全。

在选择延时方法时，如果是简单的控制台应用程序，对线程执行顺序有严格要求，且不需要线程在延时期间执行其他任务，可以选择thread.sleep；如果是在 ui 应用程序或者需要处理高并发的异步操作场景中，为了保持界面响应性或提高系统资源利用率，应优先选择task.delay；如果需要实现更复杂的定时任务，包括循环触发或单次触发等，可以考虑使用定时器来实现延时效果。

实战案例：打造定时数据采集程序

需求分析

在实际的项目开发中，定时采集数据并存储是一个非常常见的需求。例如，在工业自动化领域，我们需要定时采集各种传感器的数据，以便对生产过程进行实时监控和分析；在物联网项目中，需要定时从各种智能设备中采集数据，用于数据分析和业务决策。

本案例的目标是实现一个定时数据采集程序，能够按照设定的时间间隔从指定的数据源采集数据，并将采集到的数据存储到本地文件或数据库中，为后续的数据分析和处理提供基础。

技术选型

为了实现这个定时数据采集程序，我们可以选择使用system.threading.timer来实现定时任务，因为它基于线程池工作，具有较高的执行效率，适合在后台长时间运行的任务。同时，使用task.delay来实现一些简单的延时操作，以满足在数据采集过程中的一些特殊时间控制需求。

在数据存储方面，我们可以选择使用文件系统来存储数据，将采集到的数据以文本文件的形式保存到本地磁盘，这种方式简单直观，适合数据量较小的场景；如果数据量较大或对数据管理和查询有更高的要求，也可以选择使用数据库，如 sqlite、mysql 等，这里我们先以文件存储为例进行演示。

代码实现

下面是一个使用system.threading.timer实现定时数据采集并存储到文件的示例代码：

using system;
using system.io;
using system.threading;

class datacollector
{
    private static timer timer;
    private static string filepath = "data.txt";

    static void main()
    {
        // 定义回调函数
        timercallback callback = new timercallback(collectdata);

        // 创建timer实例，设置启动时间为0，间隔时间为5000毫秒（5秒）
        timer = new system.threading.timer(callback, null, 0, 5000);

        console.writeline("数据采集程序已启动，按任意键停止...");
        console.readkey();

        // 停止定时器
        timer.dispose();
        console.writeline("数据采集程序已停止");
    }

    // 回调函数，用于采集数据并存储
    private static void collectdata(object state)
    {
        // 模拟数据采集，这里使用当前时间作为采集数据
        string data = datetime.now.tostring("yyyy-mm-dd hh:mm:ss");

        // 将数据存储到文件中
        using (streamwriter sw = file.appendtext(filepath))
        {
            sw.writeline(data);
        }

        console.writeline($"采集到数据：{data} 并已存储到文件");
    }
}

在上述代码中，首先在main方法中创建了一个system.threading.timer实例，设置其回调函数为collectdata，首次执行时间为 0（即立即执行），执行间隔为 5 秒。在collectdata回调函数中，模拟采集数据（这里使用当前时间作为数据），并将数据追加写入到名为data.txt的文件中。

到此这篇关于c#定时器与延时操作的使用的文章就介绍到这了,更多相关c#定时器与延时操作内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！