## 简介

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

## 实现原理

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

## 完整代码实现


![image.png](https://blog.idiosoft.com/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://blog.idiosoft.com/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://blog.idiosoft.com/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://blog.idiosoft.com/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
    }
}

```

## 总结

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

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

## 简介

在工业控制、监控系统等应用中，指示灯是一个常用的可视化控件。本文将详细介绍如何使用C#和GDI+开发一个功能丰富的指示灯自定义控件。这个控件将支持多种颜色、闪烁效果、3D效果等特性。

## 控件特性

- 支持多种颜色设置
- 可配置的闪烁效果
- 3D立体效果
- 可自定义大小
- 支持不同的形状（圆形、方形）
- 鼠标悬停效果
- 支持禁用状态显示
- 可配置的边框样式

## 完整代码实现


![image.png](https://blog.idiosoft.com/static/img/523029887fce7156ee67a503016fbc25.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 IndicatorLight : Control
    {
        #region 私有字段
        private bool isOn = false;
        private Color onColor = Color.Lime;
        private Color offColor = Color.DarkGray;
        private bool is3D = true;
        private bool isBlinking = false;
        private int blinkInterval = 500;
        private Timer blinkTimer;
        private bool isCircular = true;
        private int borderWidth = 1;
        private Color borderColor = Color.DarkGray;
        private bool temporaryState = false;
        #endregion

        #region 动画相关字段  
        private bool isBreathing = false;
        private bool isRotating = false;
        private bool isRippling = false;
        private float breathingOpacity = 1.0f;
        private float rotationAngle = 0f;
        private List<float> rippleRadii = new List<float>();
        private const float BREATHING_STEP = 0.05f;
        private const float ROTATION_STEP = 2f;
        private const float RIPPLE_STEP = 2f;
        private const int MAX_RIPPLES = 3;
        private Timer animationTimer;
        private bool breathingDirection = false; // false为淡出，true为淡入  
        #endregion

        #region 属性

        [Category("Animation")]
        public bool IsBreathing
        {
            get { return isBreathing; }
            set
            {
                isBreathing = value;
                if (isBreathing)
                    animationTimer.Start();
                else if (!IsAnimating())
                    animationTimer.Stop();
                Invalidate();
            }
        }

        [Category("Animation")]
        public bool IsRotating
        {
            get { return isRotating; }
            set
            {
                isRotating = value;
                if (isRotating)
                    animationTimer.Start();
                else if (!IsAnimating())
                    animationTimer.Stop();
                Invalidate();
            }
        }

        [Category("Animation")]
        public bool IsRippling
        {
            get { return isRippling; }
            set
            {
                isRippling = value;
                if (isRippling)
                    animationTimer.Start();
                else
                {
                    rippleRadii.Clear();
                    if (!IsAnimating())
                        animationTimer.Stop();
                }
                Invalidate();
            }
        }

        [Category("Appearance")]
        public bool IsOn
        {
            get { return isOn; }
            set
            {
                isOn = value;
                Invalidate();
            }
        }


        [Category("Appearance")]
        public Color OnColor
        {
            get { return onColor; }
            set
            {
                onColor = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public Color OffColor
        {
            get { return offColor; }
            set
            {
                offColor = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public bool Is3D
        {
            get { return is3D; }
            set
            {
                is3D = value;
                Invalidate();
            }
        }

        [Category("Behavior")]
        public bool IsBlinking
        {
            get { return isBlinking; }
            set
            {
                isBlinking = value;
                if (isBlinking)
                    blinkTimer.Start();
                else
                {
                    blinkTimer.Stop();
                    temporaryState = false;
                }
                Invalidate();
            }
        }

        [Category("Behavior")]
        public int BlinkInterval
        {
            get { return blinkInterval; }
            set
            {
                blinkInterval = value;
                blinkTimer.Interval = value;
            }
        }

        [Category("Appearance")]
        public bool IsCircular
        {
            get { return isCircular; }
            set
            {
                isCircular = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public int BorderWidth
        {
            get { return borderWidth; }
            set
            {
                borderWidth = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public Color BorderColor
        {
            get { return borderColor; }
            set
            {
                borderColor = value;
                Invalidate();
            }
        }
        #endregion

        #region 构造函数
        public IndicatorLight()
        {
            SetStyle(ControlStyles.SupportsTransparentBackColor, true);
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.ResizeRedraw, true);

            Size = new Size(30, 30);
            BackColor = Color.Transparent;

            blinkTimer = new Timer();
            blinkTimer.Interval = blinkInterval;
            blinkTimer.Tick += BlinkTimer_Tick;

            animationTimer = new Timer();
            animationTimer.Interval = 50; // 20fps  
            animationTimer.Tick += AnimationTimer_Tick;
        }
        #endregion

        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            bool needInvalidate = false;

            // 处理呼吸效果  
            if (isBreathing)
            {
                if (!breathingDirection)
                {
                    breathingOpacity -= BREATHING_STEP;
                    if (breathingOpacity <= 0.3f)
                    {
                        breathingOpacity = 0.3f;
                        breathingDirection = true;
                    }
                }
                else
                {
                    breathingOpacity += BREATHING_STEP;
                    if (breathingOpacity >= 1.0f)
                    {
                        breathingOpacity = 1.0f;
                        breathingDirection = false;
                    }
                }
                needInvalidate = true;
            }

            // 处理旋转效果  
            if (isRotating)
            {
                rotationAngle = (rotationAngle + ROTATION_STEP) % 360;
                needInvalidate = true;
            }

            // 处理波纹效果  
            if (isRippling)
            {
                // 更新现有波纹  
                for (int i = rippleRadii.Count - 1; i >= 0; i--)
                {
                    rippleRadii[i] += RIPPLE_STEP;
                    if (rippleRadii[i] > Math.Max(Width, Height))
                    {
                        rippleRadii.RemoveAt(i);
                    }
                }

                // 添加新波纹  
                if (rippleRadii.Count < MAX_RIPPLES && (rippleRadii.Count == 0 || rippleRadii[rippleRadii.Count - 1] > 20))
                {
                    rippleRadii.Add(0f);
                }

                needInvalidate = true;
            }

            if (needInvalidate)
                Invalidate();
        }

        private bool IsAnimating()
        {
            return isBreathing || isRotating || isRippling || isBlinking;
        }

        #region 事件处理
        private void BlinkTimer_Tick(object sender, EventArgs e)
        {
            temporaryState = !temporaryState;
            Invalidate();
        }
        #endregion

        #region 绘制方法

        protected override void OnPaint(PaintEventArgs e)
        {
            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;

            bool currentState = isBlinking ? temporaryState : isOn;
            Color currentColor = currentState ? onColor : offColor;

            // 应用呼吸效果的透明度  
            if (isBreathing)
            {
                currentColor = Color.FromArgb(
                    (int)(255 * breathingOpacity),
                    currentColor.R,
                    currentColor.G,
                    currentColor.B
                );
            }

            // 保存当前图形状态  
            GraphicsState state = e.Graphics.Save();

            // 应用旋转  
            if (isRotating)
            {
                e.Graphics.TranslateTransform(Width / 2f, Height / 2f);
                e.Graphics.RotateTransform(rotationAngle);
                e.Graphics.TranslateTransform(-Width / 2f, -Height / 2f);
            }

            using (GraphicsPath path = new GraphicsPath())
            {
                Rectangle bounds = new Rectangle(
                    borderWidth,
                    borderWidth,
                    Width - 2 * borderWidth - 1,
                    Height - 2 * borderWidth - 1
                );

                if (isCircular)
                    path.AddEllipse(bounds);
                else
                    path.AddRectangle(bounds);

                // 绘制主体  
                if (is3D)
                {
                    // 3D效果绘制代码保持不变  
                    using (PathGradientBrush gradientBrush = new PathGradientBrush(path))
                    {
                        gradientBrush.CenterColor = LightenColor(currentColor, 50);
                        gradientBrush.SurroundColors = new Color[] { currentColor };
                        gradientBrush.FocusScales = new PointF(0.8f, 0.8f);

                        e.Graphics.FillPath(gradientBrush, path);
                    }

                    // 高光效果  
                    DrawHighlight(e.Graphics, bounds);
                }
                else
                {
                    using (SolidBrush brush = new SolidBrush(currentColor))
                    {
                        e.Graphics.FillPath(brush, path);
                    }
                }

                // 绘制边框  
                if (borderWidth > 0)
                {
                    using (Pen borderPen = new Pen(borderColor, borderWidth))
                    {
                        e.Graphics.DrawPath(borderPen, path);
                    }
                }
            }
            // 恢复图形状态  
            e.Graphics.Restore(state);

            // 绘制波纹效果  
            if (isRippling && rippleRadii.Count > 0)
            {
                DrawRipples(e.Graphics);
            }

            base.OnPaint(e);
        }
        #endregion

        private void DrawHighlight(Graphics g, Rectangle bounds)
        {
            using (GraphicsPath highlightPath = new GraphicsPath())
            {
                // 计算高光区域（左上角域）  
                Rectangle highlightBounds = new Rectangle(
                    bounds.X + bounds.Width / 4,
                    bounds.Y + bounds.Height / 4,
                    bounds.Width / 4,
                    bounds.Height / 4
                );

                highlightPath.AddEllipse(highlightBounds);

                // 创建径向渐变画刷实现高光效果 
                using (PathGradientBrush highlightBrush = new PathGradientBrush(highlightPath))
                {
                    highlightBrush.CenterColor = Color.FromArgb(180, Color.White);
                    highlightBrush.SurroundColors = new Color[] { Color.FromArgb(0, Color.White) };

                    g.FillPath(highlightBrush, highlightPath);
                }
            }
        }

        private void DrawRipples(Graphics g)
        {
            float centerX = Width / 2f;
            float centerY = Height / 2f;

            foreach (float radius in rippleRadii)
            {
                // 计算波纹透明度  
                float alpha = 1.0f - (radius / Math.Max(Width, Height));
                if (alpha <= 0) continue;

                // 绘制波纹圆圈  
                using (Pen ripplePen = new Pen(Color.FromArgb((int)(alpha * 255), onColor), 2))
                {
                    g.DrawEllipse(ripplePen,
                        centerX - radius,
                        centerY - radius,
                        radius * 2,
                        radius * 2);
                }
            }
        }

        #region 辅助方法
        private Color LightenColor(Color color, int amount)
        {
            return Color.FromArgb(
                color.A,
                Math.Min(color.R + amount, 255),
                Math.Min(color.G + amount, 255),
                Math.Min(color.B + amount, 255)
            );
        }
        #endregion

        #region 公共方法
        public void StartBlinking()
        {
            IsBlinking = true;
        }

        public void StopBlinking()
        {
            IsBlinking = false;
        }

        public void Toggle()
        {
            IsOn = !IsOn;
        }

        public void StartBreathing()
        {
            IsBreathing = true;
        }

        public void StopBreathing()
        {
            IsBreathing = false;
        }

        public void StartRotating()
        {
            IsRotating = true;
        }

        public void StopRotating()
        {
            IsRotating = false;
        }

        public void StartRippling()
        {
            IsRippling = true;
        }

        public void StopRippling()
        {
            IsRippling = false;
        }
        #endregion

        #region 析构函数
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                blinkTimer?.Dispose();
                animationTimer?.Dispose();
            }
            base.Dispose(disposing);
        }
        #endregion
    }
}


```


## 总结

这个指示灯控件实现了丰富的功能，可以满足大多数工业控制和监控系统的需求。通过属性设置，可以轻松地自定义外观和行为。代码结构清晰，易于维护和扩展。

希望这个教程能帮助你理解如何使用C#和GDI+开发专业的自定义控件。如果你有任何问题或建议，欢迎讨论和交流。

C# WinForms自定义指示灯控件开发教程

link

script

这个博客将是我技术思考、创业经验和个人成长的记录本。无论是技术解决方案、创业感悟，还是职场心得，我都将坦诚相见，希望能为正在成长的技术人和创业者提供一些真实而有价值的洞察。"