在现代应用程序开发中，定时任务是不可或缺的组成部分。无论是数据同步、邮件发送、系统维护，还是定期生成报告，都需要可靠的定时任务支持。本文将介绍如何使用 Cronos，一个强大的 .NET 任务调度库，通过控制台应用程序来实现定时任务。

## 什么是 Cronos？

Cronos 是一个轻量级的 .NET 库，用于解析和计算 CRON 表达式。它允许开发者使用熟悉的 CRON 语法来安排任务的执行时间。Cronos 的主要特点包括：

- **支持标准 CRON 语法**：包括秒、分、时、日、月和星期。
- **高性能**：采用高效的算法解析 CRON 表达式。
- **灵活性**：可用于各种 .NET 程序，包括控制台、Web 应用和服务。

## 环境准备

在开始之前，请确保您已安装以下环境：

- .NET 6 SDK 或更高版本
- 一个文本编辑器或 IDE（如 Visual Studio 或 Visual Studio Code）

## 安装 Cronos 包

在项目中安装 Cronos 包：

```Bash
dotnet add package Cronos
```



## 实现定时任务

接下来，我们将创建一个通用的定时任务基类，使用 `Cronos` 来解析 CRON 表达式，并使用 `Task.Delay` 来等待下一个执行时间。

### 创建基础定时任务类

```C#
using Cronos;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppCron
{
    public abstract class CronJob
    {
        private readonly CronExpression _expression;
        private readonly TimeZoneInfo _timeZoneInfo;

        protected CronJob(string cronExpression, TimeZoneInfo timeZoneInfo = null)
        {
            _expression = CronExpression.Parse(cronExpression, CronFormat.IncludeSeconds); // 指定格式为包含秒  
            _timeZoneInfo = timeZoneInfo ?? TimeZoneInfo.Local;
        }

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                var next = _expression.GetNextOccurrence(DateTimeOffset.Now, _timeZoneInfo);
                if (next.HasValue)
                {
                    var delay = next.Value - DateTimeOffset.Now;
                    if (delay.TotalMilliseconds > 0)
                    {
                        await Task.Delay(delay, cancellationToken);
                    }

                    if (!cancellationToken.IsCancellationRequested)
                    {
                        await ExecuteAsync(cancellationToken);
                    }
                }
                else
                {
                    break;
                }
            }
        }

        protected abstract Task ExecuteAsync(CancellationToken cancellationToken);
    }
}


```

### 示例任务：打印消息

让我们创建一个示例任务，每分钟打印一条消息。

```C#
using System;
using System.Threading;
using System.Threading.Tasks;

public class PrintMessageJob : CronJob
{
    public PrintMessageJob() : base("0 * * * * *") // 每分钟的第 0 秒执行
    {
    }

    protected override Task ExecuteAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine($"当前时间：{DateTime.Now}");
        return Task.CompletedTask;
    }
}
```

### 在主程序中运行任务

修改 `Program.cs` 文件：

```C#
using System;
using System.Threading;
using System.Threading.Tasks;

namespace CronosDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var cts = new CancellationTokenSource();
            Console.CancelKeyPress += (sender, eventArgs) =>
            {
                Console.WriteLine("正在退出...");
                cts.Cancel();
                eventArgs.Cancel = true;
            };

            var job = new PrintMessageJob();
            await job.StartAsync(cts.Token);
        }
    }
}
```


![image.png](https://www.otteach.cn/static/img/73c6248e7062041abe07f379147bbdee.image.webp)

每分钟，程序将输出当前时间。

## 更多示例

### 示例 1：每隔 5 秒执行任务

修改任务的 CRON 表达式：

```C#
public class PrintMessageJob : CronJob
{
    public PrintMessageJob() : base("*/5 * * * * *") // 每隔 5 秒执行
    {
    }

    // 其余代码保持不变
}
```


![image.png](https://www.otteach.cn/static/img/32d8fd4b379fdcd27b2daf36d0252fd4.image.webp)

### 示例 2：每天凌晨 2 点执行数据备份

创建一个新的任务类：

```C#
using System;
using System.Threading;
using System.Threading.Tasks;

public class DataBackupJob : CronJob
{
    public DataBackupJob() : base("0 0 2 * * *") // 每天凌晨 2 点执行
    {
    }

    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("开始数据备份...");
        // 模拟备份操作
        await Task.Delay(2000, cancellationToken);
        Console.WriteLine("数据备份完成！");
    }
}
```

修改 `Program.cs`，使其可以同时管理多个任务：

```C#
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace CronosDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var cts = new CancellationTokenSource();
            Console.CancelKeyPress += (sender, eventArgs) =>
            {
                Console.WriteLine("正在退出...");
                cts.Cancel();
                eventArgs.Cancel = true;
            };

            var jobs = new List<CronJob>
            {
                new PrintMessageJob(),
                new DataBackupJob()
            };

            var tasks = new List<Task>();
            foreach (var job in jobs)
            {
                tasks.Add(job.StartAsync(cts.Token));
            }

            await Task.WhenAll(tasks);
        }
    }
}
```

## 理解 CRON 表达式

CRON 表达式由空格分隔的六个字段组成：

```text
┌──────── 秒 (0 - 59)
│ ┌────── 分钟 (0 - 59)
│ │ ┌──── 小时 (0 - 23)
│ │ │ ┌── 日期 (1 - 31)
│ │ │ │ ┌ 月份 (1 - 12)
│ │ │ │ │ ┌─ 星期 (0 - 6) [星期日=0]
│ │ │ │ │ │
* * * * * *
```

### 常用示例

- `* * * * * *`：每秒执行
- `0 * * * * *`：每分钟的第 0 秒执行
- `0 0 * * * *`：每小时的第 0 分 0 秒执行
- `0 0 2 * * *`：每天凌晨 2 点执行
- `0 */5 * * * *`：每隔 5 分钟执行
- `0 0 9-17 * * 1-5`：周一至周五的 9 点至 17 点，每小时执行一次

## 注意事项和最佳实践

- **时区设置**：确保任务的执行时间与预期的时区一致。默认情况下，Cronos 使用本地时区。
- **异常处理**：在任务执行过程中，要捕获并处理可能的异常，防止任务崩溃。
- **任务间隔**：避免使用过短的间隔（如每秒执行），以免对系统造成压力。
- **资源释放**：如果任务使用了文件、网络连接等资源，确保在任务完成后正确释放。

## 小结

Cronos 为 .NET 应用程序提供了强大的定时任务调度能力。通过本文的控制台示例，您可以轻松实现各种定时任务需求。记住要根据实际业务场景选择合适的 CRON 表达式，并始终关注任务的可靠性和性能。

## 参考资料

- [Cronos 官方文档](https://github.com/HangfireIO/Cronos)
- [CRON 表达式生成器](https://crontab.guru/)

---

希望这篇文章对您有所帮助，祝您在 .NET 开发中一切顺利！

掌握 Cronos：使用 .NET 和控制台实现定时任务的指南

## 简介

本文将详细介绍如何使用C#和GDI+技术实现一个精美的液晶数字显示控件。这个控件支持显示数字0-9和小数点，可以用来模拟各种电子设备上的LCD显示效果。

## 实现原理

液晶数字显示是由7段LED组成的，每个数字由不同的段组合显示。我们将使用GDI+的绘图功能来实现发光效果，使用Path来绘制每个段，并添加渐变效果使其看起来更真实。

## 完整代码实现

![image.png](https://www.otteach.cn/static/img/a0caba8895447cb0cf207d43ef98535b.image.webp)



```C#
using System;
using System.Collections.Generic;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Timer = System.Windows.Forms.Timer;

namespace AppControls
{
    public class LcdDisplayControl : Control
    {
        private string _displayText = "0";
        private Color _digitColor = Color.LightGreen;
        private Color _backgroundColor = Color.Black;
        private const float SEGMENT_WIDTH_RATIO = 0.15f; //每个发光段的宽度比例
        private const float DIGIT_HEIGHT_RATIO = 0.8f;  //数字显示区域的高度比例
        private const float SEGMENT_GAP_RATIO = 0.05f; //段之间的间隙比例
        private float _padding = 2f;

        private Color _shadowColor = Color.FromArgb(30, Color.LightGreen); // 默认投影颜色  
        private float _shadowOffset = 1.5f; // 默认投影偏移量  

        private bool _enableGlassEffect = true;
        private Color _glassHighlightColor = Color.FromArgb(40, Color.White);
        private float _glassEffectHeight = 0.4f; // 玻璃效果占控件高度的比例  

        private Timer _animationTimer;
        private double _currentValue = 0;
        private double _targetValue = 0;
        private bool _isAnimating = false;
        private int _animationDuration = 1000; // 默认动画持续时间（毫秒）  
        private DateTime _animationStartTime;
        private string _originalFormat = "0"; // 保存显示格式  


        public float Padding
        {
            get => _padding;
            set
            {
                if (_padding != value)
                {
                    _padding = Math.Max(0, value);
                    Invalidate();
                }
            }
        }

        public int AnimationDuration
        {
            get => _animationDuration;
            set
            {
                if (_animationDuration != value && value > 0)
                {
                    _animationDuration = value;
                }
            }
        }

        public bool EnableGlassEffect
        {
            get => _enableGlassEffect;
            set
            {
                if (_enableGlassEffect != value)
                {
                    _enableGlassEffect = value;
                    Invalidate();
                }
            }
        }

        public Color GlassHighlightColor
        {
            get => _glassHighlightColor;
            set
            {
                if (_glassHighlightColor != value)
                {
                    _glassHighlightColor = value;
                    Invalidate();
                }
            }
        }

        public Color ShadowColor
        {
            get => _shadowColor;
            set
            {
                if (_shadowColor != value)
                {
                    _shadowColor = value;
                    Invalidate();
                }
            }
        }

        public float ShadowOffset
        {
            get => _shadowOffset;
            set
            {
                if (_shadowOffset != value)
                {
                    _shadowOffset = Math.Max(0, value); // 确保偏移量不为负数  
                    Invalidate();
                }
            }
        }

        public LcdDisplayControl()
        {
            SetStyle(ControlStyles.DoubleBuffer |
                            ControlStyles.AllPaintingInWmPaint |
                            ControlStyles.UserPaint |
                            ControlStyles.ResizeRedraw, true);

            ForeColor = _digitColor;
            EnableGlassEffect = true; // 默认启用玻璃效果  

            _animationTimer = new Timer();
            _animationTimer.Interval = 16; // 约60fps  
            _animationTimer.Tick += AnimationTimer_Tick;
        }



        public string DisplayText
        {
            get => _displayText;
            set
            {
                if (_displayText != value)
                {
                    // 尝试解析新值  
                    if (double.TryParse(value, out double newValue))
                    {
                        // 保存显示格式  
                        _originalFormat = value.Contains(".") ?
                            "F" + (value.Length - value.IndexOf('.') - 1) : "0";

                        // 开始动画  
                        StartAnimation(newValue);
                    }
                    else
                    {
                        // 如果不是数字，直接设置  
                        _displayText = value;
                        Invalidate();
                    }
                }
            }
        }

        public Color DigitColor
        {
            get => _digitColor;
            set
            {
                if (_digitColor != value)
                {
                    _digitColor = value;
                    Invalidate();
                }
            }
        }

        private void StartAnimation(double targetValue)
        {
            _targetValue = targetValue;
            _currentValue = double.TryParse(_displayText, out double currentValue) ?
                currentValue : 0;

            if (_currentValue == _targetValue)
                return;

            _animationStartTime = DateTime.Now;
            _isAnimating = true;
            _animationTimer.Start();
        }

        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            var elapsed = (DateTime.Now - _animationStartTime).TotalMilliseconds;
            var progress = Math.Min(elapsed / _animationDuration, 1.0);

            // 使用缓动函数使动画更自然  
            progress = EaseOutCubic(progress);

            // 计算当前值  
            _currentValue = _currentValue + (_targetValue - _currentValue) * progress;

            // 更新显示  
            _displayText = _currentValue.ToString(_originalFormat);
            Invalidate();

            // 检查动画是否完成  
            if (progress >= 1.0)
            {
                _animationTimer.Stop();
                _isAnimating = false;
                _currentValue = _targetValue;
                _displayText = _targetValue.ToString(_originalFormat);
                Invalidate();
            }
        }

        // 缓动函数  
        private double EaseOutCubic(double t)
        {
            return 1 - Math.Pow(1 - t, 3);
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            g.PixelOffsetMode = PixelOffsetMode.HighQuality;
            g.CompositingQuality = CompositingQuality.HighQuality;

            // 绘制背景和边框  
            using (var bgBrush = new SolidBrush(_backgroundColor))
            {
                g.FillRectangle(bgBrush, ClientRectangle);
            }

            // 计算实际显示区域（考虑内边距和边框）  
            float effectivePadding = _padding;
            float displayAreaWidth = Width - (effectivePadding * 2);
            float displayAreaHeight = Height - (effectivePadding * 2);

            // 计算单个数字的大小  
            float digitWidth = displayAreaWidth / _displayText.Length;
            float digitHeight = displayAreaHeight * 0.8f;

            // 起始位置（考虑内边距和边框）  
            float x = effectivePadding;
            float y = effectivePadding + (displayAreaHeight - digitHeight) / 2;

            // 绘制数字  
            for (int i = 0; i < _displayText.Length; i++)
            {
                if (_displayText[i] == '.')
                {
                    DrawDecimalPoint(g, x, y, digitWidth, digitHeight);
                    x += digitWidth * 0.3f;
                }
                else
                {
                    DrawDigit(g, _displayText[i], x, y, digitWidth, digitHeight);
                    x += digitWidth;
                }
            }

            // 如果启用玻璃效果，绘制玻璃效果  
            if (_enableGlassEffect)
            {
                DrawGlassEffect(g);
            }
        }

        // 玻璃效果绘制方法  
        private void DrawGlassEffect(Graphics g)
        {
            float glassHeight = Height * _glassEffectHeight;

            // 创建渐变画笷  
            using (var path = new GraphicsPath())
            {
                path.AddRectangle(new RectangleF(0, 0, Width, glassHeight));

                // 创建渐变  
                using (var brush = new LinearGradientBrush(
                    new PointF(0, 0),
                    new PointF(0, glassHeight),
                    Color.FromArgb(60, _glassHighlightColor),
                    Color.FromArgb(10, _glassHighlightColor)))
                {
                    g.FillPath(brush, path);
                }

                // 添加微弱的边缘高光  
                float highlightThickness = 1.0f;
                using (var highlightBrush = new LinearGradientBrush(
                    new RectangleF(0, 0, Width, highlightThickness),
                    Color.FromArgb(100, _glassHighlightColor),
                    Color.FromArgb(0, _glassHighlightColor),
                    LinearGradientMode.Vertical))
                {
                    g.FillRectangle(highlightBrush, 0, 0, Width, highlightThickness);
                }
            }
        }


        private void DrawDigit(Graphics g, char digit, float x, float y, float width, float height)
        {
            bool[] segments = GetSegments(digit);

            float segmentWidth = width * SEGMENT_WIDTH_RATIO;
            float segmentLength = width * 0.8f;
            float gap = width * SEGMENT_GAP_RATIO;

            // 水平段  
            if (segments[0]) DrawHorizontalSegment(g, x + gap, y, segmentLength, segmentWidth); // 顶段  
            if (segments[3]) DrawHorizontalSegment(g, x + gap, y + height / 2, segmentLength, segmentWidth); // 中段  
            if (segments[6]) DrawHorizontalSegment(g, x + gap, y + height - segmentWidth, segmentLength, segmentWidth); // 底段  

            // 垂直段  
            if (segments[1]) DrawVerticalSegment(g, x, y + gap, segmentWidth, height / 2 - gap); // 左上  
            if (segments[2]) DrawVerticalSegment(g, x + segmentLength, y + gap, segmentWidth, height / 2 - gap); // 右上  
            if (segments[4]) DrawVerticalSegment(g, x, y + height / 2 + gap, segmentWidth, height / 2 - gap); // 左下  
            if (segments[5]) DrawVerticalSegment(g, x + segmentLength, y + height / 2 + gap, segmentWidth, height / 2 - gap); // 右下  
        }

        private void DrawHorizontalSegment(Graphics g, float x, float y, float length, float width)
        {
            using (var path = new GraphicsPath())
            {
                // 创建水平段的路径  
                path.AddLine(x + width / 2, y, x + length - width / 2, y);
                path.AddLine(x + length, y + width / 2, x + length - width / 2, y + width);
                path.AddLine(x + width / 2, y + width, x, y + width / 2);
                path.CloseFigure();

                // 绘制阴影效果  
                using (var shadowBrush = new SolidBrush(_shadowColor))
                {
                    var shadowPath = (GraphicsPath)path.Clone();
                    var shadowMatrix = new Matrix();
                    shadowMatrix.Translate(_shadowOffset, _shadowOffset);
                    shadowPath.Transform(shadowMatrix);
                    g.FillPath(shadowBrush, shadowPath);
                    shadowPath.Dispose();
                }

                // 绘制主体  
                using (var brush = new SolidBrush(_digitColor))
                {
                    g.FillPath(brush, path);
                }

                // 如果启用玻璃效果，添加额外的光泽  
                if (_enableGlassEffect)
                {
                    using (var glassBrush = new LinearGradientBrush(
                        new RectangleF(x, y, length, width),
                        Color.FromArgb(40, Color.White),
                        Color.FromArgb(10, Color.White),
                        LinearGradientMode.Vertical))
                    {
                        g.FillPath(glassBrush, path);
                    }
                }

                // 添加发光边缘  
                using (var pen = new Pen(Color.FromArgb(100, _digitColor), 0.5f))
                {
                    g.DrawPath(pen, path);
                }
            }
        }

        private void DrawVerticalSegment(Graphics g, float x, float y, float width, float length)
        {
            using (var path = new GraphicsPath())
            {
                path.AddLine(x, y + width / 2, x + width / 2, y);
                path.AddLine(x + width, y + width / 2, x + width / 2, y + length);
                path.AddLine(x, y + length - width / 2, x, y + width / 2);
                path.CloseFigure();

                // 绘制阴影  
                using (var shadowBrush = new SolidBrush(_shadowColor))
                {
                    var shadowPath = (GraphicsPath)path.Clone();
                    var shadowMatrix = new Matrix();
                    shadowMatrix.Translate(_shadowOffset, _shadowOffset);
                    shadowPath.Transform(shadowMatrix);
                    g.FillPath(shadowBrush, shadowPath);
                    shadowPath.Dispose();
                }

                // 绘制主体  
                using (var brush = new SolidBrush(_digitColor))
                {
                    g.FillPath(brush, path);
                }

                // 如果启用玻璃效果，添加额外的光泽  
                if (_enableGlassEffect)
                {
                    using (var glassBrush = new LinearGradientBrush(
                        new RectangleF(x, y, width, length),
                        Color.FromArgb(40, Color.White),
                        Color.FromArgb(10, Color.White),
                        LinearGradientMode.Vertical))
                    {
                        g.FillPath(glassBrush, path);
                    }
                }

                // 添加发光边缘  
                using (var pen = new Pen(Color.FromArgb(100, _digitColor), 0.5f))
                {
                    g.DrawPath(pen, path);
                }
            }
        }

        private void DrawDecimalPoint(Graphics g, float x, float y, float width, float height)
        {
            float dotSize = width * 0.2f;

            // 绘制阴影效果  
            using (var shadowBrush = new SolidBrush(_shadowColor))
            {
                g.FillEllipse(shadowBrush,
                    x + _shadowOffset,
                    y + height - dotSize + _shadowOffset,
                    dotSize,
                    dotSize);
            }

            // 绘制主体  
            using (var brush = new SolidBrush(_digitColor))
            {
                g.FillEllipse(brush, x, y + height - dotSize, dotSize, dotSize);
            }

            // 添加发光边缘  
            using (var pen = new Pen(Color.FromArgb(100, _digitColor), 0.5f))
            {
                g.DrawEllipse(pen, x, y + height - dotSize, dotSize, dotSize);
            }
        }

        private bool[] GetSegments(char digit)
        {
            // 7段显示的状态表 [顶, 左上, 右上, 中, 左下, 右下, 底]  
            switch (digit)
            {
                case '0': return new bool[] { true, true, true, false, true, true, true };
                case '1': return new bool[] { false, false, true, false, false, true, false };
                case '2': return new bool[] { true, false, true, true, true, false, true };
                case '3': return new bool[] { true, false, true, true, false, true, true };
                case '4': return new bool[] { false, true, true, true, false, true, false };
                case '5': return new bool[] { true, true, false, true, false, true, true };
                case '6': return new bool[] { true, true, false, true, true, true, true };
                case '7': return new bool[] { true, false, true, false, false, true, false };
                case '8': return new bool[] { true, true, true, true, true, true, true };
                case '9': return new bool[] { true, true, true, true, false, true, true };
                default: return new bool[] { false, false, false, false, false, false, false };
            }
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_animationTimer != null)
                {
                    _animationTimer.Stop();
                    _animationTimer.Dispose();
                }
            }
            base.Dispose(disposing);
        }

    }
}




```

## 注意事项

1. 控件的最小尺寸应该根据显示字符的数量来确定，
2. 发光效果的渲染可能在某些低配置机器上造成性能影响，如有需要可以简化绘制方式。
3. 控件的尺寸变化会自动触发重绘，确保显示效果始终保持最佳状态。

## 扩展建议

1. 可以添加动画效果，实现数字切换时的过渡动画。
2. 可以添加不同的显示样式，如不同的段形状或发光效果。
3. 可以添加显示方向的支持，实现垂直方向的显示。
4. 可以添加更多的自定义属性，如段的宽度比例、间距等。

## 总结

这个液晶数字显示控件实现了一个专业的显示效果，可以用于各种需要数字显示的场景。通过GDI+的高级绘图功能，实现了平滑的显示效果和漂亮的发光效果。代码结构清晰，易于扩展和维护。

C# GDI+ 自定义液晶数字显示控件实现

## 简介

本文将详细介绍如何使用C#和GDI+技术实现一个自定义的温度计控件。这个控件具有以下特点：

- 可视化温度显示
- 可自定义最大最小温度值
- 支持动态更新温度
- 具有平滑的动画效果
- 支持自定义颜色主题

## 实现代码


![image.png](https://www.otteach.cn/static/img/c54d5811e1c41de727fb3261d89804d3.image.webp)



首先，创建一个继承自`Control`的自定义控件类：

```C#
using System;
using System.Collections.Generic;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppControls
{
    public class ThermometerControl : Control
    {
        // 温度相关属性  
        private float _currentTemperature = 0;
        private float _minTemperature = -20;
        private float _maxTemperature = 50;

        // 尺寸相关属性  
        private int _bulbRadius = 20;

        // 颜色设置  
        private Color _mercuryColor = Color.Red;
        private Color _backgroundColor = Color.White;
        private Color _borderColor = Color.Black;

        // 控件尺寸常量  
        private const int TUBE_WIDTH = 10;
        private const int SCALE_LENGTH = 5;
        private const int LEFT_MARGIN = 15;
        private const int BOTTOM_MARGIN = 25;


        // 球形底部半径属性  
        public int BulbRadius
        {
            get => _bulbRadius;
            set
            {
                if (value != _bulbRadius && value >= 10 && value <= 50) // 设置合理的范围限制  
                {
                    _bulbRadius = value;
                    UpdateControlSize();
                    Invalidate();
                }
            }
        }

        // 温度相关属性  
        public float CurrentTemperature
        {
            get => _currentTemperature;
            set
            {
                if (value != _currentTemperature)
                {
                    _currentTemperature = Math.Max(_minTemperature, Math.Min(_maxTemperature, value));
                    Invalidate();
                }
            }
        }

        public float MinTemperature
        {
            get => _minTemperature;
            set
            {
                if (value != _minTemperature)
                {
                    _minTemperature = value;
                    Invalidate();
                }
            }
        }

        public float MaxTemperature
        {
            get => _maxTemperature;
            set
            {
                if (value != _maxTemperature)
                {
                    _maxTemperature = value;
                    Invalidate();
                }
            }
        }

        // 颜色属性  
        public Color MercuryColor
        {
            get => _mercuryColor;
            set
            {
                if (value != _mercuryColor)
                {
                    _mercuryColor = value;
                    Invalidate();
                }
            }
        }

        public Color BackgroundColor
        {
            get => _backgroundColor;
            set
            {
                if (value != _backgroundColor)
                {
                    _backgroundColor = value;
                    Invalidate();
                }
            }
        }

        public Color BorderColor
        {
            get => _borderColor;
            set
            {
                if (value != _borderColor)
                {
                    _borderColor = value;
                    Invalidate();
                }
            }
        }

        public ThermometerControl()
        {
            SetStyle(ControlStyles.DoubleBuffer |
                    ControlStyles.AllPaintingInWmPaint |
                    ControlStyles.UserPaint |
                    ControlStyles.ResizeRedraw, true);

            UpdateControlSize();
        }

        // 更新控件尺寸  
        private void UpdateControlSize()
        {
            // 根据球形底部半径计算合适的控件尺寸  
            int minWidth = LEFT_MARGIN + _bulbRadius * 2 + SCALE_LENGTH + 35; // 35为刻度文本预留空间  
            int minHeight = _bulbRadius * 4 + BOTTOM_MARGIN; // 确保有足够空间显示温度计管体  

            MinimumSize = new Size(minWidth, minHeight);
            if (Width < minWidth) Width = minWidth;
            if (Height < minHeight) Height = minHeight;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;

            // 计算关键尺寸  
            int bulbCenterX = LEFT_MARGIN + _bulbRadius;
            int bulbCenterY = Height - BOTTOM_MARGIN - _bulbRadius;
            int tubeHeight = Height - 2 * _bulbRadius - BOTTOM_MARGIN;
            int tubeTop = _bulbRadius;

            // 绘制温度计外壳  
            DrawThermometerBody(g, bulbCenterX, bulbCenterY, tubeHeight);

            // 绘制水银柱  
            DrawMercury(g, bulbCenterX, bulbCenterY, tubeHeight);

            // 绘制刻度  
            DrawScale(g, bulbCenterX, tubeTop, tubeHeight);
        }

        private void DrawThermometerBody(Graphics g, int bulbCenterX, int bulbCenterY, int tubeHeight)
        {
            using (Pen borderPen = new Pen(_borderColor, 2))
            {
                // 绘制管子  
                g.DrawLine(borderPen,
                    bulbCenterX - TUBE_WIDTH / 2, _bulbRadius,
                    bulbCenterX - TUBE_WIDTH / 2, bulbCenterY);
                g.DrawLine(borderPen,
                    bulbCenterX + TUBE_WIDTH / 2, _bulbRadius,
                    bulbCenterX + TUBE_WIDTH / 2, bulbCenterY);

                // 绘制球形底部  
                g.DrawEllipse(borderPen,
                    bulbCenterX - _bulbRadius,
                    bulbCenterY - _bulbRadius,
                    _bulbRadius * 2,
                    _bulbRadius * 2);
            }

            // 填充球形底部背景  
            using (SolidBrush bulbBrush = new SolidBrush(_backgroundColor))
            {
                g.FillEllipse(bulbBrush,
                    bulbCenterX - _bulbRadius + 1,
                    bulbCenterY - _bulbRadius + 1,
                    (_bulbRadius - 1) * 2,
                    (_bulbRadius - 1) * 2);
            }
        }

        private void DrawMercury(Graphics g, int bulbCenterX, int bulbCenterY, int tubeHeight)
        {
            float temperatureRange = _maxTemperature - _minTemperature;
            float temperatureHeight = (_currentTemperature - _minTemperature) / temperatureRange;
            int mercuryHeight = (int)(tubeHeight * temperatureHeight);

            using (SolidBrush mercuryBrush = new SolidBrush(_mercuryColor))
            {
                // 填充管中的水银  
                g.FillRectangle(mercuryBrush,
                    bulbCenterX - TUBE_WIDTH / 2 + 2,
                    bulbCenterY - mercuryHeight,
                    TUBE_WIDTH - 3,
                    mercuryHeight);

                // 填充球部的水银  
                g.FillEllipse(mercuryBrush,
                    bulbCenterX - _bulbRadius + 2,
                    bulbCenterY - _bulbRadius + 2,
                    (_bulbRadius - 2) * 2,
                    (_bulbRadius - 2) * 2);
            }
        }

        private void DrawScale(Graphics g, int centerX, int topY, int height)
        {
            using (Pen scalePen = new Pen(_borderColor, 1))
            using (Font scaleFont = new Font("Arial", 8))
            using (StringFormat sf = new StringFormat { Alignment = StringAlignment.Near })
            {
                int scaleCount = 10;
                float temperatureStep = (_maxTemperature - _minTemperature) / scaleCount;
                float pixelStep = height / (float)scaleCount;

                for (int i = 0; i <= scaleCount; i++)
                {
                    int y = topY + (int)(i * pixelStep);

                    // 绘制刻度线  
                    g.DrawLine(scalePen,
                        centerX + TUBE_WIDTH / 2,
                        y,
                        centerX + TUBE_WIDTH / 2 + SCALE_LENGTH,
                        y);

                    // 绘制温度值  
                    float temperature = _maxTemperature - i * temperatureStep;
                    g.DrawString(
                        temperature.ToString("F0") + "°",
                        scaleFont,
                        Brushes.Black,
                        new RectangleF(
                            centerX + TUBE_WIDTH / 2 + SCALE_LENGTH + 2,
                            y - 6,
                            30,
                            12),
                        sf);
                }
            }
        }
    }
}
```

### 核心属性设计：

- 温度相关属性：当前温度(_currentTemperature)、最小温度(_minTemperature)、最大温度(_maxTemperature)
- 外观属性：球部半径(_bulbRadius)、水银颜色(_mercuryColor)、背景色(_backgroundColor)、边框色(_borderColor)
- 控件尺寸常量：管宽(TUBE_WIDTH)、刻度长度(SCALE_LENGTH)等

### 主要绘制逻辑(OnPaint方法)分为三个部分

```C#
DrawThermometerBody() // 绘制温度计外壳
DrawMercury()        // 绘制水银柱
DrawScale()          // 绘制刻度
```

## 总结

这个温度计控件实现了基本的温度显示功能，具有良好的可扩展性和自定义性。通过GDI+绘图技术，我们实现了平滑的显示效果和专业的外观。该控件可以用于各种需要温度显示的应用场景，如天气站、工业控制等领域。

C# GDI+ 自定义温度计控件实现教程

## 简介

本文将详细介绍如何使用C#和GDI+技术实现一个自定义的线性表控件(Linear Gauge)。这个控件具有清晰的刻度显示、数值指示和专业的外观，适用于各种仪表盘和监控界面。

## 控件特性

- 垂直方向显示
- 可自定义最大值和最小值
- 大小刻度线显示
- 刻度值标签
- 当前值指示器
- 可自定义颜色和样式

## 完整代码实现


![image.png](https://www.otteach.cn/static/img/e66c83cd014c8a9b8b7da27f02b50af4.image.webp)



```C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Timer = System.Windows.Forms.Timer;

namespace AppControls
{
    public class LinearGauge : Control
    {
        // 私有字段  
        private float _minimum = 0;
        private float _maximum = 100;
        private float _value = 0;
        private Color _scaleColor = Color.FromArgb(40, 40, 40);
        private Color _valueColor = Color.FromArgb(220, 50, 50);
        private Color _glassColor = Color.FromArgb(200, 210, 230);
        private Color _borderColor = Color.FromArgb(120, 120, 120);
        private int _majorTickCount = 5;
        private int _minorTickCount = 5;
        private int _cornerRadius = 10;
        private float _borderWidth = 1.5f;
        private bool _enableRoundedCorners = true;

        private Timer animationTimer;
        private float currentAnimatedValue;
        private float targetValue;
        private float animationStep;
        private int animationDuration = 500; // 默认动画持续时间（毫秒）  
        private int animationInterval = 16;  // 约60fps  
        private bool isAnimating = false;
        private AnimationMode animationMode = AnimationMode.EaseInOut;

        // 动画模式枚举  
        public enum AnimationMode
        {
            Linear,
            EaseIn,
            EaseOut,
            EaseInOut
        }

        // 动画完成事件  
        public event EventHandler AnimationCompleted;

        [Description("动画持续时间（毫秒）")]
        public int AnimationDuration
        {
            get => animationDuration;
            set
            {
                animationDuration = Math.Max(0, value);
                CalculateAnimationStep(_value);
            }
        }

        [Description("动画模式")]
        public AnimationMode AnimationType
        {
            get => animationMode;
            set
            {
                animationMode = value;
                Invalidate();
            }
        }

        [Description("是否正在动画")]
        public bool IsAnimating => isAnimating;

        // 属性  
        [Description("最小值")]
        public float Minimum
        {
            get => _minimum;
            set
            {
                _minimum = value;
                Invalidate();
            }
        }

        [Description("最大值")]
        public float Maximum
        {
            get => _maximum;
            set
            {
                _maximum = value;
                Invalidate();
            }
        }

        [Description("当前值")]
        public float Value
        {
            get => _value;
            set
            {
                if (_value != value)
                {
                    if (animationDuration > 0 && IsHandleCreated)
                    {
                        StartAnimation(value);
                    }
                    else
                    {
                        _value = Math.Max(Minimum, Math.Min(Maximum, value));
                        currentAnimatedValue = _value;
                        Invalidate();
                    }
                }
            }
        }

        [Description("玻璃效果颜色")]
        public Color GlassColor
        {
            get => _glassColor;
            set
            {
                _glassColor = value;
                Invalidate();
            }
        }

        [Description("边框颜色")]
        public Color BorderColor
        {
            get => _borderColor;
            set
            {
                _borderColor = value;
                Invalidate();
            }
        }

        [Description("边框宽度")]
        public float BorderWidth
        {
            get => _borderWidth;
            set
            {
                _borderWidth = value;
                Invalidate();
            }
        }

        [Description("是否启用圆角")]
        public bool EnableRoundedCorners
        {
            get => _enableRoundedCorners;
            set
            {
                _enableRoundedCorners = value;
                Invalidate();
            }
        }

        [Description("圆角半径")]
        public int CornerRadius
        {
            get => _cornerRadius;
            set
            {
                _cornerRadius = Math.Max(0, Math.Min(value, Math.Min(Width, Height) / 2));
                Invalidate();
            }
        }

        // 构造函数  
        public LinearGauge()
        {
            SetStyle(ControlStyles.DoubleBuffer |
                                ControlStyles.AllPaintingInWmPaint |
                                ControlStyles.UserPaint |
                                ControlStyles.ResizeRedraw, true);

            Size = new Size(80, 300);
            BackColor = Color.FromArgb(240, 240, 240);

            // 初始化动画计时器  
            animationTimer = new Timer();
            animationTimer.Interval = animationInterval;
            animationTimer.Tick += AnimationTimer_Tick;

            // 初始化动画值  
            currentAnimatedValue = _value;
            targetValue = _value;
        }

        // 启动动画  
        private void StartAnimation(float newValue)
        {
            if (IsDisposed || !IsHandleCreated) return;

            targetValue = Math.Max(Minimum, Math.Min(Maximum, newValue));

            if (Math.Abs(targetValue - currentAnimatedValue) < float.Epsilon)
            {
                return;
            }

            // 计算动画步长  
            float totalDistance = targetValue - currentAnimatedValue;
            float totalSteps = animationDuration / animationInterval;
            animationStep = totalDistance / totalSteps;

            isAnimating = true;
            animationTimer.Start();
        }

        // 动画计时器事件处理  
        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            if (!isAnimating) return;

            float previousValue = currentAnimatedValue;
            float progress = Math.Abs((currentAnimatedValue - _value) / (targetValue - _value));

            // 根据动画模式计算新值  
            float step = CalculateAnimationStep(progress);
            currentAnimatedValue += step;

            // 检查是否到达目标值  
            if ((step > 0 && currentAnimatedValue >= targetValue) ||
                (step < 0 && currentAnimatedValue <= targetValue))
            {
                currentAnimatedValue = targetValue;
                _value = targetValue;
                isAnimating = false;
                animationTimer.Stop();
                AnimationCompleted?.Invoke(this, EventArgs.Empty);
            }

            // 当值改变时才重绘  
            if (Math.Abs(previousValue - currentAnimatedValue) > float.Epsilon)
            {
                Invalidate();
            }
        }

        // 计算动画步长  
        private float CalculateAnimationStep(float progress)
        {
            float step = animationStep;

            switch (animationMode)
            {
                case AnimationMode.Linear:
                    // 线性动画，步长保持不变  
                    break;

                case AnimationMode.EaseIn:
                    // 缓入动画，开始慢后来快  
                    step *= (progress + 0.5f);
                    break;

                case AnimationMode.EaseOut:
                    // 缓出动画，开始快后来慢  
                    step *= (1.5f - progress);
                    break;

                case AnimationMode.EaseInOut:
                    // 缓入缓出动画，开始和结束慢，中间快  
                    if (progress < 0.5f)
                        step *= (progress + 0.5f);
                    else
                        step *= (1.5f - progress);
                    break;
            }

            return step;
        }

        // 创建圆角路径  
        private GraphicsPath CreateRoundedRectangle(Rectangle bounds, int radius)
        {
            if (!EnableRoundedCorners || radius <= 0)
            {
                GraphicsPath path = new GraphicsPath();
                path.AddRectangle(bounds);
                return path;
            }

            radius = Math.Min(radius, Math.Min(bounds.Width, bounds.Height) / 2);
            GraphicsPath roundedPath = new GraphicsPath();
            int diameter = radius * 2;

            Rectangle arc = new Rectangle(bounds.Location, new Size(diameter, diameter));

            // 左上角  
            roundedPath.AddArc(arc, 180, 90);

            // 右上角  
            arc.X = bounds.Right - diameter;
            roundedPath.AddArc(arc, 270, 90);

            // 右下角  
            arc.Y = bounds.Bottom - diameter;
            roundedPath.AddArc(arc, 0, 90);

            // 左下角  
            arc.X = bounds.Left;
            roundedPath.AddArc(arc, 90, 90);

            roundedPath.CloseFigure();
            return roundedPath;
        }

        // 重写OnPaint方法  
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;

            // 计算绘制区域，考虑边框宽度  
            Rectangle gaugeRect = new Rectangle(
                Padding.Left + (int)Math.Ceiling(_borderWidth / 2),
                Padding.Top + (int)Math.Ceiling(_borderWidth / 2),
                Width - Padding.Horizontal - (int)Math.Ceiling(_borderWidth),
                Height - Padding.Vertical - (int)Math.Ceiling(_borderWidth)
            );

            // 创建路径  
            using (GraphicsPath path = CreateRoundedRectangle(gaugeRect, _enableRoundedCorners ? _cornerRadius : 0))
            {
                // 绘制玻璃效果背景  
                DrawGlassEffect(g, path, gaugeRect);

                // 计算刻度区域  
                int scaleMargin = 25;
                Rectangle scaleRect = new Rectangle(
                    gaugeRect.Left + scaleMargin,
                    gaugeRect.Top + 10,
                    10,
                    gaugeRect.Height - 20
                );

                // 绘制刻度线和刻度值  
                DrawScale(g, scaleRect);

                // 绘制当前值指示器  
                DrawValueIndicator(g, scaleRect);

                // 绘制边框  
                using (Pen borderPen = new Pen(_borderColor, _borderWidth))
                {
                    // 设置边框连接和端点样式  
                    borderPen.LineJoin = LineJoin.Round;
                    borderPen.StartCap = LineCap.Round;
                    borderPen.EndCap = LineCap.Round;

                    g.DrawPath(borderPen, path);
                }
            }
        }

        // 绘制玻璃效果  
        private void DrawGlassEffect(Graphics g, GraphicsPath path, Rectangle bounds)
        {
            // 主背景 - 使用更细腻的渐变  
            using (LinearGradientBrush backgroundGradient = new LinearGradientBrush(
                bounds,
                Color.FromArgb(240, _glassColor),
                Color.FromArgb(180, _glassColor),
                LinearGradientMode.Vertical))
            {
                ColorBlend blend = new ColorBlend(3);
                blend.Colors = new Color[] {
                    Color.FromArgb(240, _glassColor),
                    Color.FromArgb(210, _glassColor),
                    Color.FromArgb(180, _glassColor)
                };
                blend.Positions = new float[] { 0f, 0.5f, 1f };
                backgroundGradient.InterpolationColors = blend;
                g.FillPath(backgroundGradient, path);
            }

            // 上部光泽效果  
            Rectangle upperGloss = new Rectangle(
                bounds.X,
                bounds.Y,
                bounds.Width,
                bounds.Height / 2);

            using (GraphicsPath glossPath = CreateRoundedRectangle(upperGloss,
                _enableRoundedCorners ? _cornerRadius : 0))
            using (LinearGradientBrush glossGradient = new LinearGradientBrush(
                upperGloss,
                Color.FromArgb(180, Color.White),
                Color.FromArgb(0, Color.White),
                LinearGradientMode.Vertical))
            {
                g.FillPath(glossGradient, glossPath);
            }

            // 顶部反光效果  
            int reflectionHeight = bounds.Height / 15;
            Rectangle reflectionRect = new Rectangle(
                bounds.X + bounds.Width / 4,
                bounds.Y + 5,
                bounds.Width / 2,
                reflectionHeight);

            using (LinearGradientBrush reflectionBrush = new LinearGradientBrush(
                reflectionRect,
                Color.FromArgb(150, Color.White),
                Color.FromArgb(0, Color.White),
                LinearGradientMode.Vertical))
            {
                if (_enableRoundedCorners)
                {
                    using (GraphicsPath reflectionPath = CreateRoundedRectangle(reflectionRect,
                        reflectionHeight / 2))
                    {
                        g.FillPath(reflectionBrush, reflectionPath);
                    }
                }
                else
                {
                    g.FillRectangle(reflectionBrush, reflectionRect);
                }
            }
        }

        // 绘制刻度  
        private void DrawScale(Graphics g, Rectangle scaleRect)
        {
            float stepValue = (_maximum - _minimum) / (_majorTickCount - 1);
            float stepPixels = scaleRect.Height / (_majorTickCount - 1);

            using (Pen scalePen = new Pen(_scaleColor, 1))
            using (Font font = new Font("Segoe UI", 8, FontStyle.Regular))
            using (StringFormat sf = new StringFormat())
            {
                sf.Alignment = StringAlignment.Far;
                sf.LineAlignment = StringAlignment.Center;

                // 绘制主刻度线和刻度值  
                for (int i = 0; i < _majorTickCount; i++)
                {
                    float y = scaleRect.Bottom - (i * stepPixels);
                    float value = _minimum + (i * stepValue);

                    // 绘制主刻度线  
                    using (Pen majorTickPen = new Pen(Color.FromArgb(180, _scaleColor), 1.5f))
                    {
                        g.DrawLine(majorTickPen,
                            scaleRect.Left - 15, y,
                            scaleRect.Right, y);
                    }

                    // 绘制刻度值  
                    using (SolidBrush textBrush = new SolidBrush(_scaleColor))
                    {
                        g.DrawString(
                            value.ToString("0"),
                            font,
                            textBrush,
                            new RectangleF(0, y - 10, scaleRect.Left - 5, 20),
                            sf);
                    }

                    // 绘制小刻度线  
                    if (i < _majorTickCount - 1)
                    {
                        float minorStep = stepPixels / (_minorTickCount + 1);
                        using (Pen minorTickPen = new Pen(Color.FromArgb(120, _scaleColor), 1))
                        {
                            for (int j = 1; j <= _minorTickCount; j++)
                            {
                                float minorY = y - (j * minorStep);
                                g.DrawLine(minorTickPen,
                                    scaleRect.Left - 5, minorY,
                                    scaleRect.Right, minorY);
                            }
                        }
                    }
                }
            }
        }

        // 绘制值指示器  
        private void DrawValueIndicator(Graphics g, Rectangle scaleRect)
        {
            float valuePosition = scaleRect.Bottom -
                ((currentAnimatedValue - Minimum) / (Maximum - Minimum) * scaleRect.Height);

            // 创建指示器渐变  
            using (LinearGradientBrush indicatorBrush = new LinearGradientBrush(
                new Point(scaleRect.Left - 15, (int)valuePosition - 2),
                new Point(scaleRect.Right + 5, (int)valuePosition + 2),
                Color.FromArgb(220, _valueColor),
                Color.FromArgb(180, _valueColor)))
            {
                // 绘制带渐变的指示器  
                g.FillRectangle(indicatorBrush,
                    scaleRect.Left - 15,
                    valuePosition - 1.5f,
                    scaleRect.Right - scaleRect.Left + 20,
                    3);

                // 添加高光效果  
                using (Pen highlightPen = new Pen(Color.FromArgb(80, Color.White), 1))
                {
                    g.DrawLine(highlightPen,
                        scaleRect.Left - 15,
                        valuePosition - 1,
                        scaleRect.Right + 5,
                        valuePosition - 1);
                }
            }
        }

        // 释放资源  
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                animationTimer?.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}

```

## 使用方法

```C#
public partial class Form1 : Form
{
    private LinearGauge linearGauge;

    public Form1()
    {
        InitializeComponent();
        
        // 创建并配置控件
        linearGauge = new LinearGauge
        {
            Location = new Point(50, 50),
            Minimum = 0,
            Maximum = 100,
            Value = 75
        };

        // 添加到窗体
        this.Controls.Add(linearGauge);
    }
}
```

## 主要功能说明

### 1. 基础属性

控件提供了三个主要属性：

- `Minimum`：最小值
- `Maximum`：最大值
- `Value`：当前值

### 2. 刻度系统

- 主刻度线：均匀分布的长刻度线，附带数值标签
- 次刻度线：主刻度线之间的短刻度线
- 刻度值：在主刻度线旁显示对应的数值

### 3. 值指示器

使用红色线条标示当前值的位置。

### 4. 性能优化

- 使用双缓冲绘制，避免闪烁
- 启用抗锯齿，提供平滑的显示效果
- 仅在必要时重绘控件

## 总结

这个自定义线性表控件实现了专业的刻度显示和值指示功能，可以方便地集成到Windows Forms应用程序中。通过调整属性和样式，可以满足不同的显示需求。代码结构清晰，易于维护和扩展。

希望这个实现对您有所帮助！如果需要更多功能，可以基于此代码进行扩展开发。

C# GDI+ 自定义线性表控件实现教程

## 概述

本教程将详细介绍如何使用C#和GDI+开发一个数字表样式的自定义控件。这个控件可以用来显示数值，并具有可自定义的外观和动画效果。

## 控件特性

- 可自定义表盘背景颜色
- 可自定义刻度颜色和样式
- 可自定义指针颜色和样式
- 支持数值范围设置
- 支持动画效果
- 支持鼠标交互

## 完整代码实现


![image.png](https://www.otteach.cn/static/img/9076c27411a9786dda115bd22d46b7c4.image.webp)



```C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Timer = System.Windows.Forms.Timer;

namespace AppControls
{
    /// <summary>  
    /// 数字表自定义控件  
    /// </summary>  
    public class DigitalGauge : Control
    {
        #region 私有字段  

        private float _minimum = 0;
        private float _maximum = 100;
        private float _value = 0;
        private float _targetValue = 0;
        private Color _dialColor = Color.DarkGray;
        private Color _pointerColor = Color.Red;
        private Timer _animationTimer;
        private bool _enableAnimation = true;

        private bool _enableGlassEffect = true;
        private float _glassOpacity = 0.3f;
        private Color _glassHighlightColor = Color.White;
        private Color _glassShadowColor = Color.FromArgb(30, 0, 0, 0);

        private bool _fullCircleScale = false;
        private float _startAngle = 225;    // 默认起始角度  
        private float _endAngle = 495;      // 默认结束角度 (等于135度)  
        private float _scaleArcLength = 270; // 刻度弧长  
        private int _majorTickCount = 10;    // 主刻度数量  
        private int _minorTickCount = 5;     // 每个主刻度之间的小刻度数量  


        #endregion


        #region 公共属性  

        /// <summary>  
        /// 获取或设置是否绘制满圈刻度  
        /// </summary>  
        [Description("获取或设置是否绘制满圈刻度")]
        public bool FullCircleScale
        {
            get { return _fullCircleScale; }
            set
            {
                _fullCircleScale = value;
                UpdateScaleAngles();
                Invalidate();
            }
        }

        /// <summary>  
        /// 获取或设置起始角度（度）  
        /// </summary>  
        [Description("获取或设置起始角度（度）")]
        public float StartAngle
        {
            get { return _startAngle; }
            set
            {
                _startAngle = value;
                UpdateScaleAngles();
                Invalidate();
            }
        }

        /// <summary>  
        /// 获取或设置结束角度（度）  
        /// </summary>  
        [Description("获取或设置结束角度（度）")]
        public float EndAngle
        {
            get { return _endAngle; }
            set
            {
                _endAngle = value;
                UpdateScaleAngles();
                Invalidate();
            }
        }

        /// <summary>  
        /// 获取或设置主刻度数量  
        /// </summary>  
        [Description("获取或设置主刻度数量")]
        public int MajorTickCount
        {
            get { return _majorTickCount; }
            set
            {
                if (value > 0)
                {
                    _majorTickCount = value;
                    Invalidate();
                }
            }
        }

        /// <summary>  
        /// 获取或设置每个主刻度之间的小刻度数量  
        /// </summary>  
        [Description("获取或设置每个主刻度之间的小刻度数量")]
        public int MinorTickCount
        {
            get { return _minorTickCount; }
            set
            {
                if (value >= 0)
                {
                    _minorTickCount = value;
                    Invalidate();
                }
            }
        }

        /// <summary>  
        /// 获取或设置是否启用玻璃效果  
        /// </summary>  
        [Description("获取或设置是否启用玻璃效果")]
        public bool EnableGlassEffect
        {
            get { return _enableGlassEffect; }
            set
            {
                _enableGlassEffect = value;
                Invalidate();
            }
        }

        /// <summary>  
        /// 获取或设置玻璃效果的透明度  
        /// </summary>  
        [Description("获取或设置玻璃效果的透明度")]
        public float GlassOpacity
        {
            get { return _glassOpacity; }
            set
            {
                _glassOpacity = Math.Max(0, Math.Min(1, value));
                Invalidate();
            }
        }


        /// <summary>  
        /// 获取或设置最小值  
        /// </summary>  
        [Description("获取或设置最小值")]
        public float Minimum
        {
            get { return _minimum; }
            set
            {
                if (value < _maximum)
                {
                    _minimum = value;
                    Invalidate();
                }
            }
        }

        /// <summary>  
        /// 获取或设置最大值  
        /// </summary>  
        [Description("获取或设置最大值")]
        public float Maximum
        {
            get { return _maximum; }
            set
            {
                if (value > _minimum)
                {
                    _maximum = value;
                    Invalidate();
                }
            }
        }

        /// <summary>  
        /// 获取或设置当前值  
        /// </summary>  
        [Description("获取或设置当前值")]
        public float Value
        {
            get { return _value; }
            set
            {
                if (value >= _minimum && value <= _maximum)
                {
                    _targetValue = value;
                    if (_enableAnimation)
                    {
                        if (!_animationTimer.Enabled)
                            _animationTimer.Start();
                    }
                    else
                    {
                        _value = value;
                        Invalidate();
                    }
                }
            }
        }

        /// <summary>  
        /// 获取或设置表盘颜色  
        /// </summary>  
        [Description("获取或设置表盘颜色")]
        public Color DialColor
        {
            get { return _dialColor; }
            set
            {
                _dialColor = value;
                Invalidate();
            }
        }

        /// <summary>  
        /// 获取或设置指针颜色  
        /// </summary>  
        [Description("获取或设置指针颜色")]
        public Color PointerColor
        {
            get { return _pointerColor; }
            set
            {
                _pointerColor = value;
                Invalidate();
            }
        }

        #endregion

        #region 构造函数  

        /// <summary>  
        /// 初始化数字表控件  
        /// </summary>  
        public DigitalGauge()
        {
            // 设置控件样式  
            SetStyle(ControlStyles.DoubleBuffer |
                    ControlStyles.AllPaintingInWmPaint |
                    ControlStyles.UserPaint |
                    ControlStyles.ResizeRedraw, true);

            // 初始化动画计时器  
            _animationTimer = new Timer();
            _animationTimer.Interval = 10;
            _animationTimer.Tick += AnimationTimer_Tick;
        }

        #endregion

        /// <summary>  
        /// 更新刻度角度  
        /// </summary>  
        private void UpdateScaleAngles()
        {
            if (_fullCircleScale)
            {
                _startAngle = 0;
                _endAngle = 360;
                _scaleArcLength = 360;
            }
            else
            {
                _scaleArcLength = _endAngle - _startAngle;
            }
        }

        /// <summary>  
        /// 将值转换为角度  
        /// </summary>  
        private float ValueToAngle(float value)
        {
            return _startAngle + ((value - _minimum) / (_maximum - _minimum) * _scaleArcLength);
        }

        /// <summary>  
        /// 将角度转换为值  
        /// </summary>  
        private float AngleToValue(float angle)
        {
            // 将角度标准化到起始角度范围内  
            while (angle < _startAngle)
                angle += 360;
            while (angle > _startAngle + _scaleArcLength)
                angle -= 360;

            return _minimum + (angle - _startAngle) * (_maximum - _minimum) / _scaleArcLength;
        }


        #region 绘制方法  

        /// <summary>  
        /// 重写绘制方法  
        /// </summary>  
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;

            float centerX = Width / 2f;
            float centerY = Height / 2f;
            float radius = Math.Min(Width, Height) / 2f - 10;

            // 绘制表盘背景  
            DrawDial(g, centerX, centerY, radius);

            // 绘制刻度  
            DrawScale(g, centerX, centerY, radius);

            // 绘制指针  
            DrawPointer(g, centerX, centerY, radius);

            // 绘制数值  
            DrawValue(g, centerX, centerY);

            // 绘制玻璃效果  
            if (_enableGlassEffect)
            {
                DrawGlassEffect(g, centerX, centerY, radius);
            }
        }

        /// <summary>  
        /// 绘制玻璃效果  
        /// </summary>  
        private void DrawGlassEffect(Graphics g, float centerX, float centerY, float radius)
        {
            // 创建玻璃效果区域路径  
            using (GraphicsPath glassPath = new GraphicsPath())
            {
                glassPath.AddEllipse(centerX - radius, centerY - radius, radius * 2, radius * 2);

                // 创建高光渐变  
                using (PathGradientBrush highlightBrush = new PathGradientBrush(glassPath))
                {
                    // 设置中心点颜色和边缘颜色  
                    highlightBrush.CenterColor = Color.FromArgb(
                        (int)(255 * _glassOpacity),
                        _glassHighlightColor);
                    highlightBrush.SurroundColors = new Color[] {
                    Color.FromArgb(0, _glassHighlightColor)
                };

                    // 设置渐变焦点  
                    highlightBrush.CenterPoint = new PointF(
                        centerX - radius * 0.3f,
                        centerY - radius * 0.3f
                    );

                    // 绘制高光效果  
                    g.FillEllipse(highlightBrush,
                        centerX - radius,
                        centerY - radius,
                        radius * 2,
                        radius * 2);
                }

                // 创建阴影效果  
                RectangleF shadowRect = new RectangleF(
                    centerX - radius,
                    centerY - radius * 0.2f,
                    radius * 2,
                    radius * 1.2f
                );

                using (LinearGradientBrush shadowBrush = new LinearGradientBrush(
                    shadowRect,
                    Color.FromArgb(0, _glassShadowColor),
                    _glassShadowColor,
                    LinearGradientMode.Vertical))
                {
                    // 创建阴影区域  
                    using (GraphicsPath shadowPath = new GraphicsPath())
                    {
                        shadowPath.AddEllipse(centerX - radius, centerY - radius,
                            radius * 2, radius * 2);

                        // 使用裁剪区域确保阴影只在表盘内部  
                        using (Region clipRegion = new Region(shadowPath))
                        {
                            g.Clip = clipRegion;
                            g.FillRectangle(shadowBrush, shadowRect);
                            g.ResetClip();
                        }
                    }
                }

                // 添加边缘高光  
                using (Pen highlightPen = new Pen(Color.FromArgb(100, Color.White), 1))
                {
                    g.DrawEllipse(highlightPen,
                        centerX - radius,
                        centerY - radius,
                        radius * 2,
                        radius * 2);
                }
            }
        }

        /// <summary>  
        /// 绘制表盘背景  
        /// </summary>  
        private void DrawDial(Graphics g, float centerX, float centerY, float radius)
        {
            using (SolidBrush brush = new SolidBrush(_dialColor))
            {
                g.FillEllipse(brush, centerX - radius, centerY - radius,
                             radius * 2, radius * 2);
            }

            // 绘制边框  
            using (Pen pen = new Pen(Color.Black, 2))
            {
                g.DrawEllipse(pen, centerX - radius, centerY - radius,
                             radius * 2, radius * 2);
            }
        }

        /// <summary>  
        /// 绘制刻度  
        /// </summary>  
        private void DrawScale(Graphics g, float centerX, float centerY, float radius)
        {
            using (Pen majorPen = new Pen(Color.White, 2))
            using (Pen minorPen = new Pen(Color.White, 1))
            using (Font font = new Font("Arial", 8))
            using (StringFormat sf = new StringFormat())
            {
                sf.Alignment = StringAlignment.Center;
                sf.LineAlignment = StringAlignment.Center;

                // 绘制主刻度和刻度值  
                for (int i = 0; i <= _majorTickCount; i++)
                {
                    float angle = _startAngle + (i * _scaleArcLength / _majorTickCount);
                    double rad = angle * Math.PI / 180;

                    // 计算刻度线的起点和终点  
                    float innerX = (float)(centerX + (radius - 15) * Math.Cos(rad));
                    float innerY = (float)(centerY + (radius - 15) * Math.Sin(rad));
                    float outerX = (float)(centerX + radius * Math.Cos(rad));
                    float outerY = (float)(centerY + radius * Math.Sin(rad));

                    // 绘制主刻度线  
                    g.DrawLine(majorPen, innerX, innerY, outerX, outerY);

                    // 绘制刻度值  
                    float value = _minimum + ((_maximum - _minimum) * i / _majorTickCount);
                    string text = value.ToString("F0");

                    // 计算文本位置  
                    float textRadius = radius - 30;
                    float textX = (float)(centerX + textRadius * Math.Cos(rad));
                    float textY = (float)(centerY + textRadius * Math.Sin(rad));

                    // 创建文本绘制区域  
                    RectangleF textRect = new RectangleF(
                        textX - 15, textY - 15, 30, 30);
                    g.DrawString(text, font, Brushes.White, textRect, sf);

                    // 绘制小刻度  
                    if (i < _majorTickCount && _minorTickCount > 0)
                    {
                        float minorStep = _scaleArcLength / _majorTickCount / (_minorTickCount + 1);
                        for (int j = 1; j <= _minorTickCount; j++)
                        {
                            float minorAngle = angle + (j * minorStep);
                            double minorRad = minorAngle * Math.PI / 180;

                            float minorInnerX = (float)(centerX + (radius - 8) * Math.Cos(minorRad));
                            float minorInnerY = (float)(centerY + (radius - 8) * Math.Sin(minorRad));
                            float minorOuterX = (float)(centerX + radius * Math.Cos(minorRad));
                            float minorOuterY = (float)(centerY + radius * Math.Sin(minorRad));

                            g.DrawLine(minorPen, minorInnerX, minorInnerY,
                                minorOuterX, minorOuterY);
                        }
                    }
                }
            }
        }

        /// <summary>  
        /// 绘制指针  
        /// </summary>  
        private void DrawPointer(Graphics g, float centerX, float centerY, float radius)
        {
            float angle = ValueToAngle(_value);
            double rad = angle * Math.PI / 180;

            PointF[] points = new PointF[3];
            points[0] = new PointF(
                (float)(centerX + (radius - 10) * Math.Cos(rad)),
                (float)(centerY + (radius - 10) * Math.Sin(rad)));
            points[1] = new PointF(
                (float)(centerX + 5 * Math.Cos(rad - Math.PI / 2)),
                (float)(centerY + 5 * Math.Sin(rad - Math.PI / 2)));
            points[2] = new PointF(
                (float)(centerX + 5 * Math.Cos(rad + Math.PI / 2)),
                (float)(centerY + 5 * Math.Sin(rad + Math.PI / 2)));

            using (SolidBrush brush = new SolidBrush(_pointerColor))
            {
                g.FillPolygon(brush, points);
            }

            // 绘制中心点  
            using (SolidBrush brush = new SolidBrush(Color.White))
            {
                g.FillEllipse(brush, centerX - 5, centerY - 5, 10, 10);
            }
        }

        /// <summary>  
        /// 绘制数值  
        /// </summary>  
        private void DrawValue(Graphics g, float centerX, float centerY)
        {
            string text = _value.ToString("F1");
            using (Font font = new Font("Arial", 12, FontStyle.Bold))
            {
                SizeF size = g.MeasureString(text, font);
                g.DrawString(text, font, Brushes.White,
                    centerX - size.Width / 2,
                    centerY + 20);
            }
        }

        #endregion

        #region 动画相关  

        /// <summary>  
        /// 动画计时器事件处理  
        /// </summary>  
        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            float delta = (_targetValue - _value) / 10;
            if (Math.Abs(delta) < 0.1)
            {
                _value = _targetValue;
                _animationTimer.Stop();
            }
            else
            {
                _value += delta;
            }
            Invalidate();
        }

        #endregion

        #region 资源释放  

        /// <summary>  
        /// 释放资源  
        /// </summary>  
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_animationTimer != null)
                {
                    _animationTimer.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        #endregion
    }
}

```

## 4. 总结

本教程详细介绍了如何使用C#和GDI+开发一个数字表样式的自定义控件。通过合理的代码组织和注释，使得代码易于理解和维护。控件具有良好的可扩展性，可以根据实际需求进行功能扩展。

C# GDI+ 数字表自定义控件开发教程

google-site-verification

6VPd1sSgMMRcd7LEbHWBHvFCB5l870aZqLrLM7Wij6A

baidu-site-verification

msvalidate.01

google-adsense-account

title

专注开发技术分享的个人博客，提供C#，Python，NodeJs，Java，WPF、.NET、OPC UA、AI开发等实战教程。包含完整项目源码和详细技术解析，助力开发者技能提升。

description

C#开发,WPF教程,Python开发，Java开发,NodeJs开发,.NET编程,OPC UA,AI开发,Semantic Kernel,技术博客,编程教程,工业软件开发，数据库