DateTime Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Representa un instante de tiempo, normalmente expresado en forma de fecha y hora del día.

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System::Runtime::Serialization::ISerializable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)

Herencia

Object

ValueType

DateTime

Implementaciones

IComparable IComparable<DateTime> IConvertible IEquatable<DateTime> IFormattable ISerializable ISpanFormattable IParsable<DateTime> IParsable<TSelf> ISpanParsable<DateTime>

Comentarios

Importante

Las eras en los calendarios japoneses se basan en el reino del emperador y, por tanto, se espera que cambien. Por ejemplo, el 1 de mayo de 2019 marcaba el comienzo de la era Reiwa en JapaneseCalendar y JapaneseLunisolarCalendar. Este cambio de era afecta a todas las aplicaciones que usan estos calendarios. Para obtener más información y determinar si las aplicaciones se ven afectadas, consulte Control de una nueva era en el calendario japonés en .NET. Para obtener información sobre cómo probar las aplicaciones en sistemas Windows para garantizar su preparación para el cambio de era, consulte Preparación de la aplicación para el cambio en la era japonesa. Para conocer las características de .NET que admiten calendarios con varias eras y procedimientos recomendados al trabajar con calendarios que admiten varias eras, consulte Trabajar con eras.

Vínculos rápidos al código de ejemplo

Nota

Algunos ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.

La zona horaria local del ejecutor de código en línea de Try.NET y del área de juegos es la hora universal coordinada o UTC. Esto puede afectar al comportamiento y la salida de ejemplos que ilustran los tipos DateTime, DateTimeOffset y TimeZoneInfo y sus miembros.

En este artículo se incluyen varios ejemplos que usan el DateTime tipo :

Ejemplos de inicialización

• Invocación de un constructor
• Invocación del constructor sin parámetros implícito
• Asignación del valor devuelto
• Análisis de una cadena que representa una fecha y hora
• Sintaxis de Visual Basic para inicializar una fecha y hora

Aplicar formato a DateTime objetos como cadenas

• Usar el formato de fecha y hora predeterminado
• Dar formato a una fecha y hora mediante una referencia cultural específica
• Dar formato a una fecha y hora mediante una cadena de formato estándar o personalizado
• Especificar una cadena de formato y una referencia cultural específica
• Dar formato a una fecha y hora con el estándar ISO 8601 para los servicios web

Análisis de cadenas como DateTime objetos

• Usar Parse o TryParse convertir una cadena en una fecha y hora
• Usar ParseExact o TryParseExact convertir una cadena en un formato conocido
• Conversión de la representación de cadena ISO 8601 a una fecha y hora

DateTime Resolución

• Exploración de la resolución de valores de fecha y hora
• Comparación de igualdad dentro de una tolerancia

Referencia cultural y calendarios

• Mostrar valores de fecha y hora mediante calendarios específicos de la referencia cultural
• Análisis de cadenas según un calendario específico de la referencia cultural
• Inicialización de una fecha y hora a partir del calendario de una referencia cultural específica
• Acceso a las propiedades de fecha y hora mediante el calendario de una referencia cultural específica
• Recuperar la semana del año mediante calendarios específicos de la referencia cultural

Persistencia

• Conservar valores de fecha y hora como cadenas en la zona horaria local
• Conservar valores de fecha y hora como cadenas en un formato invariable de referencia cultural y hora
• Conservar valores de fecha y hora como enteros
• Conservación de valores de fecha y hora mediante XmlSerializer

Vínculos rápidos a temas de comentarios

Esta sección contiene temas para muchos usos comunes de la DateTime estructura:

• Inicialización de un DateTime objeto
• Valores DateTime y sus representaciones de cadena
• Análisis de valores DateTime de cadenas
• Valores dateTime
• Operaciones DateTime
• Resolución dateTime
• Valores y calendarios dateTime
• Conservación de valores DateTime
• DateTime frente a TimeSpan
• Comparación de la igualdad dentro de la tolerancia
• Consideraciones sobre la interoperabilidad COM

El DateTime tipo de valor representa fechas y horas con valores que van desde las 00:00:00 (medianoche), 1 de enero de 0001 Anno Domini (Era común) hasta las 11:59:59 p.m., 31 de diciembre de 9999 A.D. (C.E.) en el calendario gregoriano.

Los valores de tiempo se miden en unidades de 100 nanosegundos denominadas tics. Una fecha determinada es el número de tics desde las 12:00 medianoche, 1 de enero de 0001 A.D. (C.E.) en el GregorianCalendar calendario. El número excluye tics que se agregarían por segundos bisiesto. Por ejemplo, un valor de tics de 31241376000000000L representa la fecha viernes, 01 de enero de 0100 12:00:00 medianoche. Un DateTime valor siempre se expresa en el contexto de un calendario explícito o predeterminado.

Nota:

Si está trabajando con un valor de tics que desea convertir en algún otro intervalo de tiempo, como minutos o segundos, debe usar la TimeSpan.TicksPerDayconstante , , TimeSpan.TicksPerSecondTimeSpan.TicksPerHourTimeSpan.TicksPerMinute, o TimeSpan.TicksPerMillisecond para realizar la conversión. Por ejemplo, para agregar el número de segundos representados por un número especificado de tics al Second componente de un DateTime valor, puede usar la expresión dateValue.Second + nTicks/Timespan.TicksPerSecond.

Puede ver el origen de todo el conjunto de ejemplos de este artículo en Visual Basic, F#o C# desde el repositorio de documentos en GitHub.

Nota:

Una alternativa a la DateTime estructura para trabajar con valores de fecha y hora en determinadas zonas horarias es la DateTimeOffset estructura . La DateTimeOffset estructura almacena información de fecha y hora en un campo privado DateTime y el número de minutos por los que esa fecha y hora difieren de UTC en un campo privado Int16 . Esto permite que un DateTimeOffset valor refleje la hora en una zona horaria determinada, mientras que un DateTime valor puede reflejar de forma inequívoca solo utc y la hora de la zona horaria local. Para obtener información sobre cuándo usar la DateTime estructura o la DateTimeOffset estructura al trabajar con valores de fecha y hora, vea Elegir entre DateTime, DateTimeOffset, TimeSpan y TimeZoneInfo.

Inicialización de un objeto DateTime

Puede asignar un valor inicial a un nuevo DateTime valor de muchas maneras diferentes:

• Llamar a un constructor, ya sea uno en el que especifique argumentos para los valores o use el constructor sin parámetros implícito.
• Asignar un DateTime objeto al valor devuelto de una propiedad o método.
• Analizar un DateTime valor a partir de su representación de cadena.
• Uso de características de lenguaje específicas de Visual Basic para crear instancias de .DateTime

Los fragmentos de código siguientes muestran ejemplos de cada uno.

Invocar constructores

Se llama a cualquiera de las sobrecargas del DateTime constructor que especifican elementos del valor de fecha y hora (como el año, el mes y el día o el número de tics). El código siguiente crea una fecha específica mediante el DateTime constructor que especifica el año, mes, día, hora, minuto y segundo.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)

var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"

Se invoca el constructor sin parámetros implícito de la DateTime estructura cuando se desea que se inicialice en DateTime su valor predeterminado. (Para obtener más información sobre el constructor implícito sin parámetros de un tipo de valor, vea Tipos de valor). Algunos compiladores también admiten la declaración de un DateTime valor sin asignarle explícitamente un valor. La creación de un valor sin una inicialización explícita también da como resultado el valor predeterminado. En el ejemplo siguiente se muestra el DateTime constructor sin parámetros implícito en C# y Visual Basic, así como una DateTime declaración sin asignación en Visual Basic.

Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))

var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));

let dat1 = DateTime()

// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"

// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"

Asignación de un valor calculado

Puede asignar al DateTime objeto un valor de fecha y hora devuelto por una propiedad o método. En el ejemplo siguiente se asignan la fecha y hora actuales, la fecha y hora universal coordinada (UTC) actuales, y la fecha actual a tres nuevas DateTime variables.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today

DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;

let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today

Análisis de una cadena que representa un valor DateTime

Los Parsemétodos , ParseExact, TryParsey TryParseExact convierten una cadena en su valor de fecha y hora equivalentes. En los ejemplos siguientes se usan los Parse métodos y ParseExact para analizar una cadena y convertirlo en un DateTime valor. El segundo formato usa un formulario admitido por el estándar ISO 8601 para representar una fecha y hora en formato de cadena. Esta representación estándar se usa a menudo para transferir información de fecha en servicios web.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)

var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

Los TryParse métodos y TryParseExact indican si una cadena es una representación válida de un DateTime valor y, si es así, realiza la conversión.

Sintaxis específica del lenguaje para Visual Basic

La siguiente instrucción de Visual Basic inicializa un nuevo DateTime valor.

Dim date1 As Date = #5/1/2008 8:30:52AM#

Valores DateTime y sus representaciones de cadena

Internamente, todos los DateTime valores se representan como el número de tics (el número de intervalos de 100 nanosegundos) que han transcurrido desde las 12:00:00 medianoche, 1 de enero de 0001. El valor real DateTime es independiente de la forma en que ese valor aparece cuando se muestra. La apariencia de un DateTime valor es el resultado de una operación de formato que convierte un valor en su representación de cadena.

La apariencia de los valores de fecha y hora depende de la cultura, los estándares internacionales, los requisitos de aplicación y las preferencias personales. La DateTime estructura ofrece flexibilidad en el formato de los valores de fecha y hora mediante sobrecargas de ToString. El método predeterminado DateTime.ToString() devuelve la representación de cadena de un valor de fecha y hora mediante el patrón de fecha y hora corta de la referencia cultural actual. En el ejemplo siguiente se usa el método predeterminado DateTime.ToString() . Muestra la fecha y hora con el patrón de fecha corta y hora larga para la referencia cultural actual. La referencia cultural en-US es la referencia cultural actual en el equipo en el que se ejecutó el ejemplo.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{date1.ToString()}"
// For en-US culture, displays 3/1/2008 7:00:00 AM

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

Es posible que tenga que dar formato a fechas en una referencia cultural específica para admitir escenarios web en los que el servidor puede estar en una referencia cultural diferente del cliente. Especifique la referencia cultural mediante el DateTime.ToString(IFormatProvider) método para crear la representación de fecha corta y de tiempo largo en una referencia cultural específica. En el ejemplo siguiente se usa el DateTime.ToString(IFormatProvider) método para mostrar la fecha y hora con el patrón de fecha corta y hora larga para la referencia cultural fr-FR.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR")}"""
// Displays 01/03/2008 07:00:00

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

Otras aplicaciones pueden requerir representaciones de cadena diferentes de una fecha. El DateTime.ToString(String) método devuelve la representación de cadena definida por un especificador de formato estándar o personalizado mediante las convenciones de formato de la referencia cultural actual. En el ejemplo siguiente se usa el DateTime.ToString(String) método para mostrar el patrón de fecha y hora completo para la referencia cultural en-US, la referencia cultural actual en el equipo en el que se ejecutó el ejemplo.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString "F"}"""
// Displays Saturday, March 01, 2008 7:00:00 AM

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

Por último, puede especificar la referencia cultural y el formato mediante el DateTime.ToString(String, IFormatProvider) método . En el ejemplo siguiente se usa el DateTime.ToString(String, IFormatProvider) método para mostrar el patrón completo de fecha y hora para la referencia cultural fr-FR.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString("F", new System.Globalization.CultureInfo "fr-FR")}"""
// Displays samedi 1 mars 2008 07:00:00

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

La DateTime.ToString(String) sobrecarga también se puede usar con una cadena de formato personalizado para especificar otros formatos. En el ejemplo siguiente se muestra cómo dar formato a una cadena mediante el formato estándar ISO 8601 que se suele usar para los servicios web. El formato Iso 8601 no tiene una cadena de formato estándar correspondiente.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00

Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00

Para obtener más información sobre los valores de formato DateTime , vea Cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizados.

Análisis de valores DateTime de cadenas

El análisis convierte la representación de cadena de una fecha y hora en un DateTime valor. Normalmente, las cadenas de fecha y hora tienen dos usos diferentes en las aplicaciones:

• Una fecha y hora tarda una variedad de formas y refleja las convenciones de la referencia cultural actual o de una referencia cultural específica. Por ejemplo, una aplicación permite que un usuario cuya referencia cultural actual sea en-US escriba un valor de fecha como "12/15/2013" o "15 de diciembre de 2013". Permite que un usuario cuya referencia cultural actual sea en-gb escriba un valor de fecha como "15/12/2013" o "15 de diciembre de 2013".

• Una fecha y hora se representa en un formato predefinido. Por ejemplo, una aplicación serializa una fecha como "20130103" independientemente de la referencia cultural en la que se ejecuta la aplicación. Una aplicación puede requerir que las fechas sean de entrada en el formato de fecha corta de la referencia cultural actual.

Use el Parse método o TryParse para convertir una cadena de uno de los formatos de fecha y hora comunes usados por una referencia cultural a un DateTime valor. En el ejemplo siguiente se muestra cómo puede usar TryParse para convertir cadenas de fecha en diferentes formatos específicos de la referencia cultural a un DateTime valor. Cambia la referencia cultural actual a inglés (Reino Unido) y llama al GetDateTimeFormats() método para generar una matriz de cadenas de fecha y hora. A continuación, pasa cada elemento de la matriz al TryParse método . La salida del ejemplo muestra que el método de análisis pudo convertir correctamente cada una de las cadenas de fecha y hora específicas de la referencia cultural.

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    else
        badFormats.Add(dateString);
}

// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
    Console.WriteLine("\nStrings that could not be parsed: ");
    foreach (var badFormat in badFormats)
        Console.WriteLine($"   {badFormat}");
}
// Press "Run" to see the output.

System.Threading.Thread.CurrentThread.CurrentCulture <-
    System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"

let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()

printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
    match DateTime.TryParse dateString with
    | true, parsedDate ->
        printfn $"%-37s{dateString} %-19O{parsedDate}\n" 
    | _ ->
        badFormats.Add dateString

// Display strings that could not be parsed.
if badFormats.Count > 0 then
    printfn "\nStrings that could not be parsed: "
    for badFormat in badFormats do
        printfn $"   {badFormat}"
// Press "Run" to see the output.

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' The example displays the following output:
'       Date String                           Date               
'       
'       01/06/2013                            01/06/2013 00:00:00
'       01/06/13                              01/06/2013 00:00:00
'       1/6/13                                01/06/2013 00:00:00
'       1.6.13                                01/06/2013 00:00:00
'       2013-06-01                            01/06/2013 00:00:00
'       01 June 2013                          01/06/2013 00:00:00
'       1 June 2013                           01/06/2013 00:00:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       01 June                               01/06/2013 00:00:00
'       01 June                               01/06/2013 00:00:00
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       2013-06-01T12:32:30                   01/06/2013 12:32:30
'       12:32                                 22/04/2013 12:32:00
'       12:32                                 22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
'       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
'       June 2013                             01/06/2013 00:00:00
'       June 2013                             01/06/2013 00:00:00

Use los ParseExact métodos y TryParseExact para convertir una cadena que debe coincidir con un formato o formato concretos en un DateTime valor. Especifique una o varias cadenas de formato de fecha y hora como parámetro para el método de análisis. En el ejemplo siguiente se usa el TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método para convertir cadenas que deben tener un formato "aaaaMMdd" o un formato "HHmmss" en DateTime valores.

string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", "  20130816   ",
                   "115216", "521116", "  115216  " };
DateTime parsedDate;

foreach (var dateString in dateStrings)
{
    if (DateTime.TryParseExact(dateString, formats, null,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings = 
    [ "20130816"; "20131608"; "  20130816   "
      "115216"; "521116"; "  115216  " ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, null,
                                System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
                                System.Globalization.DateTimeStyles.AdjustToUniversal) with
    | true, parsedDate ->
        printfn $"{dateString} --> {parsedDate:g}"
    | _ ->
        printfn $"Cannot convert {dateString}"

// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' The example displays the following output:
'       20130816 --> 8/16/2013 12:00 AM
'       Cannot convert 20131608
'         20130816    --> 8/16/2013 12:00 AM
'       115216 --> 4/22/2013 11:52 AM
'       Cannot convert 521116
'         115216   --> 4/22/2013 11:52 AM

Un uso común para ParseExact es convertir una representación de cadena de un servicio web, normalmente en formato estándar ISO 8601 . En el código siguiente se muestra la cadena de formato correcta que se va a usar:

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");

let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

printfn $"{iso8601String} --> {dateISO8602:g}"

Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

Si no se puede analizar una cadena, los Parse métodos y ParseExact inician una excepción. Los TryParse métodos y TryParseExact devuelven un Boolean valor que indica si la conversión se realizó correctamente o no. Debe usar los TryParse métodos o TryParseExact en escenarios en los que el rendimiento es importante. La operación de análisis de cadenas de fecha y hora tiende a tener una alta tasa de errores y el control de excepciones es costoso. Use estos métodos si los usuarios escriben cadenas o proceden de un origen desconocido.

Para obtener más información sobre el análisis de valores de fecha y hora, vea Analizar cadenas de fecha y hora.

Valores dateTime

Las descripciones de los valores de hora del DateTime tipo se expresan a menudo mediante el estándar hora universal coordinada (UTC). La hora universal coordinada es el nombre reconocido internacionalmente por la hora media de Greenwich (GMT). La hora universal coordinada es la hora medida en longitud de cero grados, el punto de origen UTC. El horario de verano no es aplicable a utc.

La hora local es relativa a una zona horaria determinada. Una zona horaria está asociada a un desplazamiento de zona horaria. Un desplazamiento de zona horaria es el desplazamiento de la zona horaria medida en horas desde el punto de origen UTC. Además, la hora local se ve afectada opcionalmente por el horario de verano, lo que agrega o resta un ajuste de intervalo de tiempo. La hora local se calcula agregando el desplazamiento de zona horaria a UTC y ajustando el horario de verano si es necesario. El desplazamiento de zona horaria en el punto de origen UTC es cero.

La hora UTC es adecuada para cálculos, comparaciones y almacenamiento de fechas y hora en archivos. La hora local es adecuada para mostrarse en interfaces de usuario de aplicaciones de escritorio. Las aplicaciones compatibles con zona horaria (como muchas aplicaciones web) también deben trabajar con una serie de otras zonas horarias.

Si la Kind propiedad de un DateTime objeto es DateTimeKind.Unspecified, no se especifica si la hora representada es hora local, hora UTC o una hora en alguna otra zona horaria.

Resolución dateTime

Nota:

Como alternativa a realizar la aritmética de fecha y hora en DateTime valores para medir el tiempo transcurrido, puede usar la Stopwatch clase .

La Ticks propiedad expresa los valores de fecha y hora en unidades de un diez millones de segundos. La Millisecond propiedad devuelve las milésimas de segundo en un valor de fecha y hora. El uso de llamadas repetidas a la DateTime.Now propiedad para medir el tiempo transcurrido depende del reloj del sistema. El reloj del sistema en Windows 7 y Windows 8 sistemas tiene una resolución de aproximadamente 15 milisegundos. Esta resolución afecta a intervalos de tiempo pequeños inferiores a 100 milisegundos.

En el ejemplo siguiente se muestra la dependencia de los valores actuales de fecha y hora en la resolución del reloj del sistema. En el ejemplo, un bucle externo se repite 20 veces y un bucle interno sirve para retrasar el bucle externo. Si el valor del contador de bucle externo es 10, una llamada al Thread.Sleep método introduce un retraso de cinco milisegundos. En el ejemplo siguiente se muestra el número de milisegundos devueltos por la DateTime.Now.Milliseconds propiedad cambia solo después de la llamada a Thread.Sleep.

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.

let mutable output = ""
for i = 0 to 20 do
    output <- output + $"{DateTime.Now.Millisecond}\n"
    // Introduce a delay loop.
    for _ = 0 to 1000 do ()

    if i = 10 then
        output <- output + "Thread.Sleep called...\n"
        System.Threading.Thread.Sleep 5

printfn $"{output}"
// Press "Run" to see the output.

Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

Operaciones DateTime

Un cálculo mediante una DateTime estructura, como Add o Subtract, no modifica el valor de la estructura. En su lugar, el cálculo devuelve una nueva DateTime estructura cuyo valor es el resultado del cálculo.

Las operaciones de conversión entre zonas horarias (como entre utc y hora local, o entre una zona horaria y otra) tienen en cuenta el horario de verano, pero las operaciones de comparación y aritméticas no.

La DateTime propia estructura ofrece compatibilidad limitada para la conversión de una zona horaria a otra. Puede usar el ToLocalTime método para convertir UTC a la hora local, o bien puede usar el ToUniversalTime método para convertir de hora local a UTC. Sin embargo, un conjunto completo de métodos de conversión de zona horaria está disponible en la TimeZoneInfo clase . Convierte la hora en cualquiera de las zonas horarias del mundo a la hora en cualquier otra zona horaria mediante estos métodos.

Los cálculos y comparaciones de DateTime objetos solo son significativos si los objetos representan horas en la misma zona horaria. Puede usar un TimeZoneInfo objeto para representar la zona horaria de un DateTime valor, aunque los dos están acoplados de forma flexible. Un DateTime objeto no tiene una propiedad que devuelve un objeto que representa la zona horaria del valor de fecha y hora. La Kind propiedad indica si representa DateTime utc, hora local o no se especifica. En una aplicación compatible con zona horaria, debe confiar en algún mecanismo externo para determinar la zona horaria en la que se creó un DateTime objeto. Podría usar una estructura que encapsula el DateTime valor y el TimeZoneInfo objeto que representa la DateTime zona horaria del valor. Para obtener más información sobre el uso de UTC en cálculos y comparaciones con DateTime valores, vea Realizar operaciones aritméticas con fechas y horas.

Cada DateTime miembro usa implícitamente el calendario gregoriano para realizar su operación. Las excepciones son métodos que especifican implícitamente un calendario. Estos incluyen constructores que especifican un calendario y métodos con un parámetro derivado de IFormatProvider, como System.Globalization.DateTimeFormatInfo.

Las operaciones por miembros del DateTime tipo tienen en cuenta detalles como años bisiestos y el número de días en un mes.

Valores y calendarios dateTime

La biblioteca de clases de .NET incluye una serie de clases de calendario, todas ellas derivadas de la Calendar clase . Son las siguientes:

• La clase ChineseLunisolarCalendar.
• La clase EastAsianLunisolarCalendar.
• La clase GregorianCalendar.
• La clase HebrewCalendar.
• La clase HijriCalendar.
• La clase JapaneseCalendar.
• La clase JapaneseLunisolarCalendar.
• La clase JulianCalendar.
• La clase KoreanCalendar.
• La clase KoreanLunisolarCalendar.
• La clase PersianCalendar.
• La clase TaiwanCalendar.
• La clase TaiwanLunisolarCalendar.
• La clase ThaiBuddhistCalendar.
• La clase UmAlQuraCalendar.

Importante

Las eras en los calendarios japoneses se basan en el reino del emperador y, por tanto, se espera que cambien. Por ejemplo, el 1 de mayo de 2019 marcaba el comienzo de la era Reiwa en JapaneseCalendar y JapaneseLunisolarCalendar. Este cambio de era afecta a todas las aplicaciones que usan estos calendarios. Para obtener más información y determinar si las aplicaciones se ven afectadas, consulte Control de una nueva era en el calendario japonés en .NET. Para obtener información sobre cómo probar las aplicaciones en sistemas Windows para garantizar su preparación para el cambio de era, consulte Preparación de la aplicación para el cambio en la era japonesa. Para conocer las características de .NET que admiten calendarios con varias eras y procedimientos recomendados al trabajar con calendarios que admiten varias eras, consulte Trabajar con eras.

Cada referencia cultural usa un calendario predeterminado definido por su propiedad de solo CultureInfo.Calendar lectura. Cada referencia cultural puede admitir uno o varios calendarios definidos por su propiedad de solo CultureInfo.OptionalCalendars lectura. El calendario usado actualmente por un objeto específico CultureInfo se define mediante su DateTimeFormatInfo.Calendar propiedad . Debe ser uno de los calendarios que se encuentran en la CultureInfo.OptionalCalendars matriz.

El calendario actual de una referencia cultural se usa en todas las operaciones de formato de esa referencia cultural. Por ejemplo, el calendario predeterminado de la cultura budista tailandesa es el calendario de la era budista tailandesa, representado por la ThaiBuddhistCalendar clase . Cuando se usa un CultureInfo objeto que representa la cultura budista tailandesa en una operación de formato de fecha y hora, el calendario de la era budista tailandesa se usa de forma predeterminada. El calendario gregoriano solo se usa si se cambia la propiedad de DateTimeFormatInfo.Calendar la referencia cultural, como se muestra en el ejemplo siguiente:

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)

printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()

printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

El calendario actual de una referencia cultural también se usa en todas las operaciones de análisis de esa referencia cultural, como se muestra en el ejemplo siguiente.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

Se crea una instancia de un DateTime valor mediante los elementos de fecha y hora (número del año, mes y día) de un calendario específico llamando a un constructor DateTime que incluye un calendar parámetro y pasándolo un Calendar objeto que representa ese calendario. En el ejemplo siguiente se usan los elementos de fecha y hora del ThaiBuddhistCalendar calendario.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)

printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"Gregorian date:   {dat:d}"

// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime constructores que no incluyen un calendar parámetro asumen que los elementos de fecha y hora se expresan como unidades en el calendario gregoriano.

Todas las demás DateTime propiedades y métodos usan el calendario gregoriano. Por ejemplo, la DateTime.Year propiedad devuelve el año en el calendario gregoriano y el DateTime.IsLeapYear(Int32) método supone que el year parámetro es un año en el calendario gregoriano. Cada DateTime miembro que usa el calendario gregoriano tiene un miembro correspondiente de la Calendar clase que usa un calendario específico. Por ejemplo, el Calendar.GetYear método devuelve el año en un calendario específico y el Calendar.IsLeapYear método interpreta el year parámetro como un número de año en un calendario específico. En el ejemplo siguiente se usan los DateTime miembros y correspondientes de la ThaiBuddhistCalendar clase .

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"

printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"Leap year: {DateTime.IsLeapYear dat.Year}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

La DateTime estructura incluye una DayOfWeek propiedad que devuelve el día de la semana en el calendario gregoriano. No incluye un miembro que le permite recuperar el número de semana del año. Para recuperar la semana del año, llame al método del Calendar.GetWeekOfYear calendario individual. Esto se muestra en el ejemplo siguiente.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"

let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

Para obtener más información sobre las fechas y calendarios, vea Trabajar con calendarios.

Conservación de valores DateTime

Puede conservar DateTime los valores de las siguientes maneras:

• Conviértalos en cadenas y conserve las cadenas.
• Conviértalos en valores enteros de 64 bits (el valor de la Ticks propiedad) y conserve los enteros.
• Serialice los valores DateTime.

Debe asegurarse de que la rutina que restaura los DateTime valores no pierde datos ni produce una excepción independientemente de la técnica que elija. DateTime los valores deben realizar un recorrido de ida y vuelta. Es decir, el valor original y el valor restaurado deben ser los mismos. Y si el valor original DateTime representa un único instante de tiempo, debe identificar el mismo momento de tiempo cuando se restaura.

Conservación de valores como cadenas

Para restaurar DateTime correctamente los valores que se conservan como cadenas, siga estas reglas:

• Realice las mismas suposiciones sobre el formato específico de la referencia cultural al restaurar la cadena que al conservarla. Para asegurarse de que se puede restaurar una cadena en un sistema cuya referencia cultural actual es diferente de la referencia cultural del sistema en la que se guardó, llame a la ToString sobrecarga para guardar la cadena mediante las convenciones de la referencia cultural invariable. Llame a la Parse(String, IFormatProvider, DateTimeStyles) sobrecarga o TryParse(String, IFormatProvider, DateTimeStyles, DateTime) para restaurar la cadena mediante las convenciones de la referencia cultural invariable. Nunca use las ToString()sobrecargas , Parse(String)o TryParse(String, DateTime) , que usan las convenciones de la referencia cultural actual.

• Si la fecha representa un único momento de tiempo, asegúrese de que representa el mismo momento en el momento en que se restaura, incluso en una zona horaria diferente. Convierta el DateTime valor en hora universal coordinada (UTC) antes de guardarlo o use DateTimeOffset.

El error más común que se produce al conservar DateTime valores como cadenas es confiar en las convenciones de formato de la referencia cultural predeterminada o actual. Se producen problemas si la referencia cultural actual es diferente al guardar y restaurar las cadenas. En el ejemplo siguiente se muestran estos problemas. Guarda cinco fechas con las convenciones de formato de la referencia cultural actual, que en este caso es inglés (Estados Unidos). Restaura las fechas mediante las convenciones de formato de una referencia cultural diferente, que en este caso es inglés (Reino Unido). Dado que las convenciones de formato de las dos referencias culturales son diferentes, no se pueden restaurar dos de las fechas y las tres fechas restantes se interpretan incorrectamente. Además, si los valores de fecha y hora originales representan momentos únicos en el tiempo, las horas restauradas son incorrectas porque se pierde la información de zona horaria.

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string? output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParse(inputValue, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine($"Cannot parse '{inputValue}'");
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

let saveLocalDatesAsString () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date}"
            string date ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreLocalDatesFromString () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParse inputValue with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue:f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsLocalStrings () =
    saveLocalDatesAsString ()
    restoreLocalDatesFromString ()

// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       Cannot parse '6/14/2014 6:32:00 AM'
'       '7/10/2014 11:49:00 PM' --> 07 October 2014 23:49
'       '1/10/2015 1:16:00 AM' --> 01 October 2015 01:16
'       Cannot parse '12/20/2014 9:45:00 PM'
'       '6/2/2014 3:14:00 PM' --> 06 February 2014 15:14
'       Restored dates...

Para realizar un recorrido DateTime de ida y vuelta correctamente, siga estos pasos:

1. Si los valores representan momentos únicos de tiempo, conviértalos de la hora local a UTC llamando al ToUniversalTime método .
2. Convierta las fechas en sus representaciones de cadena llamando a la ToString(String, IFormatProvider) sobrecarga o String.Format(IFormatProvider, String, Object[]) . Use las convenciones de formato de la referencia cultural invariable especificando CultureInfo.InvariantCulture como argumento provider . Especifique que el valor debe realizar un recorrido de ida y vuelta mediante la cadena de formato estándar "O" o "R".

Para restaurar los valores persistentes DateTime sin pérdida de datos, siga estos pasos:

1. Analice los datos mediante una llamada a la ParseExact sobrecarga o TryParseExact . Especifique CultureInfo.InvariantCulture como argumento provider y use la misma cadena de formato estándar que usó para el argumento durante la format conversión. Incluya el DateTimeStyles.RoundtripKind valor en el styles argumento .
2. Si los DateTime valores representan momentos únicos en el tiempo, llame al ToLocalTime método para convertir la fecha analizada de UTC a hora local.

En el ejemplo siguiente se usa la referencia cultural invariable y la cadena de formato estándar "O" para asegurarse de que DateTime los valores guardados y restaurados representan el mismo momento en el tiempo, independientemente del sistema, la referencia cultural o la zona horaria de los sistemas de origen y destino.

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string? output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
                  + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                              DateTimeStyles.RoundtripKind, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{0}'", inputValue);
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

let saveDatesAsInvariantStrings () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreDatesAsInvariantStrings () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    
    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsInvariantStrings () =
    saveDatesAsInvariantStrings ()
    restoreDatesAsInvariantStrings ()

// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
'       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
'       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
'       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
'       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
'       Restored dates...

Conservación de valores como enteros

Puede conservar una fecha y hora como un Int64 valor que represente una serie de tics. En este caso, no es necesario tener en cuenta la referencia cultural de los sistemas en los que se conservan y restauran los DateTime valores.

Para conservar un DateTime valor como un entero:

• Si los DateTime valores representan momentos únicos en el tiempo, conviértalos en UTC llamando al ToUniversalTime método .
• Recupere el número de tics representados por el DateTime valor de su Ticks propiedad .

Para restaurar un DateTime valor que se ha conservado como un entero:

1. Cree una instancia de un nuevo DateTime objeto pasando el Int64 valor al DateTime(Int64) constructor.
2. Si el DateTime valor representa un único momento en el tiempo, conviértelo de UTC a la hora local llamando al ToLocalTime método .

En el ejemplo siguiente se conserva una matriz de DateTime valores como enteros en un sistema de la zona horaria del Pacífico de EE. UU. Lo restaura en un sistema en la zona UTC. El archivo que contiene los enteros incluye un Int32 valor que indica el número total de Int64 valores que lo siguen inmediatamente.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var ticks = new long[dates.Length];
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var bw = new BinaryWriter(fs);
    bw.Write(ticks.Length);
    foreach (var tick in ticks)
        bw.Write(tick);

    bw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, FileMode.Open);
    BinaryReader br = new BinaryReader(fs);
    int items;
    DateTime[] dates;

    try
    {
        items = br.ReadInt32();
        dates = new DateTime[items];

        for (int ctr = 0; ctr < items; ctr++)
        {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
        }
    }
    catch (EndOfStreamException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    catch (IOException)
    {
        Console.WriteLine("Unspecified I/O error. Unable to restore data...");
        return;
    }
    // Thrown during array initialization.
    catch (OutOfMemoryException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    finally
    {
        br.Close();
    }

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

let saveDatesAsInts () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    let ticks =
        [| for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().Ticks |]
    use fs = new FileStream(filenameInts, FileMode.Create)
    use bw = new BinaryWriter(fs)
    bw.Write ticks.Length

    for tick in ticks do
        bw.Write tick

    printfn "Saved dates..."

let restoreDatesAsInts () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    use fs = new FileStream(filenameInts, FileMode.Open)
    use br = new BinaryReader(fs)

    try
        let items = br.ReadInt32()
        let dates =
            [| for _ in 0..items do
                let ticks = br.ReadInt64()
                DateTime(ticks).ToLocalTime() |]

        printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
        for value in dates do
            printfn $"{value:f}"
    with 
    | :? EndOfStreamException ->
        printfn "File corruption detected. Unable to restore data..."
    | :? IOException ->
        printfn "Unspecified I/O error. Unable to restore data..."
    // Thrown during array initialization.
    | :? OutOfMemoryException ->
        printfn"File corruption detected. Unable to restore data..."

    printfn "Restored dates..."

let persistAsIntegers () =
    saveDatesAsInts ()
    restoreDatesAsInts ()

// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       14 June 2014 14:32
'       11 July 2014 07:49
'       10 January 2015 09:16
'       21 December 2014 05:45
'       02 June 2014 23:14
'       Restored dates...

Serialización de valores DateTime

Puede conservar DateTime los valores mediante la serialización en una secuencia o archivo y, a continuación, restaurarlos mediante la deserialización. DateTime los datos se serializan en algún formato de objeto especificado. Los objetos se restauran cuando se deserializan. Un formateador o serializador, como XmlSerializer o BinaryFormatter, controla el proceso de serialización y deserialización. Para obtener más información sobre la serialización y los tipos de serialización admitidos por .NET Framework, consulte Serialización.

En el ejemplo siguiente se usa la XmlSerializer clase para serializar y deserializar DateTime valores. Los valores representan todos los días bisiesto del año en el siglo XXI. La salida representa el resultado si el ejemplo se ejecuta en un sistema cuya referencia cultural actual es inglés (Reino Unido). Dado que ha deserializado el DateTime propio objeto, el código no tiene que controlar las diferencias culturales en formatos de fecha y hora.

public static void PersistAsXML()
{
    // Serialize the data.
    var leapYears = new List<DateTime>();
    for (int year = 2000; year <= 2100; year += 4)
    {
        if (DateTime.IsLeapYear(year))
            leapYears.Add(new DateTime(year, 2, 29));
    }
    DateTime[] dateArray = leapYears.ToArray();

    var serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(filenameXml);

    try
    {
        serializer.Serialize(sw, dateArray);
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.InnerException?.Message);
    }
    finally
    {
        if (sw != null) sw.Close();
    }

    // Deserialize the data.
    DateTime[]? deserializedDates;
    using (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[]?)serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    if (deserializedDates is not null)
    {
        foreach (var dat in deserializedDates)
        {
            Console.Write($"   {dat:d}     ");
            nItems++;
            if (nItems % 5 == 0)
                Console.WriteLine();
        }
    }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

let persistAsXML () =
    // Serialize the data.
    let leapYears =
        [| for year in 2000..4..2100 do
            if DateTime.IsLeapYear year then
                DateTime(year, 2, 29) |]

    let serializer = XmlSerializer(leapYears.GetType())
    use sw = new StreamWriter(filenameXml)

    try
        serializer.Serialize(sw, leapYears)
    with :? InvalidOperationException as e ->
        printfn $"{e.InnerException.Message}"

    // Deserialize the data.
    use fs = new FileStream(filenameXml, FileMode.Open)
        
    let deserializedDates = serializer.Deserialize fs :?> DateTime []

    // Display the dates.
    printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    let mutable nItems = 0
    for dat in deserializedDates do
        printf $"   {dat:d}     "
        nItems <- nItems + 1
        if nItems % 5 = 0 then
            printfn ""

// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' The example displays the following output:
'    Leap year days from 2000-2100 on an en-GB system:
'       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
'       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
'       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
'       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
'       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

En el ejemplo anterior no se incluye información de tiempo. Si un DateTime valor representa un momento en el tiempo y se expresa como una hora local, conviértelo de hora local a UTC antes de serializarlo llamando al ToUniversalTime método . Después de deserializarla, conviértela de UTC a hora local llamando al ToLocalTime método .

DateTime frente a TimeSpan

Los DateTime tipos de valor y TimeSpan difieren en que DateTime un objeto representa un instante en el tiempo, mientras que un TimeSpan representa un intervalo de tiempo. Puede restar una instancia de de DateTime otra para obtener un TimeSpan objeto que represente el intervalo de tiempo entre ellos. O bien, podría agregar un positivo TimeSpan al actual DateTime para obtener un DateTime valor que represente una fecha futura.

Puede agregar o restar un intervalo de tiempo de un DateTime objeto . Los intervalos de tiempo pueden ser negativos o positivos, y se pueden expresar en unidades como tics, segundos o como un TimeSpan objeto.

Comparación de la igualdad dentro de la tolerancia

Las comparaciones de igualdad de DateTime los valores son exactas. Esto significa que se deben expresar dos valores como el mismo número de tics que se deben considerar iguales. Esa precisión suele ser innecesaria o incluso incorrecta para muchas aplicaciones. A menudo, quiere probar si DateTime los objetos son aproximadamente iguales.

En el ejemplo siguiente se muestra cómo comparar valores aproximadamente equivalentes DateTime . Acepta un pequeño margen de diferencia al declararlos iguales.

public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
    long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
    delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
    return Math.Abs(delta) < windowInSeconds;
}

public static void TestRoughlyEquals()
{
    int window = 10;
    int freq = 60 * 60 * 2; // 2 hours;

    DateTime d1 = DateTime.Now;

    DateTime d2 = d1.AddSeconds(2 * window);
    DateTime d3 = d1.AddSeconds(-2 * window);
    DateTime d4 = d1.AddSeconds(window / 2);
    DateTime d5 = d1.AddSeconds(-window / 2);

    DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
    DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
    DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
    DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
    let delta = 
        int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
    
    let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
    abs delta < windowInSeconds

let testRoughlyEquals () =
    let window = 10
    let window' = 10.
    let freq = 60 * 60 * 2 // 2 hours

    let d1 = DateTime.Now

    let d2 = d1.AddSeconds(2. * window')
    let d3 = d1.AddSeconds(-2. * window')
    let d4 = d1.AddSeconds(window' / 2.)
    let d5 = d1.AddSeconds(-window' / 2.)

    let d6 = (d1.AddHours 2).AddSeconds(2. * window')
    let d7 = (d1.AddHours 2).AddSeconds(-2. * window')
    let d8 = (d1.AddHours 2).AddSeconds(window' / 2.)
    let d9 = (d1.AddHours 2).AddSeconds(-window' / 2.)

    printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
    printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
    printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
    printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
    printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"

    printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
    printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
    printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
    printfn $"d1 ({d1}) ~= d9 ({d9}): {roughlyEquals d1 d9 window freq}"

// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

    Dim d2 As DateTime = d1.AddSeconds(2 * window)
    Dim d3 As DateTime = d1.AddSeconds(-2 * window)
    Dim d4 As DateTime = d1.AddSeconds(window / 2)
    Dim d5 As DateTime = d1.AddSeconds(-window / 2)

    Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
    Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
    Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
    Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
'    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Consideraciones de interoperabilidad COM

Un DateTime valor que se transfiere a una aplicación COM y, a continuación, se transfiere de vuelta a una aplicación administrada, se dice que realiza un recorrido de ida y vuelta. Sin embargo, un DateTime valor que especifica solo una hora no realiza el recorrido de ida y vuelta como cabría esperar.

Si solo realiza un recorrido de ida y vuelta, como 3 p.m., la fecha y hora finales es el 30 de diciembre de 1899 C.E. a las 3:00 p.m., en lugar del 1 de enero de 0001 C.E. a las 3:00 p.m. .NET Framework y COM asumen una fecha predeterminada cuando solo se especifica una hora. Sin embargo, el sistema COM asume una fecha base del 30 de diciembre de 1899 C.E., mientras que .NET Framework asume una fecha base del 1 de enero de 0001 C.E.

Cuando solo se pasa una hora de .NET Framework a COM, se realiza un procesamiento especial que convierte la hora al formato utilizado por COM. Cuando solo se pasa una hora de COM a .NET Framework, no se realiza ningún procesamiento especial porque eso dañaría las fechas y horas legítimas el 30 de diciembre de 1899 o antes. Si una fecha inicia su recorrido de ida y vuelta desde COM, .NET Framework y COM conservan la fecha.

El comportamiento de .NET Framework y COM significa que si la aplicación solo DateTime especifica una hora, la aplicación debe recordar modificar o omitir la fecha errónea del objeto final DateTime .

Constructores

DateTime(Int32, Int32, Int32)	Inicializa una nueva instancia de la estructura DateTime en el año, mes y día especificados.
DateTime(Int32, Int32, Int32, Calendar)	Inicializa una nueva instancia de la estructura DateTime en el año, mes y día especificados para el calendario determinado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto y segundo especificados.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto y segundo especificados para el calendario indicado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo y hora universal coordinada (UTC) u hora local especificados.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo y milisegundo especificados.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo y milisegundo especificados para el calendario indicado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo, y hora universal coordinada (UTC) u hora local especificados para el calendario indicado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo y hora universal coordinada (UTC) u hora local especificados.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo, y hora universal coordinada (UTC) u hora local especificados para el calendario indicado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo, y hora universal coordinada (UTC) u hora local especificados para el calendario indicado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo, y hora universal coordinada (UTC) u hora local especificados para el calendario indicado.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo, y hora universal coordinada (UTC) u hora local especificados para el calendario indicado.
DateTime(Int64)	Inicializa una nueva instancia de la estructura DateTime en un número de pasos especificado.
DateTime(Int64, DateTimeKind)	Inicializa una nueva instancia de la estructura DateTime en el número de pasos y hora universal coordinada (UTC) u hora local especificados.

Campos

MaxValue	Representa el mayor valor posible de DateTime. Este campo es de solo lectura.
MinValue	Representa el menor valor posible de DateTime. Este campo es de solo lectura.
UnixEpoch	El valor de esta constante es equivalente a 00:00:00.0000000 UTC, 1 de enero de 1970, en el calendario gregoriano. UnixEpoch define el momento dado en el que la hora de Unix es igual a 0.

Propiedades

Date	Obtiene el componente correspondiente a la fecha de esta instancia.
Day	Obtiene el día del mes representado por esta instancia.
DayOfWeek	Obtiene el día de la semana representado por esta instancia.
DayOfYear	Obtiene el día del año representado por esta instancia.
Hour	Obtiene el componente correspondiente a la hora de la fecha representada por esta instancia.
Kind	Obtiene un valor que indica si la hora representada por esta instancia está basada en la hora local, en la hora universal coordinada (UTC), o en ninguna de ellas.
Microsecond	Componente microsegundos, expresado como un valor entre 0 y 999.
Millisecond	Obtiene el componente correspondiente a los milisegundos de la fecha representada por esta instancia.
Minute	Obtiene el componente correspondiente a los minutos de la fecha representada por esta instancia.
Month	Obtiene el componente correspondiente al mes de la fecha representada por esta instancia.
Nanosecond	Componente nanosegundos, expresado como un valor entre 0 y 900 (en incrementos de 100 nanosegundos).
Now	Obtiene un objeto DateTime que se establece en la fecha y hora actual de este equipo, expresada como hora local.
Second	Obtiene el componente correspondiente a los segundos de la fecha representada por esta instancia.
Ticks	Obtiene el número de pasos que representan la fecha y hora de esta instancia.
TimeOfDay	Obtiene la hora del día para esta instancia.
Today	Obtiene la fecha actual.
UtcNow	Obtiene un objeto DateTime que se establece en la fecha y hora actual del equipo, expresada como hora universal coordinada (UTC).
Year	Obtiene el componente correspondiente al año de la fecha representada por esta instancia.

Métodos

Add(TimeSpan)	Devuelve un nuevo objeto DateTime que suma el valor del objeto TimeSpan especificado al valor de esta instancia.
AddDays(Double)	Devuelve un nuevo objeto DateTime que suma el número especificado de días al valor de esta instancia.
AddHours(Double)	Devuelve un nuevo objeto DateTime que suma el número especificado de horas al valor de esta instancia.
AddMicroseconds(Double)	Devuelve un nuevo DateTime objeto que agrega el número especificado de microsegundos al valor de esta instancia.
AddMilliseconds(Double)	Devuelve un nuevo objeto DateTime que suma el número especificado de milisegundos al valor de esta instancia.
AddMinutes(Double)	Devuelve un nuevo objeto DateTime que suma el número especificado de minutos al valor de esta instancia.
AddMonths(Int32)	Devuelve un nuevo objeto DateTime que suma el número especificado de meses al valor de esta instancia.
AddSeconds(Double)	Devuelve un nuevo objeto DateTime que suma el número especificado de segundos al valor de esta instancia.
AddTicks(Int64)	Devuelve un nuevo objeto DateTime que suma el número especificado de pasos al valor de esta instancia.
AddYears(Int32)	Devuelve un nuevo objeto DateTime que suma el número especificado de años al valor de esta instancia.
Compare(DateTime, DateTime)	Compara dos instancias de DateTime y devuelve un entero que indica si la primera instancia es anterior, igual o posterior a la segunda instancia.
CompareTo(DateTime)	Compara el valor de esta instancia con un valor de DateTime especificado y devuelve un entero que indica si esta instancia es anterior, igual o posterior al valor de DateTime especificado.
CompareTo(Object)	Compara el valor de esta instancia con un objeto especificado que contiene un valor de DateTime especificado y devuelve un entero que indica si esta instancia es anterior, igual o posterior al valor de DateTime especificado.
DaysInMonth(Int32, Int32)	Devuelve el número de días del mes y año especificados.
Equals(DateTime)	Devuelve un valor que indica si el valor de esta instancia equivale al valor de la instancia de DateTime especificada.
Equals(DateTime, DateTime)	Devuelve un valor que indica si dos DateTime instancias tienen el mismo valor de fecha y hora.
Equals(Object)	Devuelve un valor que indica si esta instancia equivale a un objeto especificado.
FromBinary(Int64)	Deserializa un valor binario de 64 bits y vuelve a crear un objeto DateTime serializado original.
FromFileTime(Int64)	Convierte la hora de archivo de Windows especificada en una hora local equivalente.
FromFileTimeUtc(Int64)	Convierte la hora de archivo de Windows especificada en una hora UTC equivalente.
FromOADate(Double)	Devuelve un DateTime que equivale a la fecha de automatización OLE especificada.
GetDateTimeFormats()	Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por los especificadores de formato de fecha y hora estándar.
GetDateTimeFormats(Char)	Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por el especificador de formato de fecha y hora estándar indicado.
GetDateTimeFormats(Char, IFormatProvider)	Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por el especificador de formato de fecha y hora estándar y la información de formato específica de la referencia cultural especificados.
GetDateTimeFormats(IFormatProvider)	Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por los especificadores de formato de fecha y hora estándar y la información de formato específica de la referencia cultural especificada.
GetHashCode()	Devuelve el código hash de esta instancia.
GetTypeCode()	Devuelve el TypeCode para el tipo de valor DateTime.
IsDaylightSavingTime()	Indica si esta instancia de DateTime está dentro del intervalo del horario de verano de la zona horaria actual.
IsLeapYear(Int32)	Devuelve una indicación en la que se precisa si el año especificado es bisiesto.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convierte un intervalo de memoria que contiene una representación de cadena de una fecha y hora en el objeto DateTime equivalente mediante la información de formato específica de la referencia cultural y un estilo de formato especificados.
Parse(String)	Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante las convenciones de la referencia cultural actual.
Parse(String, IFormatProvider)	Convierte la representación de cadena para una fecha y hora en su DateTime equivalente, usando la información de formato específica de la referencia cultural especificada.
Parse(String, IFormatProvider, DateTimeStyles)	Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y un estilo de formato especificados.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante la matriz especificada de formatos, información de formato específica de la referencia cultural y estilo. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.
ParseExact(String, String, IFormatProvider)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y el formato que se hayan especificado. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la matriz de formatos, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.
SpecifyKind(DateTime, DateTimeKind)	Crea un nuevo objeto DateTime que tiene el mismo número de pasos que el objeto DateTime especificado, pero en hora local, en hora universal coordinada (UTC) o en ninguna de ellas, según indique el valor de DateTimeKind especificado.
Subtract(DateTime)	Devuelve un nuevo objeto TimeSpan que resta la fecha y hora especificadas del valor de esta instancia.
Subtract(TimeSpan)	Devuelve un nuevo objeto DateTime que resta la duración especificada del valor de esta instancia.
ToBinary()	Serializa el objeto DateTime actual a un valor binario de 64 bits que se puede usar después para volver a crear el objeto DateTime.
ToFileTime()	Convierte el valor del objeto DateTime actual en una hora de archivo de Windows.
ToFileTimeUtc()	Convierte el valor del objeto DateTime actual en una hora de archivo de Windows.
ToLocalTime()	Convierte el valor del objeto DateTime actual a la hora local.
ToLongDateString()	Convierte el valor del objeto DateTime actual en su representación de cadena de fecha larga equivalente.
ToLongTimeString()	Convierte el valor del objeto DateTime actual en su representación de cadena de hora larga equivalente.
ToOADate()	Convierte el valor de esta instancia en la fecha de Automation OLE equivalente.
ToShortDateString()	Convierte el valor del objeto DateTime actual en su representación de cadena de fecha corta equivalente.
ToShortTimeString()	Convierte el valor del objeto DateTime actual en su representación de cadena de hora corta equivalente.
ToString()	Convierte el valor del objeto DateTime actual en su representación de cadena equivalente mediante las convenciones de formato de la referencia cultural actual.
ToString(IFormatProvider)	Convierte el valor del objeto DateTime actual en su representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.
ToString(String)	Convierte el valor del objeto DateTime actual en su representación de cadena equivalente mediante el formato especificado y las convenciones de formato de la referencia cultural actual.
ToString(String, IFormatProvider)	Convierte el valor del objeto DateTime actual en la representación de cadena equivalente usando el formato y la información de formato específica de la referencia cultural especificados.
ToUniversalTime()	Convierte el valor del objeto DateTime actual a la hora universal coordinada (UTC).
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia de fecha y hora actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Char>, DateTime)	Convierte el intervalo de caracteres especificado de una fecha y hora en su valor DateTime equivalente y devuelve un valor que indica si la conversión se ha realizado correctamente.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Intenta analizar un intervalo de caracteres en un valor.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de intervalo de una fecha y hora en su valor DateTime equivalente mediante la información de formato de la referencia cultural y el estilo de formato especificados, y devuelve un valor que indica si la conversión se ha realizado correctamente.
TryParse(String, DateTime)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente y devuelve un valor que indica si la conversión se realizó correctamente.
TryParse(String, IFormatProvider, DateTime)	Intenta analizar una cadena en un valor.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de cadena especificada de una fecha y hora en su equivalente DateTime usando la información de formato de la referencia cultural y el estilo de formato especificados, y devuelve un valor que indica si la conversión tuvo éxito.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. El método devuelve un valor que indica si la conversión se realizó correctamente.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Convierte el intervalo de caracteres especificado de una fecha y hora en su valor DateTime equivalente y devuelve un valor que indica si la conversión se ha realizado correctamente.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. El método devuelve un valor que indica si la conversión se realizó correctamente.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la matriz de formatos, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con al menos uno de los formatos especificados. El método devuelve un valor que indica si la conversión se realizó correctamente.

Operadores

Addition(DateTime, TimeSpan)	Agrega un intervalo de tiempo especificado a una fecha y hora especificadas, generando una fecha y hora nuevas.
Equality(DateTime, DateTime)	Determina si dos instancias especificadas de DateTime son iguales.
GreaterThan(DateTime, DateTime)	Determina si un DateTime especificado es posterior a otro DateTime especificado.
GreaterThanOrEqual(DateTime, DateTime)	Determina si un DateTime especificado representa una fecha y hora que es el igual o posterior a otro DateTime especificado.
Inequality(DateTime, DateTime)	Determina si dos instancias especificadas de DateTime no son iguales.
LessThan(DateTime, DateTime)	Determina si un DateTime especificado es anterior a otro DateTime especificado.
LessThanOrEqual(DateTime, DateTime)	Determina si un DateTime especificado representa una fecha y hora que es el igual o anterior a otro DateTime especificado.
Subtraction(DateTime, DateTime)	Resta una fecha y hora especificadas de otra fecha y hora especificadas y devuelve un intervalo de tiempo.
Subtraction(DateTime, TimeSpan)	Resta un intervalo de tiempo especificado de un valor de fecha y hora especificado y devuelve un nuevo valor de fecha y hora.

Implementaciones de interfaz explícitas

IConvertible.ToBoolean(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToByte(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToChar(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Devuelve el objeto DateTime actual.
IConvertible.ToDecimal(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToInt32(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToInt64(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToSByte(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToSingle(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Convierte el objeto DateTime actual en un objeto de un tipo especificado.
IConvertible.ToUInt16(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToUInt32(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToUInt64(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto DateTime actual.

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que parecen modificar el estado de la instancia devuelven realmente una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo deben estar protegidas por un bloqueo para garantizar la seguridad de los subprocesos.

Consulte también

• DateTimeOffset
• TimeSpan
• Calendar
• GetUtcOffset(DateTime)
• TimeZoneInfo
• Elección entre DateTime, DateTimeOffset, TimeSpan y TimeZoneInfo
• Trabajar con calendarios
• Ejemplo: Utilidad de formato WinForms de .NET Core (C#)
• Ejemplo: Utilidad de formato WinForms de .NET Core (Visual Basic)