Compartir a través de

Conversión entre DateTime y DateTimeOffset

Aunque la estructura proporciona un mayor grado de reconocimiento de zona horaria que la estructura, los parámetros se usan con más frecuencia en las llamadas a métodos. Debido a este enfoque, la capacidad de convertir valores en valores y viceversa es importante. En este artículo se muestra cómo realizar estas conversiones de forma que conserve la información de zona horaria lo más posible.

Nota:

Tanto los tipos como los tienen algunas limitaciones al representar horas en zonas horarias. Con su propiedad específica, es capaz de reflejar solo el Tiempo Universal Coordinado (UTC) y la zona horaria local del sistema. refleja el desplazamiento de una hora de UTC, pero no refleja la zona horaria real a la que pertenece ese desplazamiento. Para obtener más información sobre los valores de hora y la compatibilidad con las zonas horarias, vea Elegir entre DateTime, DateTimeOffset, TimeSpan y TimeZoneInfo.

Conversiones de DateTime a DateTimeOffset

La estructura proporciona dos maneras equivalentes de realizar la conversión que son adecuadas para la mayoría de las conversiones:

  • El constructor, que crea un nuevo objeto basado en un valor.

  • Operador de conversión implícito, que permite asignar un valor a un objeto .

Para los valores UTC y locales, la propiedad del valor resultante refleja con precisión el desplazamiento de la zona horaria UTC o local. Por ejemplo, el código siguiente convierte una hora UTC en su valor equivalente :

DateTime utcTime1 = new DateTime(2008, 6, 19, 7, 0, 0);
utcTime1 = DateTime.SpecifyKind(utcTime1, DateTimeKind.Utc);
DateTimeOffset utcTime2 = utcTime1;
Console.WriteLine($"Converted {utcTime1} {utcTime1.Kind} to a DateTimeOffset value of {utcTime2}");
// This example displays the following output to the console:
//    Converted 6/19/2008 7:00:00 AM Utc to a DateTimeOffset value of 6/19/2008 7:00:00 AM +00:00

Dim utcTime1 As Date = Date.SpecifyKind(#06/19/2008 7:00AM#, _
                                        DateTimeKind.Utc)
Dim utcTime2 As DateTimeOffset = utcTime1
Console.WriteLine("Converted {0} {1} to a DateTimeOffset value of {2}", _
                  utcTime1, _
                  utcTime1.Kind.ToString(), _
                  utcTime2)
' This example displays the following output to the console:
'    Converted 6/19/2008 7:00:00 AM Utc to a DateTimeOffset value of 6/19/2008 7:00:00 AM +00:00

En este caso, el desfase de la variable es 00:00. Del mismo modo, el código siguiente convierte una hora local en su valor equivalente . La conversión se ejecuta en la zona horaria estándar del Pacífico de EE. UU.:

DateTime localTime1 = new DateTime(2008, 6, 19, 7, 0, 0);
localTime1 = DateTime.SpecifyKind(localTime1, DateTimeKind.Local);
DateTimeOffset localTime2 = localTime1;
Console.WriteLine($"Converted {localTime1} {localTime1.Kind} to a DateTimeOffset value of {localTime2}");
// This example displays the following output to the console:
//    Converted 6/19/2008 7:00:00 AM Local to a DateTimeOffset value of 6/19/2008 7:00:00 AM -07:00

Dim localTime1 As Date = Date.SpecifyKind(#06/19/2008 7:00AM#, DateTimeKind.Local)
Dim localTime2 As DateTimeOffset = localTime1
Console.WriteLine("Converted {0} {1} to a DateTimeOffset value of {2}", _
                  localTime1, _
                  localTime1.Kind.ToString(), _
                  localTime2)
' This example displays the following output to the console:
'    Converted 6/19/2008 7:00:00 AM Local to a DateTimeOffset value of 6/19/2008 7:00:00 AM -07:00

Sin embargo, para los valores cuya propiedad es , estos dos métodos de conversión generan un valor cuyo desplazamiento es el de la zona horaria local. La conversión se muestra en el ejemplo siguiente, que se ejecuta en la zona horaria estándar del Pacífico de EE. UU.:

DateTime time1 = new DateTime(2008, 6, 19, 7, 0, 0);  // Kind is DateTimeKind.Unspecified
DateTimeOffset time2 = time1;
Console.WriteLine($"Converted {time1} {time1.Kind} to a DateTimeOffset value of {time2}");
// This example displays the following output to the console:
//    Converted 6/19/2008 7:00:00 AM Unspecified to a DateTimeOffset value of 6/19/2008 7:00:00 AM -07:00

Dim time1 As Date = #06/19/2008 7:00AM#      ' Kind is DateTimeKind.Unspecified
Dim time2 As DateTimeOffset = time1
Console.WriteLine("Converted {0} {1} to a DateTimeOffset value of {2}", _
                  time1, _
                  time1.Kind.ToString(), _
                  time2)
' This example displays the following output to the console:
'    Converted 6/19/2008 7:00:00 AM Unspecified to a DateTimeOffset value of 6/19/2008 7:00:00 AM -07:00

Si el valor refleja la fecha y hora en otra zona horaria distinta de la local o UTC, puede convertirlo en un valor y conservar su información de zona horaria llamando al constructor sobrecargado. Por ejemplo, en el ejemplo siguiente se crea una instancia de un objeto que refleja la hora estándar central:

DateTime time1 = new DateTime(2008, 6, 19, 7, 0, 0);     // Kind is DateTimeKind.Unspecified
try
{
   DateTimeOffset time2 = new DateTimeOffset(time1,
                  TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time").GetUtcOffset(time1));
   Console.WriteLine($"Converted {time1} {time1.Kind} to a DateTime value of {time2}");
}
// Handle exception if time zone is not defined in registry
catch (TimeZoneNotFoundException)
{
   Console.WriteLine("Unable to identify target time zone for conversion.");
}
// This example displays the following output to the console:
//    Converted 6/19/2008 7:00:00 AM Unspecified to a DateTime value of 6/19/2008 7:00:00 AM -05:00

Dim time1 As Date = #06/19/2008 7:00AM#      ' Kind is DateTimeKind.Unspecified
Try
    Dim time2 As New DateTimeOffset(time1, _
                     TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time").GetUtcOffset(time1))
    Console.WriteLine("Converted {0} {1} to a DateTime value of {2}", _
                      time1, _
                      time1.Kind.ToString(), _
                      time2)
    ' Handle exception if time zone is not defined in registry
Catch e As TimeZoneNotFoundException
    Console.WriteLine("Unable to identify target time zone for conversion.")
End Try
' This example displays the following output to the console:
'    Converted 6/19/2008 7:00:00 AM Unspecified to a DateTime value of 6/19/2008 7:00:00 AM -05:00

El segundo parámetro para esta sobrecarga del constructor es un objeto que representa el desplazamiento de la hora respecto a la UTC. Para recuperarlo, llame al método de la zona horaria correspondiente al tiempo. El parámetro único del método es el valor que representa la fecha y hora que se va a convertir. Si la zona horaria admite el horario de verano, este parámetro permite al método determinar el desplazamiento adecuado para esa fecha y hora en particular.

Conversiones de DateTimeOffset a DateTime

La propiedad se usa normalmente para realizar la conversión. Sin embargo, devuelve un valor cuya propiedad es , como se muestra en el ejemplo siguiente:

DateTime baseTime = new DateTime(2008, 6, 19, 7, 0, 0);
DateTimeOffset sourceTime;
DateTime targetTime;

// Convert UTC to DateTime value
sourceTime = new DateTimeOffset(baseTime, TimeSpan.Zero);
targetTime = sourceTime.DateTime;
Console.WriteLine($"{sourceTime} converts to {targetTime} {targetTime.Kind}");

// Convert local time to DateTime value
sourceTime = new DateTimeOffset(baseTime,
                                TimeZoneInfo.Local.GetUtcOffset(baseTime));
targetTime = sourceTime.DateTime;
Console.WriteLine($"{sourceTime} converts to {targetTime} {targetTime.Kind}");

// Convert Central Standard Time to a DateTime value
try
{
   TimeSpan offset = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time").GetUtcOffset(baseTime);
   sourceTime = new DateTimeOffset(baseTime, offset);
   targetTime = sourceTime.DateTime;
   Console.WriteLine($"{sourceTime} converts to {targetTime} {targetTime.Kind}");
}
catch (TimeZoneNotFoundException)
{
   Console.WriteLine("Unable to create DateTimeOffset based on U.S. Central Standard Time.");
}
// This example displays the following output to the console:
//    6/19/2008 7:00:00 AM +00:00 converts to 6/19/2008 7:00:00 AM Unspecified
//    6/19/2008 7:00:00 AM -07:00 converts to 6/19/2008 7:00:00 AM Unspecified
//    6/19/2008 7:00:00 AM -05:00 converts to 6/19/2008 7:00:00 AM Unspecified

Const baseTime As Date = #06/19/2008 7:00AM#
Dim sourceTime As DateTimeOffset
Dim targetTime As Date

' Convert UTC to DateTime value
sourceTime = New DateTimeOffset(baseTime, TimeSpan.Zero)
targetTime = sourceTime.DateTime
Console.WriteLine("{0} converts to {1} {2}", _
                  sourceTime, _
                  targetTime, _
                  targetTime.Kind.ToString())

' Convert local time to DateTime value
sourceTime = New DateTimeOffset(baseTime, _
                                TimeZoneInfo.Local.GetUtcOffset(baseTime))
targetTime = sourceTime.DateTime
Console.WriteLine("{0} converts to {1} {2}", _
                  sourceTime, _
                  targetTime, _
                  targetTime.Kind.ToString())

' Convert Central Standard Time to a DateTime value
Try
    Dim offset As TimeSpan = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time").GetUtcOffset(baseTime)
    sourceTime = New DateTimeOffset(baseTime, offset)
    targetTime = sourceTime.DateTime
    Console.WriteLine("{0} converts to {1} {2}", _
                      sourceTime, _
                      targetTime, _
                      targetTime.Kind.ToString())
Catch e As TimeZoneNotFoundException
    Console.WriteLine("Unable to create DateTimeOffset based on U.S. Central Standard Time.")
End Try
' This example displays the following output to the console:
'    6/19/2008 7:00:00 AM +00:00 converts to 6/19/2008 7:00:00 AM Unspecified
'    6/19/2008 7:00:00 AM -07:00 converts to 6/19/2008 7:00:00 AM Unspecified
'    6/19/2008 7:00:00 AM -05:00 converts to 6/19/2008 7:00:00 AM Unspecified

En el ejemplo anterior se muestra que se pierde cualquier información sobre la relación del valor con UTC debido a la conversión cuando se utiliza la propiedad. Este comportamiento también afecta a los valores que corresponden a la hora UTC o a la hora local del sistema porque la estructura solo refleja esas dos zonas horarias en su propiedad.

Para conservar la mayor cantidad posible de información de zona horaria al convertir un [elemento] a un [valor], puede usar las propiedades [A] y [B].

Convirtiendo una hora UTC

Para indicar que un valor convertido es la hora UTC, puede recuperar el valor de la propiedad. Se diferencia de la propiedad en dos aspectos:

  • Devuelve un valor cuya propiedad es .

  • Si el valor de la propiedad no es igual a , convierte la hora a UTC.

Nota:

Si la aplicación requiere que los valores convertidos identifiquen de forma inequívoca un único punto en el tiempo, debe considerar la posibilidad de usar la propiedad para controlar todas las conversiones.

El código siguiente usa la propiedad para convertir un valor cuyo desplazamiento es igual a un valor:

DateTimeOffset utcTime1 = new DateTimeOffset(2008, 6, 19, 7, 0, 0, TimeSpan.Zero);
DateTime utcTime2 = utcTime1.UtcDateTime;
Console.WriteLine($"{utcTime1} converted to {utcTime2} {utcTime2.Kind}");
// The example displays the following output to the console:
//   6/19/2008 7:00:00 AM +00:00 converted to 6/19/2008 7:00:00 AM Utc

Dim utcTime1 As New DateTimeOffset(#06/19/2008 7:00AM#, TimeSpan.Zero)
Dim utcTime2 As Date = utcTime1.UtcDateTime
Console.WriteLine("{0} converted to {1} {2}", _
                  utcTime1, _
                  utcTime2, _
                  utcTime2.Kind.ToString())
' The example displays the following output to the console:
'   6/19/2008 7:00:00 AM +00:00 converted to 6/19/2008 7:00:00 AM Utc

El código siguiente usa la propiedad para realizar una conversión de zona horaria y una conversión de tipos en un valor:

DateTimeOffset originalTime = new DateTimeOffset(2008, 6, 19, 7, 0, 0, new TimeSpan(5, 0, 0));
DateTime utcTime = originalTime.UtcDateTime;
Console.WriteLine($"{originalTime} converted to {utcTime} {utcTime.Kind}");
// The example displays the following output to the console:
//       6/19/2008 7:00:00 AM +05:00 converted to 6/19/2008 2:00:00 AM Utc

Dim originalTime As New DateTimeOffset(#6/19/2008 7:00AM#, _
                                       New TimeSpan(5, 0, 0))
Dim utcTime As Date = originalTime.UtcDateTime
Console.WriteLine("{0} converted to {1} {2}", _
                  originalTime, _
                  utcTime, _
                  utcTime.Kind.ToString())
' The example displays the following output to the console:
'       6/19/2008 7:00:00 AM +05:00 converted to 6/19/2008 2:00:00 AM Utc

Conversión de una hora local

Para indicar que un valor de representa la hora local, puede pasar el valor /< >c1 /> devuelto por la propiedad al método ( en Visual Basic) . El método devuelve la fecha y hora que se le pasa como primer parámetro, pero establece la propiedad en el valor especificado por su segundo parámetro. El siguiente código usa el método al convertir un valor cuyo desplazamiento corresponde al de la zona horaria local.

DateTime sourceDate = new DateTime(2008, 6, 19, 7, 0, 0);
DateTimeOffset utcTime1 = new DateTimeOffset(sourceDate,
                          TimeZoneInfo.Local.GetUtcOffset(sourceDate));
DateTime utcTime2 = utcTime1.DateTime;
if (utcTime1.Offset.Equals(TimeZoneInfo.Local.GetUtcOffset(utcTime1.DateTime)))
   utcTime2 = DateTime.SpecifyKind(utcTime2, DateTimeKind.Local);

Console.WriteLine($"{utcTime1} converted to {utcTime2} {utcTime2.Kind}");
// The example displays the following output to the console:
//   6/19/2008 7:00:00 AM -07:00 converted to 6/19/2008 7:00:00 AM Local

Dim sourceDate As Date = #06/19/2008 7:00AM#
Dim utcTime1 As New DateTimeOffset(sourceDate, _
                                   TimeZoneInfo.Local.GetUtcOffset(sourceDate))
Dim utcTime2 As Date = utcTime1.DateTime
If utcTime1.Offset.Equals(TimeZoneInfo.Local.GetUtcOffset(utcTime1.DateTime)) Then
    utcTime2 = DateTime.SpecifyKind(utcTime2, DateTimeKind.Local)
End If
Console.WriteLine("{0} converted to {1} {2}", _
                  utcTime1, _
                  utcTime2, _
                  utcTime2.Kind.ToString())
' The example displays the following output to the console:
'   6/19/2008 7:00:00 AM -07:00 converted to 6/19/2008 7:00:00 AM Local

También puede usar la propiedad para convertir un valor en un valor local . La propiedad del valor devuelto es . El código siguiente usa la propiedad al convertir un valor cuyo desplazamiento corresponde al de la zona horaria local:

DateTime sourceDate = new DateTime(2008, 6, 19, 7, 0, 0);
DateTimeOffset localTime1 = new DateTimeOffset(sourceDate,
                          TimeZoneInfo.Local.GetUtcOffset(sourceDate));
DateTime localTime2 = localTime1.LocalDateTime;

Console.WriteLine($"{localTime1} converted to {localTime2} {localTime2.Kind}");
// The example displays the following output to the console:
//   6/19/2008 7:00:00 AM -07:00 converted to 6/19/2008 7:00:00 AM Local

Dim sourceDate As Date = #06/19/2008 7:00AM#
Dim localTime1 As New DateTimeOffset(sourceDate, _
                                   TimeZoneInfo.Local.GetUtcOffset(sourceDate))
Dim localTime2 As Date = localTime1.LocalDateTime
Console.WriteLine("{0} converted to {1} {2}", _
                  localTime1, _
                  localTime2, _
                  localTime2.Kind.ToString())
' The example displays the following output to the console:
'   6/19/2008 7:00:00 AM -07:00 converted to 6/19/2008 7:00:00 AM Local

Cuando se recupera un valor mediante la propiedad , el descriptor de acceso de la propiedad convierte primero el valor en UTC y, a continuación, lo convierte en hora local llamando al método . Este comportamiento significa que puede recuperar un valor de la propiedad para realizar una conversión de zona horaria al mismo tiempo que se realiza una conversión de tipo. También significa que las reglas de ajuste de la zona horaria local se aplican al realizar la conversión. En el código siguiente se muestra el uso de la propiedad para realizar una conversión de tipo y de zona horaria. La salida de ejemplo es para una máquina configurada en la zona horaria del Pacífico (EE. UU. y Canadá). La fecha de noviembre es hora estándar del Pacífico, que es UTC-8, mientras que la fecha de junio es horario de verano, que es UTC-7.

DateTimeOffset originalDate;
DateTime localDate;

// Convert time originating in a different time zone
originalDate = new DateTimeOffset(2008, 6, 18, 7, 0, 0,
                                  new TimeSpan(-5, 0, 0));
localDate = originalDate.LocalDateTime;
Console.WriteLine($"{originalDate} converted to {localDate} {localDate.Kind}");
// Convert time originating in a different time zone
// so local time zone's adjustment rules are applied
originalDate = new DateTimeOffset(2007, 11, 4, 4, 0, 0,
                                  new TimeSpan(-5, 0, 0));
localDate = originalDate.LocalDateTime;
Console.WriteLine($"{originalDate} converted to {localDate} {localDate.Kind}");
// The example displays the following output to the console,
// when you run it on a machine that is set to Pacific Time (US & Canada):
//       6/18/2008 7:00:00 AM -05:00 converted to 6/18/2008 5:00:00 AM Local
//       11/4/2007 4:00:00 AM -05:00 converted to 11/4/2007 1:00:00 AM Local

Dim originalDate As DateTimeOffset
Dim localDate As Date

' Convert time originating in a different time zone
originalDate = New DateTimeOffset(#06/19/2008 7:00AM#, _
                                  New TimeSpan(-5, 0, 0))
localDate = originalDate.LocalDateTime
Console.WriteLine("{0} converted to {1} {2}", _
                  originalDate, _
                  localDate, _
                  localDate.Kind.ToString())
' Convert time originating in a different time zone 
' so local time zone's adjustment rules are applied
originalDate = New DateTimeOffset(#11/04/2007 4:00AM#, _
                                  New TimeSpan(-5, 0, 0))
localDate = originalDate.LocalDateTime
Console.WriteLine("{0} converted to {1} {2}", _
                  originalDate, _
                  localDate, _
                  localDate.Kind.ToString())
' The example displays the following output to the console,
' when you run it on a machine that is set to Pacific Time (US & Canada):
'       6/18/2008 7:00:00 AM -05:00 converted to 6/18/2008 5:00:00 AM Local
'       11/4/2007 4:00:00 AM -05:00 converted to 11/4/2007 1:00:00 AM Local

Un método de conversión de uso general

En el ejemplo siguiente se define un método denominado que convierte los valores en valores. Basado en su diferencia horaria, determina si el valor es una hora UTC, una hora local o alguna otra hora y define la propiedad del valor de fecha y hora retornados de acuerdo con ello.

static DateTime ConvertFromDateTimeOffset(DateTimeOffset dateTime)
{
   if (dateTime.Offset.Equals(TimeSpan.Zero))
      return dateTime.UtcDateTime;
   else if (dateTime.Offset.Equals(TimeZoneInfo.Local.GetUtcOffset(dateTime.DateTime)))
      return DateTime.SpecifyKind(dateTime.DateTime, DateTimeKind.Local);
   else
      return dateTime.DateTime;
}

Function ConvertFromDateTimeOffset(dateTime As DateTimeOffset) As Date
    If dateTime.Offset.Equals(TimeSpan.Zero) Then
        Return dateTime.UtcDateTime
    ElseIf dateTime.Offset.Equals(TimeZoneInfo.Local.GetUtcOffset(dateTime.DateTime))
        Return Date.SpecifyKind(dateTime.DateTime, DateTimeKind.Local)
    Else
        Return dateTime.DateTime
    End If
End Function

En el ejemplo siguiente se llama al método para convertir valores que representan una hora UTC, una hora local y una hora en la zona horaria central de EE. UU.

DateTime timeComponent = new DateTime(2008, 6, 19, 7, 0, 0);
DateTime returnedDate;

// Convert UTC time
DateTimeOffset utcTime = new DateTimeOffset(timeComponent, TimeSpan.Zero);
returnedDate = ConvertFromDateTimeOffset(utcTime);
Console.WriteLine($"{utcTime} converted to {returnedDate} {returnedDate.Kind}");

// Convert local time
DateTimeOffset localTime = new DateTimeOffset(timeComponent,
                           TimeZoneInfo.Local.GetUtcOffset(timeComponent));
returnedDate = ConvertFromDateTimeOffset(localTime);
Console.WriteLine($"{localTime} converted to {returnedDate} {returnedDate.Kind}");

// Convert Central Standard Time
DateTimeOffset cstTime = new DateTimeOffset(timeComponent,
               TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time").GetUtcOffset(timeComponent));
returnedDate = ConvertFromDateTimeOffset(cstTime);
Console.WriteLine($"{cstTime} converted to {returnedDate} {returnedDate.Kind}");
// The example displays the following output to the console:
//    6/19/2008 7:00:00 AM +00:00 converted to 6/19/2008 7:00:00 AM Utc
//    6/19/2008 7:00:00 AM -07:00 converted to 6/19/2008 7:00:00 AM Local
//    6/19/2008 7:00:00 AM -05:00 converted to 6/19/2008 7:00:00 AM Unspecified

Dim timeComponent As Date = #06/19/2008 7:00AM#
Dim returnedDate As Date

' Convert UTC time
Dim utcTime As New DateTimeOffset(timeComponent, TimeSpan.Zero)
returnedDate = ConvertFromDateTimeOffset(utcTime)
Console.WriteLine("{0} converted to {1} {2}", _
                  utcTime, _
                  returnedDate, _
                  returnedDate.Kind.ToString())

' Convert local time
Dim localTime As New DateTimeOffset(timeComponent, _
                                    TimeZoneInfo.Local.GetUtcOffset(timeComponent))
returnedDate = ConvertFromDateTimeOffset(localTime)
Console.WriteLine("{0} converted to {1} {2}", _
                  localTime, _
                  returnedDate, _
                  returnedDate.Kind.ToString())

' Convert Central Standard Time
Dim cstTime As New DateTimeOffset(timeComponent, _
               TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time").GetUtcOffset(timeComponent))
returnedDate = ConvertFromDateTimeOffset(cstTime)
Console.WriteLine("{0} converted to {1} {2}", _
                  cstTime, _
                  returnedDate, _
                  returnedDate.Kind.ToString())
' The example displays the following output to the console:
'    6/19/2008 7:00:00 AM +00:00 converted to 6/19/2008 7:00:00 AM Utc
'    6/19/2008 7:00:00 AM -07:00 converted to 6/19/2008 7:00:00 AM Local
'    6/19/2008 7:00:00 AM -05:00 converted to 6/19/2008 7:00:00 AM Unspecified

Nota:

El código realiza las dos suposiciones siguientes, según la aplicación y el origen de sus valores de fecha y hora, podría no ser siempre válido:

  • Se supone que un valor de fecha y hora cuyo desplazamiento se representa como UTC. De hecho, UTC no es una hora en una zona horaria determinada, sino la hora en relación con la cual está estandarizada la hora en las zonas horarias del mundo. Las zonas horarias también pueden tener un desplazamiento de .

  • Se supone que una fecha y hora cuyo desplazamiento es igual al de la zona horaria local representa la zona horaria local. Dado que los valores de fecha y hora se desasocian de su zona horaria original, es posible que esto no sea el caso; la fecha y hora se pueden haber originado en otra zona horaria con el mismo desplazamiento.

Consulte también

  • fechas, horas y zonas horarias
  • Last updated on