C#

Number of query values and destination fields are not the same.

com.CommandText = "INSERT INTO Kharid_Detail(" + dt.Columns[i].ColumnName.Trim() + ")VALUES(" + (i++) + ",'" +
dt.Rows[i].ItemArray.GetValue(i) + "')";

com.CommandText = "INSERT INTO Kharid_Detail(" + x + ")VALUES(" + y + ",'" + z + "')";

"<pre>System.Data.OleDb.OleDbException: 'You must enter a value in the 'Kharid_Detail.KalaKhadamatName' field.'

<pre>for (int j = 0; j < (TtmsdataGridView.ColumnCount); j++)

                    for (int i = 0; i < (TtmsdataGridView.Rows.Count); i++)
                    {
                        com.CommandText = "INSERT INTO Kharid_Detail(" + TtmsdataGridView.Columns[j].Name.Trim() + ")VALUES(" + TtmsdataGridView.Rows[i].Cells[j].Value + ")";

                        com.ExecuteNonQuery();
                    }

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 (