Perché DateTime.AddDays viene arrotondato al millisecondo più prossimo?

Question

sto dividendo due doppie in .NET e utilizzando l'oggetto risultato di elaborare una data di fine da una data di inizio chiamando (dtstart è predefinito):

var dValue = 1500.0/8400.0; 
var dtEnd = dtStart.AddDays(dValue); 

Dopo aver ispezionato DTEND ho scoperto che il risultato solo è stato accurato al millisecondo più vicino. Dopo averlo trovato, ho trovato che .AddMilliseconds ecc. Per tutto il numero e TimeSpan.FromDays fa una cosa simile. Mi stavo chiedendo se ci fosse un motivo per cui questo arrotondamento è stato fatto poiché sembra che l'unico modo per ottenere il valore corretto qui sia usare .AddTicks?

Per .AddDays di riferimento chiamate (dove MillisPerDay = 86400000)

public DateTime AddDays(double value) 
{ 
    return Add(value, MillisPerDay); 
} 

che chiama

private DateTime Add(double value, int scale) 
{ 
    long millis = (long)(value * scale + (value >= 0? 0.5: -0.5)); 
    if (millis <= -MaxMillis || millis >= MaxMillis) 
    throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_AddValue")); 
    return AddTicks(millis * TicksPerMillisecond); 
} 

Answer 1

Edit: Dopo averci pensato le cose, ora mi rendo conto la prima versione della mia risposta era sbagliato.

Ecco i commenti nel codice sorgente di Microsoft:

// Returns the DateTime resulting from adding a fractional number of 
// xxxxs to this DateTime. The result is computed by rounding the 
// fractional number of xxxxs given by value to the nearest 
// millisecond, and adding that interval to this DateTime. The 
// value argument is permitted to be negative. 

Questi commenti appaiono su cinque diversi metodi di AddXxxxs (valore doppio), dove xxxx = giorni, ore, millisecondi, minuti e secondi.

Si noti che questo è solo per i metodi che accettano un valore in virgola mobile. (E si può chiedere se sia o meno una buona idea coinvolgere i valori in virgola mobile nei calcoli della data - ma questo è un argomento per un altro giorno.)

Ora, come l'OP sottolinea correttamente, questi cinque metodi tutti chiamano questo metodo:

// Returns the DateTime resulting from adding a fractional number of 
// time units to this DateTime. 
private DateTime Add(double value, int scale) { 
    long millis = (long)(value * scale + (value >= 0? 0.5: -0.5)); 
    if (millis <= -MaxMillis || millis >= MaxMillis) 
     throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_AddValue")); 
    return AddTicks(millis * TicksPerMillisecond); 
} 

Quindi, ciò che viene fatto è che il valore viene aggiunto al DateTime viene arrotondato al numero più vicino di millisecondi prima di essere aggiunto. Ma non il risultato - solo il valore aggiunto (o sottratto).

Questo è effettivamente documentato, ad esempio http://msdn.microsoft.com/en-us/library/system.datetime.adddays%28v=vs.110%29.aspx "Il parametro del valore viene arrotondato al millisecondo più vicino."

Perché non lo so. Forse i programmatori hanno capito che se si utilizzano valori in virgola mobile si dovrebbe essere consapevoli del fatto che i valori in genere non sono completamente accurati. O forse vogliono simulare in qualche modo i tempi in stile Java, che sono basati su millisecondi.