C#

private void TextBox_KeyPress(object sender, KeyPressEventArgs e)
{
    var control = sender as TextBox;
    if (control != null && !char.IsControl(e.KeyChar))
    {
        string testString = control.Text.Substring(0, control.SelectionStart) + e.KeyChar +
            control.Text.Substring(control.SelectionStart + control.SelectionLength);
        e.Handled = !ValueIsNumeric(testString, 5, 2, -100.00, 200.00, true, true);
    }
}

private bool ValueIsNumeric(string testString, int precision, int scale, decimal? minValue,
    decimal? maxValue, bool allowNegativeValues, bool allowNullValues)
{
    bool result = false;
    // Precision must be greater than or equal to zero.
    if (precision < 0)
    {
        precision = 0;
    }

    // Scale must be greater than or equal to zero.
    if (scale < 0)
    {
        scale = 0;
    }

    // Precision must be greater than scale
    if ((precision - scale) < 0)
    {
        precision = 0;
        scale = 0;
    }


    if (string.IsNullOrWhiteSpace(testString))
    {
        // If we allow null values, then return true
        if (allowNullValues)
        {
            result = true;
        }
    }
    else
    {
        // If we have a period in the string, validate the Scale of the number.
        bool checkDefinitionMinMax = true;
        int periodIndex = testString.IndexOf('.');
        if (periodIndex >= 0)
        {
            if (scale > 0)
            {
                // We have to add 1 to the period index to eliminate
                // the period character from our result string.
                if (testString.Substring(periodIndex + 1).Length > scale)
                {
                    // Remainder of string is greater than our specified scale,
                    // something like 12.345 would fail for Numeric(5,2).
                    checkDefinitionMinMax = false;
                }
            }
            else
            {
                // We do not support a number with a period.
                checkDefinitionMinMax = false;
            }
        }

        decimal value = 0;
        if (checkDefinitionMinMax && decimal.TryParse(testString, out value))
        {
            // Validate that this value is within the precision and scale specified.
            decimal maxDefinitionValue = decimal.Parse(string.Empty.PadLeft(precision, '9'));
            if (scale > 0)
            {
                string p = string.Empty.PadLeft(precision - scale, '9');
                string s = string.Empty.PadLeft(scale, '9');
                maxDefinitionValue = decimal.Parse(string.Format("{0}.{1}", p, s));
            }

            decimal minDefinitionValue = 0;
            if (allowNegativeValues)
            {
                minDefinitionValue = maxDefinitionValue * -1;
            }

            // Minimum/Maximum values may not be inclusive of the type definition's precision/scale values.
            // Example: days of year = 365, but type declaration is Numeric(3,0).
            if (value >= minDefinitionValue && value <= maxDefinitionValue)
            {
                if (minValue.HasValue | maxValue.HasValue)
                {
                    if (minValue.HasValue & maxValue.HasValue)
                    {
                        if (value >= minValue.Value && value <= maxValue.Value)
                        {
                            result = true;
                        }
                    }
                    else if (minValue.HasValue)
                    {
                        if (value >= minValue.Value)
                        {
                            result = true;
                        }
                    }
                    else if (maxValue.HasValue)
                    {
                        if (value <= maxValue.Value)
                        {
                            result = true;
                        }
                    }
                }
                else
                {
                    result = true;
                }
            }
        }
    }
    return result;
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows.Forms;

namespace FourFormUI
{
    [ToolboxItem(true)]
    public partial class DoubleTextBox : TextBox
    {
        public DoubleTextBox()
        {
            InitializeComponent();
        }

        private bool delimiterSeen = false;

        private const char delimiter = '.';
        private const char backspace = '\b';
        private const char minus = '-';

        private string AllowedChars = ".-\b01234567890";
        private List<char> allowedChars;

        private int postDelimiterLimit = 3;

        public DoubleTextBox(IContainer container)
        {
            container.Add(this);

            InitializeComponent();

            allowedChars = AllowedChars.ToCharArray().ToList();
        }

        private void DoubleTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            var ch = e.KeyChar;

            // legal ?
            if (!allowedChars.Contains(ch))
            {
                e.Handled = true;
                return;
            }

            switch (ch)
            {
                case delimiter:
                {
                    if (delimiterSeen)
                    {
                        e.Handled = true;
                        return;
                    }

                    delimiterSeen = true;

                    break;
                }

                case backspace: // delimiter erased
                {
                    delimiterSeen = Text.Contains(delimiter);
                    break;
                }

                case minus:
                {
                    if (this.SelectionStart != 0)
                    {
                        e.Handled = true;
                        return;
                    }

                    break;
                }

                default:
                {
                    if (delimiterSeen)
                    {
                        int delimiterpos = Text.IndexOf(delimiter);

                        if (this.SelectionStart > delimiterpos)
                        {
                            if (Text.Length - delimiterpos > postDelimiterLimit)
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                    }

                    break;
                }
            }
        }
    }
}

Rap Gutierrez wrote:

When users put the invalid numbers it will remove the newly inputted value ex 11.999 it will become 11.99 while typing.

jschell wrote:

Validate the input, tell them what value is wrong

jschell wrote:

don't try to auto-correct (

Member 14190267 wrote:

project work matrix

namespace Lads_in_CSharp
{
    public class Program
    {
        int i = 0;
        int num;
        int numberOfVerbs;
        int y=0;
        int a = 0;
        //String sr;
        String Text1="";
        String[] CollectText = new String[1000];
        String [] TT = new String[3] ;
        public static void Main(string[] args)
         {
            Program prog = new Program();
            StreamReader sr = new StreamReader("demo.adv");


           Console.WriteLine("Start of Program");
           prog.y = 4;
           prog.ReadHeader(sr);
           Console.WriteLine(prog.i);
           prog.ReadVerbs(sr);
           prog.ReadNouns(sr);
           prog.ReadObjects(sr);
           prog.ReadStartRoom(sr);
           prog.ReadRooms(sr);
           prog.ReadMessages(sr);
           prog.ReadAutoActions(sr);
           prog.ReadActions(sr);
           sr.Close(); 
           Console.Read();

        }
        public void ReadHeader(StreamReader sr)
        {
            
            Console.WriteLine("Read Header");
          
                ReadLineOfText(sr);
                Console.WriteLine("Text1 is: " + sr);
                      
         //   Console.WriteLine(y);
          //  i = 6;
        }

        public void ReadVerbs(StreamReader sr) //                                      VERBS
        {
            Console.WriteLine("Read Verbs++++++++++");
            // Verb1 = "Paint";
            int i=0;
            ReadLineOfText(sr);
            numberOfVerbs = num;
            Console.WriteLine("Text1 is:: " + Text1);
            Console.WriteLine("Collect Text 2 = "+CollectText[2]);   // TEST
            Console.WriteLine("Number of Verbs is "+num);

            // string[] authorsList = Text1.Split(",");


            Console.WriteLine("Comma separated strings");
            // String of authors  
            //  string authors = "Mahesh Chand, Henry He, Chris Love, Raj Beniwal, Praveen Kumar";
            // Split authors separated by a comma followed by space  
            //string[] authorsList = authors.Split(", ");
            // foreach (string author in authorsList)
            //    Console.WriteLine(author);



           // int i = 0;
          //  foreach (string line in File.ReadAllLines("TextFile1.txt"))
            {
                i = 0;

                while (a < 10)
                {
                    string[] parts = CollectText[1].Split(',');
                    foreach (string part in parts)
                    {
                        Console.WriteLine("part = {0}  ", part);
                        i++;
                        if (i == 1)
                        {
                            TT[i] = part;
                        }
                        else
                        {
                            TT[i] = part;
                        }
                        a++;
                    }
                }

                   
                }
                Console.WriteLine("TT[1] = " + TT[1]);
                Console.WriteLine("TT[2] = " + TT[2]);
                i++; // For demonstration.
            }
        }
                 //   Console.WriteLine("Text1 split:"+authorsList);
          


        public void ReadNouns(StreamReader sr)
        { 
            Console.WriteLine("Read Nouns ++++++++++++++++++"); //               NOUNS
            //Console.WriteLine("Verb : "+Verb1);
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: " + Text1);
        }

        public void ReadObjects(StreamReader sr)
        {
            Console.WriteLine("Read Objects+++++++++++++");
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: " + Text1);
        }

        public void ReadStartRoom(StreamReader sr)
        {
            Console.WriteLine("Read Start Room+++++++++++");
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: " + Text1);
        }

        public void ReadRooms(StreamReader sr)
        {
            Console.WriteLine("Read Rooms+++++++++++++");
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: " + Text1);
        }

        public void ReadMessages(StreamReader sr)
        {
            Console.WriteLine("Read Messages+++++++++++");
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: " + Text1);
        }

        public void ReadAutoActions(StreamReader sr)
        {
            Console.WriteLine("Read Auto Actions+++++++++");
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: " + Text1);
        }

        public void ReadActions(StreamReader sr)
        {
            Console.WriteLine("Read Actions");
            ReadLineOfText(sr);
            Console.WriteLine("Text1 is: "+Text1);
        }
        public void ReadLineOfText(StreamReader sr)
        {
            Text1 = "null";
            i = 0;
            while (Text1 != "")
            {
                Text1 = sr.ReadLine();

                Console.WriteLine("ReadLine is: [read from ReadOfText producer]" + Text1);
               
                i++;
                CollectText[i] = Text1;
            }
            i = i-1;
            num = i;
            
            Console.WriteLine(i);

        }

    }
<pre>