DateTimeOffset.ToOffset(TimeSpan) Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Convierte el valor del objeto DateTimeOffset actual en la fecha y hora especificadas por un valor de desplazamiento.

public:
 DateTimeOffset ToOffset(TimeSpan offset);

public DateTimeOffset ToOffset (TimeSpan offset);

member this.ToOffset : TimeSpan -> DateTimeOffset

Public Function ToOffset (offset As TimeSpan) As DateTimeOffset

Parámetros

offset: TimeSpan

Desplazamiento al que se convierte el valor DateTimeOffset.

Devoluciones

DateTimeOffset

Un objeto que es igual al objeto DateTimeOffset original (es decir, sus métodos ToUniversalTime() devuelven momentos de tiempo idénticos), pero cuya propiedad Offset está establecida en offset.

Excepciones

ArgumentException

El objeto resultante DateTimeOffset tiene un DateTime valor anterior a DateTimeOffset.MinValue.

o bien

El objeto resultante DateTimeOffset tiene un DateTime valor posterior a DateTimeOffset.MaxValue.

ArgumentOutOfRangeException

offset es menor que -14 horas.

o bien

offset es mayor que 14 horas.

Ejemplos

En el ejemplo siguiente se muestra cómo usar el ToOffset método para convertir un DateTimeOffset objeto en un DateTimeOffset objeto con un desplazamiento diferente.

using System;

public class DateTimeOffsetConversion
{
   private static DateTimeOffset sourceTime;

   public static void Main()
   {
      DateTimeOffset targetTime;
      sourceTime = new DateTimeOffset(2007, 9, 1, 9, 30, 0,
                                      new TimeSpan(-5, 0, 0));

      // Convert to same time (return sourceTime unchanged)
      targetTime = sourceTime.ToOffset(new TimeSpan(-5, 0, 0));
      ShowDateAndTimeInfo(targetTime);

      // Convert to UTC (0 offset)
      targetTime = sourceTime.ToOffset(TimeSpan.Zero);
      ShowDateAndTimeInfo(targetTime);

      // Convert to 8 hours behind UTC
      targetTime = sourceTime.ToOffset(new TimeSpan(-8, 0, 0));
      ShowDateAndTimeInfo(targetTime);

      // Convert to 3 hours ahead of UTC
      targetTime = sourceTime.ToOffset(new TimeSpan(3, 0, 0));
      ShowDateAndTimeInfo(targetTime);
   }

   private static void ShowDateAndTimeInfo(DateTimeOffset newTime)
   {
      Console.WriteLine("{0} converts to {1}", sourceTime, newTime);
      Console.WriteLine("{0} and {1} are equal: {2}",
                        sourceTime, newTime, sourceTime.Equals(newTime));
      Console.WriteLine("{0} and {1} are identical: {2}",
                        sourceTime, newTime,
                        sourceTime.EqualsExact(newTime));
      Console.WriteLine();
   }
}
//
// The example displays the following output:
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 9:30:00 AM -05:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 9:30:00 AM -05:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 9:30:00 AM -05:00 are identical: True
//
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 2:30:00 PM +00:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 2:30:00 PM +00:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 2:30:00 PM +00:00 are identical: False
//
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 6:30:00 AM -08:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 6:30:00 AM -08:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 6:30:00 AM -08:00 are identical: False
//
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 5:30:00 PM +03:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 5:30:00 PM +03:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 5:30:00 PM +03:00 are identical: False

open System

let sourceTime = DateTimeOffset(2007, 9, 1, 9, 30, 0, TimeSpan(-5, 0, 0))

let showDateAndTimeInfo newTime =
    printfn $"{sourceTime} converts to {newTime}"
    printfn $"{sourceTime} and {newTime} are equal: {sourceTime.Equals newTime}"
    printfn $"{sourceTime} and {newTime} are identical: {sourceTime.EqualsExact newTime}\n"

[<EntryPoint>]
let main _ =
    // Convert to same time (return sourceTime unchanged)
    let targetTime = sourceTime.ToOffset(TimeSpan(-5, 0, 0))
    showDateAndTimeInfo targetTime

    // Convert to UTC (0 offset)
    let targetTime = sourceTime.ToOffset TimeSpan.Zero
    showDateAndTimeInfo targetTime

    // Convert to 8 hours behind UTC
    let targetTime = sourceTime.ToOffset(TimeSpan(-8, 0, 0))
    showDateAndTimeInfo targetTime

    // Convert to 3 hours ahead of UTC
    let targetTime = sourceTime.ToOffset(TimeSpan(3, 0, 0))
    showDateAndTimeInfo targetTime

    0

// The example displays the following output:
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 9:30:00 AM -05:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 9:30:00 AM -05:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 9:30:00 AM -05:00 are identical: True
//
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 2:30:00 PM +00:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 2:30:00 PM +00:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 2:30:00 PM +00:00 are identical: False
//
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 6:30:00 AM -08:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 6:30:00 AM -08:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 6:30:00 AM -08:00 are identical: False
//
//    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 5:30:00 PM +03:00
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 5:30:00 PM +03:00 are equal: True
//    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 5:30:00 PM +03:00 are identical: False

Module DateTimeOffsetConversion
   Private sourceTime As New DateTimeOffset(#9/1/2007 9:30AM#, _
                                            New TimeSpan(-5, 0, 0))
   
   Public Sub Main()
      Dim targetTime As DateTimeOffset
      
      ' Convert to same time (return sourceTime unchanged)
      targetTime = sourceTime.ToOffset(New TimeSpan(-5, 0, 0))
      ShowDateAndTimeInfo(targetTime)
      
      ' Convert to UTC (0 offset)
      targetTime = sourceTime.ToOffset(TimeSpan.Zero)
      ShowDateAndTimeInfo(targetTime)
      
      ' Convert to 8 hours behind UTC
      targetTime = sourceTime.ToOffset(New TimeSpan(-8, 0, 0))
      ShowDateAndTimeInfo(targetTime)
      
      ' Convert to 3 hours ahead of UTC
      targetTime = sourceTime.ToOffset(New TimeSpan(3, 0, 0))
      ShowDateAndTimeInfo(targetTime)
   End Sub
   
   Private Sub ShowDateAndTimeInfo(newTime As DateTimeOffset)
      Console.WriteLine("{0} converts to {1}", sourceTime, newTime)
      Console.WriteLine("{0} and {1} are equal: {2}", _
                        sourceTime, newTime, sourceTime.Equals(newTime))
      Console.WriteLine("{0} and {1} are identical: {2}", _
                        sourceTime, newTime, _
                        sourceTime.EqualsExact(newTime)) 
      Console.WriteLine()
   End Sub
End Module
'
' The example displays the following output:
'    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 9:30:00 AM -05:00
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 9:30:00 AM -05:00 are equal: True
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 9:30:00 AM -05:00 are identical: True
'    
'    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 2:30:00 PM +00:00
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 2:30:00 PM +00:00 are equal: True
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 2:30:00 PM +00:00 are identical: False
'    
'    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 6:30:00 AM -08:00
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 6:30:00 AM -08:00 are equal: True
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 6:30:00 AM -08:00 are identical: False
'    
'    9/1/2007 9:30:00 AM -05:00 converts to 9/1/2007 5:30:00 PM +03:00
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 5:30:00 PM +03:00 are equal: True
'    9/1/2007 9:30:00 AM -05:00 and 9/1/2007 5:30:00 PM +03:00 are identical: False

Comentarios

El ToOffset método es una alternativa a llamar al TimeZoneInfo.ConvertTime(DateTimeOffset, TimeZoneInfo) método . Puede ser útil para realizar conversiones simples de una zona horaria a otra cuando se conocen los desplazamientos de las zonas horarias de la hora universal coordinada (UTC). Sin embargo, dado que ni el objeto original DateTimeOffset ni el nuevo DateTimeOffset objeto devuelto por la llamada al método están inequívocamente relacionados con una zona horaria determinada, el método no aplica ninguna regla de ajuste de zona horaria en la conversión.

Se aplica a

Compartir vía