如何用ToString()格式化可为空的DateTime ?

如何将可空的DateTime dt2转换为格式化的字符串?

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方法没有重载 一个参数< / p >

216373 次浏览
小开
最佳答案 
Console.WriteLine(dt2 != null ? dt2.Value.ToString("yyyy-MM-dd hh:mm:ss") : "n/a");

编辑:如其他注释中所述，检查是否有一个非空值。

更新:如评论中推荐，扩展方法:

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

从c# 6开始，你可以使用null-conditional运营商来进一步简化代码。如果DateTime?为空，下面的表达式将返回空。

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

你可以使用dt2.Value.ToString("format")，但当然这需要dt2 != null，这就否定了可空类型的使用。

这里有几个解决方案，但最大的问题是:你想如何格式化null日期?

小开

试试这个尺寸:

您希望格式化的实际dateTime对象在dt中。Value属性，而不是dt2对象本身。

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

这个问题的问题在于，当可为空的datetime没有值时，您没有指定所需的输出。在这种情况下，下面的代码将输出DateTime.MinValue，与当前接受的答案不同，它不会抛出异常。

dt2.GetValueOrDefault().ToString(format);
小开

我认为你必须使用getvalueordefault - method。如果实例为空，则不定义ToString("yy…")的行为。

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

正如其他人所说，你需要在调用ToString之前检查null，但为了避免重复你自己，你可以创建一个扩展方法，这样做，比如:

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


}

可以像这样调用:

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'
小开

这里有一个更通用的方法。这将允许您对任何可空值类型进行字符串格式化。我包含了第二个方法，允许重写默认字符串值，而不是为值类型使用默认值。

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

考虑到您实际上想要提供格式，我建议将IFormattable接口添加到Smalls扩展方法中，这样您就不会有讨厌的字符串格式连接。

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
}
小开

iformatable还包括一个可以使用的格式提供程序，它允许IFormatProvider的两种格式在dotnet 4.0中都为空

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

与命名参数一起使用，你可以做到:

dt2。ToString (defaultValue:“n / a”);

在旧版本的dotnet中，你会遇到很多重载

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

你们把事情搞得太复杂了。重要的是，停止使用ToString，开始使用字符串格式，比如string。支持字符串格式的格式或方法，如Console.WriteLine。下面是这个问题的最佳解决方案。这也是最安全的。

更新:

我用当前c#编译器的最新方法更新了示例。有条件的运营商,字符串插值

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://learn.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://learn.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}'");

输出:(我在里面放了单引号，所以你可以看到它返回为空字符串时为null)

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


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

简单的通用扩展

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

c# 6.0宝贝:

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

小开

也许这是一个迟来的答案，但可能对其他人有所帮助。

简单的是:

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

或者用其他格式代替d。

最好的

小开

你可以使用简单的线条:

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

我喜欢这个选项:

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

像这样简单的事情怎么样:

String.Format("{0:dd/MM/yyyy}", d2)
小开
这里是布莱克的精彩回答作为扩展方法。将此添加到您的项目中，问题中的调用将按预期工作 这意味着它像MyNullableDateTime.ToString("dd/MM/yyyy")一样使用，输出与MyDateTime.ToString("dd/MM/yyyy")相同，只是如果DateTime为空，值将为"N/A" 
public static string ToString(this DateTime? date, string format)
{
return date != null ? date.Value.ToString(format) : "N/A";
}
小开

最短的回答

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

测试

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中有一个更好的解决方案:

DateTime? birthdate;


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

剃须刀的语法:

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

. datetime != null ?((DateTime) . senddatetime).ToString(" HH:mm:ss"): null


提交答案