Warum Zeitspanne.FromSeconds(Doppel -) Runde auf Millisekunden?

Als Sie gefunden haben, aus sich selbst, es ist ein dokumentiertes feature. Es ist beschrieben in der Dokumentation von TimeSpan:

Parameter

Wert Typ: System.Doppel -

Einer Anzahl von Sekunden, genau auf die nächste Millisekunde.

Der Grund für dies ist wahrscheinlich, weil ein doppelter ist nicht, dass genau alle. Es ist immer eine gute Idee, einige Runden beim Vergleich verdoppelt, denn es könnte nur ein sehr kleines bisschen größer oder kleiner, als man erwarten würde. Dieses Verhalten könnte tatsächlich bieten Sie mit einigen unerwarteten Nanosekunden, wenn Sie versuchen, in ganzen Millisekunden. Ich denke, das ist der Grund, warum Sie wählte, um Runde den Wert auf ganze Millisekunden und entsorgen Sie die kleinere stellen.

Stell dir vor, du bist der Entwickler verantwortlich für die Erstellung der TimeSpan geben. Sie haben alle grundlegenden Funktionen vorhanden sind; es scheint alles zu funktionieren Super. Dann, eines Tages einige beta-tester kommt zusammen und zeigt Sie diesen code:

double x = 100000000000000;
double y = 0.5;
TimeSpan t1 = TimeSpan.FromMilliseconds(x + y);
TimeSpan t2 = TimeSpan.FromMilliseconds(x) + TimeSpan.FromMilliseconds(y);
Console.WriteLine(t1 == t2);

Warum funktioniert die Ausgabe False? der tester fragt Sie. Obwohl Sie verstehen, warum dies passiert ist (Verlust der Präzision in addition x und y), Sie müssen zugeben, es tut scheinen ein bisschen seltsam aus der Perspektive eines Clients. Dann wirft er das ein an Sie:

x = 10.0;
y = 0.5;
t1 = TimeSpan.FromMilliseconds(x + y);
t2 = TimeSpan.FromMilliseconds(x) + TimeSpan.FromMilliseconds(y);
Console.WriteLine(t1 == t2);

, Dass man Ausgänge True! Der tester ist verständlicherweise skeptisch.

An diesem Punkt müssen Sie eine Entscheidung treffen. Sie können entweder ermöglichen eine arithmetische operation zwischen TimeSpan Werte, die gebaut wurden, von double Werte ergeben ein Ergebnis , deren Präzision übersteigt die Genauigkeit der double Typ selbst—z.B., 100000000000000.5 (16 bedeutende Persönlichkeiten)—oder Sie können, Sie wissen, nicht erlauben.

So dass Sie entscheiden, wissen Sie was, ich werde einfach machen Sie es so, dass jede Methode, die verwendet eine double zu konstruieren TimeSpan wird gerundet auf die nächste Millisekunde. So ist es explizit dokumentiert, dass eine Umstellung von einem double zu einem TimeSpan ist eine verlustbehaftete Betrieb, absolvierte Sie mir in Fällen, in denen ein client sieht komisch Verhalten, wie dies nach der Umstellung double zu TimeSpan und hoffen auf ein genaues Ergebnis.

Ich bin ja nicht unbedingt argumentieren, dass dies die "richtige" Entscheidung zu treffen; dies hier ist klar, dieser Ansatz verursacht einige Verwirrung über seine eigenen. Ich sage nur, dass eine Entscheidung musste getroffen werden die eine oder andere Weise, und dies ist, was war offenbar entschieden.

FromSeconds verwendet private Methode Intervall

public static TimeSpan FromSeconds(double value)
{
    return Interval(value, 0x3e8);
}

0x3e8 == 1000

Intervall-Methode multiplay Wert auf die const und dann cast zu lang (siehe Letzte Zeile):

private static TimeSpan Interval(double value, int scale)
{
    if (double.IsNaN(value))
    {
        throw new ArgumentException(Environment.GetResourceString("Arg_CannotBeNaN"));
    }
    double num = value * scale; //Multiply!!!!
    double num2 = num + ((value >= 0.0) ? 0.5 : -0.5);
    if ((num2 > 922337203685477) || (num2 < -922337203685477))
    {
        throw new OverflowException(Environment.GetResourceString("Overflow_TimeSpanTooLong"));
    }
    return new TimeSpan(((long) num2) * 0x2710L); //Cast to long!!!
}

Als Ergebnis haben wir die Präzision, mit 3 (x1000) Zeichen.
Verwenden Reflektor zu untersuchen