C#

SELECT * FROM MyTable WHERE StreetAddress = 'Baker's Wood'

SELECT * FROM MyTable WHERE StreetAddress = 'x';DROP TABLE MyTable;--'

SELECT * FROM MyTable WHERE StreetAddress = 'x';

DROP TABLE MyTable;

--'

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