C#

using Microsoft.AspNet.OData;
using Microsoft.AspNet.OData.Routing;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Oyg.Domain.DataTypes;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace Oyg.Api.Controllers
{
    public partial class ClassesController : ODataController
    {
        /// <summary>
        /// Get all bookings. Get the class reservation queue.
        /// </summary>
        /// <returns></returns> 
        [HttpGet]
        [ODataRoute("Classes({classId})/Bookings")]
        public async Task<IActionResult> GetBookings([FromODataUri] Guid classId)
        {
            return Ok(await _context.Bookings
                .Where(y => y.Class.Id == classId)
                .ToListAsync());
        }

        /// <summary>
        /// Get a specific booking
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [ODataRoute("Classes({classId})/Bookings({bookingId})")]
        public async Task<IActionResult> GetBooking([FromODataUri] Guid classId, [FromODataUri] Guid bookingId)
        {
            var @class = await _context.Classes.FirstOrDefaultAsync(y => y.Id == classId);

            if (@class == null)
            {
                return NotFound();
            }

            var booking = _context.Bookings.Where(y => y.Class.Id == classId && y.Id == bookingId);

            if (!booking.Any())
            {
                return NotFound();
            }

            return Ok(SingleResult.Create(booking));
        }

        /// <summary>
        /// Add a booking reservation in a class
        /// </summary>
        /// <param name="class"></param>
        /// <returns></returns>
        [HttpPost]
        [ODataRoute("Classes({classKey})/Bookings")]
        public async Task<IActionResult> PostBooking([FromODataUri] Guid classKey, [FromBody] Booking booking)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var @class = _context.Classes
                .FindAsync(classKey);

            if (@class == null)
            {
                return NotFound();
            }

            booking.Id = Guid.NewGuid();
            booking.Position = _context.Bookings.Where(y => y.Class.Id == classKey).Count();
            booking.ReservationTime = DateTime.UtcNow;

            _context.Bookings.Add(booking);
            await _context.SaveChangesAsync();
            return Created(booking);
        }

        ///// <summary>
        ///// DELETE: api/Classes/5
        ///// </summary>
        ///// <param name="id"></param>
        ///// <returns></returns>
        //[HttpDelete()]
        //[ODataRoute("Classes({classKey})/Bookings({key})")]
        //public async Task<IActionResult> DeleteBooking([FromODataUri] Guid classKey, [FromODataUri] Guid key)
        //{
        //    var @class = await _context.Classes.FindAsync(classKey);

        //    if (@class == null)
        //    {
        //        return NotFound();
        //    }

        //    var booking = await _context.Bookings.FindAsync(key);

        //    if (booking == null)
        //    {
        //        return NotFound();
        //    }

        //    booking.CancelTime = DateTime.UtcNow;
        //    await _context.SaveChangesAsync();

        //    return Ok(@class);
        //}

        [HttpPost]
        [ODataRoute("Classes({classKey})/Oyg.Actions.Register")]
        public async Task<IActionResult> Register([FromODataUri] Guid classKey, ODataActionParameters parameters)
        {
            var @class = await _context.Classes.FindAsync(classKey);

            if (@class == null)
            {
                return NotFound();
            }

            if (!parameters.TryGetValue("studentId", out object outputFromDictionary))
            {
                return NotFound();
            }

            if (!Guid.TryParse(outputFromDictionary.ToString(), out Guid studentId))
            {
                return NotFound();
            }

            // the student must exist
            var student = await _context.Students.FirstOrDefaultAsync(y => y.Id == studentId);

            if (student == null)
            {
                return NotFound();
            }

            var booking = new Booking()
            {
                Id = Guid.NewGuid(),
                Class = @class,
                Student = student,
                Position = _context.Bookings.Where(y => y.Class.Id == classKey).Count(),
                ReservationTime = DateTime.UtcNow
            };

            _context.Bookings.Add(booking);
            await _context.SaveChangesAsync();
            // return true
            return Ok(booking);
        }

        [HttpPost]
        [ODataRoute("Classes({classKey})/Oyg.Actions.CancelRegistration")]
        public async Task<IActionResult> CancelRegistration([FromODataUri] int classKey, ODataActionParameters parameters)
        {
            var @class = await _context.Classes.FindAsync(classKey);

            if (@class == null)
            {
                return NotFound();
            }

            if (!parameters.TryGetValue("studentId", out object outputFromDictionary))
            {
                return NotFound();
            }

            if (!Guid.TryParse(outputFromDictionary.ToString(), out Guid studentId))
            {
                return NotFound();
            }

            // the student must exist
            var student = _context.Students.FirstOrDefault(y => y.Id == studentId);

            if (student == null)
            {
                return NotFound();
            }

            var booking = await _context.Bookings.SingleOrDefaultAsync(y => y.Class.Id == @class.Id &&
                y.Student.Id == student.Id && y.CancelTime == null);

            if (booking == null)
            {
                return NotFound();
            }

            booking.CancelTime = DateTime.UtcNow;
            await _context.SaveChangesAsync();

            return NoContent();
        }
    }
}

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;
}