（三十八）c#Winform自定义控件-圆形进度条

已于 2024-09-07 15:14:31 修改
阅读量2.3k 收藏 13
点赞数 2
分类专栏： 自定义控件 文章标签： c# winform 自定义控件
于 2019-09-09 09:04:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kwwwvagaa/article/details/100622190
版权

前提

入行已经7,8年了，一直想做一套漂亮点的自定义控件，于是就有了本系列文章。

官网：https://www.hzhcontrols.cn​

GitHub：https://github.com/kwwwvagaa/NetWinformControl

码云：HZHControls控件库: HZHControls控件库，c#的winform自定义控件，对触屏具有更好的操作支持，项目是基于framework4.0，完全原生控件开发，没有使用任何第三方控件，你可以放心的用在你的项目中(winfromcontrol/winformcontrol/.net)。还有更丰富的工业控件持续增加中~~~

如果觉得写的还行，请点个 star 支持一下吧

欢迎前来交流探讨： 企鹅群568015492 企鹅群568015492​

目录

c#Winform自定义控件-目录_c#winform自定义控件-有图标的按钮-CSDN博客

准备工作

我们理一下思路，进度条支持圆环或扇形显示，支持百分比和数值显示

开始

添加一个用户控件，命名UCProcessEllipse

定义2个枚举

复制代码​

 1  public enum ValueType
 2     {
 3         /// <summary>
 4         /// 百分比
 5         /// </summary>
 6         Percent,
 7         /// <summary>
 8         /// 数值
 9         /// </summary>
10         Absolute
11     }
12 
13     public enum ShowType
14     {
15         /// <summary>
16         /// 圆环
17         /// </summary>
18         Ring,
19         /// <summary>
20         /// 扇形
21         /// </summary>
22         Sector
23     }

复制代码​

添加属性

复制代码​

  1  [Description("值改变事件"), Category("自定义")]
  2         public event EventHandler ValueChanged;
  3 
  4         private Color m_backEllipseColor = Color.FromArgb(22, 160, 133);
  5         /// <summary>
  6         /// 圆背景色
  7         /// </summary>
  8         [Description("圆背景色"), Category("自定义")]
  9         public Color BackEllipseColor
 10         {
 11             get { return m_backEllipseColor; }
 12             set
 13             {
 14                 m_backEllipseColor = value;
 15                 Refresh();
 16             }
 17         }
 18 
 19         private Color m_coreEllipseColor = Color.FromArgb(180, 180, 180);
 20         /// <summary>
 21         /// 内圆颜色，ShowType=Ring 有效
 22         /// </summary>
 23         [Description("内圆颜色，ShowType=Ring 有效"), Category("自定义")]
 24         public Color CoreEllipseColor
 25         {
 26             get { return m_coreEllipseColor; }
 27             set
 28             {
 29                 m_coreEllipseColor = value;
 30                 Refresh();
 31             }
 32         }
 33 
 34         private Color m_valueColor = Color.FromArgb(255, 77, 59);
 35 
 36         [Description("值圆颜色"), Category("自定义")]
 37         public Color ValueColor
 38         {
 39             get { return m_valueColor; }
 40             set
 41             {
 42                 m_valueColor = value;
 43                 Refresh();
 44             }
 45         }
 46 
 47         private bool m_isShowCoreEllipseBorder = true;
 48         /// <summary>
 49         /// 内圆是否显示边框，ShowType=Ring 有效
 50         /// </summary>
 51         [Description("内圆是否显示边框，ShowType=Ring 有效"), Category("自定义")]
 52         public bool IsShowCoreEllipseBorder
 53         {
 54             get { return m_isShowCoreEllipseBorder; }
 55             set
 56             {
 57                 m_isShowCoreEllipseBorder = value;
 58                 Refresh();
 59             }
 60         }
 61 
 62         private ValueType m_valueType = ValueType.Percent;
 63         /// <summary>
 64         /// 值文字类型
 65         /// </summary>
 66         [Description("值文字类型"), Category("自定义")]
 67         public ValueType ValueType
 68         {
 69             get { return m_valueType; }
 70             set
 71             {
 72                 m_valueType = value;
 73                 Refresh();
 74             }
 75         }
 76 
 77         private int m_valueWidth = 30;
 78         /// <summary>
 79         /// 外圆值宽度
 80         /// </summary>
 81         [Description("外圆值宽度，ShowType=Ring 有效"), Category("自定义")]
 82         public int ValueWidth
 83         {
 84             get { return m_valueWidth; }
 85             set
 86             {
 87                 if (value <= 0 || value > Math.Min(this.Width, this.Height))
 88                     return;
 89                 m_valueWidth = value;
 90                 Refresh();
 91             }
 92         }
 93 
 94         private int m_valueMargin = 5;
 95         /// <summary>
 96         /// 外圆值间距
 97         /// </summary>
 98         [Description("外圆值间距"), Category("自定义")]
 99         public int ValueMargin
100         {
101             get { return m_valueMargin; }
102             set
103             {
104                 if (value < 0 || m_valueMargin >= m_valueWidth)
105                     return;
106                 m_valueMargin = value;
107                 Refresh();
108             }
109         }
110 
111         private int m_maxValue = 100;
112         /// <summary>
113         /// 最大值
114         /// </summary>
115         [Description("最大值"), Category("自定义")]
116         public int MaxValue
117         {
118             get { return m_maxValue; }
119             set
120             {
121                 if (value > m_value || value <= 0)
122                     return;
123                 m_maxValue = value;
124                 Refresh();
125             }
126         }
127 
128         private int m_value = 0;
129         /// <summary>
130         /// 当前值
131         /// </summary>
132         [Description("当前值"), Category("自定义")]
133         public int Value
134         {
135             get { return m_value; }
136             set
137             {
138                 if (m_maxValue < value || value <= 0)
139                     return;
140                 m_value = value;
141                 if (ValueChanged != null)
142                 {
143                     ValueChanged(this, null);
144                 }
145                 Refresh();
146             }
147         }
148         private Font m_font = new Font("Arial Unicode MS", 20);
149         [Description("文字字体"), Category("自定义")]
150         public override Font Font
151         {
152             get
153             {
154                 return m_font;
155             }
156             set
157             {
158                 m_font = value;
159                 Refresh();
160             }
161         }
162         Color m_foreColor = Color.White;
163         [Description("文字颜色"), Category("自定义")]
164         public override Color ForeColor
165         {
166             get
167             {
168                 return m_foreColor;
169             }
170             set
171             {
172                 m_foreColor = value;
173                 Refresh();
174             }
175         }
176 
177         private ShowType m_showType = ShowType.Ring;
178 
179         [Description("显示类型"), Category("自定义")]
180         public ShowType ShowType
181         {
182             get { return m_showType; }
183             set
184             {
185                 m_showType = value;
186                 Refresh();
187             }
188         }

复制代码​

重绘

复制代码​

 1   protected override void OnPaint(PaintEventArgs e)
 2         {
 3             base.OnPaint(e);
 4 
 5             var g = e.Graphics;
 6             g.SmoothingMode = SmoothingMode.AntiAlias;  //使绘图质量最高，即消除锯齿
 7             g.InterpolationMode = InterpolationMode.HighQualityBicubic;
 8             g.CompositingQuality = CompositingQuality.HighQuality;
 9 
10             int intWidth = Math.Min(this.Size.Width, this.Size.Height);
11             //底圆
12             g.FillEllipse(new SolidBrush(m_backEllipseColor), new Rectangle(new Point(0, 0), new Size(intWidth, intWidth)));
13             if (m_showType == HZH_Controls.Controls.ShowType.Ring)
14             {
15                 //中心圆
16                 int intCore = intWidth - m_valueWidth * 2;
17                 g.FillEllipse(new SolidBrush(m_coreEllipseColor), new Rectangle(new Point(m_valueWidth, m_valueWidth), new Size(intCore, intCore)));
18                 //中心圆边框
19                 if (m_isShowCoreEllipseBorder)
20                 {
21                     g.DrawEllipse(new Pen(m_valueColor, 2), new Rectangle(new Point(m_valueWidth + 1, m_valueWidth + 1), new Size(intCore - 1, intCore - 1)));
22                 }
23                 if (m_value > 0 && m_maxValue > 0)
24                 {
25                     float fltPercent = (float)m_value / (float)m_maxValue;
26                     if (fltPercent > 1)
27                     {
28                         fltPercent = 1;
29                     }
30 
31                     g.DrawArc(new Pen(m_valueColor, m_valueWidth - m_valueMargin * 2), new RectangleF(new Point(m_valueWidth / 2 + m_valueMargin / 4, m_valueWidth / 2 + m_valueMargin / 4), new SizeF(intWidth - m_valueWidth - m_valueMargin / 2 + (m_valueMargin == 0 ? 0 : 1), intWidth - m_valueWidth - m_valueMargin / 2 + (m_valueMargin == 0 ? 0 : 1))), -90, fltPercent * 360);
32 
33                     string strValueText = m_valueType == HZH_Controls.Controls.ValueType.Percent ? fltPercent.ToString("0%") : m_value.ToString();
34                     System.Drawing.SizeF _txtSize = g.MeasureString(strValueText, this.Font);
35                     g.DrawString(strValueText, this.Font, new SolidBrush(this.ForeColor), new PointF((intWidth - _txtSize.Width) / 2 + 1, (intWidth - _txtSize.Height) / 2 + 1));
36                 }
37             }
38             else
39             {
40                 if (m_value > 0 && m_maxValue > 0)
41                 {
42                     float fltPercent = (float)m_value / (float)m_maxValue;
43                     if (fltPercent > 1)
44                     {
45                         fltPercent = 1;
46                     }
47 
48                     g.FillPie(new SolidBrush(m_valueColor), new Rectangle(m_valueMargin, m_valueMargin, intWidth - m_valueMargin * 2, intWidth - m_valueMargin * 2), -90, fltPercent * 360);
49 
50                     string strValueText = m_valueType == HZH_Controls.Controls.ValueType.Percent ? fltPercent.ToString("0%") : m_value.ToString();
51                     System.Drawing.SizeF _txtSize = g.MeasureString(strValueText, this.Font);
52                     g.DrawString(strValueText, this.Font, new SolidBrush(this.ForeColor), new PointF((intWidth - _txtSize.Width) / 2 + 1, (intWidth - _txtSize.Height) / 2 + 1));
53                 }
54             }
55 
56         }

复制代码​

完整代码如下

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Drawing2D;

namespace HZH_Controls.Controls
{
    public partial class UCProcessEllipse : UserControl
    {
        [Description("值改变事件"), Category("自定义")]
        public event EventHandler ValueChanged;

        private Color m_backEllipseColor = Color.FromArgb(22, 160, 133);
        /// <summary>
        /// 圆背景色
        /// </summary>
        [Description("圆背景色"), Category("自定义")]
        public Color BackEllipseColor
        {
            get { return m_backEllipseColor; }
            set
            {
                m_backEllipseColor = value;
                Refresh();
            }
        }

        private Color m_coreEllipseColor = Color.FromArgb(180, 180, 180);
        /// <summary>
        /// 内圆颜色，ShowType=Ring 有效
        /// </summary>
        [Description("内圆颜色，ShowType=Ring 有效"), Category("自定义")]
        public Color CoreEllipseColor
        {
            get { return m_coreEllipseColor; }
            set
            {
                m_coreEllipseColor = value;
                Refresh();
            }
        }

        private Color m_valueColor = Color.FromArgb(255, 77, 59);

        [Description("值圆颜色"), Category("自定义")]
        public Color ValueColor
        {
            get { return m_valueColor; }
            set
            {
                m_valueColor = value;
                Refresh();
            }
        }

        private bool m_isShowCoreEllipseBorder = true;
        /// <summary>
        /// 内圆是否显示边框，ShowType=Ring 有效
        /// </summary>
        [Description("内圆是否显示边框，ShowType=Ring 有效"), Category("自定义")]
        public bool IsShowCoreEllipseBorder
        {
            get { return m_isShowCoreEllipseBorder; }
            set
            {
                m_isShowCoreEllipseBorder = value;
                Refresh();
            }
        }

        private ValueType m_valueType = ValueType.Percent;
        /// <summary>
        /// 值文字类型
        /// </summary>
        [Description("值文字类型"), Category("自定义")]
        public ValueType ValueType
        {
            get { return m_valueType; }
            set
            {
                m_valueType = value;
                Refresh();
            }
        }

        private int m_valueWidth = 30;
        /// <summary>
        /// 外圆值宽度
        /// </summary>
        [Description("外圆值宽度，ShowType=Ring 有效"), Category("自定义")]
        public int ValueWidth
        {
            get { return m_valueWidth; }
            set
            {
                if (value <= 0 || value > Math.Min(this.Width, this.Height))
                    return;
                m_valueWidth = value;
                Refresh();
            }
        }

        private int m_valueMargin = 5;
        /// <summary>
        /// 外圆值间距
        /// </summary>
        [Description("外圆值间距"), Category("自定义")]
        public int ValueMargin
        {
            get { return m_valueMargin; }
            set
            {
                if (value < 0 || m_valueMargin >= m_valueWidth)
                    return;
                m_valueMargin = value;
                Refresh();
            }
        }

        private int m_maxValue = 100;
        /// <summary>
        /// 最大值
        /// </summary>
        [Description("最大值"), Category("自定义")]
        public int MaxValue
        {
            get { return m_maxValue; }
            set
            {
                if (value > m_value || value <= 0)
                    return;
                m_maxValue = value;
                Refresh();
            }
        }

        private int m_value = 0;
        /// <summary>
        /// 当前值
        /// </summary>
        [Description("当前值"), Category("自定义")]
        public int Value
        {
            get { return m_value; }
            set
            {
                if (m_maxValue < value || value <= 0)
                    return;
                m_value = value;
                if (ValueChanged != null)
                {
                    ValueChanged(this, null);
                }
                Refresh();
            }
        }
        private Font m_font = new Font("Arial Unicode MS", 20);
        [Description("文字字体"), Category("自定义")]
        public override Font Font
        {
            get
            {
                return m_font;
            }
            set
            {
                m_font = value;
                Refresh();
            }
        }
        Color m_foreColor = Color.White;
        [Description("文字颜色"), Category("自定义")]
        public override Color ForeColor
        {
            get
            {
                return m_foreColor;
            }
            set
            {
                m_foreColor = value;
                Refresh();
            }
        }

        private ShowType m_showType = ShowType.Ring;

        [Description("显示类型"), Category("自定义")]
        public ShowType ShowType
        {
            get { return m_showType; }
            set
            {
                m_showType = value;
                Refresh();
            }
        }

        public UCProcessEllipse()
        {
            InitializeComponent();
            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.DoubleBuffer, true);
            this.SetStyle(ControlStyles.ResizeRedraw, true);
            this.SetStyle(ControlStyles.Selectable, true);
            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
            this.SetStyle(ControlStyles.UserPaint, true);
        }

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

            var g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;  //使绘图质量最高，即消除锯齿
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            g.CompositingQuality = CompositingQuality.HighQuality;

            int intWidth = Math.Min(this.Size.Width, this.Size.Height);
            //底圆
            g.FillEllipse(new SolidBrush(m_backEllipseColor), new Rectangle(new Point(0, 0), new Size(intWidth, intWidth)));
            if (m_showType == HZH_Controls.Controls.ShowType.Ring)
            {
                //中心圆
                int intCore = intWidth - m_valueWidth * 2;
                g.FillEllipse(new SolidBrush(m_coreEllipseColor), new Rectangle(new Point(m_valueWidth, m_valueWidth), new Size(intCore, intCore)));
                //中心圆边框
                if (m_isShowCoreEllipseBorder)
                {
                    g.DrawEllipse(new Pen(m_valueColor, 2), new Rectangle(new Point(m_valueWidth + 1, m_valueWidth + 1), new Size(intCore - 1, intCore - 1)));
                }
                if (m_value > 0 && m_maxValue > 0)
                {
                    float fltPercent = (float)m_value / (float)m_maxValue;
                    if (fltPercent > 1)
                    {
                        fltPercent = 1;
                    }

                    g.DrawArc(new Pen(m_valueColor, m_valueWidth - m_valueMargin * 2), new RectangleF(new Point(m_valueWidth / 2 + m_valueMargin / 4, m_valueWidth / 2 + m_valueMargin / 4), new SizeF(intWidth - m_valueWidth - m_valueMargin / 2 + (m_valueMargin == 0 ? 0 : 1), intWidth - m_valueWidth - m_valueMargin / 2 + (m_valueMargin == 0 ? 0 : 1))), -90, fltPercent * 360);

                    string strValueText = m_valueType == HZH_Controls.Controls.ValueType.Percent ? fltPercent.ToString("0%") : m_value.ToString();
                    System.Drawing.SizeF _txtSize = g.MeasureString(strValueText, this.Font);
                    g.DrawString(strValueText, this.Font, new SolidBrush(this.ForeColor), new PointF((intWidth - _txtSize.Width) / 2 + 1, (intWidth - _txtSize.Height) / 2 + 1));
                }
            }
            else
            {
                if (m_value > 0 && m_maxValue > 0)
                {
                    float fltPercent = (float)m_value / (float)m_maxValue;
                    if (fltPercent > 1)
                    {
                        fltPercent = 1;
                    }

                    g.FillPie(new SolidBrush(m_valueColor), new Rectangle(m_valueMargin, m_valueMargin, intWidth - m_valueMargin * 2, intWidth - m_valueMargin * 2), -90, fltPercent * 360);

                    string strValueText = m_valueType == HZH_Controls.Controls.ValueType.Percent ? fltPercent.ToString("0%") : m_value.ToString();
                    System.Drawing.SizeF _txtSize = g.MeasureString(strValueText, this.Font);
                    g.DrawString(strValueText, this.Font, new SolidBrush(this.ForeColor), new PointF((intWidth - _txtSize.Width) / 2 + 1, (intWidth - _txtSize.Height) / 2 + 1));
                }
            }

        }
    }

    public enum ValueType
    {
        /// <summary>
        /// 百分比
        /// </summary>
        Percent,
        /// <summary>
        /// 数值
        /// </summary>
        Absolute
    }

    public enum ShowType
    {
        /// <summary>
        /// 圆环
        /// </summary>
        Ring,
        /// <summary>
        /// 扇形
        /// </summary>
        Sector
    }
}
namespace HZH_Controls.Controls
{
    partial class UCProcessEllipse
    {
        /// <summary> 
        /// 必需的设计器变量。
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary> 
        /// 清理所有正在使用的资源。
        /// </summary>
        /// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region 组件设计器生成的代码

        /// <summary> 
        /// 设计器支持所需的方法 - 不要
        /// 使用代码编辑器修改此方法的内容。
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        }

        #endregion
    }
}

用处及效果

​

​

最后的话

如果你喜欢的话，请到 HZHControls控件库: HZHControls控件库，c#的winform自定义控件，对触屏具有更好的操作支持，项目是基于framework4.0，完全原生控件开发，没有使用任何第三方控件，你可以放心的用在你的项目中(winfromcontrol/winformcontrol/.net)。还有更丰富的工业控件持续增加中~~~ 点个星 星吧

kwwwvagaa
关注
专栏目录
C# Winform圆形进度条（改良版）
03-22
C# Winform圆形进度条（改良版）从csdn下载，增加了圆形进度值文字显示。GDI+绘制，效率高。
一个用C#编写的圆形进度条
09-26
用C#编写的圆形进度条，仅利用绘图工具编成
Winform画圆以及无边框窗体的移动
愿你历尽千帆，归来仍是少年。
08-12 439
创建一个自定义控件，重写OnPaint方法来绘制圆形。// 圆的半径然后您可以将这个自定义控件添加到窗体上。
[C#]winform制作圆形进度条好用的圆环圆形进度条控件和使用方法
FL1623863129的博客
02-10 2495
圆形进度条控件制作是是否考验自己编程能力如果有开源免费的圆形进度条就很好了，偶然发现一个好用圆形进度条控件，支持圆形、圆环等指定圆形进度条创建，使用十分简单就跟C#里面trackbar使用方法一样，只是简单调用即可。下面是一个简单的例子，演示如何使用System.Drawing命名空间中的图形绘制功能来绘制一个基本的圆形进度条。// 直径等于宽度和高度的最小值减一。// 计算扫过的角度。// 半径等于直径的一半。// 绘制进度条背景。
CircularProgressBar c#圆形进度条
11-28
在国外找到的一个圆环型的进度条，拖到项目生成即可使用，有两种进度显示方式。
C#圆形进度条
07-28
一个C#圆形进度条的demo,希望能帮助到你.
C#winform 自定义控件实现圆形进度条和环形进度条控件
12-11
在C# WinForm应用开发中，自定义控件可以极大地扩展UI的表现力和功能。本项目专注于创建两种特殊的进度条控件：圆形进度条和环形进度条，这些控件适用于展示任务或进程的进度，视觉效果独特，能吸引用户注意力。通过...
C# Winform 自定义进度条ProgressBar
06-23
除了颜色之外，还可以进一步扩展这个自定义控件的功能，如改变进度条的形状（圆形、弧形等）、添加动画效果、自定义边框样式等。这需要更深入地了解GDI+绘图，包括线性渐变、圆角矩形、路径绘图等技术。 总之，...
C#-绘制好看的进度条用户控件-圆环进度条（中级）
03-15
在Windows Forms中，我们可以继承自`UserControl`类来创建自定义控件；而在WPF中，我们可以使用`UserControl`或者更底层的`Canvas`、`Path`等元素进行绘制。本案例中的“圆环进度条”可能更适合WPF，因为它提供了更...
C# GDI+ 圆形进度条，比例图自定义控件
05-19
总之，使用C#的GDI+实现自定义圆形进度条控件是一项具有挑战性的任务，但通过理解图形绘制的基本原理和GDI+的使用方法，你可以创建出富有视觉吸引力的UI元素，提升应用程序的整体用户体验。在实践中，不断调整和优化...
C#/WinForm实现圆形进度条
QyLost
08-31 2940
CircledProgressBar 一个简单的圆形进度条，通过简单的圆弧绘制来实现，实现了基本的大小适配、文字大小修改、颜色调整等功能。 效果图 自动适配 属性说明 1、FinsihedColor 设置进度达到最大值后对勾的颜色 2、TopColor 设置已达成的进度条的颜色 3、BottomColor 设置底部整个进度条的颜色。 4、Font 设置进度值的显示字体 5、ForeColor ...
漂亮的圆形进度条
06-02
漂亮的圆形进度条，C#使用，可适用于各个netFrame版本
WinForm圆形按钮(C#)
02-23
利用C#语言制作的自定义控件：圆形按钮，按钮形状参数可定义。可显示音乐播放器形态的按钮。包含Demo和Dll
winform圆形进度条测试源码
09-28
c#.net实现圆形进度条源代码。c#.net实现圆形进度条源代码。
C#自定义圆形控件 可缩放和移动
05-09
C#开发的自定义空间，圆形的图标，可以随鼠标拖动，放大和缩小，有2个版本，不记得哪个好用了，用的时候，在VS的工具箱右击——选项——选择这个Dll，可以添加上。试一试吧
C#自定义控件：一个简单的圆形按钮源码
12-11
VS2010下，C#自定义控件源代码示例，为一个圆形的Button控件，包括dll和源文件项目
圆形进度条
WANG_CSD的博客
09-05 269
圆形进度条     html: &lt;div class="canvas-box pr"&gt; &lt;canvas class="mycanvas" width="20" height="20"&gt;您的浏览器不支持canvas，请更换或者升级浏览器&lt;/canvas&gt; &lt;span class="data"&amp
c# 实现圆形的进度条(ProgressBar)
chinaherolts2008的博客
03-21 2096
这篇文章主要介绍了c# 如何实现圆形的进度条(ProgressBar)，帮助大家更好的理解和学习使用c#，感兴趣的朋友可以了解下在我们实际的工作中可能经常使用到圆形的进度条，但是这c#教程是怎么实现的呢？其实这只不过是修改了一下ProgressBar的模板，我们在下面的代码中我们将ProgressBar的Value值绑定到Border的Background上面，并且使用了一个ValueToProcessConverter的转换器进行相应地转换，这里重点介绍一下这个转换器 <ProgressBar Na
c#Winform自定义控件-仪表盘
最新发布
09-12
WinForms中的自定义控件开发允许开发者创建具有特定功能的控件，这些控件可以用于多种应用程序。仪表盘控件是一种常见的自定义控件，它模拟物理仪表盘，用于显示从简单到复杂的各种数据。在C#中开发WinForms仪表盘控件通常涉及以下几个步骤： 1. **创建控件类**：首先，你需要继承自`UserControl`类，创建一个新的类，这个类将作为基础来定义你的仪表盘控件。 2. **设计界面**：在类中，使用设计器或代码来绘制控件的用户界面。这可能包括刻度、指针和数据标签等元素。 3. **编写业务逻辑**：实现控件的数据绑定和逻辑处理，这可能包括如何读取和显示数据，以及如何响应用户的交互。 4. **属性和事件**：定义公共属性来获取和设置控件的外观和行为，如颜色、范围等，并且创建事件以允许外部代码响应特定的用户操作，如值改变等。 5. **测试和调试**：在完成开发后，需要对控件进行彻底的测试，确保在不同情况下都能正确工作。 以下是一个简单的示例代码，展示了如何创建一个基础的仪表盘控件： ```csharp using System; using System.Drawing; using System.Windows.Forms; public class DashboardControl : UserControl { private float value = 0; // 仪表盘的当前值 // 公共属性，允许外部设置仪表盘值 public float Value { get { return value; } set { if (value != this.value) { this.value = value; Invalidate(); // 重绘控件 } } } // 绘制控件 protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); Graphics g = e.Graphics; // 绘制仪表盘的刻度和指针等 // ... } // 其他方法，如响应用户事件等 } ``` 开发自定义控件是一个复杂的过程，它需要深入了解WinForms框架、GDI+绘图以及可能涉及的动画和数据绑定技术。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值