the - datetime to string c#

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

Question

¿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

Answer 1

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

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

Answer 2

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

Answer 3

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

Answer 4

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

Answer 5

C # 6.0 bebé:

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

Answer 6

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

Answer 7

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

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

Answer 8

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

Answer 9

Extensiones genéricas simples

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

Answer 10

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

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

utilizando junto con parámetros nombrados que puede hacer:

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

En versiones anteriores de dotnet obtienes muchas sobrecargas

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

Answer 11

Incluso una mejor solución en C # 6.0:

DateTime? birthdate;

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

Answer 12

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: 

Answer 13

Me gusta esta opción:

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

Answer 14

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

Answer 15

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 ?

Answer 16

Sintaxis RAZOR:

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

Answer 17

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

Answer 18

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

Answer 19

puedes usar una línea simple:

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

Answer 20

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