¿Cómo puedo formatear un DateTime nullable con ToString ()?

¿Cómo puedo convertir el DateTime dt2 que se puede anular en una cadena formateada?

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: 

sin sobrecarga al método ToString toma un argumento

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

EDITAR: Como se indicó en otros comentarios, verifique que haya un valor no nulo.

Actualización: como se recomienda en los comentarios, método de extensión:

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

Y comenzando en C # 6, puede usar el operador nulo-condicional para simplificar aún más el código. La siguiente expresión devolverá nulo si DateTime? es nulo.

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

Prueba esto para el tamaño:

El objeto dateTime real que desea formatear se encuentra en la propiedad dt.Value, y no en el objeto dt2 en sí.

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

Como otros han declarado que necesita comprobar null antes de invocar a ToString, pero para evitar repetirlo, puede crear un método de extensión que lo haga, algo así como:

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

Que se puede invocar como:

 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' 

Ustedes están sobreingeniendo todo esto y haciéndolo mucho más complicado de lo que realmente es. Algo importante, deje de usar ToString y comience a usar el formato de cadena como cadena. Formato o métodos que admiten el formato de cadenas como Console.WriteLine. Aquí está la solución preferida para esta pregunta. Este es también el más seguro.

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

Resultado: (Puse comillas simples en él para que pueda ver que vuelve como una cadena vacía cuando es nulo)

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

C # 6.0 bebé:

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

El problema con la formulación de una respuesta a esta pregunta es que no especifica el resultado deseado cuando la fecha y hora nullable no tiene ningún valor. El siguiente código generará DateTime.MinValue en dicho caso y, a diferencia de la respuesta actualmente aceptada, no arrojará una excepción.

 dt2.GetValueOrDefault().ToString(format); 

Al ver que en realidad desea proporcionar el formato, le sugiero que agregue la interfaz IFormattable al método de extensión de Smalls así, de esa manera no tendrá la desagradable concatenación de formato de cadena.

 public static string ToString(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 } 

Puede usar dt2.Value.ToString("format") , pero por supuesto eso requiere que dt2! = Null, y eso niega el uso de un tipo que admite nulos en primer lugar.

Aquí hay varias soluciones, pero la gran pregunta es: ¿cómo quieres formatear una fecha null ?

Aquí hay un enfoque más genérico. Esto le permitirá formatear en cadena cualquier tipo de valor que acepte nulos. He incluido el segundo método para permitir anular el valor de cadena predeterminado en lugar de usar el valor predeterminado para el tipo de valor.

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

¿Qué pasa con algo tan fácil como esto?

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

La respuesta más corta

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

Pruebas

 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: 

Creo que debes usar GetValueOrDefault-Methode. El comportamiento con ToString (“yy …”) no está definido si la instancia es nula.

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

IFormattable también incluye un proveedor de formatos que se puede usar, permite que ambos formatos de IFormatProvider sean nulos en dotnet 4.0, esto sería

 ///  /// Extentionclass for a nullable structs ///  public static class NullableStructExtensions { ///  /// Formats a nullable struct ///  ///  /// The format string /// If null use the default format defined for the type of the IFormattable implementation. /// The format provider /// If null the default provider is used /// The string to show when the source is null. /// If null an empty string is returned /// The formatted string or the default value if the source is null public static string ToString(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); } } 

utilizando junto con parámetros nombrados que puede hacer:

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

En versiones anteriores de dotnet obtienes muchas sobrecargas

 ///  /// Extentionclass for a nullable structs ///  public static class NullableStructExtensions { ///  /// Formats a nullable struct ///  ///  /// The format string /// If null use the default format defined for the type of the IFormattable implementation. /// The format provider /// If null the default provider is used /// The string to show when the source is null. /// If null an empty string is returned /// The formatted string or the default value if the source is null public static string ToString(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); } ///  /// Formats a nullable struct ///  ///  /// The format string /// If null use the default format defined for the type of the IFormattable implementation. /// The string to show when the source is null. If null an empty string is returned /// The formatted string or the default value if the source is null public static string ToString(this T? source, string format, string defaultValue) where T : struct, IFormattable { return ToString(source, format, null, defaultValue); } ///  /// Formats a nullable struct ///  ///  /// The format string /// If null use the default format defined for the type of the IFormattable implementation. /// The format provider (if null the default provider is used) /// The formatted string or an empty string if the source is null public static string ToString(this T? source, string format, IFormatProvider provider) where T : struct, IFormattable { return ToString(source, format, provider, null); } ///  /// Formats a nullable struct or returns an empty string ///  ///  /// The format string /// If null use the default format defined for the type of the IFormattable implementation. /// The formatted string or an empty string if the source is null public static string ToString(this T? source, string format) where T : struct, IFormattable { return ToString(source, format, null, null); } ///  /// Formats a nullable struct ///  ///  /// The format provider (if null the default provider is used) /// The string to show when the source is null. If null an empty string is returned /// The formatted string or the default value if the source is null public static string ToString(this T? source, IFormatProvider provider, string defaultValue) where T : struct, IFormattable { return ToString(source, null, provider, defaultValue); } ///  /// Formats a nullable struct or returns an empty string ///  ///  /// The format provider (if null the default provider is used) /// The formatted string or an empty string if the source is null public static string ToString(this T? source, IFormatProvider provider) where T : struct, IFormattable { return ToString(source, null, provider, null); } ///  /// Formats a nullable struct or returns an empty string ///  ///  /// The formatted string or an empty string if the source is null public static string ToString(this T? source) where T : struct, IFormattable { return ToString(source, null, null, null); } } 

Me gusta esta opción:

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

Incluso una mejor solución en C # 6.0:

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

Sintaxis RAZOR:

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

Extensiones genéricas simples

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

Aquí está la excelente respuesta de Blake como método de extensión. Agregue esto a su proyecto y las llamadas en la pregunta funcionarán como se espera. Como en él se usa como MyNullableDateTime.ToString("dd/MM/yyyy") , con el mismo resultado que MyDateTime.ToString("dd/MM/yyyy") , excepto que el valor será "N/A" si el DateTime es nulo.

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

Tal vez es una respuesta tardía, pero puede ayudar a cualquier otra persona.

Simple es:

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

o simplemente use cualquier formato en lugar de “d”.

Mejor

puedes usar una línea simple:

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