comparar dos valores de fecha y hora de SQL Server con C#

Question

quiero saber cómo comparar dos de fecha y hora valores que se retreived de base de datos SQL y el otro es el actual con C#

Answer 1

Usted puede utilizar el método DateTime.CompareTo.

El uso es de esta manera:

firstDateTime.CompareTo(secondDatetime); 

y devuelve un int como resultado que indica

Menos de cero - Este ejemplo es anterior a valor.

Cero: esta instancia es igual a la del valor.

Mayor que cero: esta instancia es posterior al valor.

Answer 2

Suponiendo que desea comprobar que los dos DateTime son equivalentes hay esta manera:

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

Usted tendrá que convertir el System.Data.SqlTypes.SqlDateTime a System.DateTime primero, por supuesto, como echosca señala en su answer.

Aunque debería haber algún error de redondeo permitido (en el rango de milisegundo), ya que es probable que sean valores derivados del mundo real, ya que la simple igualdad no sería lo suficientemente buena. Se necesitaría algo como esto:

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

Si lo que desea es comparar si una fecha es antes o después de otro uso del método DateTime.CompareTo como han sugerido otros.

Answer 3

Los operadores de comparación estándar (por ejemplo, igualdad, menor que, mayor que) están sobrecargados para el tipo DateTime. Así que usted puede simplemente realizar pruebas como las siguientes:

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

Usted necesita poner el valor del objeto SQL para C# DateTime, y luego compararlos en C#. Aquí hay un link de MSDN sobre cómo hacerlo.

Answer 5

Cuando se recupera de la base de datos, debe poder usar un SqlDataReader para convertirlo al tipo .NET correcto. (o use DataTable/DataSet, que automáticamente hace esto).

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

entonces se puede comparar con normalidad:

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 estructura anula 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 y System.DateTime utilizan diferentes estructuras subyacentes para representar fechas.

SqlDateTime representa el rango 01 de enero 1753 a 31 de diciembre de 9999 con una precisión de 3,33 milisegundos

DateTime (.NET Framework type) representa el rango entre el 1 de enero de 0001 y el 31 de diciembre de 1999 a la precisión de 100 nanosegundos

Debe tener cuidado con estos límites al comparar fechas. Una táctica para aliviar problemas en las comparaciones podría ser enviar todo a System.DateTime y luego realizar la comparación.

Puede usar la propiedad Value de la estructura SqlDateTime (que devuelve System.DateTime) para realizar la comparación de forma elegante y sin conversión explícita.

Puede encontrar this article informativo.

Answer 8

Espero que este artículo (DATEDIFF Function Demystified) le resulte útil, aunque es específico de la fecha en SQL, es útil para entender cómo se maneja en el lado de la base de datos.

Answer 9

Tenga cuidado al comparar DateTimes generado dentro de C#. La estructura DateTime en C# tiene más precisión que datetime tipo en SQL Server. Por lo tanto, si genera un DateTime en C# (por ejemplo, DateTime.Now), lo almacena en la base de datos y lo recupera, lo más probable es que sea diferente.

Por ejemplo, el siguiente código:

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); 

}

devuelve el siguiente resultado de la muestra.

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

lo tanto, en esta situación, que se quiere comprobar que la diferencia está dentro de cierto épsilon:

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

Tenga en cuenta que esto no es un problema si usted está comparando dos datetimes recuperado de la base de datos, o una fecha y hora construida a partir de componentes con una granularidad segunda o más grande.

Consulte también: this blog post

^{_{Ver nota acerca de la precisión, donde se menciona "redondeado a incrementos de .000, .003, .007 segundos o"}}