C# GDI+ 实现流动管道控件的完整指南

## 引言

在工业自动化领域，阀门作为最基础的控制元件之一，其可视化显示对于操作员监控系统运行状态至关重要。本文将详细介绍如何使用C#和GDI+技术开发一个功能强大、外观精美的阀门控件，该控件不仅性能优异，还支持高DPI显示和各种自定义选项。

## 控件特性概览

- 支持圆形和矩形（圆角可调）两种阀门形状
- 垂直和水平两种显示方向
- 可自定义开关状态颜色和文本
- 支持管道显示控制
- 高DPI显示支持
- 透明背景支持
- 事件驱动的状态变更机制



## 核心实现

### 1. 基础属性设计

控件的核心是一系列可自定义的属性，包括：

```C#
private bool _isOpen = false;        // 阀门开关状态
private string _valveText = "阀门";   // 阀门显示文本
private Color _openColor = Color.Green;  // 开启颜色
private Color _closeColor = Color.Red;   // 关闭颜色
private ValveOrientation _orientation = ValveOrientation.Vertical; // 显示方向
private float _pipeWidth = 2f;       // 管道宽度
private Color _pipeColor = Color.Black;  // 管道颜色
```

### 2. 透明背景支持

为实现真正的透明效果，需要特别设置控件样式和重写相关方法：

```C#
public ValveControl()
{
    SetStyle(ControlStyles.SupportsTransparentBackColor, true);
    SetStyle(ControlStyles.OptimizedDoubleBuffer, false);
    SetStyle(ControlStyles.AllPaintingInWmPaint, true);
    SetStyle(ControlStyles.UserPaint, true);
    SetStyle(ControlStyles.ResizeRedraw, true);
    SetStyle(ControlStyles.Opaque, false);
    
    this.BackColor = Color.Transparent;
}

protected override CreateParams CreateParams
{
    get
    {
        CreateParams cp = base.CreateParams;
        cp.ExStyle |= 0x20; // WS_EX_TRANSPARENT
        return cp;
    }
}
```

### 3. 高质量绘图实现

为确保控件在各种分辨率下都能完美显示，实现了高质量绘图模式：

```C#
protected override void OnPaint(PaintEventArgs e)
{
    // 设置高质量绘图模式
    e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
    e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
    e.Graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
    e.Graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
    
    // 使用双倍分辨率缓冲绘图
    using (var bmp = new Bitmap(this.Width * 2, this.Height * 2))
    {
        // ... 绘制代码 ...
    }
}
```

### 4. 完整代码实现

```C#
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;

namespace AppControls
{
    // 形状枚举  
    public enum ValveShape
    {
        Circle,
        Rectangle
    }
    public class ValveControl : Control
    {
        private bool _isOpen = false;
        private string _valveText = "阀门";
        private Color _openColor = Color.Green;
        private Color _closeColor = Color.Red;
        private ValveOrientation _orientation = ValveOrientation.Vertical;
        private float _pipeWidth = 2f;
        private Color _pipeColor = Color.Black;
        private bool _showFirstPipe = true;   // 第一根管道（上/左）显示控制  
        private bool _showSecondPipe = true;  // 第二根管道（下/右）显示控制  

        private bool _showStatus = true;   // 状态显示控制  
        private string _openText = "开启";  // 开启状态文本  
        private string _closeText = "关闭"; // 关闭状态文本  
        // 形状字段  
        private ValveShape _valveShape = ValveShape.Circle;
        private int _cornerRadius = 10;

        // 事件声明  
        public event EventHandler ValveOpened;
        public event EventHandler ValveClosed;

        // 定义阀门方向的枚举  
        public enum ValveOrientation
        {
            Horizontal,
            Vertical
        }

        // 第一根管道显示控制属性（上管道/左管道）  
        [Description("显示第一根管道（垂直方向时为上管道，水平方向时为左管道）")]
        [DefaultValue(true)]
        public bool ShowFirstPipe
        {
            get { return _showFirstPipe; }
            set
            {
                _showFirstPipe = value;
                Invalidate();
            }
        }

        // 第二根管道显示控制属性（下管道/右管道）  
        [Description("显示第二根管道（垂直方向时为下管道，水平方向时为右管道）")]
        [DefaultValue(true)]
        public bool ShowSecondPipe
        {
            get { return _showSecondPipe; }
            set
            {
                _showSecondPipe = value;
                Invalidate();
            }
        }

        // 管道宽度属性  
        [Description("管道宽度")]
        [DefaultValue(2f)]
        public float PipeWidth
        {
            get { return _pipeWidth; }
            set
            {
                if (value > 0)
                {
                    _pipeWidth = value;
                    Invalidate();
                }
            }
        }

        // 管道颜色属性  
        [Description("管道颜色")]
        public Color PipeColor
        {
            get { return _pipeColor; }
            set
            {
                _pipeColor = value;
                Invalidate();
            }
        }

        [Description("阀门显示方向")]
        public ValveOrientation Orientation
        {
            get { return _orientation; }
            set
            {
                _orientation = value;
                if (value == ValveOrientation.Vertical)
                {
                    this.Size = new Size(100, 150);
                }
                else
                {
                    this.Size = new Size(150, 100);
                }
                Invalidate();
            }
        }

        [Description("阀门状态")]
        public bool IsOpen
        {
            get { return _isOpen; }
            set
            {
                if (_isOpen != value)  // 只在状态确实发生改变时才触发事件  
                {
                    _isOpen = value;
                    // 触发相应的事件  
                    if (_isOpen)
                    {
                        OnValveOpened(EventArgs.Empty);
                    }
                    else
                    {
                        OnValveClosed(EventArgs.Empty);
                    }
                    Invalidate();
                }
            }
        }

        [Description("阀门显示文本")]
        public string ValveText
        {
            get { return _valveText; }
            set
            {
                _valveText = value;
                Invalidate();
            }
        }

        [Description("阀门打开时的颜色")]
        public Color OpenColor
        {
            get { return _openColor; }
            set
            {
                _openColor = value;
                Invalidate();
            }
        }

        [Description("阀门关闭时的颜色")]
        public Color CloseColor
        {
            get { return _closeColor; }
            set
            {
                _closeColor = value;
                Invalidate();
            }
        }

        [Description("是否显示阀门状态文本")]
        [DefaultValue(true)]
        public bool ShowStatus
        {
            get { return _showStatus; }
            set
            {
                _showStatus = value;
                Invalidate();
            }
        }

        [Description("阀门开启时显示的文本")]
        [DefaultValue("开启")]
        public string OpenText
        {
            get { return _openText; }
            set
            {
                _openText = value;
                if (_isOpen) Invalidate();
            }
        }

        [Description("阀门关闭时显示的文本")]
        [DefaultValue("关闭")]
        public string CloseText
        {
            get { return _closeText; }
            set
            {
                _closeText = value;
                if (!_isOpen) Invalidate();
            }
        }

        // 形状属性  
        [Description("阀门形状")]
        [DefaultValue(ValveShape.Circle)]
        public ValveShape ValveShape
        {
            get { return _valveShape; }
            set
            {
                _valveShape = value;
                Invalidate();
            }
        }

        [Description("矩形模式下的圆角半径")]
        [DefaultValue(10)]
        public int CornerRadius
        {
            get { return _cornerRadius; }
            set
            {
                if (value >= 0)
                {
                    _cornerRadius = value;
                    Invalidate();
                }
            }
        }

        public ValveControl()
        {
            // 设置关键的控件样式  
            SetStyle(ControlStyles.SupportsTransparentBackColor, true);
            SetStyle(ControlStyles.OptimizedDoubleBuffer, false);//这个影响透明
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.ResizeRedraw, true);

            // 启用透明  
            SetStyle(ControlStyles.Opaque, false);

            this.Size = new Size(100, 150);
            this.BackColor = Color.Transparent;
            this.Click += new EventHandler(ValveControl_Click);
        }

        // 重写这个方法来支持真正的透明  
        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.ExStyle |= 0x20; // WS_EX_TRANSPARENT  
                return cp;
            }
        }

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            // 不执行任何操作，保持背景透明  
        }


        private void ValveControl_Click(object sender, EventArgs e)
        {
            IsOpen = !IsOpen;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            // 设置高质量绘图模式  
            e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
            e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            e.Graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
            e.Graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;

            // 使用高分辨率绘图  
            using (var bmp = new Bitmap(this.Width * 2, this.Height * 2))
            {
                using (var tempG = Graphics.FromImage(bmp))
                {
                    // 设置高质量绘图模式  
                    tempG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                    tempG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                    tempG.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
                    tempG.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                    tempG.ScaleTransform(2, 2); // 缩放以支持高DPI  

                    // 计算绘制区域  
                    Rectangle valveRect;
                    if (_orientation == ValveOrientation.Vertical)
                    {
                        valveRect = new Rectangle(
                            Width / 4,
                            Height / 4,
                            Width / 2,
                            Height / 2
                        );
                    }
                    else
                    {
                        valveRect = new Rectangle(
                            Width / 4,
                            Height / 4,
                            Width / 2,
                            Height / 2
                        );
                    }

                    // 绘制管道  
                    using (Pen pipePen = new Pen(_pipeColor, _pipeWidth))
                    {
                        pipePen.EndCap = System.Drawing.Drawing2D.LineCap.Round;
                        pipePen.StartCap = System.Drawing.Drawing2D.LineCap.Round;
                        pipePen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;

                        if (_orientation == ValveOrientation.Vertical)
                        {
                            if (_showFirstPipe)
                            {
                                tempG.DrawLine(pipePen,
                                    new Point(Width / 2, 0),
                                    new Point(Width / 2, valveRect.Top));
                            }

                            if (_showSecondPipe)
                            {
                                tempG.DrawLine(pipePen,
                                    new Point(Width / 2, valveRect.Bottom),
                                    new Point(Width / 2, Height));
                            }
                        }
                        else
                        {
                            if (_showFirstPipe)
                            {
                                tempG.DrawLine(pipePen,
                                    new Point(0, Height / 2),
                                    new Point(valveRect.Left, Height / 2));
                            }

                            if (_showSecondPipe)
                            {
                                tempG.DrawLine(pipePen,
                                    new Point(valveRect.Right, Height / 2),
                                    new Point(Width, Height / 2));
                            }
                        }
                    }

                    // 绘制阀门主体  
                    using (SolidBrush valveBrush = new SolidBrush(_isOpen ? _openColor : _closeColor))
                    using (Pen valvePen = new Pen(Color.Black, 2))
                    {
                        valvePen.EndCap = System.Drawing.Drawing2D.LineCap.Round;
                        valvePen.StartCap = System.Drawing.Drawing2D.LineCap.Round;
                        valvePen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;

                        if (_valveShape == ValveShape.Circle)
                        {
                            // 圆形阀门  
                            tempG.FillEllipse(valveBrush, valveRect);
                            tempG.DrawEllipse(valvePen, valveRect);
                        }
                        else
                        {
                            // 矩形阀门（圆角）  
                            using (var path = new System.Drawing.Drawing2D.GraphicsPath())
                            {
                                path.AddArc(valveRect.X, valveRect.Y, _cornerRadius * 2, _cornerRadius * 2, 180, 90);
                                path.AddArc(valveRect.Right - _cornerRadius * 2, valveRect.Y, _cornerRadius * 2, _cornerRadius * 2, 270, 90);
                                path.AddArc(valveRect.Right - _cornerRadius * 2, valveRect.Bottom - _cornerRadius * 2, _cornerRadius * 2, _cornerRadius * 2, 0, 90);
                                path.AddArc(valveRect.X, valveRect.Bottom - _cornerRadius * 2, _cornerRadius * 2, _cornerRadius * 2, 90, 90);
                                path.CloseFigure();

                                tempG.FillPath(valveBrush, path);
                                tempG.DrawPath(valvePen, path);
                            }
                        }
                    }

                    // 绘制文本  
                    using (var textFont = new Font(this.Font.FontFamily, this.Font.Size, FontStyle.Regular, GraphicsUnit.Point))
                    using (var sf = new StringFormat())
                    {
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;
                        sf.FormatFlags |= StringFormatFlags.NoWrap;

                        using (var textBrush = new SolidBrush(Color.Black))
                        {
                            // 使用TextRenderingHint.ClearTypeGridFit提高文本清晰度  
                            tempG.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
                            tempG.DrawString(_valveText,
                                textFont,
                                textBrush,
                                valveRect,
                                sf);
                        }
                    }

                    // 绘制状态文本  
                    if (_showStatus)
                    {
                        string status = _isOpen ? _openText : _closeText;
                        using (var smallFont = new Font(this.Font.FontFamily, 8, FontStyle.Regular, GraphicsUnit.Point))
                        using (var sf = new StringFormat())
                        {
                            sf.Alignment = StringAlignment.Center;
                            Rectangle statusRect;

                            if (_orientation == ValveOrientation.Vertical)
                            {
                                statusRect = new Rectangle(
                                    0,
                                    valveRect.Bottom + 5,
                                    Width,
                                    20
                                );
                            }
                            else
                            {
                                statusRect = new Rectangle(
                                    valveRect.Right + 5,
                                    0,
                                    (Width - valveRect.Right - 5),
                                    Height
                                );
                            }

                            tempG.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
                            tempG.DrawString(status,
                                smallFont,
                                Brushes.Black,
                                statusRect,
                                sf);
                        }
                    }

                    // 将高分辨率图像绘制到控件上  
                    e.Graphics.DrawImage(bmp, 0, 0, this.Width, this.Height);
                }
            }
        }

        // 事件触发方法  
        protected virtual void OnValveOpened(EventArgs e)
        {
            ValveOpened?.Invoke(this, e);
        }

        protected virtual void OnValveClosed(EventArgs e)
        {
            ValveClosed?.Invoke(this, e);
        }

    }
}
```

## 使用示例


![image.png](https://blog.idiosoft.com/static/img/ad3e72d5aa6c191e36dd61b0182a432a.image.webp)

## 结论

本文介绍的阀门控件实现了工控系统中常用的阀门可视化需求，具有良好的可定制性和性能表现。通过合理的代码架构和绘图优化，确保了控件在实际应用中的稳定性和效率。开发者可以基于此继续扩展，添加更多功能特性，以满足不同场景的需求。

这个控件的实现充分展示了C# GDI+在工控图形开发中的应用价值，为工控软件开发提供了一个很好的参考示例。

C# GDI+ 实现一个简单的阀门控件

在WinForm应用程序开发中，一个富有视觉吸引力的用户界面往往能够提升用户体验。今天，我将为大家介绍一个自定义的水波进度控件（WaveProgressControl），它不仅功能强大，还具有出色的视觉效果。

## 控件特性

- 流畅的水波动画效果
- 渐变色水波
- 可自定义的边框样式
- 阴影和高光效果
- 实时进度显示
- 丰富的自定义选项



## 核心实现

### 1. 基础架构

```C#
public class WaveProgressControl : Control
{
    private float _progress = 0f;
    private float _targetProgress = 0f;
    private Timer _animationTimer;
    private Timer _waveTimer;
    private float _waveOffset = 0f;
}
```

控件继承自基础Control类，通过两个Timer实现水波动画和进度变化的平滑过渡。

### 2. 视觉定制选项

控件提供了丰富的自定义选项，包括：

- 水波颜色（双色渐变）
- 边框样式（颜色、宽度、线型）
- 阴影效果
- 高光效果
- 文本颜色

### 3. 动画系统

```C#
private void InitializeTimers()
{
    _animationTimer = new Timer();
    _animationTimer.Interval = 16;
    _animationTimer.Tick += (s, e) =>
    {
        if (Math.Abs(_progress - _targetProgress) > 0.001f)
        {
            _progress += (_targetProgress - _progress) * ANIMATION_SPEED;
            Invalidate();
        }
    };
    _animationTimer.Start();

    _waveTimer = new Timer();
    _waveTimer.Interval = 16;
    _waveTimer.Tick += (s, e) =>
    {
        _waveOffset += 0.1f;
        if (_waveOffset > Math.PI * 2)
            _waveOffset = 0;
        Invalidate();
    };
    _waveTimer.Start();
}

```

采用双Timer机制：

- animationTimer负责进度值的平滑过渡
- waveTimer控制水波动画效果

### 4. 绘制过程

控件的绘制过程分为几个关键步骤：

**阴影效果**

```C#
// 绘制阴影效果  
if (EnableShade)
{
    using (GraphicsPath shadowPath = new GraphicsPath())
    {
        shadowPath.AddEllipse(circleRect);
        using (PathGradientBrush shadowBrush = new PathGradientBrush(shadowPath))
        {
            shadowBrush.CenterColor = ShadeColor;
            shadowBrush.SurroundColors = new Color[] { Color.Transparent };
            e.Graphics.FillPath(shadowBrush, shadowPath);
        }
    }
}

```

**边框绘制**

```C#
// 绘制外圆  
if (ShowBorder)
{
    using (GraphicsPath borderPath = new GraphicsPath())
    {
        borderPath.AddEllipse(circleRect);
        using (Pen borderPen = new Pen(BorderColor, BorderWidth))
        {

            borderPen.DashStyle = BorderStyle;
            e.Graphics.DrawPath(borderPen, borderPath);
        }
    }
}

```

**水波效果**

```C#
// 绘制水波  
int waveBottom = (int)(circleRect.Bottom - (circleRect.Height * currentProgress));

using (GraphicsPath wavePath = new GraphicsPath())
{
    Point[] points = new Point[circleRect.Width + 3];
    for (int x = 0; x <= circleRect.Width; x++)
    {
        int y = (int)(Math.Sin(x * 0.05f + _waveOffset) * WAVE_HEIGHT);
        points[x] = new Point(x + circleRect.X, waveBottom + y);
    }

    points[points.Length - 2] = new Point(circleRect.Right, circleRect.Bottom);
    points[points.Length - 1] = new Point(circleRect.Left, circleRect.Bottom);

    wavePath.AddLines(points);

    using (LinearGradientBrush brush = new LinearGradientBrush(
        circleRect,
        WaveColor1,
        WaveColor2,
        90f))
    {
        e.Graphics.FillPath(brush, wavePath);
    }
}

```

**高光效果**

```C#
// 绘制高光效果  
if (EnableHighlight)
{
    using (LinearGradientBrush highlightBrush = new LinearGradientBrush(
        circleRect,
        HighlightColor,
        Color.Transparent,
        45f))
    {
        e.Graphics.FillEllipse(highlightBrush, circleRect);
    }
}

```

## 完整代码

```C#
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using Timer = System.Windows.Forms.Timer;

[ToolboxItem(true)]
[Description("水波浪进度控件")]
public class WaveProgressControl : Control
{
    private float _progress = 0f;
    private float _targetProgress = 0f;
    private Timer _animationTimer;
    private Timer _waveTimer;
    private float _waveOffset = 0f;
    private const float WAVE_HEIGHT = 10f;
    private const float ANIMATION_SPEED = 0.02f;

    #region 属性定义  

    // 基本属性  
    private Color _waveColor1 = Color.FromArgb(100, 181, 246);
    private Color _waveColor2 = Color.FromArgb(33, 150, 243);
    private Color _borderColor = Color.FromArgb(200, 200, 200);
    private float _borderWidth = 2f;
    private DashStyle _borderStyle = DashStyle.Solid;
    private bool _enableShade = true;
    private Color _shadeColor = Color.FromArgb(30, 0, 0, 0);
    private bool _enableHighlight = true;
    private Color _highlightColor = Color.FromArgb(30, 255, 255, 255);
    private Color _textColor = Color.FromArgb(64, 64, 64);
    private bool _showBorder = true;

    [Category("Appearance")]
    [Description("第一个波浪颜色")]
    public Color WaveColor1
    {
        get => _waveColor1;
        set
        {
            _waveColor1 = value;
            Invalidate();
        }
    }

    [Category("Appearance")]
    [Description("第二个波浪颜色")]
    public Color WaveColor2
    {
        get => _waveColor2;
        set
        {
            _waveColor2 = value;
            Invalidate();
        }
    }

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

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

    [Category("Border")]
    [Description("边框样式")]
    public DashStyle BorderStyle
    {
        get => _borderStyle;
        set
        {
            _borderStyle = value;
            Invalidate();
        }
    }

    [Category("Border")]
    [Description("是否显示边框")]
    public bool ShowBorder
    {
        get => _showBorder;
        set
        {
            _showBorder = value;
            Invalidate();
        }
    }

    [Category("Effects")]
    [Description("启用阴影效果")]
    public bool EnableShade
    {
        get => _enableShade;
        set
        {
            _enableShade = value;
            Invalidate();
        }
    }

    [Category("Effects")]
    [Description("阴影颜色")]
    public Color ShadeColor
    {
        get => _shadeColor;
        set
        {
            _shadeColor = value;
            Invalidate();
        }
    }

    [Category("Effects")]
    [Description("启用高光效果")]
    public bool EnableHighlight
    {
        get => _enableHighlight;
        set
        {
            _enableHighlight = value;
            Invalidate();
        }
    }

    [Category("Effects")]
    [Description("高光颜色")]
    public Color HighlightColor
    {
        get => _highlightColor;
        set
        {
            _highlightColor = value;
            Invalidate();
        }
    }

    [Category("Appearance")]
    [Description("文本颜色")]
    public Color TextColor
    {
        get => _textColor;
        set
        {
            _textColor = value;
            Invalidate();
        }
    }

    [Category("Behavior")]
    [Description("当前进度值(0-1)")]
    [DefaultValue(0f)]
    public float Progress
    {
        get => _targetProgress;
        set
        {
            if (value < 0f) value = 0f;
            if (value > 1f) value = 1f;
            _targetProgress = value;
        }
    }

    #endregion

    public WaveProgressControl()
    {
        Size = new Size(100, 100);

        SetStyle(ControlStyles.DoubleBuffer |
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw |
                ControlStyles.SupportsTransparentBackColor,
                true);

        if (!DesignMode)
        {
            InitializeTimers();
        }
    }

    private void InitializeTimers()
    {
        _animationTimer = new Timer();
        _animationTimer.Interval = 16;
        _animationTimer.Tick += (s, e) =>
        {
            if (Math.Abs(_progress - _targetProgress) > 0.001f)
            {
                _progress += (_targetProgress - _progress) * ANIMATION_SPEED;
                Invalidate();
            }
        };
        _animationTimer.Start();

        _waveTimer = new Timer();
        _waveTimer.Interval = 16;
        _waveTimer.Tick += (s, e) =>
        {
            _waveOffset += 0.1f;
            if (_waveOffset > Math.PI * 2)
                _waveOffset = 0;
            Invalidate();
        };
        _waveTimer.Start();
    }

    protected override void OnHandleCreated(EventArgs e)
    {
        base.OnHandleCreated(e);
        if (!DesignMode)
        {
            InitializeTimers();
        }
    }

    protected override void OnHandleDestroyed(EventArgs e)
    {
        if (!DesignMode)
        {
            _animationTimer?.Stop();
            _waveTimer?.Stop();
        }
        base.OnHandleDestroyed(e);
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
        e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
        e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
        e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
        e.Graphics.CompositingQuality = CompositingQuality.HighQuality;

        int size = Math.Min(Width, Height);
        int padding = 10;
        Rectangle circleRect = new Rectangle(padding, padding, size - padding * 2, size - padding * 2);

        // 计算当前进度  
        float currentProgress = DesignMode ? Progress : _progress;

        // 绘制阴影效果  
        if (EnableShade)
        {
            using (GraphicsPath shadowPath = new GraphicsPath())
            {
                shadowPath.AddEllipse(circleRect);
                using (PathGradientBrush shadowBrush = new PathGradientBrush(shadowPath))
                {
                    shadowBrush.CenterColor = ShadeColor;
                    shadowBrush.SurroundColors = new Color[] { Color.Transparent };
                    e.Graphics.FillPath(shadowBrush, shadowPath);
                }
            }
        }

        // 绘制外圆  
        if (ShowBorder)
        {
            using (GraphicsPath borderPath = new GraphicsPath())
            {
                borderPath.AddEllipse(circleRect);
                using (Pen borderPen = new Pen(BorderColor, BorderWidth))
                {

                    borderPen.DashStyle = BorderStyle;
                    e.Graphics.DrawPath(borderPen, borderPath);
                }
            }
        }

        // 创建圆形裁剪区域  
        using (GraphicsPath clipPath = new GraphicsPath())
        {
            clipPath.AddEllipse(circleRect);
            e.Graphics.SetClip(clipPath);

            // 绘制水波  
            int waveBottom = (int)(circleRect.Bottom - (circleRect.Height * currentProgress));

            using (GraphicsPath wavePath = new GraphicsPath())
            {
                Point[] points = new Point[circleRect.Width + 3];
                for (int x = 0; x <= circleRect.Width; x++)
                {
                    int y = (int)(Math.Sin(x * 0.05f + _waveOffset) * WAVE_HEIGHT);
                    points[x] = new Point(x + circleRect.X, waveBottom + y);
                }

                points[points.Length - 2] = new Point(circleRect.Right, circleRect.Bottom);
                points[points.Length - 1] = new Point(circleRect.Left, circleRect.Bottom);

                wavePath.AddLines(points);

                using (LinearGradientBrush brush = new LinearGradientBrush(
                    circleRect,
                    WaveColor1,
                    WaveColor2,
                    90f))
                {
                    e.Graphics.FillPath(brush, wavePath);
                }
            }

            // 绘制高光效果  
            if (EnableHighlight)
            {
                using (LinearGradientBrush highlightBrush = new LinearGradientBrush(
                    circleRect,
                    HighlightColor,
                    Color.Transparent,
                    45f))
                {
                    e.Graphics.FillEllipse(highlightBrush, circleRect);
                }
            }

            e.Graphics.ResetClip();
        }

        // 绘制百分比文本  
        string percentText = $"{(currentProgress * 100):F0}%";
        using (Font font = new Font("Arial", size / 8))
        {
            SizeF textSize = e.Graphics.MeasureString(percentText, font);
            PointF textPos = new PointF(
                circleRect.X + (circleRect.Width - textSize.Width) / 2,
                circleRect.Y + (circleRect.Height - textSize.Height) / 2
            );

            using (Brush textBrush = new SolidBrush(TextColor))
            {
                e.Graphics.DrawString(percentText, font, textBrush, textPos);
            }
        }

        base.OnPaint(e);
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            _animationTimer?.Dispose();
            _waveTimer?.Dispose();
        }
        base.Dispose(disposing);
    }
}
```

![image.png](https://blog.idiosoft.com/static/img/30f16ebdc8b1a228ecc7412b4dd1a27f.image.webp)

## 总结

这个水波进度控件不仅提供了醒目的视觉效果，还具有良好的可定制性和性能表现。它适用于需要展示进度信息的各种场景，能够为您的WinForm应用增添一份独特的视觉魅力。

希望这个控件能为您的项目锦上添花。如有任何问题或建议，欢迎讨论交流！

C# 打造炫酷的WinForm水波进度控件：完整教程与源码分析

在Windows Forms开发中，有时候我们需要一些特殊的自定义控件来满足项目的需求。本文将详细介绍如何使用GDI+技术开发一个专业级的垂直进度条控件，它不仅功能强大，而且具有出色的视觉效果。

## 控件特性概述

这个垂直进度条控件具有以下突出特点：

- 支持从下向上或从上向下的进度显示方向
- 平滑的动画过渡效果
- 可自定义的边框样式（实线、虚线、点线等）
- 精确的进度显示（带小数点）
- 渐变色进度填充
- 防闪烁的双缓冲绘制



## 核心实现原理

### 基础架构

控件继承自`Control`类，通过重写`OnPaint`方法实现自定义绘制。为了确保绘制性能，启用了以下绘制选项：

```C#
SetStyle(ControlStyles.UserPaint |
        ControlStyles.AllPaintingInWmPaint |
        ControlStyles.OptimizedDoubleBuffer, true);
```

### 动画系统

采用Timer实现平滑动画效果，关键参数设置：

```C#
private const double ANIMATION_PRECISION = 0.01;
private const double ANIMATION_SPEED = 1.0;
private Timer _animationTimer;
```

动画计算采用线性插值方式，保证了过渡的流畅性：

```C#
double diff = _targetValue - _value;
double step = Math.Sign(diff) * Math.Min(Math.Abs(diff), ANIMATION_SPEED);
_value += step;
```

### 边框系统

设计了丰富的边框样式枚举：

```C#
public enum BorderStyles
{
    None,
    Solid,
    Dash,
    Dot,
    DashDot,
    DashDotDot,
    Custom
}
```

边框绘制考虑了线宽偏移，确保边框显示准确：

```C#
Rectangle borderRect = new Rectangle(
    _borderWidth / 2,
    _borderWidth / 2,
    Width - _borderWidth,
    Height - _borderWidth
);
```

## 绘制技术详解

### 进度条绘制

进度条采用渐变填充，提供更好的视觉效果：

```C#
using (var gradientBrush = new LinearGradientBrush(
    new Point(contentRect.Left, 0),
    new Point(contentRect.Right, 0),
    Color.FromArgb(200, _progressColor),
    _progressColor))
{
    g.FillRectangle(gradientBrush, ...);
}
```

### 文本渘染

百分比文本采用抗锯齿渲染，确保清晰度：

```C#
g.SmoothingMode = SmoothingMode.AntiAlias;
string percentText = $"{Math.Round(_value, 1)}%";
```

## 属性系统设计

控件提供了丰富的可配置属性：

- BorderColor：边框颜色
- BorderWidth：边框宽度
- BorderStyle：边框样式
- IsUpward：进度方向
- ProgressColor：进度条颜色
- Value：进度值
- CurrentValue：当前实际值（只读）

每个属性都添加了适当的特性标记，支持设计器中的配置：

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

## 完整代码

```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 VerticalProgressBar : Control
    {
        private double _value = 0;
        private double _targetValue = 0;
        private bool _isUpward = true;
        private Timer _animationTimer;
        private Color _progressColor = Color.FromArgb(0, 122, 204);
        private Color _backgroundColor = Color.FromArgb(240, 240, 240);
        private Color _borderColor = Color.Gray;
        private int _borderWidth = 1;
        private BorderStyles _borderStyle = BorderStyles.Solid;

        // 添加动画精度控制  
        private const double ANIMATION_PRECISION = 0.01;
        private const double ANIMATION_SPEED = 1.0;

        public enum BorderStyles
        {
            None,
            Solid,
            Dash,
            Dot,
            DashDot,
            DashDotDot,
            Custom
        }

        public VerticalProgressBar()
        {
            SetStyle(ControlStyles.UserPaint |
                    ControlStyles.AllPaintingInWmPaint |
                    ControlStyles.OptimizedDoubleBuffer, true);

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

        #region 属性  

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

        [Category("Appearance")]
        [Description("边框宽度")]
        public int BorderWidth
        {
            get => _borderWidth;
            set
            {
                if (value < 0) value = 0;
                _borderWidth = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        [Description("边框样式")]
        public BorderStyles BorderStyle
        {
            get => _borderStyle;
            set
            {
                _borderStyle = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public bool IsUpward
        {
            get => _isUpward;
            set
            {
                _isUpward = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public Color ProgressColor
        {
            get => _progressColor;
            set
            {
                _progressColor = value;
                Invalidate();
            }
        }

        [Category("Appearance")]
        public double Value
        {
            get => _targetValue;
            set
            {
                value = Math.Max(0, Math.Min(100, value));
                if (Math.Abs(_targetValue - value) > ANIMATION_PRECISION)
                {
                    _targetValue = value;
                    _animationTimer.Start();
                }
            }
        }

        // 添加当前值的只读属性  
        [Browsable(false)]
        public double CurrentValue => Math.Round(_value, 2);

        #endregion

        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            double diff = _targetValue - _value;

            // 如果差值小于精度阈值，直接设置为目标值  
            if (Math.Abs(diff) < ANIMATION_PRECISION)
            {
                _value = _targetValue;
                _animationTimer.Stop();
                Invalidate();
                return;
            }

            // 计算每一步的变化量  
            double step = Math.Sign(diff) * Math.Min(Math.Abs(diff), ANIMATION_SPEED);
            _value += step;

            // 确保值在有效范围内  
            _value = Math.Max(0, Math.Min(100, _value));

            Invalidate();
        }

        private DashStyle GetDashStyle(BorderStyles style)
        {
            return style switch
            {
                BorderStyles.Solid => DashStyle.Solid,
                BorderStyles.Dash => DashStyle.Dash,
                BorderStyles.Dot => DashStyle.Dot,
                BorderStyles.DashDot => DashStyle.DashDot,
                BorderStyles.DashDotDot => DashStyle.DashDotDot,
                _ => DashStyle.Solid
            };
        }

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

            // 计算边框内的实际绘制区域  
            Rectangle contentRect = new Rectangle(
                _borderWidth,
                _borderWidth,
                Width - 2 * _borderWidth,
                Height - 2 * _borderWidth
            );

            // 绘制背景  
            using (var brush = new SolidBrush(_backgroundColor))
            {
                g.FillRectangle(brush, contentRect);
            }

            // 精确计算进度条高度，避免舍入误差  
            double progressPercentage = _value / 100.0;
            int progressHeight = (int)Math.Round(contentRect.Height * progressPercentage);

            // 创建渐变画刷  
            using (var gradientBrush = new LinearGradientBrush(
                new Point(contentRect.Left, 0),
                new Point(contentRect.Right, 0),
                Color.FromArgb(200, _progressColor),
                _progressColor))
            {
                // 根据方向绘制进度条  
                if (_isUpward)
                {
                    g.FillRectangle(gradientBrush,
                        contentRect.X,
                        contentRect.Bottom - progressHeight,
                        contentRect.Width,
                        progressHeight);
                }
                else
                {
                    g.FillRectangle(gradientBrush,
                        contentRect.X,
                        contentRect.Y,
                        contentRect.Width,
                        progressHeight);
                }
            }

            // 绘制边框  
            if (_borderStyle != BorderStyles.None && _borderWidth > 0)
            {
                using (var pen = new Pen(_borderColor, _borderWidth))
                {
                    pen.DashStyle = GetDashStyle(_borderStyle);

                    if (_borderStyle == BorderStyles.Custom)
                    {
                        pen.DashPattern = new float[] { 3.0F, 2.0F, 1.0F, 2.0F };
                    }

                    Rectangle borderRect = new Rectangle(
                        _borderWidth / 2,
                        _borderWidth / 2,
                        Width - _borderWidth,
                        Height - _borderWidth
                    );
                    g.DrawRectangle(pen, borderRect);
                }
            }

            // 绘制百分比文字，使用固定的小数位数  
            string percentText = $"{Math.Round(_value, 1)}%";
            using (var textBrush = new SolidBrush(ForeColor))
            using (var font = new Font("Arial", 9f, FontStyle.Bold))
            {
                var textSize = g.MeasureString(percentText, font);
                g.DrawString(percentText, font, textBrush,
                    new PointF((Width - textSize.Width) / 2, 5 + _borderWidth));
            }
        }
    }
}
```


![image.png](https://blog.idiosoft.com/static/img/577e29de9c231de36fdb68bc77f79bc5.image.webp)

## 总结

这个垂直进度条控件展示了如何将GDI+技术应用于实际开发中。通过精心的设计和优化，我们实现了一个既美观又实用的控件，它可以轻松集成到任何Windows Forms应用程序中。

核心要点：

1. 合理的架构设计
2. 平滑的动画效果
3. 精确的绘制计算
4. 丰富的自定义选项
5. 良好的性能优化

这个控件不仅可以直接使用，还可以作为学习GDI+和自定义控件开发的极好示例。

C# 从零开始打造专业级GDI+垂直进度条控件

## 简介

本教程将详细介绍如何在 Windows Forms 中创建一个自定义的仪表盘控件。这个控件具有以下特性：

- 可配置的颜色区间
- 平滑的动画效果
- 可自定义的外观
- 刻度和数值显示
- 设计时支持，这个以前没咋研究过，有点尴尬了。。

先看一下效果


![image.png](https://blog.idiosoft.com/static/img/6d3a0796eabdd4deb5d1b6548e538828.image.webp)

以前一直没有认真的实现过控件集合编辑，发现这块还是挺麻烦的。




![image.png](https://blog.idiosoft.com/static/img/dcff627d90645b015c115384e5eece0a.image.webp)

## 基础类定义

### 颜色区间类 (GaugeColorRange)

```C#
// 颜色区间类  
[Serializable]
[TypeConverter(typeof(ExpandableObjectConverter))]
public class GaugeColorRange : ICloneable
{
    private float _startValue;
    private float _endValue;
    private Color _color;

    public GaugeColorRange()
    {
        _startValue = 0;
        _endValue = 0;
        _color = Color.Black;
    }

    public GaugeColorRange(float start, float end, Color color)
    {
        _startValue = start;
        _endValue = end;
        _color = color;
    }

    [Description("区间起始值")]
    [Browsable(true)]
    [DefaultValue(0f)]
    public float StartValue
    {
        get => _startValue;
        set => _startValue = value;
    }

    [Description("区间结束值")]
    [Browsable(true)]
    [DefaultValue(0f)]
    public float EndValue
    {
        get => _endValue;
        set => _endValue = value;
    }

    [Description("区间颜色")]
    [Browsable(true)]
    public Color Color
    {
        get => _color;
        set => _color = value;
    }

    public object Clone()
    {
        return new GaugeColorRange(StartValue, EndValue, Color);
    }

    public override string ToString()
    {
        return $"{StartValue} - {EndValue}: {Color.Name}";
    }
}

```

### 颜色区间集合类 (GaugeColorRangeCollection)

```C#
// 颜色区间集合类  
[Serializable]
public class GaugeColorRangeCollection : BindingList<GaugeColorRange>
{
    public GaugeColorRangeCollection()
    {
        AllowNew = true;
        AllowEdit = true;
        AllowRemove = true;
    }

    public GaugeColorRangeCollection Clone()
    {
        var newCollection = new GaugeColorRangeCollection();
        foreach (var range in this)
        {
            newCollection.Add((GaugeColorRange)range.Clone());
        }
        return newCollection;
    }
}

```

### 颜色区间集合编辑器 (GaugeColorRangeCollectionEditor)

```C#
// 颜色区间集合编辑器  
public class GaugeColorRangeCollectionEditor : CollectionEditor
{
    public GaugeColorRangeCollectionEditor(Type type) : base(type)
    {
    }

    protected override Type CreateCollectionItemType()
    {
        return typeof(GaugeColorRange);
    }

    protected override object CreateInstance(Type itemType)
    {
        return new GaugeColorRange(0, 100, Color.Black);
    }
}

```

## 主控件类 (GaugeMeter)

### 字段和属性

```C#
public class GaugeMeter : Control
{
    private float _currentValue;
    private float _minValue = 0;
    private float _maxValue = 100;
    private Color _dialColor = Color.DarkBlue;
    private Color _pointerColor = Color.Red;
    private Timer _animationTimer;
    private float _targetValue;
    private float _dialThickness = 3f;
    private GaugeColorRangeCollection _colorRanges;

    public GaugeMeter()
    {
        SetStyle(ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.UserPaint, true);

        Size = new Size(200, 200);
        BackColor = Color.White;
        _colorRanges = new GaugeColorRangeCollection();
    }

    [Category("Appearance")]
    [Description("颜色区间集合")]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    [Editor(typeof(GaugeColorRangeCollectionEditor), typeof(UITypeEditor))]
    public GaugeColorRangeCollection ColorRanges
    {
        get => _colorRanges;
        set
        {
            if (_colorRanges != value)
            {
                _colorRanges = value;
                Invalidate();
            }
        }
    }

    public float DialThickness
    {
        get => _dialThickness;
        set
        {
            if (value >= 1 && value <= 20) // 限制合理范围  
            {
                _dialThickness = value;
                Invalidate();
            }
        }
    }

    public float MinValue
    {
        get => _minValue;
        set
        {
            _minValue = value;
            Invalidate();
        }
    }

    public float MaxValue
    {
        get => _maxValue;
        set
        {
            _maxValue = value;
            Invalidate();
        }
    }

    public float Value
    {
        get => _currentValue;
        set
        {
            if (value < _minValue) value = _minValue;
            if (value > _maxValue) value = _maxValue;
            _targetValue = value;

            if (_animationTimer == null)
            {
                _animationTimer = new Timer();
                _animationTimer.Interval = 16;
                _animationTimer.Tick += AnimationTimer_Tick;
            }
            _animationTimer.Start();
        }
    }

    public Color DialColor
    {
        get => _dialColor;
        set
        {
            _dialColor = value;
            Invalidate();
        }
    }

    public Color PointerColor
    {
        get => _pointerColor;
        set
        {
            _pointerColor = value;
            Invalidate();
        }
    }


    private void AnimationTimer_Tick(object sender, EventArgs e)
    {
        float diff = _targetValue - _currentValue;
        if (Math.Abs(diff) < 0.1f)
        {
            _currentValue = _targetValue;
            _animationTimer.Stop();
        }
        else
        {
            _currentValue += diff * 0.1f;
        }
        Invalidate();
    }

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

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

        using (var path = new GraphicsPath())
        {
            // 绘制外圈  
            float adjustedRadius = radius - _dialThickness / 2;

            if (_colorRanges != null && _colorRanges.Count > 0)
            {
                foreach (var range in _colorRanges)
                {
                    if (range.StartValue >= range.EndValue) continue;

                    // 计算起始和结束角度  
                    float startAngle = 135 + (range.StartValue - _minValue) /
                        (_maxValue - _minValue) * 270;
                    float endAngle = 135 + (range.EndValue - _minValue) /
                        (_maxValue - _minValue) * 270;
                    float sweepAngle = endAngle - startAngle;

                    using (var pen = new Pen(range.Color, _dialThickness))
                    {
                        e.Graphics.DrawArc(pen,
                            centerX - adjustedRadius,
                            centerY - adjustedRadius,
                            adjustedRadius * 2,
                            adjustedRadius * 2,
                            startAngle,
                            sweepAngle);
                    }
                }
            }
            else
            {
                // 如果没有设置颜色区间，使用默认颜色  
                using (var pen = new Pen(_dialColor, _dialThickness))
                {
                    e.Graphics.DrawArc(pen,
                        centerX - adjustedRadius,
                        centerY - adjustedRadius,
                        adjustedRadius * 2,
                        adjustedRadius * 2,
                        135,
                        270);
                }
            }

            // 获取当前值对应的颜色  
            Color currentColor = GetColorForValue(_currentValue);

            // 绘制刻度  
            for (int i = 0; i <= 10; i++)
            {
                float angle = 135 + i * 27;
                float radian = angle * (float)Math.PI / 180f;

                float scaleLength = _dialThickness + 7;
                float startX = centerX + (radius - scaleLength) * (float)Math.Cos(radian);
                float startY = centerY + (radius - scaleLength) * (float)Math.Sin(radian);
                float endX = centerX + radius * (float)Math.Cos(radian);
                float endY = centerY + radius * (float)Math.Sin(radian);

                // 获取刻度值对应的颜色  
                float value = _minValue + (_maxValue - _minValue) * i / 10f;
                Color scaleColor = GetColorForValue(value);

                using (var pen = new Pen(scaleColor, Math.Max(1, _dialThickness / 2)))
                {
                    e.Graphics.DrawLine(pen, startX, startY, endX, endY);
                }

                // 绘制刻度值  
                string text = value.ToString("F0");
                using (var font = new Font("Arial", 8))
                {
                    float textX = centerX + (radius - scaleLength - 15) * (float)Math.Cos(radian);
                    float textY = centerY + (radius - scaleLength - 15) * (float)Math.Sin(radian);

                    using (var brush = new SolidBrush(scaleColor))
                    {
                        e.Graphics.DrawString(text, font, brush,
                            textX - 10, textY - 5);
                    }
                }
            }

            // 绘制指针  
            float valueAngle = 135 + (_currentValue - _minValue) /
                (_maxValue - _minValue) * 270;
            float valueRadian = valueAngle * (float)Math.PI / 180f;

            float pointerLength = radius * 0.8f;
            float pointerWidth = Math.Max(2, _dialThickness * 0.8f);

            PointF[] pointer = new PointF[]
            {
        new PointF(centerX + pointerLength * (float)Math.Cos(valueRadian),
            centerY + pointerLength * (float)Math.Sin(valueRadian)),
        new PointF(centerX + pointerWidth * (float)Math.Cos(valueRadian + Math.PI / 2),
            centerY + pointerWidth * (float)Math.Sin(valueRadian + Math.PI / 2)),
        new PointF(centerX - 20 * (float)Math.Cos(valueRadian),
            centerY - 20 * (float)Math.Sin(valueRadian)),
        new PointF(centerX + pointerWidth * (float)Math.Cos(valueRadian - Math.PI / 2),
            centerY + pointerWidth * (float)Math.Sin(valueRadian - Math.PI / 2)),
            };

            using (var brush = new SolidBrush(_pointerColor))
            {
                e.Graphics.FillPolygon(brush, pointer);
            }

            // 中心圆  
            float centerCircleSize = Math.Max(10, _dialThickness * 3);
            using (var brush = new SolidBrush(_pointerColor))
            {
                e.Graphics.FillEllipse(brush,
                    centerX - centerCircleSize / 2,
                    centerY - centerCircleSize / 2,
                    centerCircleSize,
                    centerCircleSize);
            }

            // 绘制当前值  
            using (var font = new Font("Arial", Math.Max(12, _dialThickness + 3), FontStyle.Bold))
            {
                string valueText = _currentValue.ToString("F1");
                SizeF size = e.Graphics.MeasureString(valueText, font);
                using (var brush = new SolidBrush(currentColor))
                {
                    e.Graphics.DrawString(valueText, font, brush,
                        centerX - size.Width / 2,
                        centerY + radius * 0.3f);
                }
            }
        }

        base.OnPaint(e);
    }
    // 根据数值获取对应的颜色  
    private Color GetColorForValue(float value)
    {
        if (_colorRanges != null)
        {
            foreach (var range in _colorRanges)
            {
                if (value >= range.StartValue && value <= range.EndValue)
                {
                    return range.Color;
                }
            }
        }
        return _dialColor;
    }


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

```

## 使用示例

### 基本使用

```C#
public partial class Form1 : Form
{
    private GaugeMeter gaugeMeter;

    public Form1()
    {
        InitializeComponent();

        gaugeMeter = new GaugeMeter
        {
            Location = new Point(50, 50),
            Size = new Size(200, 200),
            MinValue = 0,
            MaxValue = 100,
            Value = 0,
            DialColor = Color.Gray,
            PointerColor = Color.Red,
            DialThickness = 5f
        };

        // 添加颜色区间
        gaugeMeter.ColorRanges.Add(new GaugeColorRange(0, 30, Color.Green));
        gaugeMeter.ColorRanges.Add(new GaugeColorRange(30, 70, Color.Yellow));
        gaugeMeter.ColorRanges.Add(new GaugeColorRange(70, 100, Color.Red));

        this.Controls.Add(gaugeMeter);
    }
}
```

## 总结

本教程展示了如何创建一个功能完整的仪表盘控件，包括：

- 自定义控件的基本结构
- 属性和事件的处理
- 绘图技术的应用
- 动画效果的实现
- 设计时支持的添加

通过这个示例，您可以了解到 Windows Forms 自定义控件开发的主要方面，并能够根据需求进行扩展和修改。

这个控件可以作为基础吧，根据具体需求进行进一步的开发和定制，有时间估计事件这块我会先增加，这个简单，想法也比较明确。

C# Windows Forms 自定义仪表盘控件开发教程

link

script

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

1. 基础类定义

引言

控件特性概览

控件特性

控件特性概述

简介