/// <summary>
    /// Changes the datatype of a column. More specifically it creates a new one and transfers the data to it
    /// </summary>
    /// <param name="column">The source column</param>
    /// <param name="type">The target type</param>
    /// <param name="parser">A lambda function for converting the value</param>
    public static void ChangeType(this DataColumn column, Type type, Func<object, object> parser)
    {
        //no table? just switch the type
        if (column.Table == null)
        {
            column.DataType = type;
            return;
        }

        //clone our table
        DataTable clonedtable = column.Table.Clone();

        //get our cloned column
        DataColumn clonedcolumn = clonedtable.Columns[column.ColumnName];

        //remove from our cloned table
        clonedtable.Columns.Remove(clonedcolumn);

        //change the data type
        clonedcolumn.DataType = type;

        //change our name
        clonedcolumn.ColumnName = Guid.NewGuid().ToString();

        //add our cloned column
        column.Table.Columns.Add(clonedcolumn);

        //interpret our rows
        foreach (DataRow drRow in column.Table.Rows)
        {
            drRow[clonedcolumn] = parser(drRow[column]);
        }

        //remove our original column
        column.Table.Columns.Remove(column);

        //change our name
        clonedcolumn.ColumnName = column.ColumnName;
    }
}

List<DataColumn> lsColumns = dtData.Columns
    .Cast<DataColumn>()
    .Where(i => i.DataType == typeof(decimal))
    .ToList()

//loop through each of our decimal columns
foreach(DataColumn column in lsColumns)
{
    //change to double
    column.ChangeType(typeof(double),(value) =>
    {
        double output = 0;
        double.TryParse(value.ToString(), out output);
        return output;  
    });
}

public static void ConvertColumnType(this DataTable dt, string columnName, Type newType)
        {
            using (DataColumn dc = new DataColumn($"{columnName}_new", newType))
            {
                // Add the new column which has the new type, and move it to the ordinal of the old column
                int ordinal = dt.Columns[columnName].Ordinal;
                dt.Columns.Add(dc);
                dc.SetOrdinal(ordinal);

                // Get and convert the values of the old column, and insert them into the new
                foreach (DataRow dr in dt.Rows)
                {
                    var obj = dr[columnName];
                    if (obj != null && obj != DBNull.Value)
                    {
                        dr[dc.ColumnName] = Convert.ChangeType(obj, newType);
                    }
                    else
                    {
                        dr[dc.ColumnName] = obj;
                    }
                }

                // Remove the old column
                dt.Columns.Remove(columnName);

                // Give the new column the old column''s name
                dc.ColumnName = columnName;
            }
        }

        public static void ConvertColumnType(this DataSet dataSet, Type sourceType, Type targetType)
        {
            foreach (DataTable table in dataSet.Tables)
            {
                var columns = table.Columns.Cast<DataColumn>().Where(x => x.DataType == sourceType).ToList();
                //do not use foreach here, otherwise you will encounter "Collection was modified; enumeration operation may not execute."
                for (int i = 0; i < columns.Count; i++)
                {
                    table.ConvertColumnType(columns[i].ColumnName, targetType);
                }
            }
        }

For a general-purpose¹ solution you need to preserve 339 places:

doubleValue.ToString("0." + new string(''#'', 339))

The maximum number of non-zero decimal digits is 16. 15 are on the right side of the decimal point. The exponent can move those 15 digits a maximum of 324 places to the right. (See the range and precision.)

It works for double.Epsilon, double.MinValue, double.MaxValue, and anything in between.

The performance will be much greater than the regex/string manipulation solutions since all formatting and string work is done in one pass by unmanaged CLR code. Also, the code is much simpler to prove correct.

For ease of use and even better performance, make it a constant:

public static class FormatStrings { public const string DoubleFixedPoint = "0.###################################################################################################################################################################################################################################################################################################################################################"; }

¹ Update: I mistakenly said that this was also a lossless solution. In fact it is not, since ToString does its normal display rounding for all formats except r. Live example. Thanks, @Loathing! Please see Lothing’s answer if you need the ability to roundtrip in fixed point notation (i.e, if you’re using .ToString("r") today).

 if (value is double d)
                    {
                        parameters[2].Value = d.ToString("r");
                    }

String t1 = (0.0001 / 7).ToString("0." + new string(''#'', 339)); // 0.0000142857142857143 versus:
            String t2 = (0.0001 / 7).ToString("r"); // 1.4285714285714287E-05
            Console.WriteLine(t1);
            Console.WriteLine(t2);

public static class FormatStrings
    {
        public const string DoubleFixedPoint = "0.###################################################################################################################################################################################################################################################################################################################################################";

        public static String ToStandardNotationString(this double d)
        {
            //Keeps precision of double up to is maximum
            return d.ToString("0.#####################################################################################################################################################################################################################################################################################################################################");

        }
    }

  public void DecimalTest()
        {
            double d = 0.0001 / 7;
            Console.WriteLine(d);
            Console.WriteLine(d.ToStandardNotationString());
            Console.WriteLine(d.ToString("r"));
        }