序列化双精度的最佳方法

Question

I am serializing values to an XML document. When I serialize a double , I want to make sure I am not losing any precision, and that culture will not interfere. Or any other "gotchas" that I haven't thought of.

Similarly for DateTime , I use ToBinary() to get a value that's very safe to serialize.

So, what is the best method to serialize / deserialize a double value in C#?

Answer 1

In order to parse back the exact value, you should use the G17 format specifier, as documented here :

d.ToString("G17")

or

$"{d:G17}"

Note that this can fail to roundtrip on versions below .NET Core 3.0 .

---

Original answer below ; the "r" format specifier mentioned actually has a bug so the documentation was incorrect .

---

The round-trip format specifier "r" guarantees that if you use double.Parse on the string, you will get back the exact same value:

d.ToString("r")

Answer 2

Checkout XmlConvert.ToString(double value)

This handles infinity too:

If value is Double.PositiveInfinity or Double.NegativeInfinity, this method returns the string INF or -INF respectively.

Answer 3

BitConverter.GetBytes(myValue)将给出一个 Byte 数组，然后可以在不损失精度的情况下对其进行序列化。

Answer 4

It looks like this should work. According to my tests, it also round-trips special values like infinity and NaN just fine.

static string SerializeDouble(double d)
{
    return d.ToString("G17", CultureInfo.InvariantCulture);
}

static double DeserializeDouble(string s)
{
    return double.Parse(s, CultureInfo.InvariantCulture);
}

---

Why "G17" ?

Source: https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings?redirectedfrom=MSDN#GFormatString

Relevant quote (at the time of this post):

Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values.

---

Why CultureInfo.InvariantCulture ?

This takes care of any culture-specific formatting that would otherwise break your round-trip. For example, this code snippet gives some very undesirable results!

double d0 = Math.PI;
Console.WriteLine("d0: " + d0); // prints 3.14159265358979
// Serialize in America
string s = d0.ToString("G17", new CultureInfo("en-us"));
Console.WriteLine("s: " + s); // prints 3.1415926535897931
// Deserialize in Germany
double d1 = double.Parse(s, new CultureInfo("de-de"));
Console.WriteLine("d1: " + d1); // prints 3.14159265358979E+16