confrontare due valori datetime da SQL Server con C#

Question

voglio sapere come confrontare due datetime valori colui che è retreived dal database SQL e l'altro è quello attuale con C#

Answer 1

È possibile utilizzare il metodo DateTime.CompareTo.

L'utilizzo è simile a questo:

firstDateTime.CompareTo(secondDatetime); 

e restituisce un int come un risultato che indica

Meno di zero - Questa istanza è precedente valore.

Zero: questa istanza equivale al valore.

Maggiore di zero: questa istanza è successiva al valore.

Answer 2

Supponendo che si desidera verificare che i due DateTimes sono equivalenti c'è in questo modo:

TimeSpan span = dateTime2 - dateTime1; 
if (span == TimeSpan.Zero) 
{ 
    // The times are the same 
} 

Sarà necessario convertire il System.Data.SqlTypes.SqlDateTime-System.DateTime prima, naturalmente, come echosca sottolinea nel suo answer.

Anche se è necessario un errore di arrotondamento consentito (nell'intervallo del millisecondo), poiché è probabile che si tratti di valori derivati ​​dal mondo reale, poiché l'uguaglianza semplice non sarebbe sufficiente. Avreste bisogno di qualcosa di simile:

if (Math.Abs(span.TotalMilliseconds) < 10.0) 
{ 
    // The times are within the allowed range 
} 

Se si desidera solo per confrontare se uno sia anteriore o dopo l'altro utilizzare il metodo DateTime.CompareTo come altri hanno suggerito.

Answer 3

Gli operatori di confronto standard (ad esempio uguaglianza, minore di, maggiore di) sono sovraccaricati per il tipo DateTime. Così si può semplicemente eseguire test come il seguente:

var foo = DateTime.Parse("01/01/1900"); 
var bar = DateTime.Now; 

var test1 = foo == bar; // false 
var test2 = foo != bar; // true 
var test3 = foo < bar; // true 
var test4 = foo > bar; // false 

Answer 4

È necessario inserire il valore da SQL ad oggetto C# DateTime, e poi confrontarli in C#. Ecco un link da MSDN su come farlo.

Answer 5

Quando recuperato dal database, dovresti essere in grado di utilizzare un SqlDataReader per eseguire il cast sul tipo .NET corretto. (o utilizzare DataTable/DataSet, che esegue automaticamente questa operazione).

SqlDataReader dr = cmd.ExecuteReader(); 
DateTime dt = dr.GetDateTime(dr.GetOrdinal("someDateTimeColumn")); 

allora si può confrontare normalmente:

DateTime otherDate = DateTime.Now; 
int compResult = dt.CompareTo(otherDate); 

if(compResult > 0) { Console.Write("dt is after otherDate"); } 
else if(compResult < 0) { Console.Write("dt is before otherDate"); } 
else { Console.Write("dt is equal to otherDate"); } 

Answer 6

DateTime struct sovrascrive GreterThen, GreaterThenOrEqual, LesserThen, LesserThenOrEqual operater, Equalty operater.

DateTime dateTime1, dateTime2; 
dateTime1 = DateTime.Now; 
dateTime2 = //set value from database; 

// all this operations are legal 
if(dateTime1 == dateTime2){} 
if(dateTime1 > dateTime2){} 
if(dateTime1 < dateTime2){} 

Answer 7

System.Data.SqlTypes.SqlDateTime e System.DateTime utilizzano diverse strutture sottostanti per rappresentare date.

SqlDateTime rappresenta l'intervallo 1 gennaio 1753 al 31 dicembre 9999 con una precisione di 3,33 millisecondi

DateTime (.NET Framework type) rappresenta l'intervallo tra Jan 1, 0001 a Dec, 31 9999 alla precisione di 100 nanosecondi

Si deve fare attenzione a questi limiti quando si confrontano le date. Una tattica per alleviare i problemi nei confronti potrebbe essere quella di trasmettere tutto a System.DateTime e quindi eseguire il confronto.

È possibile utilizzare la proprietà Value della struttura SqlDateTime (che restituisce un System.DateTime) per eseguire il confronto in modo elegante e senza casting esplicito.

È possibile trovare informazioni this article.

Answer 8

Spero che questo articolo (DATEDIFF Function Demystified) sia utile, sebbene sia specifico per datetime in SQL, è utile per capire come viene gestito sul lato del database.

Answer 9

Attenzione quando si confrontano DateTimes generate all'interno di C#. La struttura DateTime in C# ha più precisione rispetto al tipo datetime in SQL Server. Quindi, se si genera un DateTime in C# (ad esempio da DateTime.Now), memorizzarlo nel database e recuperarlo, sarà molto probabilmente diverso.

Per esempio, il codice seguente:

using(SqlConnection conn = new SqlConnection("Data Source=.;Integrated Security=SSPI")) 
using(SqlCommand cmd = new SqlCommand("SELECT @d", conn)){ 
    DateTime now = DateTime.Now; 
    cmd.Parameters.Add(new SqlParameter("@d", now)); 
    conn.Open(); 
    DateTime then = (DateTime)cmd.ExecuteScalar(); 
    Console.WriteLine(now.ToString("yyyy/MM/dd HH:mm:ss.fffffff")); 
    Console.WriteLine(then.ToString("yyyy/MM/dd HH:mm:ss.fffffff")); 
    Console.WriteLine(then - now); 

}

restituisce il seguente risultato di esempio.

 
2009.06.20 12:28:23.6115968 
2009.06.20 12:28:23.6100000 
-00:00:00.0015968 

Quindi, in questa situazione, si consiglia di controllare che la differenza è all'interno di un certo epsilon:

Math.Abs((now - then).TotalMilliseconds) < 3 

Si noti che questo non è un problema se si sta confrontando due datetimes recuperato dal database, o un datetime costruito da componenti con granularità seconda o maggiore.

Consulta anche: this blog post

^{_{Vedere nota circa la precisione, dove si parla di "arrotondato a incrementi di .000, .003, .007 o secondi"}}