now - new datetime c#

¿Hay una mejor manera de recortar un DateTime con una precisión específica?

Question

Esta pregunta ya tiene una respuesta aquí:

• Cómo truncar milisegundos fuera de .NET DateTime 13 respuestas

¿Cuál es la mejor manera de recortar un objeto DateTime a una precisión específica? Por ejemplo, si tengo un DateTime con un valor de ''2008-09-29 09:41:43'', pero solo quiero que su precisión sea al minuto, ¿hay alguna forma mejor de hacerlo que esto?

private static DateTime TrimDateToMinute(DateTime date)
{
    return new DateTime(
        date.Year, 
        date.Month, 
        date.Day, 
        date.Hour, 
        date.Minute, 
        0);
}

Lo que realmente me gustaría es hacerlo variable para que pueda establecer su precisión en el segundo, minuto, hora o día.

Answer 1

Si tiene hora y fecha como un número (continuo) similar a time_t , puede simplemente usar módulo para obtener minutos completos (% 60), horas, etc.

En mi experiencia, los valores parecen estar alineados con el tiempo real (el módulo 60 ocurre en el minuto completo), pero es muy probable que esto no esté garantizado en ninguna parte.

Aquí hay un código para obtener lo que desea (con una resolución de menos de segundo):

/*
* Returns millisecond timing (in seconds) for the current time.
*
* Note: This function should be called once in single-threaded mode in Win32,
*       to get it initialized.
*/
double now_secs(void) {

#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
    /*
    * Windows FILETIME values are "100-nanosecond intervals since 
    * January 1, 1601 (UTC)" (MSDN). Well, we''d want Unix Epoch as
    * the offset and it seems, so would they:
    *
    * <http://msdn.microsoft.com/en-us/library/ms724928(VS.85).aspx>
    */
    SYSTEMTIME st;
    FILETIME ft;
    ULARGE_INTEGER uli;
    static ULARGE_INTEGER uli_epoch;   // Jan 1st 1970 0:0:0

    if (uli_epoch.HighPart==0) {
        st.wYear= 1970;
        st.wMonth= 1;   // Jan
        st.wDay= 1;
        st.wHour= st.wMinute= st.wSecond= st.wMilliseconds= 0;
        //
        st.wDayOfWeek= 0;  // ignored

        if (!SystemTimeToFileTime( &st, &ft ))
            FAIL( "SystemTimeToFileTime", GetLastError() );

        uli_epoch.LowPart= ft.dwLowDateTime;
        uli_epoch.HighPart= ft.dwHighDateTime;
    }

    GetSystemTime( &st );   // current system date/time in UTC
    if (!SystemTimeToFileTime( &st, &ft ))
        FAIL( "SystemTimeToFileTime", GetLastError() );

    uli.LowPart= ft.dwLowDateTime;
    uli.HighPart= ft.dwHighDateTime;

    /* ''double'' has less accuracy than 64-bit int, but if it were to degrade,
     * it would do so gracefully. In practise, the integer accuracy is not
     * of the 100ns class but just 1ms (Windows XP).
     */
    return (double)(uli.QuadPart - uli_epoch.QuadPart) / 10000000.0;
#else
    struct timeval tv;
        // {
        //   time_t       tv_sec;   /* seconds since Jan. 1, 1970 */
        //   suseconds_t  tv_usec;  /* and microseconds */
        // };

    int rc= gettimeofday( &tv, NULL /*time zone not used any more (in Linux)*/ );
    assert( rc==0 );

    return ((double)tv.tv_sec) + ((tv.tv_usec)/1000) / 1000.0;
#endif
}

Answer 2

static class Program
{
    //using extension method:
    static DateTime Trim(this DateTime date, long roundTicks)
    {
        return new DateTime(date.Ticks - date.Ticks % roundTicks);
    }

    //sample usage:
    static void Main(string[] args)
    {
        Console.WriteLine(DateTime.Now);
        Console.WriteLine(DateTime.Now.Trim(TimeSpan.TicksPerDay));
        Console.WriteLine(DateTime.Now.Trim(TimeSpan.TicksPerHour));
        Console.WriteLine(DateTime.Now.Trim(TimeSpan.TicksPerMillisecond));
        Console.WriteLine(DateTime.Now.Trim(TimeSpan.TicksPerMinute));
        Console.WriteLine(DateTime.Now.Trim(TimeSpan.TicksPerSecond));
        Console.ReadLine();
    }

}

Answer 3

    static DateTime TrimDate(DateTime date, long roundTicks)
    {
        return new DateTime(date.Ticks - date.Ticks % roundTicks);
    }

    //sample usage:
    static void Main(string[] args)
    {
        Console.WriteLine(DateTime.Now);
        Console.WriteLine(TrimDate(DateTime.Now, TimeSpan.TicksPerDay));
        Console.WriteLine(TrimDate(DateTime.Now, TimeSpan.TicksPerHour));
        Console.WriteLine(TrimDate(DateTime.Now, TimeSpan.TicksPerMillisecond));
        Console.WriteLine(TrimDate(DateTime.Now, TimeSpan.TicksPerMinute));
        Console.WriteLine(TrimDate(DateTime.Now, TimeSpan.TicksPerSecond));
        Console.ReadLine();
    }

Answer 4

DateTime dt = new DateTime()
dt = dt.AddSeconds(-dt.Second)

El código anterior recortará los segundos.

Answer 5

Me gusta este método Alguien mencionó que era bueno preservar el Tipo de fecha, etc. Esto lo logra porque no hace una nueva fecha, simplemente resta los tics restantes.

private DateTime FloorToHour(DateTime dt)
{
  return dt.AddTicks(-1 * (dt.Ticks % TimeSpan.TicksPerHour));
}

Answer 6

Puedes usar una enumeración

public enum DateTimePrecision
{
  Hour, Minute, Second
}

public static DateTime TrimDate(DateTime date, DateTimePrecision precision)
{
  switch (precision)
  {
    case DateTimePrecision.Hour:
      return new DateTime(date.Year, date.Month, date.Day, date.Hour, 0, 0);
    case DateTimePrecision.Minute:
      return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, 0);
    case DateTimePrecision.Second:
      return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second);
    default:
      break;
  }
}

y expandir según sea necesario.

Answer 7

Aquí se presentan algunas buenas soluciones, pero cuando necesito hacer esto, simplemente lo hago:

DateTime truncDate;
truncDate = date.Date; // trim to day
truncDate = date.Date + TimeSpan.Parse(string.Format("{0:HH:00:00}", date)); // trim to hour
truncDate = date.Date + TimeSpan.Parse(string.Format("{0:HH:mm}", date)); // trim to minute
truncDate = date.Date + TimeSpan.Parse(string.Format("{0:HH:mm:ss}", date)); // trim to second

Espero eso ayude.