DateTime.ToLocalTime Método

Definição

Espaço de Nomes:
System
Assemblagens:
mscorlib.dll, System.Runtime.dll
Assemblagem:
mscorlib.dll
Assemblagem:
System.Runtime.dll
Assemblagem:
netstandard.dll

Converte o valor do objeto atual DateTime para hora local.

public:
 DateTime ToLocalTime();
public DateTime ToLocalTime();
member this.ToLocalTime : unit -> DateTime
Public Function ToLocalTime () As DateTime

Devoluções

DateTime

Um objeto cuja Kind propriedade é Local, e cujo valor é o tempo local equivalente ao valor do objeto atual DateTime , ou DateTime.MaxValue se o valor convertido for demasiado grande para ser representado por um DateTime objeto, ou DateTime.MinValue se o valor convertido for demasiado pequeno para ser representado como um DateTime objeto.

Exemplos

O exemplo seguinte demonstra o ToLocalTime método. Note-se que a saída exata depende da cultura atual e do fuso horário local do sistema onde é executada.

open System

printfn "Enter a date and time."

try
    let strDateTime = stdin.ReadLine()
    let localDateTime = DateTime.Parse strDateTime
    let univDateTime = localDateTime.ToUniversalTime()

    printfn $"{localDateTime} local time is {univDateTime} universal time."

with :? FormatException ->
    printfn "Invalid format."

printfn "Enter a date and time in universal time."

try
    let strDateTime = stdin.ReadLine()
    let univDateTime = DateTime.Parse strDateTime
    let localDateTime = univDateTime.ToLocalTime()

    printfn $"{univDateTime} universal time is {localDateTime} local time."

with :? FormatException ->
    printfn "Invalid format."

// The example displays output like the following when run on a
// computer whose culture is en-US in the Pacific Standard Time zone:
//     Enter a date and time.
//     12/10/2015 6:18 AM
//     12/10/2015 6:18:00 AM local time is 12/10/2015 2:18:00 PM universal time.
//     Enter a date and time in universal time.
//     12/20/2015 6:42:00
//     12/20/2015 6:42:00 AM universal time is 12/19/2015 10:42:00 PM local time.

using System;

class Example
{
    static void Main()
    {
        DateTime localDateTime, univDateTime;
        
        Console.WriteLine("Enter a date and time.");
        string strDateTime = Console.ReadLine();

        try {
            localDateTime = DateTime.Parse(strDateTime);
            univDateTime = localDateTime.ToUniversalTime();

            Console.WriteLine("{0} local time is {1} universal time.",
                                localDateTime,
                                    univDateTime);
        }
        catch (FormatException) {
            Console.WriteLine("Invalid format.");
            return;
        }

        Console.WriteLine("Enter a date and time in universal time.");
        strDateTime = Console.ReadLine();

        try {
            univDateTime = DateTime.Parse(strDateTime);
            localDateTime = univDateTime.ToLocalTime();

            Console.WriteLine("{0} universal time is {1} local time.",
                                     univDateTime,
                                     localDateTime);
        }
        catch (FormatException) {
            Console.WriteLine("Invalid format.");
            return;
        }
    }
}
// The example displays output like the following when run on a
// computer whose culture is en-US in the Pacific Standard Time zone:
//     Enter a date and time.
//     12/10/2015 6:18 AM
//     12/10/2015 6:18:00 AM local time is 12/10/2015 2:18:00 PM universal time.
//     Enter a date and time in universal time.
//     12/20/2015 6:42:00
//     12/20/2015 6:42:00 AM universal time is 12/19/2015 10:42:00 PM local time.

Module Example
    Sub Main()
      Dim localDateTime, univDateTime As DateTime
      
      Console.WriteLine("Enter a date and time.")
      Dim strDateTime As String = Console.ReadLine()
      Try
         localDateTime = DateTime.Parse(strDateTime)
         univDateTime = localDateTime.ToUniversalTime()
         Console.WriteLine("{0} local time is {1} universal time.", 
                           localDateTime, univDateTime)
      Catch exp As FormatException
         Console.WriteLine("Invalid format.")
      End Try

      Console.WriteLine("Enter a date and time in universal time.")
      strDateTime = Console.ReadLine()
      Try
         univDateTime = DateTime.Parse(strDateTime)
         localDateTime = univDateTime.ToLocalTime()
  
         Console.WriteLine("{0} universal time is {1} local time.", _
                           univDateTime, localDateTime)
      Catch exp As FormatException
         Console.WriteLine("Invalid format.")
      End Try
    End Sub
End Module
' The example displays output like the following when run on a 
' computer whose culture is en-US in the Pacific Standard Time zone:
'     Enter a date and time.
'     12/10/2015 6:18 AM
'     12/10/2015 6:18:00 AM local time is 12/10/2015 2:18:00 PM universal time.
'     Enter a date and time in universal time.
'     12/20/2015 6:42:00
'     12/20/2015 6:42:00 AM universal time is 12/19/2015 10:42:00 PM local time.

O exemplo seguinte utiliza o SpecifyKind método para demonstrar como a Kind propriedade influencia os ToLocalTime métodos de conversão.ToUniversalTime

// This code example demonstrates the DateTime Kind, Now, and
// UtcNow properties, and the SpecifyKind(), ToLocalTime(),
// and ToUniversalTime() methods.

open System

// Display the value and Kind property of a DateTime structure, the
// DateTime structure converted to local time, and the DateTime
// structure converted to universal time.

let datePatt = @"M/d/yyyy hh:mm:ss tt"

let display title (inputDt: DateTime) =
    // Display the original DateTime.

    let dispDt = inputDt
    let dtString = dispDt.ToString datePatt
    printfn $"%s{title} {dtString}, Kind = {dispDt.Kind}"

    // Convert inputDt to local time and display the result.
    // If inputDt.Kind is DateTimeKind.Utc, the conversion is performed.
    // If inputDt.Kind is DateTimeKind.Local, the conversion is not performed.
    // If inputDt.Kind is DateTimeKind.Unspecified, the conversion is
    // performed as if inputDt was universal time.

    let dispDt = inputDt.ToLocalTime()
    let dtString = dispDt.ToString datePatt
    printfn $"  ToLocalTime:     {dtString}, Kind = {dispDt.Kind}"

    // Convert inputDt to universal time and display the result.
    // If inputDt.Kind is DateTimeKind.Utc, the conversion is not performed.
    // If inputDt.Kind is DateTimeKind.Local, the conversion is performed.
    // If inputDt.Kind is DateTimeKind.Unspecified, the conversion is
    // performed as if inputDt was local time.

    let dispDt = inputDt.ToUniversalTime()
    let dtString = dispDt.ToString datePatt
    printfn $"  ToUniversalTime: {dtString}, Kind = {dispDt.Kind}\n" 

    // Display the value and Kind property for DateTime.Now and DateTime.UtcNow.

let displayNow title (inputDt: DateTime) =
    let dtString = inputDt.ToString datePatt
    printfn $"%s{title} {dtString}, Kind = {inputDt.Kind}"

[<EntryPoint>]
let main _ =

    // Get the date and time for the current moment, adjusted
    // to the local time zone.

    let saveNow = DateTime.Now

    // Get the date and time for the current moment expressed
    // as coordinated universal time (UTC).

    let saveUtcNow = DateTime.UtcNow

    // Display the value and Kind property of the current moment
    // expressed as UTC and local time.

    displayNow "UtcNow: .........." saveUtcNow
    displayNow "Now: ............." saveNow
    printfn ""

    // Change the Kind property of the current moment to
    // DateTimeKind.Utc and display the result.

    let myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Utc)
    display "Utc: ............." myDt

    // Change the Kind property of the current moment to
    // DateTimeKind.Local and display the result.

    let myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Local)
    display "Local: ..........." myDt

    // Change the Kind property of the current moment to
    // DateTimeKind.Unspecified and display the result.

    let myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Unspecified)
    display "Unspecified: ....." myDt

    0


// This code example produces the following results:
//
// UtcNow: .......... 5/6/2005 09:34:42 PM, Kind = Utc
// Now: ............. 5/6/2005 02:34:42 PM, Kind = Local
//
// Utc: ............. 5/6/2005 02:34:42 PM, Kind = Utc
//   ToLocalTime:     5/6/2005 07:34:42 AM, Kind = Local
//   ToUniversalTime: 5/6/2005 02:34:42 PM, Kind = Utc
//
// Local: ........... 5/6/2005 02:34:42 PM, Kind = Local
//   ToLocalTime:     5/6/2005 02:34:42 PM, Kind = Local
//   ToUniversalTime: 5/6/2005 09:34:42 PM, Kind = Utc
//
// Unspecified: ..... 5/6/2005 02:34:42 PM, Kind = Unspecified
//   ToLocalTime:     5/6/2005 07:34:42 AM, Kind = Local
//   ToUniversalTime: 5/6/2005 09:34:42 PM, Kind = Utc

// This code example demonstrates the DateTime Kind, Now, and
// UtcNow properties, and the SpecifyKind(), ToLocalTime(),
// and ToUniversalTime() methods.

using System;

class Sample
{
    public static void Main()
    {
        // Get the date and time for the current moment, adjusted
        // to the local time zone.

        DateTime saveNow = DateTime.Now;

        // Get the date and time for the current moment expressed
        // as coordinated universal time (UTC).

        DateTime saveUtcNow = DateTime.UtcNow;
        DateTime myDt;

        // Display the value and Kind property of the current moment
        // expressed as UTC and local time.

        DisplayNow("UtcNow: ..........", saveUtcNow);
        DisplayNow("Now: .............", saveNow);
        Console.WriteLine();

        // Change the Kind property of the current moment to
        // DateTimeKind.Utc and display the result.

        myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Utc);
        Display("Utc: .............", myDt);

        // Change the Kind property of the current moment to
        // DateTimeKind.Local and display the result.

        myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Local);
        Display("Local: ...........", myDt);

        // Change the Kind property of the current moment to
        // DateTimeKind.Unspecified and display the result.

        myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Unspecified);
        Display("Unspecified: .....", myDt);
    }

    // Display the value and Kind property of a DateTime structure, the
    // DateTime structure converted to local time, and the DateTime
    // structure converted to universal time.

    public static string datePatt = @"M/d/yyyy hh:mm:ss tt";
    public static void Display(string title, DateTime inputDt)
    {
        DateTime dispDt = inputDt;
        string dtString;

        // Display the original DateTime.

        dtString = dispDt.ToString(datePatt);
        Console.WriteLine("{0} {1}, Kind = {2}",
                          title, dtString, dispDt.Kind);

        // Convert inputDt to local time and display the result.
        // If inputDt.Kind is DateTimeKind.Utc, the conversion is performed.
        // If inputDt.Kind is DateTimeKind.Local, the conversion is not performed.
        // If inputDt.Kind is DateTimeKind.Unspecified, the conversion is
        // performed as if inputDt was universal time.

        dispDt = inputDt.ToLocalTime();
        dtString = dispDt.ToString(datePatt);
        Console.WriteLine("  ToLocalTime:     {0}, Kind = {1}",
                          dtString, dispDt.Kind);

        // Convert inputDt to universal time and display the result.
        // If inputDt.Kind is DateTimeKind.Utc, the conversion is not performed.
        // If inputDt.Kind is DateTimeKind.Local, the conversion is performed.
        // If inputDt.Kind is DateTimeKind.Unspecified, the conversion is
        // performed as if inputDt was local time.

        dispDt = inputDt.ToUniversalTime();
        dtString = dispDt.ToString(datePatt);
        Console.WriteLine("  ToUniversalTime: {0}, Kind = {1}",
                          dtString, dispDt.Kind);
        Console.WriteLine();
    }

    // Display the value and Kind property for DateTime.Now and DateTime.UtcNow.

    public static void DisplayNow(string title, DateTime inputDt)
    {
        string dtString = inputDt.ToString(datePatt);
        Console.WriteLine("{0} {1}, Kind = {2}",
                          title, dtString, inputDt.Kind);
    }
}

/*
This code example produces the following results:

UtcNow: .......... 5/6/2005 09:34:42 PM, Kind = Utc
Now: ............. 5/6/2005 02:34:42 PM, Kind = Local

Utc: ............. 5/6/2005 02:34:42 PM, Kind = Utc
  ToLocalTime:     5/6/2005 07:34:42 AM, Kind = Local
  ToUniversalTime: 5/6/2005 02:34:42 PM, Kind = Utc

Local: ........... 5/6/2005 02:34:42 PM, Kind = Local
  ToLocalTime:     5/6/2005 02:34:42 PM, Kind = Local
  ToUniversalTime: 5/6/2005 09:34:42 PM, Kind = Utc

Unspecified: ..... 5/6/2005 02:34:42 PM, Kind = Unspecified
  ToLocalTime:     5/6/2005 07:34:42 AM, Kind = Local
  ToUniversalTime: 5/6/2005 09:34:42 PM, Kind = Utc

*/


' This code example demonstrates the DateTime Kind, Now, and
' UtcNow properties, and the SpecifyKind(), ToLocalTime(), 
' and ToUniversalTime() methods.
Class Sample
    Public Shared Sub Main() 
        ' Get the date and time for the current moment, adjusted 
        ' to the local time zone.
        Dim saveNow As DateTime = DateTime.Now
        
        ' Get the date and time for the current moment expressed 
        ' as coordinated universal time (UTC).
        Dim saveUtcNow As DateTime = DateTime.UtcNow
        Dim myDt As DateTime
        
        ' Display the value and Kind property of the current moment 
        ' expressed as UTC and local time.
        DisplayNow("UtcNow: ..........", saveUtcNow)
        DisplayNow("Now: .............", saveNow)
        Console.WriteLine()
        
        ' Change the Kind property of the current moment to 
        ' DateTimeKind.Utc and display the result.
        myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Utc)
        Display("Utc: .............", myDt)
        
        ' Change the Kind property of the current moment to 
        ' DateTimeKind.Local and display the result.
        myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Local)
        Display("Local: ...........", myDt)
        
        ' Change the Kind property of the current moment to 
        ' DateTimeKind.Unspecified and display the result.
        myDt = DateTime.SpecifyKind(saveNow, DateTimeKind.Unspecified)
        Display("Unspecified: .....", myDt)
    End Sub
    
    ' Display the value and Kind property of a DateTime structure, the 
    ' DateTime structure converted to local time, and the DateTime 
    ' structure converted to universal time. 

    Public Shared datePatt As String = "M/d/yyyy hh:mm:ss tt"
    
    Public Shared Sub Display(ByVal title As String, ByVal inputDt As DateTime) 
        Dim dispDt As DateTime = inputDt
        Dim dtString As String
        
        ' Display the original DateTime.
        dtString = dispDt.ToString(datePatt)
        Console.WriteLine("{0} {1}, Kind = {2}", title, dtString, dispDt.Kind)
        
        ' Convert inputDt to local time and display the result. 
        ' If inputDt.Kind is DateTimeKind.Utc, the conversion is performed.
        ' If inputDt.Kind is DateTimeKind.Local, the conversion is not performed.
        ' If inputDt.Kind is DateTimeKind.Unspecified, the conversion is 
        ' performed as if inputDt was universal time.
        dispDt = inputDt.ToLocalTime()
        dtString = dispDt.ToString(datePatt)
        Console.WriteLine("  ToLocalTime:     {0}, Kind = {1}", dtString, dispDt.Kind)
        
        ' Convert inputDt to universal time and display the result. 
        ' If inputDt.Kind is DateTimeKind.Utc, the conversion is not performed.
        ' If inputDt.Kind is DateTimeKind.Local, the conversion is performed.
        ' If inputDt.Kind is DateTimeKind.Unspecified, the conversion is 
        ' performed as if inputDt was local time.
        dispDt = inputDt.ToUniversalTime()
        dtString = dispDt.ToString(datePatt)
        Console.WriteLine("  ToUniversalTime: {0}, Kind = {1}", dtString, dispDt.Kind)
        Console.WriteLine()
    End Sub
    
    
    ' Display the value and Kind property for DateTime.Now and DateTime.UtcNow.

    Public Shared Sub DisplayNow(ByVal title As String, ByVal inputDt As DateTime) 
        Dim dtString As String = inputDt.ToString(datePatt)
        Console.WriteLine("{0} {1}, Kind = {2}", title, dtString, inputDt.Kind)
    End Sub
End Class

'
'This code example produces the following results:
'
'UtcNow: .......... 5/6/2005 09:34:42 PM, Kind = Utc
'Now: ............. 5/6/2005 02:34:42 PM, Kind = Local
'
'Utc: ............. 5/6/2005 02:34:42 PM, Kind = Utc
'  ToLocalTime:     5/6/2005 07:34:42 AM, Kind = Local
'  ToUniversalTime: 5/6/2005 02:34:42 PM, Kind = Utc
'
'Local: ........... 5/6/2005 02:34:42 PM, Kind = Local
'  ToLocalTime:     5/6/2005 02:34:42 PM, Kind = Local
'  ToUniversalTime: 5/6/2005 09:34:42 PM, Kind = Utc
'
'Unspecified: ..... 5/6/2005 02:34:42 PM, Kind = Unspecified
'  ToLocalTime:     5/6/2005 07:34:42 AM, Kind = Local
'  ToUniversalTime: 5/6/2005 09:34:42 PM, Kind = Utc
'

Observações

A hora local é igual à hora do Tempo Universal Coordenado (UTC) mais o deslocamento UTC. Para mais informações sobre o deslocamento UTC, veja TimeZoneInfo.GetUtcOffset. A conversão também tem em conta a regra do horário de verão que se aplica ao tempo representado pelo objeto atual DateTime .

Importante

Em sistemas Windows XP, o método ToLocalTime reconhece apenas a regra de ajuste atual ao converter do UTC para a hora local. Como resultado, conversões para períodos anteriores à regra de ajuste atual entrar em vigor podem não refletir com precisão a diferença entre UTC e hora local.

A partir da versão 2.0 do .NET Framework, o valor devolvido pelo método ToLocalTime é determinado pela propriedade Kind do objeto atual DateTime. A tabela seguinte descreve os possíveis resultados.

Variante Results
Utc Esta instância de DateTime é convertida para a hora local.
Local Não é realizada qualquer conversão.
Unspecified Esta instância de DateTime é assumida como uma hora UTC, e a conversão é realizada como se Kind fosse Utc.

Note

O ToLocalTime método converte um DateTime valor do UTC para a hora local. Para converter a hora em qualquer fuso horário designado para hora local, use o TimeZoneInfo.ConvertTime método.

O valor devolvido pela conversão é um DateTime cuja Kind propriedade devolve Localsempre . Consequentemente, um resultado válido é devolvido mesmo que ToLocalTime seja aplicado repetidamente ao mesmo DateTime.

Notas para Chamadores

Pode usar o ToLocalTime() método para restaurar um valor local de data e hora que foi convertido para UTC pelo ToUniversalTime() método ou.FromFileTimeUtc(Int64) No entanto, se a hora original representar uma hora inválida no fuso horário local, não corresponderá ao valor restaurado. Quando o ToLocalTime() método converte uma hora de UTC para o fuso horário local, também ajusta a hora para que seja válida no fuso horário local.

Por exemplo, a transição do horário padrão para o horário de verão ocorre no fuso horário do Pacífico dos EUA a 14 de março de 2010, às 2:00 da manhã, quando o horário avança uma hora, para as 3:00 da manhã. Este intervalo de uma hora é um tempo inválido, ou seja, um intervalo de tempo que não existe neste fuso horário. O exemplo seguinte mostra que, quando um tempo que se enquadra neste intervalo é convertido em UTC pelo ToUniversalTime() método e depois restaurado pelo ToLocalTime() método, o valor original é ajustado para se tornar um tempo válido. Você pode determinar se um determinado valor de data e hora pode estar sujeito a modificação passando-o para o método IsInvalidTime(DateTime), como ilustra o exemplo.

using System;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2010, 3, 14, 2, 30, 0, DateTimeKind.Local);
      Console.WriteLine("Invalid time: {0}",
                        TimeZoneInfo.Local.IsInvalidTime(date1));
      DateTime utcDate1 = date1.ToUniversalTime();
      DateTime date2 = utcDate1.ToLocalTime();
      Console.WriteLine("{0} --> {1}", date1, date2);
   }
}
// The example displays the following output:
//       Invalid time: True
//       3/14/2010 2:30:00 AM --> 3/14/2010 3:30:00 AM

open System

let date1 = DateTime(2010, 3, 14, 2, 30, 0, DateTimeKind.Local)
printfn $"Invalid time: {TimeZoneInfo.Local.IsInvalidTime date1}"
let utcDate1 = date1.ToUniversalTime()
let date2 = utcDate1.ToLocalTime()
printfn $"{date1} --> {date2}"

// The example displays the following output:
//       Invalid time: True
//       3/14/2010 2:30:00 AM --> 3/14/2010 3:30:00 AM

Module Example
   Public Sub Main()
      Dim date1 As New Date(2010, 3, 14, 2, 30, 0, DateTimeKind.Local)
      Console.WriteLine("Invalid time: {0}", _
                        TimeZoneInfo.Local.IsInvalidTime(date1))
      Dim utcDate1 As Date = date1.ToUniversalTime()
      Dim date2 As Date = utcDate1.ToLocalTime()
      Console.WriteLine("{0} --> {1}", date1, date2)      
   End Sub
End Module
' The example displays the following output:
'       Invalid time: True
'       3/14/2010 2:30:00 AM --> 3/14/2010 3:30:00 AM

Aplica-se a

Ver também