C# 中金额文本框，每隔三位以逗号隔开,做金额输入的时候可以用下

一直都是在做java开发，最近刚刚在搞C#，本来想做一个文本框来进行金额与数理的输入，可是很无奈vs没有这个控件

就去微软官网找到了一个类似的控件，不过不能进行负数的输入，也不能进行小数点的动态配置，

经过两天我改成了我想要的样子可以，可是动态设置小数点位数，可以进行负数输入，负数的时候文本显示为红色。效果图如下

代码可以直接拷贝出来就用

 

  

namespace miniShop.custCom
{
    using System;
    using System.Text;
    using System.ComponentModel;
    using System.Windows.Forms;
    using System.Globalization;
    using System.Diagnostics;

    /// <devdoc>
    ///     DecimalTextBox control definition class. 
    ///     A text box that accepts numeric decimal input only.
    /// </devdoc>
    public class DecimalTextBox : TextBox
    {
        const int WM_COPY = 0x0301,
                    WM_CUT = 0x0300,
                    WM_PASTE = 0x0302,
                    WM_CLEAR = 0x0303,
                    WM_CONTEXTMENU = 0x007B;

        //static NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;
        public Decimal TextValue;//文本的 Decimal值
        private NumberFormatInfo nfi = new System.Globalization.NumberFormatInfo();
        private System.Drawing.Color _redColor = System.Drawing.Color.Red; //为负数时候的颜色
        private int _intDecimal=2;
        private bool _isNegative=false;
        private int _decimalLength = 15;
        [Category("Categoria"), DefaultValue(2), Browsable(true), Description("小数的位数")]
        public int intDecimal
        {
            get { return _intDecimal; }
            set
            {
                this._intDecimal = value;
                nfi.NumberDecimalDigits = value;
               
                ResetText();
               
            }
           
        }
        [Category("Categoria"), DefaultValue(false), Browsable(true), Description("是否为可以为负数")]

        public bool isNegative
        {
            get { return this._isNegative; }
            set { this._isNegative = value;
            try
            {
                if (isNegative)
                {
                   
                    if (Text.ToString().IndexOf("-") < 0)
                    {
                        base.Text = "-" + base.Text;
                        this.ForeColor = _redColor;
                    }
                }
            }
            catch { }
            }
        }
        [Category("Categoria"), DefaultValue(15), Browsable(true), Description("文本框的文本长度")]
        public int decimalLength
        {
            get { return _decimalLength; }
            set { this._decimalLength = value; }
        }
       
        /// <devdoc>
        ///     Set the initial params.
        /// </devdoc>
        public DecimalTextBox()
        {
          //  nfi.NumberDecimalDigits = intDecimal;
            base.TextAlign = HorizontalAlignment.Right;
            ResetText();
        }
       
       
        /// <devdoc>
        ///     Overridden to validate and format the text.
        /// </devdoc>
        public override string Text
        {
            get
            {
                return base.Text;
               
            }
            set
            {
                if (value != base.Text)
                {
                    SetFormattedText(new StringBuilder(value));
                }

            }
        }
       

        /// <devdoc>
        ///     Overridden to handle unsupported RETURN key.
        /// </devdoc>
        protected override bool IsInputKey(Keys keyData)
        {
            if ((keyData & Keys.KeyCode) == Keys.Return)
            {
                return false;
            }
            return base.IsInputKey(keyData);
        }

        /// <devdoc>
        ///     Overridden to handle supported shortcuts Ctrl-C (Copy All) & Ctrl-D (Delete All).
        /// </devdoc>
        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            //
            // The base class should be called first because it implements ShortcutsEnabled,
            // which takes precedence over Ctrl+C
            //
            bool msgProcessed = base.ProcessCmdKey(ref msg, keyData);
           
            if (!msgProcessed)
            {
                if ((int)keyData == (int)Shortcut.CtrlC)
                {
                    WmCopy();
                    msgProcessed = true;
                }
                else if (((int)keyData == (int)Shortcut.CtrlD))
                {
                    ResetText();
                    msgProcessed = true;
                }
                else if (((int)keyData == (int)Shortcut.CtrlX))
                {
                    WmCopy();
                    ResetText();
                    msgProcessed = true;
                }
            }

            return msgProcessed;
        }

        /// <devdoc>
        ///     Set the initial text.
        /// </devdoc>
        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);

            if (this.Visible)
            {
                this.SelectionStart = 1;
                this.SelectionLength = 0;
            }
        }

        /// <devdoc>
        ///     Handle text deletion.
        /// </devdoc>
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            Keys keyCode = e.KeyCode;

            if (this.SelectionLength > 0)
            {
                // For now we don't support replace over selection.
                this.SelectionLength = 0;
            }

            if (keyCode == Keys.Back || keyCode == Keys.Delete)
            {
                e.Handled = true;

                if ((e.Modifiers & Keys.Modifiers) != 0)
                {
                    // Key modifiers not allowed for these keys.
                    return;
                }

                int caretPos = this.SelectionStart;
                StringBuilder txt = new StringBuilder(this.Text);
                int originalTextLength = txt.Length;

                if (originalTextLength - caretPos <= nfi.NumberDecimalDigits) // caret at a decimal location
                {
                    // Corner cases for caret postion.
                    // At the beginning: Del works as normal.  Bck jumps over the decimal separator.
                    // At the end:: Del does nothing.  Bck works as normal.

                    if (caretPos == originalTextLength && keyCode == Keys.Delete)
                    {
                        return;
                    }

                    // On Bck move caret back by one to perform Del.
                    if (keyCode == Keys.Back)
                    {
                        caretPos--;
                    }

                    bool updateCaret = true;

                    if (txt[caretPos] != nfi.NumberDecimalSeparator[0]) // Not at the decimal separator.
                    {
                        txt.Remove(caretPos, 1);
                        updateCaret = SetFormattedText(txt);
                    }

                    if (updateCaret)
                    {
                        this.SelectionStart = caretPos;
                    }
                }
                else // caret at a whole number's location or at the decimal separator's location.
                {
                    // Corner cases for caret postion.
                    // At the beginning: Del should not move the caret (exeption: When first number is zero it should jump it).
                    //                   Bck should do nothing.
                    // At the end: Del jumps over the decimal separator. Bck works as normal.

                    if (txt[caretPos] == nfi.NumberDecimalSeparator[0]) // at the decimal separator location (end).
                    {
                        if (keyCode == Keys.Delete) // Jump caret over the decimal separator.
                        {
                            this.SelectionStart = caretPos + 1;
                            return;
                        }
                    }

                    if (keyCode == Keys.Back)
                    {
                        if (caretPos == 0) // at the beginning of string.
                        {
                            return;
                        }
                        caretPos--; // Get ready for a Del.
                    }

                    // If caret is at a group separator, deleting the separator would not change the text since it would
                    // get formatted the same way.  We need to skip over it.
                    // Del: skip right.  Bck: we alread skip left above.
                    if (txt[caretPos] == nfi.NumberGroupSeparator[0])
                    {
                        if (keyCode == Keys.Delete)
                        {
                            caretPos++;
                        }

                        this.SelectionStart = caretPos;
                        return;
                    }

                    // removing a number.
                    txt.Remove(caretPos, 1);
                    if (SetFormattedText(txt))
                    {

                        // Set new caret location.
                        if (caretPos == 0)
                        {
                            // When first number is 0, Del on it should simply skip over it.
                            if (txt[0] == '0' && keyCode == Keys.Delete)
                            {
                                caretPos++;
                            }
                        }
                        else
                        {
                            // +1 so the caret moves on Delete or stays on BackSpc.
                            caretPos = caretPos - (originalTextLength - txt.Length) + 1;
                        }

                        this.SelectionStart = caretPos;
                    }
                }
            }
        }

        /// <devdoc>
        ///     Handle input filtering and text insertion.
        /// </devdoc>
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            base.OnKeyPress(e);
            e.Handled = true;  // This disables undersired keys. ProcessCmdKey is used to enabled supported shortcuts.

            // Filter allowed input: integers or decimal separator only.
            if (this.Text.Length > decimalLength)
            {
                e.Handled = true;

            }
            else
            {
                //如果是负数并且输入的为负数
                if (this.isNegative && e.KeyChar == '-')
                {
                    if (!(this.isNegative && this.SelectionStart == 0 && this.Text.IndexOf("-") < 0))
                    {
                        return;
                    }
                }
                else
                {

                    if ((!char.IsDigit(e.KeyChar)) && e.KeyChar != nfi.NumberDecimalSeparator[0])
                    {
                        return;
                    }
                }

                int caretPos = this.SelectionStart;
                StringBuilder txt = new StringBuilder(this.Text);

                if (e.KeyChar == nfi.NumberDecimalSeparator[0])
                {
                    // Go to decimal input location.
                    this.SelectionStart = txt.Length - nfi.NumberDecimalDigits;
                    return;
                }

                if (caretPos == txt.Length) // caret at the end of the box
                {
                    // input ignored.
                    return;
                }

                int originalTextLength = txt.Length;

                if (originalTextLength - caretPos <= nfi.NumberDecimalDigits) // caret at decimal location
                {
                    // Replace the current location's value with the input.
                    txt[caretPos] = e.KeyChar;
                    this.Text = txt.ToString();
                    this.SelectionStart = caretPos + 1;
                }
                else // caret at a whole number's location or at the decimal separator's location.
                {
                    // If caret is at pos 0 and the number is zero, we need to move caret so it can be inserted after the 0
                    // and get properly formatted; otherwise, the input would be inserted at zero (effect = multiplied by 10).
                    if (caretPos == 0 && txt[0] == '0')
                    {
                        caretPos++;
                    }

                    // Insert value.
                   
                    if (e.KeyChar == '-'&&txt.ToString().IndexOf("-")<0)
                    {
                        txt.Insert(0, e.KeyChar);
                    }else
                    {
                        txt.Insert(caretPos, e.KeyChar);
                    }
                    if (SetFormattedText(txt))
                    {
                        this.SelectionStart = caretPos + (txt.Length - originalTextLength);
                    }
                }
            }
          
        }

        /// <devdoc>
        ///     Overridden to reset selected text.
        /// </devdoc>
        protected override void OnMouseUp(MouseEventArgs mevent)
        {
            base.OnMouseUp(mevent);
            ResetSelection();
        }

        /// <devdoc>
        ///     Selecting Text is not allowed.
        /// </devdoc>
        private void ResetSelection()
        {
            if (this.SelectionLength > 0)
            {
                this.SelectionLength = 0;
            }
        }

        /// <devdoc>
        /// </devdoc>
        public override void ResetText()
        {
            SetFormattedText(new StringBuilder("0"));
        }

        /// <devdoc>
        ///     Sets the decimal-formatted text into the control's text.
        ///     Returns false if an exception is thrown during text formatting due to overflow or unexpected characters in
        ///     the specified text.
        ///     Methods calling this method should check for the return value before doing further processing.
        ///     The input should contain interger numbers and decimal group separator characters only; it does not expect
        ///     the string to represent a well formatted decimal number.
        /// </devdoc>
        private bool SetFormattedText(StringBuilder txt)
        {
            // Remove group separators to re-format the string.

            String _text = txt.ToString();
           
            txt.Replace(nfi.NumberGroupSeparator, "");

            try
            {
                string _temp = "-";
                if (_text.IndexOf("-") > -1&&this.isNegative)
                {
                    _temp = "-";
                }
                else
                {
                    _temp = "";
                }
                decimal value = decimal.Parse(txt.ToString()); // parse decimal value.
                txt.Length = 0; // clear text.
              
                txt.Append(value.ToString("N", nfi)); // set new text.
                if (_temp == "-" && txt.ToString().IndexOf("-") < 0)
                {
                    base.Text = _temp + txt.ToString(); // set control's text.
                }
                else
                {
                    base.Text = txt.ToString();
                }
                if (Text.ToString().IndexOf("-") < 0)
                {
                    //isNegative = false;
                    this.ForeColor = System.Drawing.SystemColors.WindowText;
                }
                else
                {
                    this.ForeColor = _redColor;
                }

                TextValue = Decimal.Parse(Decimal.Parse(this.Text).ToString(nfi));
               
               
                return true;
            }
            catch (System.OverflowException)
            {
                // Input too big.
            }
            catch (System.FormatException)
            {
               // Debug.Fail("Input was not in a correct format.");
                // Input not formatted properly.
            }

            return false;
        }

        /// <devdoc>
        ///     Copies current selection text to the clipboard, formatted according to the IncludeLiterals properties but
        ///     ignoring the prompt character.
        ///     Returns true if the operation succeeded, false otherwise.
        /// </devdoc>
        private bool WmCopy()
        {
            try
            {
                Clipboard.SetText(this.Text);
            }
            catch (Exception ex)
            {
                // Note: Sometimes the above operation throws but it successfully sets the
                // data in the clipboard. This usually happens when the Application's Main
                // is not attributed with [STAThread].
                if ( ex is OutOfMemoryException || ex is StackOverflowException)
                {
                    throw;
                }
            }
            return true;
        }

        /// <devdoc>
        /// </devdoc>
        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                // Disabled operations.
                case WM_CONTEXTMENU:
                case WM_PASTE:
                    // Do nothing.
                    break;

                case WM_COPY:
                    WmCopy();
                    break;

                case WM_CUT:
                    WmCopy();
                    ResetText();
                    break;

                default:
                    base.WndProc(ref m);
                    break;
            }
        }

        /// Unsupported methods /

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new bool AcceptsReturn
        {
            get { return false; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new bool AcceptsTab
        {
            get { return false; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new event EventHandler AcceptsTabChanged
        {
            add { }
            remove { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new AutoCompleteMode AutoCompleteMode
        {
            get { return AutoCompleteMode.None; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new AutoCompleteSource AutoCompleteSource
        {
            get { return AutoCompleteSource.None; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        ///     virtual method.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public override int MaxLength
        {
            get { return base.MaxLength; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        ///     virtual method.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public override bool Multiline
        {
            get { return false; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new event EventHandler MultilineChanged
        {
            add { }
            remove { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        ///     virtual method.
        /// </devdoc>
        [
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        protected override void OnMultilineChanged(EventArgs e)
        {
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new char PasswordChar
        {
            get { return '\0'; }
            set { }
        }

        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public  new ScrollBars ScrollBars
        {
            get { return ScrollBars.None; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public new void ScrollToCaret()
        {
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new HorizontalAlignment TextAlign
        {
            get { return base.TextAlign; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public new event EventHandler TextAlignChanged
        {
            add
            {
            }
            remove
            {
            }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new bool UseSystemPasswordChar
        {
            get { return false; }
            set { }
        }

        /// <devdoc>
        ///     Unsupported method/property.
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public new bool WordWrap
        {
            get { return false; }
            set { }
        }
    }
}