Verificando se uma variável DateTime teve um valor atribuído

Existe uma maneira fácil no C # para verificar se uma instância DateTime foi atribuída a um valor ou não?

A única maneira de ter uma variável que não foi atribuída a um valor em C # é que ela seja uma variável local - nesse caso, no tempo de compilação, você pode dizer que ela não é definitivamente atribuída tentando ler a partir dela: )

Eu suspeito que você realmente deseja Nullable<DateTime>(ou DateTime?com o açúcar sintático em C #) - faça com que nullcomece e atribua um DateTimevalor normal (que será convertido adequadamente). Em seguida, você pode simplesmente comparar com null(ou usar a HasValuepropriedade) para ver se um valor "real" foi definido.

você quer dizer assim:

DateTime datetime = new DateTime();

if (datetime == DateTime.MinValue)
{
    //unassigned
}

ou você pode usar Nullable

DateTime? datetime = null;

 if (!datetime.HasValue)
 {
     //unassigned
 }

coloque isso em algum lugar:

public static class DateTimeUtil //or whatever name
{
    public static bool IsEmpty(this DateTime dateTime)
    {
        return dateTime == default(DateTime);
    }
}

então:

DateTime datetime = ...;

if (datetime.IsEmpty())
{
    //unassigned
}

DateTime é o tipo de valor, portanto, nunca pode ser nulo. Se você acha o DateTime? (Anulável), você pode usar:

DateTime? something = GetDateTime();
bool isNull = (something == null);
bool isNull2 = !something.HasValue;

Acabei de descobrir que GetHashCode () para um datetime não atribuído é sempre zero. Não tenho certeza se essa é uma boa maneira de verificar se há data e hora nulas, porque não consigo encontrar nenhuma documentação sobre por que esse comportamento é exibido.

if(dt.GetHashCode()==0)
{
    Console.WriteLine("DateTime is unassigned"); 
} 

Use Nullable<DateTime>se possível.

Eu diria que o valor padrão é sempre new DateTime(). Para que possamos escrever

DateTime datetime;

if (datetime == new DateTime())
{
    //unassigned
}

Geralmente, prefiro, sempre que possível, usar o valor padrão dos tipos de valor para determinar se eles foram definidos. Obviamente, isso não é possível o tempo todo, especialmente com ints - mas para DateTimes, acho que reservar o MinValue para significar que não foi alterado é justo o suficiente. O benefício disso em relação às nuláveis ​​é que há um local a menos em que você obterá uma exceção de referência nula (e provavelmente em muitos lugares em que não é necessário procurar nulo antes de acessá-lo!)

Se você não precisa se preocupar com problemas de valor nulo, como verificar nulo toda vez que usá-lo ou agrupá-lo em alguma lógica, e também não deseja se preocupar com problemas de tempo de compensação, então isso é como eu resolvi o problema:

startDate = startDate < DateTime.MinValue.AddDays(1) ? keepIt : resetIt

Acabei de verificar se o valor padrão é inferior a um dia após o início dos tempos. Funciona como um encanto.