public LightDataTableShared()
 {
     Columns             = new ColumnsCollections <string>();
     ColumnsWithIndexKey = new ColumnsCollections <int>();
     RoundingSettings    = new RoundingSettings();
     ValidateCulture();
     Culture = new CultureInfo("en");
 }
        protected void TypeValidation(ref object value, Type dataType, bool loadDefaultOnError, object defaultValue = null)
        {
            try
            {
                ValidateCulture();
                if (value == null || value.GetType() == typeof(System.DBNull))
                {
                    value = ValueByType(dataType, defaultValue);
                    return;
                }

                if (IgnoreTypeValidation)
                {
                    return;
                }

                if (dataType == typeof(int?) || dataType == typeof(int))
                {
                    if (double.TryParse(CleanValue(dataType, value).ToString(), NumberStyles.Float, Culture, out var douTal))
                    {
                        value = Convert.ToInt32(douTal);
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }

                    return;
                }

                if (dataType == typeof(Int64?) || dataType == typeof(Int64))
                {
                    if (double.TryParse(CleanValue(dataType, value).ToString(), NumberStyles.Float, Culture, out var douTal))
                    {
                        value = Convert.ToInt64(douTal);
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }

                    return;
                }

                if (dataType == typeof(decimal?) || dataType == typeof(decimal))
                {
                    if (decimal.TryParse(CleanValue(dataType, value).ToString(), NumberStyles.Float, Culture, out var decTal))
                    {
                        value = RoundingSettings.Round(decTal);
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }
                    return;
                }

                if (dataType == typeof(double?) || dataType == typeof(double))
                {
                    if (double.TryParse(CleanValue(dataType, value).ToString(), NumberStyles.Float, Culture, out var douTal))
                    {
                        value = RoundingSettings.Round(douTal);
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }
                    return;
                }

                if (dataType == typeof(DateTime?) || dataType == typeof(DateTime))
                {
                    if (DateTime.TryParse(value.ToString(), Culture, DateTimeStyles.None, out var dateValue))
                    {
                        value = dateValue;
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }
                    return;
                }

                if (dataType == typeof(bool?) || dataType == typeof(bool))
                {
                    if (bool.TryParse(value.ToString(), out var boolValue))
                    {
                        value = boolValue;
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }
                    return;
                }

                if (dataType == typeof(TimeSpan?) || dataType == typeof(TimeSpan))
                {
                    if (TimeSpan.TryParse(value.ToString(), Culture, out var timeSpanValue))
                    {
                        value = timeSpanValue;
                    }
                    else
                    if (loadDefaultOnError)
                    {
                        value = ValueByType(dataType, defaultValue);
                    }
                    return;
                }

                if (dataType.IsEnum)
                {
                    if (value.GetType() == typeof(int))
                    {
                        Enum.IsDefined(dataType, value);
                    }
                    else if (Enum.IsDefined(dataType, value))
                    {
                        value = Enum.Parse(dataType, value.ToString(), true);
                    }
                }
                else if (dataType == typeof(string))
                {
                    value = value.ToString();
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Error: InvalidType. ColumnType is " + dataType.FullName + " and the given value is of type " + value.GetType().FullName + " Orginal Exception " + ex.Message);
            }
        }