मैं ToString () के साथ एक अशक्त DateTime को कैसे प्रारूपित कर सकता हूं?


226

मैं nullable 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 एक तर्क लेता है


3
नमस्कार, क्या आप स्वीकृत और वर्तमान उत्तरों की समीक्षा करना चाहेंगे? अधिक प्रासंगिक दिन का उत्तर अधिक सही हो सकता है।
uliu.net

जवाबों:


334
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 में शुरू करके, आप कोड को और भी सरल बनाने के लिए नल-सशर्त ऑपरेटर का उपयोग कर सकते हैं । नीचे की अभिव्यक्ति अशक्त होने पर वापस लौट आएगी DateTime?

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

26
ऐसा लगता है कि यह मेरे लिए एक विस्तार विधि के लिए भीख माँग रहा है।
डेविड ग्लेन


@ यह नहीं है कि कार्य तुच्छ नहीं है ... stackoverflow.com/a/44683673/5043056
सिनजई

3
क्या आप इसके लिए तैयार हैं ... dt? .TString ("dd / MMM / yyyy") ?? "" C # 6 के महान लाभ
टॉम मैकडोनो

CS0029 त्रुटि: स्पष्ट रूप से प्रकार 'स्ट्रिंग' को 'System.DateTime?' में परिवर्तित नहीं कर सकता (CS0029)। .Net कोर 2.0
ऑक्युलर मैन

80

आकार के लिए इसे पहनकर देखें:

आपके फॉर्मेट को देखने की वास्तविक डेटटाइम ऑब्जेक्ट dt.Value प्रॉपर्टी में है, और dt2 ऑब्जेक्ट पर ही नहीं।

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

36

आप लोग इस सब से अधिक इंजीनियरिंग कर रहे हैं और यह वास्तव में है की तुलना में इसे और अधिक जटिल बना रहा है। महत्वपूर्ण बात, ToString का उपयोग करना बंद कर दें और string फ़ॉर्मेटिंग का उपयोग करना शुरू करें जैसे string.ormat या वे विधियाँ जो स्ट्रिंग स्वरूपण का समर्थन करती हैं जैसे Console.WriteLine। यहाँ इस सवाल का पसंदीदा समाधान है। यह सबसे सुरक्षित भी है।

अपडेट करें:

मैं आज के सी # संकलक के तरीकों के साथ उदाहरणों को अपडेट करता हूं। सशर्त ऑपरेटरों और स्ट्रिंग प्रक्षेप

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

आउटपुट: (मैं इसमें सिंगल कोट्स डालता हूँ ताकि आप देख सकें कि यह रिक्त स्ट्रिंग के रूप में वापस आता है जब अशक्त)

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

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

30

जैसा कि दूसरों ने कहा है कि आपको ToString को लागू करने से पहले अशक्त के लिए जाँच करने की आवश्यकता है, लेकिन अपने आप को दोहराने से बचने के लिए आप एक विस्तार विधि बना सकते हैं जो ऐसा करती है, जैसे कुछ:

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'

28

सी # 6.0 बच्चे:

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


2
मैं निम्नलिखित संस्करण का सुझाव दूंगा ताकि यह उत्तर C # 6.0 के लिए मौजूदा स्वीकृत उत्तर के बराबर हो। Console.WriteLine(dt2?.ToString("yyyy-MM-dd hh:mm:ss" ?? "n/a");
कैन बड

15

इस प्रश्न का उत्तर तैयार करने में समस्या यह है कि आप अशक्त डेटाटाइम का कोई मूल्य नहीं होने पर वांछित आउटपुट निर्दिष्ट नहीं करते हैं। निम्नलिखित कोड DateTime.MinValueऐसे मामले में आउटपुट करेगा , और वर्तमान में स्वीकृत उत्तर के विपरीत, अपवाद नहीं फेंकेगा।

dt2.GetValueOrDefault().ToString(format);

7

यह देखते हुए कि आप वास्तव में प्रारूप प्रदान करना चाहते हैं, जैसे कि IFormattable इंटरफ़ेस को स्मॉल एक्सटेंशन विधि में जोड़ने का सुझाव है, इस तरह से आपके पास गंदा स्ट्रिंग प्रारूप का संयोजन नहीं है।

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   
}


5

आप उपयोग कर सकते हैं dt2.Value.ToString("format"), लेकिन निश्चित रूप से कि dt2! = Null की आवश्यकता है, और यह पहली जगह में एक अशक्त प्रकार के वें उपयोग को नकार देता है।

यहां कई समाधान हैं, लेकिन बड़ा सवाल यह है: आप एक nullतिथि को कैसे प्रारूपित करना चाहते हैं ?


5

यहाँ एक अधिक सामान्य दृष्टिकोण है। यह आपको किसी भी अशक्त मान प्रकार को स्ट्रिंग करने की अनुमति देगा। मैंने मूल्य प्रकार के लिए डिफ़ॉल्ट मान का उपयोग करने के बजाय डिफ़ॉल्ट स्ट्रिंग मान को ओवरराइड करने की अनुमति देने के लिए दूसरी विधि को शामिल किया है।

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

4

सबसे छोटा जवाब

$"{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: 


4

राज़ वाक्य रचना:

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

2

मुझे लगता है कि आपको GetValueOrDefault-Methode का उपयोग करना होगा। यदि उदाहरण अशक्त है तो Toringring ("yy ...") के साथ व्यवहार को परिभाषित नहीं किया गया है।

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

1
ToString ("yy ...") के साथ व्यवहार को परिभाषित किया जाता है यदि उदाहरण अशक्त है, क्योंकि GetValueOrDefault () DateTime.MinValue
Lucas

2

यहां विस्तार विधि के रूप में ब्लेक का उत्कृष्ट उत्तर है । इसे अपनी परियोजना में जोड़ें और प्रश्न में कॉल अपेक्षित रूप से काम करेगी।
मतलब इसे 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";
}

1

IFormattable में एक प्रारूप प्रदाता भी शामिल है जिसका उपयोग किया जा सकता है, यह IFormatProvider के दोनों प्रारूप को डॉटनेट 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");

डॉटनेट के पुराने संस्करणों में आपको बहुत अधिक भार मिलता है

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


0

सरल जेनेरिक एक्सटेंशन

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

-2

हो सकता है कि यह देर से जवाब हो लेकिन किसी और की मदद कर सकता है।

सरल है:

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

या "d" के बजाय किसी भी प्रारूप का उपयोग करें।

श्रेष्ठ


1
Nullabledatevariable.Value शून्य होने पर यह त्रुटि करेगा।
जॉन सी।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.