参考多家，终于写出自认为比较好的数值型TextBox

using System;

using System.ComponentModel;

using System.Drawing;

using System.Globalization;

using System.Windows.Forms;



namespace WindowsApplication1

{

    [ToolboxItem(true)]

    [ToolboxBitmap(typeof(TextBox))]

    [DefaultProperty("Value"), DefaultBindingProperty("Value")]

    [DesignTimeVisible]

    public partial class DecimalTextBox : TextBox, ISupportInitialize

    {

        #region 字段



        private static readonly decimal DefaultMaximum = 999999999M;

        private static readonly decimal DefaultMinimum = 0M;

        private static readonly decimal DefaultValue = 0M; //默认值

        private decimal currentValue = DefaultValue; //当前值

        private bool currentValueChanged; //当前值是否改变

        private int decimalPlaces = 2; //要显示的小数位数

        private bool hexadecimal = false; //十六进制

        private bool initializing;

        private Color m_BackColor; //背景色

        private Color m_BackColorWhenReadOnly; //只读背景色

        private decimal maximum = DefaultMaximum; //最大值

        private decimal minimum = DefaultMinimum; //最小值

        private bool thousandsSeparator = true; //千分位分隔符

        private bool userEdit; //用户是否编辑

        private bool m_AllowNegative = true;//负值



        #endregion



        public DecimalTextBox()

        {

            InitializeComponent();

            TextAlign = HorizontalAlignment.Right;

            ForeColor = SystemColors.WindowText;

            Text = "0";

            m_BackColor = base.BackColor; //记录当前背景色

            ReadOnly = true;

            m_BackColorWhenReadOnly = base.BackColor; // 记录只读时的颜色

            ReadOnly = false;

            base.ImeMode = ImeMode.Disable;

        }



        #region 属性



        [Category("扩展属性")]

        [Description("只读背景色")]

        [DefaultValue(typeof(Color), "Control")]

        public Color BackColorWhenReadOnly

        {

            get { return m_BackColorWhenReadOnly; }

            set

            {

                if (m_BackColorWhenReadOnly != value)

                {

                    m_BackColorWhenReadOnly = value;

                    OnBackColorChanged(EventArgs.Empty);

                }

            }

        }



        [Description("背景色")]

        [DefaultValue(typeof(Color), "White")]

        public new Color BackColor

        {

            get { return m_BackColor; }

            set

            {

                if (m_BackColor != value)

                {

                    m_BackColor = value;

                    OnBackColorChanged(EventArgs.Empty);

                }

            }

        }



        [DefaultValue(typeof(SystemColors), "WindowText")]

        public new Color ForeColor

        {

            get { return base.ForeColor; }

            set { base.ForeColor = value; }

        }



        [Description("指示数值是否应以16进制显示"), Category("外观"), DefaultValue(false)]

        public bool Hexadecimal

        {

            get { return hexadecimal; }

            set

            {

                hexadecimal = value;

                UpdateEditText();

            }

        }



        [Description("指示要显示的小数位数"), Category("数据"), DefaultValue(2)]

        public int DecimalPlaces

        {

            get { return decimalPlaces; }

            set

            {

                if (decimalPlaces != value)

                {

                    if ((value < 0) || (value > 0x63))

                    {

                        throw new ArgumentOutOfRangeException("DecimalPlaces", "DecimalPlaces 应介于 0 和 99 之间");

                    }

                    decimalPlaces = value;

                    UpdateEditText();

                }

            }

        }



        [RefreshProperties(RefreshProperties.All), Description("控件的最大值"), Category("数据")]

        public decimal Maximum

        {

            get { return maximum; }

            set

            {

                maximum = value;

                if (minimum > maximum)

                {

                    minimum = maximum;

                }

                Value = Constrain(currentValue);

            }

        }



        [Category("数据"), RefreshProperties(RefreshProperties.All), Description("控件的最小值")]

        public decimal Minimum

        {

            get { return minimum; }

            set

            {

                minimum = value;

                if (minimum > maximum)

                {

                    maximum = value;

                }

                Value = Constrain(currentValue);

            }

        }



        [Category("数据"), DefaultValue(true), Localizable(true), Description("指示是否插入千位分隔符")]

        public bool ThousandsSeparator

        {

            get { return thousandsSeparator; }

            set

            {

                thousandsSeparator = value;

                UpdateEditText();

            }

        }



        [Category("数据"), Description("指示是否允许负值"), DefaultValue(true)]

        public bool AllowNegative

        {

            get { return m_AllowNegative; }

            set

            {

                if (m_AllowNegative != value)

                {

                    m_AllowNegative = value;

                    Text = base.Text;

                }

            }

        }



        [Bindable(true), Category("外观"), Description("控件的当前值")]

        public decimal Value

        {

            get

            {

                if (userEdit)

                {

                    ValidateEditText();

                }

                return currentValue;

            }

            set

            {

                if (value != currentValue)

                {

                    if (!initializing && ((value < minimum) || (value > maximum)))

                    {

                        throw new ArgumentOutOfRangeException("Value", "超过最大值或最小值");

                    }

                    currentValue = value;

                    currentValueChanged = true;

                    UpdateEditText();

                }

            }

        }



        #region 禁用的TextBox属性



        [Browsable(false), Bindable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),

         EditorBrowsable(EditorBrowsableState.Never)]

        public override string Text

        {

            get

            {

                return base.Text;

            }

            set

            {

                base.Text = value;

            }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new HorizontalAlignment TextAlign

        {

            get { return base.TextAlign; }

            set { base.TextAlign = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new string[] Lines

        {

            get { return base.Lines; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new ImeMode ImeMode

        {

            get { return base.ImeMode; }

            set { base.ImeMode = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new char PasswordChar

        {

            get { return base.PasswordChar; }

            set { base.PasswordChar = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new bool UseSystemPasswordChar

        {

            get { return base.UseSystemPasswordChar; }

            set { base.UseSystemPasswordChar = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new bool Multiline

        {

            get { return base.Multiline; }

            set { base.Multiline = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new AutoCompleteStringCollection AutoCompleteCustomSource

        {

            get { return base.AutoCompleteCustomSource; }

            set { base.AutoCompleteCustomSource = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new AutoCompleteMode AutoCompleteMode

        {

            get { return base.AutoCompleteMode; }

            set { base.AutoCompleteMode = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new AutoCompleteSource AutoCompleteSource

        {

            get { return base.AutoCompleteSource; }

            set { base.AutoCompleteSource = value; }

        }



        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

        public new CharacterCasing CharacterCasing

        {

            get { return base.CharacterCasing; }

            set { base.CharacterCasing = value; }

        }



        #endregion



        #endregion



        protected override void OnReadOnlyChanged(EventArgs e)

        {

            base.OnReadOnlyChanged(e);

            OnBackColorChanged(EventArgs.Empty);

        }



        protected override void OnBackColorChanged(EventArgs e)

        {

            base.OnBackColorChanged(e);



            base.BackColor = ReadOnly ? m_BackColorWhenReadOnly : m_BackColor;

            Invalidate();

        }



        protected override void OnLostFocus(EventArgs e)

        {

            base.OnLostFocus(e);

            if (userEdit)

            {

                UpdateEditText();

            }

        }



        protected override void OnKeyPress(KeyPressEventArgs e)

        {

            base.OnKeyPress(e);

            NumberFormatInfo numberFormat = CultureInfo.CurrentCulture.NumberFormat;

            string numberDecimalSeparator = numberFormat.NumberDecimalSeparator;

            string numberGroupSeparator = numberFormat.NumberGroupSeparator;

            string negativeSign = numberFormat.NegativeSign;

            string str4 = e.KeyChar.ToString();



            if (m_AllowNegative)//允许负数

            {

                if (e.KeyChar == '-')

                {

                    if (SelectionStart > 0 || base.Text.IndexOf("-") > 0) // 负号的位置不对或已经存在，负号必须在最前

                    {

                        e.Handled = true;

                    }

                    return;

                }

            }

            else//不允许负数

            {

                if (e.KeyChar == '-')

                {

                    e.Handled = true;

                    return;

                }

            }



            if (decimalPlaces > 0)//允许小数

            {

                if (e.KeyChar == '.')

                {

                    if (base.Text.IndexOf('.') >= 0)// 存在小数点

                    {

                        //SelectionStart = base.Text.IndexOf('.') + 1; //定位到小数点后一位置

                        e.Handled = true;

                        return;

                    }

                }

            }

            else//不允许小数

            {

                if (e.KeyChar == '.')

                {

                    e.Handled = true;

                    return;

                }

            }



            if (((!char.IsDigit(e.KeyChar) && (!str4.Equals(numberDecimalSeparator) && 

                  !str4.Equals(numberGroupSeparator))) && !str4.Equals(negativeSign)) && (e.KeyChar != '\b'))

            {

                if (Hexadecimal)

                {

                    if ((e.KeyChar >= 'a') && (e.KeyChar <= 'f'))

                    {

                        return;

                    }

                    if ((e.KeyChar >= 'A') && (e.KeyChar <= 'F'))

                    {

                        return;

                    }

                }

                if ((ModifierKeys & (Keys.Alt | Keys.Control)) == Keys.None)

                {

                    e.Handled = true;

                }

            }

        }



        protected void ParseEditText()

        {

            try

            {

                if (!string.IsNullOrEmpty(Text) && ((Text.Length != 1) || (Text != "-")))

                {

                    if (Hexadecimal)

                    {

                        Value = Constrain(Convert.ToDecimal(Convert.ToInt32(Text, 0x10)));

                    }

                    else

                    {

                        Value = Constrain(decimal.Parse(Text, CultureInfo.CurrentCulture));

                    }

                }

                else

                {

                    Text = "0";

                }

            }

            catch

            {

            }

            finally

            {

                userEdit = false;

            }

        }



        private decimal Constrain(decimal value) //当超出值的范围，强制为最大值或最小值

        {

            if (value < minimum)

            {

                value = minimum;

            }

            if (value > maximum)

            {

                value = maximum;

            }

            return value;

        }



        private string GetNumberText(decimal num)

        {

            if (Hexadecimal)

            {

                long num2 = (long)num;

                return num2.ToString("X", CultureInfo.InvariantCulture);

            }

            return num.ToString((ThousandsSeparator ? "N" : "F") + DecimalPlaces.ToString(CultureInfo.CurrentCulture), CultureInfo.CurrentCulture);

        }



        protected void UpdateEditText()

        {

            if (!initializing)

            {

                if (userEdit)

                {

                    ParseEditText();

                }

                if (currentValueChanged || (!string.IsNullOrEmpty(Text) && ((Text.Length != 1) || (Text != "-"))))

                {

                    currentValueChanged = false;

                    userEdit = true;

                    Text = GetNumberText(currentValue);

                }

            }

        }



        protected void ValidateEditText()

        {

            ParseEditText();

            UpdateEditText();

        }



        private void ResetMaximum()

        {

            Maximum = DefaultMaximum;

        }



        private void ResetMinimum()

        {

            Minimum = DefaultMinimum;

        }



        private void ResetValue()

        {

            Value = DefaultValue;

        }



        private bool ShouldSerializeMaximum()

        {

            return !Maximum.Equals(DefaultMaximum);

        }



        private bool ShouldSerializeMinimum()

        {

            return !Minimum.Equals(DefaultMinimum);

        }



        private bool ShouldSerializeValue()

        {

            return !Value.Equals(DefaultValue);

        }



        #region ISupportInitialize 成员



        public void BeginInit()

        {

            initializing = true;

        }



        public void EndInit()

        {

            initializing = false;

            Value = Constrain(currentValue);

            UpdateEditText();

        }



        #endregion

    }

}