Boş bir DateTime'ı ToString () ile nasıl biçimlendirebilirim?

Sıfırlanabilir DateTime dt2'yi biçimlendirilmiş bir dizeye nasıl dönüştürebilirim ?

DateTime dt = DateTime.Now;
Console.WriteLine(dt.ToString("yyyy-MM-dd hh:mm:ss")); //works

DateTime? dt2 = DateTime.Now;
Console.WriteLine(dt2.ToString("yyyy-MM-dd hh:mm:ss")); //gives following error:

ToString yöntemine aşırı yük binmemesi bir argüman alır

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

EDIT: Diğer yorumlarda belirtildiği gibi, null olmayan bir değer olup olmadığını kontrol edin.

Güncelleme: yorumlarda tavsiye edildiği gibi, uzantı yöntemi:

public static string ToString(this DateTime? dt, string format)
    => dt == null ? "n/a" : ((DateTime)dt).ToString(format);

Ve C # 6'dan başlayarak , kodu daha da basitleştirmek için null koşullu işleci kullanabilirsiniz. Null ise aşağıdaki ifade null değerini döndürür DateTime?.

dt2?.ToString("yyyy-MM-dd hh:mm:ss")

Boyut için bunu deneyin:

Biçimlendirmek istediğiniz gerçek dateTime nesnesi, dt2 nesnesinin kendisinde değil, dt.Value özelliğinde bulunur.

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

Siz bütün bunları çok fazla mühendislik yapıyorsunuz ve gerçekten olduğundan daha karmaşık hale getiriyorsunuz. Önemli olan, ToString'i kullanmayı bırakın ve string.Format gibi dize biçimlendirmesini kullanmaya başlayın veya Console.WriteLine gibi dize biçimlendirmesini destekleyen yöntemler. İşte bu sorunun tercih edilen çözümü. Bu aynı zamanda en güvenli olanıdır.

Güncelleme:

Ben bugünün C # derleyici güncel yöntemlerle örnekleri güncelleyin. koşullu işleçler ve dizi enterpolasyonu

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);
// New C# 6 conditional operators (makes using .ToString safer if you must use it)
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators
Console.WriteLine(dt1?.ToString("yyyy-MM-dd hh:mm:ss"));
Console.WriteLine(dt2?.ToString("yyyy-MM-dd hh:mm:ss"));
// New C# 6 string interpolation
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated
Console.WriteLine($"'{dt1:yyyy-MM-dd hh:mm:ss}'");
Console.WriteLine($"'{dt2:yyyy-MM-dd hh:mm:ss}'");

Çıktı: (içine tek tırnak koydum, böylece boş olduğunda boş bir dize olarak geldiğini görebilirsiniz)

'2019-04-09 08:01:39'
''
2019-04-09 08:01:39

'2019-04-09 08:01:39'
''

Diğerlerinin de belirttiği gibi, ToString'i çağırmadan önce null olup olmadığını kontrol etmeniz gerekir, ancak kendinizi tekrar etmekten kaçınmak için bunu yapan bir uzantı yöntemi oluşturabilirsiniz:

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);
  }

}

Hangi gibi çağrılabilir:

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'

C # 6.0 bebek:

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

Bu soruya bir yanıt formüle etmeyle ilgili sorun, boş değer tarih saatinin değeri olmadığında istenen çıktıyı belirtmemenizdir. DateTime.MinValueBöyle bir durumda aşağıdaki kod çıkacaktır ve şu anda kabul edilen cevabın aksine bir istisna atmayacaktır.

dt2.GetValueOrDefault().ToString(format);

Aslında IFormattable arabirimini Smalls uzantısı yöntemine böyle eklemeyi öneririm biçimi sağlamak istediğinizi görünce, bu şekilde kötü dize biçimi birleştirme yok.

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   
}

Bu kadar kolay bir şeye ne dersiniz:

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

Kullanabilirsiniz dt2.Value.ToString("format"), ama tabii ki bu dt2! = Null gerektirir ve bu ilk etapta nullable tipinin kullanımını reddeder.

Burada birkaç çözüm var, ancak büyük soru şu: Bir nulltarihi nasıl biçimlendirmek istiyorsunuz ?

İşte daha genel bir yaklaşım. Bu, herhangi bir boş değer türünü dize olarak biçimlendirmenize olanak tanır. Değer türü için varsayılan değeri kullanmak yerine varsayılan dize değerini geçersiz kılmak için ikinci yöntemi dahil ettim.

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;
    }
}

En kısa cevap

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

Testler

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: 

C # 6.0'da daha iyi bir çözüm:

DateTime? birthdate;

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

RAZOR sözdizimi:

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

Bence GetValueOrDefault-Methode kullanmanız gerekiyor. Örnek null olursa, ToString ("yy ...") ile olan davranış tanımlanmaz.

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

İşte Blake'in bir uzatma yöntemi olarak mükemmel cevabı . Bunu projenize ekleyin, sorudaki çağrılar beklendiği gibi çalışacaktır. DateTime boşsa değerin olması dışında , aynı çıktı ile aynı
şekilde kullanılır .MyNullableDateTime.ToString("dd/MM/yyyy")MyDateTime.ToString("dd/MM/yyyy")"N/A"

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

IFormattable, kullanılabilecek bir biçim sağlayıcı da içerir; IFormatProvider biçiminin her iki biçiminin de dotnet 4.0'da null olmasını sağlar.

/// <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);
    }
}

adlandırılmış parametrelerle birlikte şunları yapabilirsiniz:

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

Dotnet'in eski sürümlerinde çok fazla aşırı yük alırsınız

/// <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);
    }
}

Bu seçeneği beğendim:

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

Basit genel uzantılar

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;
    }
}

Belki geç bir cevaptır ama başkalarına yardım edebilir.

Basit:

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

veya "d" yerine herhangi bir format kullanın.

En iyi

basit bir çizgi kullanabilirsiniz:

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