Verifica se a una variabile DateTime è stato assegnato un valore

Esiste un modo semplice in C # per verificare se a un'istanza di DateTime è stato assegnato un valore o no?

L'unico modo per avere una variabile a cui non è stato assegnato un valore in C # è che sia una variabile locale - nel qual caso in fase di compilazione puoi dire che non è definitivamente assegnata cercando di leggere da essa: )

Ho il sospetto che tu voglia davvero Nullable<DateTime>(o DateTime?con lo zucchero sintattico C #) - fai in modo che nullinizi e poi assegni un DateTimevalore normale (che verrà convertito in modo appropriato). Quindi puoi solo confrontare con null(o utilizzare la HasValueproprietà) per vedere se è stato impostato un valore "reale".

vuoi dire così:

DateTime datetime = new DateTime();

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

oppure potresti usare Nullable

DateTime? datetime = null;

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

metti questo da qualche parte:

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

poi:

DateTime datetime = ...;

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

DateTime è un tipo di valore, quindi non può mai essere nullo. Se pensi che DateTime? (Nullable) è possibile utilizzare:

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

Ho appena scoperto che GetHashCode () per un datetime non assegnato è sempre zero. Non sono sicuro se questo è un buon modo per verificare la presenza di un datetime nullo, perché non riesco a trovare alcuna documentazione sul motivo per cui questo comportamento viene visualizzato.

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

Utilizzare Nullable<DateTime>se possibile.

Direi che il valore predefinito è sempre new DateTime(). Quindi possiamo scrivere

DateTime datetime;

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

In genere preferisco, ove possibile, utilizzare il valore predefinito dei tipi di valore per determinare se sono stati impostati. Questo ovviamente non è sempre possibile, specialmente con ints - ma per DateTimes, penso che riservare MinValue per indicare che non è stato modificato sia abbastanza giusto. Il vantaggio di questo su nullable è che c'è un posto in meno in cui otterrai un'eccezione di riferimento null (e probabilmente molti posti in cui non è necessario verificare la presenza di null prima di accedervi!)

Se non vuoi preoccuparti di problemi di valore Null come il controllo di null ogni volta che lo usi o lo avvolgi in una logica, e non devi preoccuparti di problemi di tempo di offset, allora questo è come ho risolto il problema:

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

Controllo solo che il valore predefinito sia inferiore a un giorno dopo l'inizio del tempo. Funziona come un fascino.