Jak sformatować nullable DateTime za pomocą ToString ()?

Przymierz to dla rozmiaru:

Rzeczywisty obiekt dateTime, który chcesz sformatować, znajduje się w dt.Właściwość Value, a nie na samym obiekcie dt2.

DateTime? dt2 = DateTime.Now;
 Console.WriteLine(dt2.HasValue ? dt2.Value.ToString("yyyy-MM-dd hh:mm:ss") : "[N/A]");

Jak stwierdzili inni, musisz sprawdzić czy nie ma null przed wywołaniem ToString, ale aby uniknąć powtarzania się, możesz utworzyć metodę rozszerzenia, która to robi, coś w stylu:

public static class DateTimeExtensions {

  public static string ToStringOrDefault(this DateTime? source, string format, string defaultValue) {
    if (source != null) {
      return source.Value.ToString(format);
    }
    else {
      return String.IsNullOrEmpty(defaultValue) ?  String.Empty : defaultValue;
    }
  }

  public static string ToStringOrDefault(this DateTime? source, string format) {
       return ToStringOrDefault(source, format, null);
  }

}

Które można wywołać jak:

DateTime? dt = DateTime.Now;
dt.ToStringOrDefault("yyyy-MM-dd hh:mm:ss");  
dt.ToStringOrDefault("yyyy-MM-dd hh:mm:ss", "n/a");
dt = null;
dt.ToStringOrDefault("yyyy-MM-dd hh:mm:ss", "n/a")  //outputs 'n/a'

Skończyliście z projektowaniem tego wszystkiego i czyniąc to bardziej skomplikowanym, niż naprawdę jest. Ważne, przestań używać ToString i zacznij formatować string jak string.Formatowanie lub metody obsługujące formatowanie łańcuchów, takie jak konsola.WriteLine. Oto preferowane rozwiązanie tego pytania. Jest to również najbezpieczniejsze.

DateTime? dt1 = DateTime.Now;
DateTime? dt2 = null;

Console.WriteLine("'{0:yyyy-MM-dd hh:mm:ss}'", dt1);
Console.WriteLine("'{0:yyyy-MM-dd hh:mm:ss}'", dt2);

Wyjście: (umieszczam w nim pojedyncze cudzysłowy, abyś mógł zobaczyć, że wraca jako pusty łańcuch, gdy null)

'2014-01-22 09:41:32'
''

C# 6.0 baby:

dt2?.ToString("dd/MM/yyyy");

Problem z formułowaniem odpowiedzi na to pytanie polega na tym, że nie określa się żądanego wyniku, gdy nullable datetime nie ma wartości. Poniższy kod wyświetli DateTime.MinValue w takim przypadku i w przeciwieństwie do aktualnie akceptowanej odpowiedzi, nie wyrzuci wyjątku.

dt2.GetValueOrDefault().ToString(format);

Widząc, że naprawdę chcesz podać format, sugeruję dodanie interfejsu IFormattable do metody rozszerzenia Smalls w ten sposób, w ten sposób nie masz paskudnej konkatenacji formatu string.

public static string ToString<T>(this T? variable, string format, string nullValue = null)
where T: struct, IFormattable
{
  return (variable.HasValue) 
         ? variable.Value.ToString(format, null) 
         : nullValue;          //variable was null so return this value instead   
}

Możesz użyć dt2.Value.ToString("format"), ale oczywiście wymaga to DT2 != null, a to neguje użycie typu nullable w pierwszej kolejności.

Istnieje kilka rozwiązań, ale pytanie brzmi: jak chcesz sformatować null datę?

Oto bardziej ogólne podejście. Pozwoli Ci to sformatować dowolny typ wartości nullable. Dodałem drugą metodę pozwalającą na nadpisanie domyślnej wartości ciągu zamiast używania domyślnej wartości dla typu value.

public static class ExtensionMethods
{
    public static string ToString<T>(this Nullable<T> nullable, string format) where T : struct
    {
        return String.Format("{0:" + format + "}", nullable.GetValueOrDefault());
    }

    public static string ToString<T>(this Nullable<T> nullable, string format, string defaultValue) where T : struct
    {
        if (nullable.HasValue) {
            return String.Format("{0:" + format + "}", nullable.Value);
        }

        return defaultValue;
    }
}

A co z czymś tak łatwym jak to:

String.Format("{0:dd/MM/yyyy}", d2)

Najkrótsza odpowiedź

$"{dt:yyyy-MM-dd hh:mm:ss}"

Testy

DateTime dt1 = DateTime.Now;
Console.Write("Test 1: ");
Console.WriteLine($"{dt1:yyyy-MM-dd hh:mm:ss}"); //works

DateTime? dt2 = DateTime.Now;
Console.Write("Test 2: ");
Console.WriteLine($"{dt2:yyyy-MM-dd hh:mm:ss}"); //Works

DateTime? dt3 = null;
Console.Write("Test 3: ");
Console.WriteLine($"{dt3:yyyy-MM-dd hh:mm:ss}"); //Works - Returns empty string

Output
Test 1: 2017-08-03 12:38:57
Test 2: 2017-08-03 12:38:57
Test 3: 

Myślę, że musisz użyć metody GetValueOrDefault. Zachowanie z Tostringiem ("yy...") nie jest zdefiniowana, jeśli instancja ma wartość null.

dt2.GetValueOrDefault().ToString("yyy...");

Składnia Razora:

@(myNullableDateTime?.ToString("yyyy-MM-dd") ?? String.Empty)

Iformattable zawiera również dostawcę formatów, który może być używany, pozwala zarówno format IFormatProvider być null w dotnet 4.0 to byłoby

/// <summary>
/// Extentionclass for a nullable structs
/// </summary>
public static class NullableStructExtensions {

    /// <summary>
    /// Formats a nullable struct
    /// </summary>
    /// <param name="source"></param>
    /// <param name="format">The format string 
    /// If <c>null</c> use the default format defined for the type of the IFormattable implementation.</param>
    /// <param name="provider">The format provider 
    /// If <c>null</c> the default provider is used</param>
    /// <param name="defaultValue">The string to show when the source is <c>null</c>. 
    /// If <c>null</c> an empty string is returned</param>
    /// <returns>The formatted string or the default value if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source, string format = null, 
                                     IFormatProvider provider = null, 
                                     string defaultValue = null) 
                                     where T : struct, IFormattable {
        return source.HasValue
                   ? source.Value.ToString(format, provider)
                   : (String.IsNullOrEmpty(defaultValue) ? String.Empty : defaultValue);
    }
}

Używając razem z nazwanymi parametrami możesz zrobić:

Dt2.ToString(defaultValue: "n/a");

W starszych wersjach dotnet dostajesz dużo przeciążeń

/// <summary>
/// Extentionclass for a nullable structs
/// </summary>
public static class NullableStructExtensions {

    /// <summary>
    /// Formats a nullable struct
    /// </summary>
    /// <param name="source"></param>
    /// <param name="format">The format string 
    /// If <c>null</c> use the default format defined for the type of the IFormattable implementation.</param>
    /// <param name="provider">The format provider 
    /// If <c>null</c> the default provider is used</param>
    /// <param name="defaultValue">The string to show when the source is <c>null</c>. 
    /// If <c>null</c> an empty string is returned</param>
    /// <returns>The formatted string or the default value if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source, string format, 
                                     IFormatProvider provider, string defaultValue) 
                                     where T : struct, IFormattable {
        return source.HasValue
                   ? source.Value.ToString(format, provider)
                   : (String.IsNullOrEmpty(defaultValue) ? String.Empty : defaultValue);
    }

    /// <summary>
    /// Formats a nullable struct
    /// </summary>
    /// <param name="source"></param>
    /// <param name="format">The format string 
    /// If <c>null</c> use the default format defined for the type of the IFormattable implementation.</param>
    /// <param name="defaultValue">The string to show when the source is null. If <c>null</c> an empty string is returned</param>
    /// <returns>The formatted string or the default value if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source, string format, string defaultValue) 
                                     where T : struct, IFormattable {
        return ToString(source, format, null, defaultValue);
    }

    /// <summary>
    /// Formats a nullable struct
    /// </summary>
    /// <param name="source"></param>
    /// <param name="format">The format string 
    /// If <c>null</c> use the default format defined for the type of the IFormattable implementation.</param>
    /// <param name="provider">The format provider (if <c>null</c> the default provider is used)</param>
    /// <returns>The formatted string or an empty string if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source, string format, IFormatProvider provider)
                                     where T : struct, IFormattable {
        return ToString(source, format, provider, null);
    }

    /// <summary>
    /// Formats a nullable struct or returns an empty string
    /// </summary>
    /// <param name="source"></param>
    /// <param name="format">The format string 
    /// If <c>null</c> use the default format defined for the type of the IFormattable implementation.</param>
    /// <returns>The formatted string or an empty string if the source is null</returns>
    public static string ToString<T>(this T? source, string format)
                                     where T : struct, IFormattable {
        return ToString(source, format, null, null);
    }

    /// <summary>
    /// Formats a nullable struct
    /// </summary>
    /// <param name="source"></param>
    /// <param name="provider">The format provider (if <c>null</c> the default provider is used)</param>
    /// <param name="defaultValue">The string to show when the source is <c>null</c>. If <c>null</c> an empty string is returned</param>
    /// <returns>The formatted string or the default value if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source, IFormatProvider provider, string defaultValue)
                                     where T : struct, IFormattable {
        return ToString(source, null, provider, defaultValue);
    }

    /// <summary>
    /// Formats a nullable struct or returns an empty string
    /// </summary>
    /// <param name="source"></param>
    /// <param name="provider">The format provider (if <c>null</c> the default provider is used)</param>
    /// <returns>The formatted string or an empty string if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source, IFormatProvider provider)
                                     where T : struct, IFormattable {
        return ToString(source, null, provider, null);
    }

    /// <summary>
    /// Formats a nullable struct or returns an empty string
    /// </summary>
    /// <param name="source"></param>
    /// <returns>The formatted string or an empty string if the source is <c>null</c></returns>
    public static string ToString<T>(this T? source) 
                                     where T : struct, IFormattable {
        return ToString(source, null, null, null);
    }
}

Podoba mi się ta opcja:

Console.WriteLine(dt2?.ToString("yyyy-MM-dd hh:mm:ss") ?? "n/a");

Jeszcze lepsze rozwiązanie w C # 6.0:

DateTime? birthdate;

birthdate?.ToString("dd/MM/yyyy");

Oto doskonała odpowiedź Blake ' a jako metoda rozszerzenia. Dodaj to do swojego projektu, a wywołania w pytaniu będą działać zgodnie z oczekiwaniami.
Co oznacza, że jest używany jak MyNullableDateTime.ToString("dd/MM/yyyy"), z tym samym wyjściem co MyDateTime.ToString("dd/MM/yyyy"), z tą różnicą, że wartością będzie "N/A" Jeśli DateTime jest null.

public static string ToString(this DateTime? date, string format)
{
    return date != null ? date.Value.ToString(format) : "N/A";
}

Simple generic extensions

public static class Extensions
{

    /// <summary>
    /// Generic method for format nullable values
    /// </summary>
    /// <returns>Formated value or defaultValue</returns>
    public static string ToString<T>(this Nullable<T> nullable, string format, string defaultValue = null) where T : struct
    {
        if (nullable.HasValue)
        {
            return String.Format("{0:" + format + "}", nullable.Value);
        }

        return defaultValue;
    }
}

Może to późna odpowiedź, ale może pomóc komukolwiek innemu.

Proste to:

nullabledatevariable.Value.Date.ToString("d")

Lub po prostu użyć dowolnego formatu zamiast "d".

Best

Możesz użyć prostej linii:

dt2.ToString("d MMM yyyy") ?? ""