string.IsNullOrEmpty (string) बनाम string.IsNullOrWhiteSpace (स्ट्रिंग)

Question

.NET 4.0 और उसके बाद के संस्करण में string.IsNullOrEmpty(string)खराब प्रथा के रूप में माने जाने वाले स्ट्रिंग की जांच करते समय इसका उपयोग किया जाता string.IsNullOrWhiteSpace(string)है?

Answer 1

सबसे अच्छा अभ्यास सबसे उपयुक्त एक का चयन कर रहा है।

.Net फ्रेमवर्क 4.0 बीटा 2 में स्ट्रिंग्स के लिए एक नया IsNullOrWhiteSpace () विधि है जो IsNullOrEmpty () विधि को सामान्य करता है जिसमें खाली स्ट्रिंग के अलावा अन्य सफेद स्थान भी शामिल है।

"व्हाइट स्पेस" शब्द में वे सभी वर्ण शामिल हैं जो स्क्रीन पर दिखाई नहीं देते हैं। उदाहरण के लिए, अंतरिक्ष, लाइन ब्रेक, टैब और खाली स्ट्रिंग सफेद अंतरिक्ष वर्ण हैं * ।

संदर्भ: यहाँ

प्रदर्शन के लिए, IsNullOrWhiteSpace आदर्श नहीं है, लेकिन अच्छा है। विधि कॉल के परिणामस्वरूप एक छोटा प्रदर्शन जुर्माना होगा। इसके अलावा, IsWhiteSpace विधि में स्वयं कुछ अप्रत्यक्ष हैं जिन्हें हटाया जा सकता है यदि आप यूनिकोड डेटा का उपयोग नहीं कर रहे हैं। हमेशा की तरह, समयपूर्व अनुकूलन बुराई हो सकता है, लेकिन यह मजेदार भी है।

संदर्भ: यहाँ

स्रोत कोड की जाँच करें (संदर्भ स्रोत .NET फ्रेमवर्क 4.6.2)

IsNullorEmpty

[Pure]
public static bool IsNullOrEmpty(String value) {
    return (value == null || value.Length == 0);
}

IsNullOrWhiteSpace

[Pure]
public static bool IsNullOrWhiteSpace(String value) {
    if (value == null) return true;

    for(int i = 0; i < value.Length; i++) {
        if(!Char.IsWhiteSpace(value[i])) return false;
    }

    return true;
}

उदाहरण

string nullString = null;
string emptyString = "";
string whitespaceString = "    ";
string nonEmptyString = "abc123";

bool result;

result = String.IsNullOrEmpty(nullString);            // true
result = String.IsNullOrEmpty(emptyString);           // true
result = String.IsNullOrEmpty(whitespaceString);      // false
result = String.IsNullOrEmpty(nonEmptyString);        // false

result = String.IsNullOrWhiteSpace(nullString);       // true
result = String.IsNullOrWhiteSpace(emptyString);      // true
result = String.IsNullOrWhiteSpace(whitespaceString); // true
result = String.IsNullOrWhiteSpace(nonEmptyString);   // false

Comments

अब मैं उलझन में हूँ: "IsNullOrWhiteSpace एक सुविधा विधि है जो निम्न कोड के समान है, सिवाय इसके कि यह बेहतर प्रदर्शन प्रदान करता है" यहाँ से: msdn.microsoft.com/en-us/library/…

— robasta

@rob प्रश्न में कोड है return String.IsNullOrEmpty(value) || value.Trim().Length == 0;, जिसमें नए स्ट्रिंग आवंटन और दो अलग-अलग चेक शामिल हैं। ज्यादातर शायद IsNullOrWhitespace के अंदर यह सिंगल पास के माध्यम से बिना किसी आवंटन के जाँच के द्वारा किया जाता है कि स्ट्रिंग में प्रत्येक चार व्हाट्सएप है, इसलिए बेहतर प्रदर्शन। आप वास्तव में क्या भ्रमित करते हैं?

— इवान डैनिलोव

धन्यवाद! मुझे कभी नहीं पता था कि IsNullOrWhitespace()एक खाली स्ट्रिंग से मेल खाएगा। संक्षेप में IsNullOrEmpty()एक सबसेट से मेल खाता है IsNullOrWhitespace()।

— gligoran

Answer 2

व्यवहार में अंतर:

string testString = "";
Console.WriteLine(string.Format("IsNullOrEmpty : {0}", string.IsNullOrEmpty(testString)));
Console.WriteLine(string.Format("IsNullOrWhiteSpace : {0}", string.IsNullOrWhiteSpace(testString)));
Console.ReadKey();

Result :
IsNullOrEmpty : True
IsNullOrWhiteSpace : True

**************************************************************
string testString = " MDS   ";

IsNullOrEmpty : False
IsNullOrWhiteSpace : False

**************************************************************
string testString = "   ";

IsNullOrEmpty : False
IsNullOrWhiteSpace : True

**************************************************************
string testString = string.Empty;

IsNullOrEmpty : True
IsNullOrWhiteSpace : True

**************************************************************
string testString = null;

IsNullOrEmpty : True
IsNullOrWhiteSpace : True

Comments

यह मेरी राय में स्वीकृत उत्तर होना चाहिए। रीडायरेक्ट के बजाय वास्तविक उदाहरण दिखाने के साथ स्वीकृत उत्तर की तुलना में अधिक समझ में आता है।

— eaglei22

Answer 3

वे अलग-अलग कार्य हैं। आपको अपनी स्थिति के लिए तय करना चाहिए कि आपको क्या चाहिए।

मैं उनमें से किसी को भी बुरे अभ्यास के रूप में उपयोग करने पर विचार नहीं करता। अधिकांश समय IsNullOrEmpty()पर्याप्त है। लेकिन आपके पास विकल्प है :)

Comments

उदाहरण के लिए, पंजीकरण पृष्ठ पर एक उपयोगकर्ता नाम फ़ील्ड IsNullOrEmtpy का उपयोग करेगा ताकि यह सत्यापित किया जा सके कि उपयोगकर्ता के पास उनके नाम के रूप में स्थान नहीं हो सकता है।

— क्रिस

@ Rfvgyhn: यदि आप यह जांचना चाहते हैं कि उपयोगकर्ता नाम कहीं भी नहीं है - आपको उपयोग करना चाहिए Contains। यदि आप यह सुनिश्चित करना चाहते हैं कि उपयोगकर्ता नाम केवल रिक्त स्थान से युक्त नहीं हो सकता - IsNullOrWhiteSpaceठीक है। IsNullOrEmptyकेवल यह सुनिश्चित करता है कि उपयोगकर्ता नाम किसी तरह दर्ज किया गया था।

— इवान डैनिलोव

वास्तव में। मैं आपके उत्तर में जोड़ने के लिए एक ठोस उदाहरण देने की कोशिश कर रहा था। वास्तविक दुनिया में, एक उपयोगकर्ता नाम सत्यापन नियम में आमतौर पर जाँच करने की तुलना में थोड़ा अधिक तर्क होगा कि क्या इसकी खाली या व्हॉट्सएप है।

— क्रिस

Answer 4

यहाँ दोनों तरीकों का वास्तविक कार्यान्वयन है (dotPeek का उपयोग करके विघटित)

[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
    public static bool IsNullOrEmpty(string value)
    {
      if (value != null)
        return value.Length == 0;
      else
        return true;
    }

    /// <summary>
    /// Indicates whether a specified string is null, empty, or consists only of white-space characters.
    /// </summary>
    /// 
    /// <returns>
    /// true if the <paramref name="value"/> parameter is null or <see cref="F:System.String.Empty"/>, or if <paramref name="value"/> consists exclusively of white-space characters.
    /// </returns>
    /// <param name="value">The string to test.</param>
    public static bool IsNullOrWhiteSpace(string value)
    {
      if (value == null)
        return true;
      for (int index = 0; index < value.Length; ++index)
      {
        if (!char.IsWhiteSpace(value[index]))
          return false;
      }
      return true;
    }

Comments

तो इस साधन के IsNullOrWhiteSpaceलिए भी सच है string.Empty! यह एक बोनस है :)

— И Г И bonus И О

हाँ, Safest IsNullOrWhiteSpace (String.empty, null और whitespace के लिए सही है) का उपयोग करना होगा

— dekdev

Answer 5

यह कहता है कि यह सब IsNullOrEmpty()सफेद रिक्ति शामिल नहीं है जबकि IsNullOrWhiteSpace()करता है!

IsNullOrEmpty()यदि स्ट्रिंग है:
-नैल-
खाली

IsNullOrWhiteSpace()यदि स्ट्रिंग है:
-नुल-
खाली-
केवल सफेद रिक्त स्थान का चयन करें

Comments

मैंने अस्वीकार कर दिया क्योंकि जब आप समझाते हैं कि प्रत्येक फ़ंक्शन क्या करता है, तो आप वास्तविक प्रश्न का उत्तर नहीं देते हैं।

— ट्यूपेसेट्रे

आपको "सफेद स्थान" के लिए पूरी सूची को शामिल करने के लिए अपने जवाब को संपादित करना चाहिए, जैसा कि उन्होंने रूपरेखा द्वारा परिभाषित किया है: शब्द "सफेद स्थान" में वे सभी वर्ण शामिल हैं जो स्क्रीन पर दिखाई नहीं देते हैं। उदाहरण के लिए, अंतरिक्ष, लाइन ब्रेक, टैब और खाली स्ट्रिंग सफेद अंतरिक्ष वर्ण हैं।

— ज्यूर्जर

Answer 6

IsNullOrEmpty और IsNullOrwhiteSpace के साथ इसे देखें

string sTestes = "I like sweat peaches";
    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();
    for (int i = 0; i < 5000000; i++)
    {
        for (int z = 0; z < 500; z++)
        {
            var x = string.IsNullOrEmpty(sTestes);// OR string.IsNullOrWhiteSpace
        }
    }

    stopWatch.Stop();
    // Get the elapsed time as a TimeSpan value.
    TimeSpan ts = stopWatch.Elapsed;
    // Format and display the TimeSpan value. 
    string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds,
        ts.Milliseconds / 10);
    Console.WriteLine("RunTime " + elapsedTime);
    Console.ReadLine();

आप देखेंगे कि IsNullOrWhiteSpace बहुत धीमी है: /

Comments

यह स्पष्ट है क्योंकि IsNullOrEmpty निरंतर समय O (1) में होता है जबकि IsNullOrwhiteSpace संभवतः स्ट्रिंग या O (n) समय की पूर्ण पुनरावृत्ति की आवश्यकता है। तब आपका समयबद्ध उदाहरण वास्तव में लगभग O (n ^ 2) समय का उपयोग कर रहा है। सामान्य आकार के स्ट्रिंग के साथ एक-टाइमर के लिए, प्रदर्शन अंतर नगण्य होने वाला है। यदि आप बहुत बड़ी मात्रा में पाठ संसाधित कर रहे थे या इसे एक बड़े लूप में बुला रहे थे, तो आप शायद इसका उपयोग नहीं करना चाहेंगे।

— चार्ल्स ओवेन

Answer 7

string.IsNullOrEmpty (str) - यदि आप जांचना चाहेंगे कि स्ट्रिंग मान प्रदान किया गया है

string.IsNullOrWhiteSpace (str) - मूल रूप से यह पहले से ही एक प्रकार का व्यावसायिक तर्क कार्यान्वयन है (अर्थात "" बुरा क्यों है, लेकिन "~~" जैसा कुछ अच्छा है)।

मेरी सलाह - तकनीकी तर्क के साथ व्यावसायिक तर्क को न मिलाएं। इसलिए, उदाहरण के लिए, string.IsNullOrEmpty उनके इनपुट मापदंडों की जांच करने के तरीकों की शुरुआत में उपयोग करने के लिए सबसे अच्छा है।

Answer 8

इस सब के लिए एक पकड़ के बारे में क्या ...

if (string.IsNullOrEmpty(x.Trim())
{
}

यह सभी रिक्त स्थान को ट्रिम कर देगा यदि वे वहां हो तो इस्वाइटस्पेस के प्रदर्शन दंड से बच रहे हैं, जो स्ट्रिंग को "रिक्त" स्थिति को पूरा करने में सक्षम करेगा अगर यह शून्य नहीं है।

मुझे भी लगता है कि यह स्पष्ट है और इसके आम तौर पर अच्छे अभ्यास के लिए स्ट्रिंग्स को ट्रिम करना है, खासकर यदि आप उन्हें डेटाबेस या किसी चीज़ में डाल रहे हैं।

Comments

इस जाँच में एक गंभीर खामी है। एक्स पर ट्रिम () को कॉल करने पर अशक्त संदर्भ अपवाद का परिणाम होगा जब इसे शून्य के रूप में पारित किया जाता है।

— 11 Г И О И О

अच्छी बात। कमियां दिखाने के लिए गलत उत्तर को छोड़ दें।

— रीमोटेक

IsNullOrWhitespace MAY सफेद स्थान के लिए स्ट्रिंग की जाँच करने से बचने के लिए, अशक्त या खाली की जाँच करें। यह विधि हमेशा ट्रिमिंग ऑपरेशन करेगी। इसके अलावा, हालांकि इसे दूर अनुकूलित किया जा सकता है, यह संभवतः स्मृति में एक और स्ट्रिंग पैदा करेगा।

— अंकुरित

अगर (string.IsNullOrEmpty (x? .Trim ()) को null मुद्दे पर मिलना चाहिए

— कैमरन फॉरवर्ड

Answer 9

.Net मानक 2.0 में:

string.IsNullOrEmpty(): इंगित करता है कि निर्दिष्ट स्ट्रिंग अशक्त है या खाली स्ट्रिंग है।

Console.WriteLine(string.IsNullOrEmpty(null));           // True
Console.WriteLine(string.IsNullOrEmpty(""));             // True
Console.WriteLine(string.IsNullOrEmpty(" "));            // False
Console.WriteLine(string.IsNullOrEmpty("  "));           // False

string.IsNullOrWhiteSpace(): इंगित करता है कि क्या एक निर्दिष्ट स्ट्रिंग अशक्त, खाली है, या केवल सफेद-अंतरिक्ष वर्ण हैं।

Console.WriteLine(string.IsNullOrWhiteSpace(null));     // True
Console.WriteLine(string.IsNullOrWhiteSpace(""));       // True
Console.WriteLine(string.IsNullOrWhiteSpace(" "));      // True
Console.WriteLine(string.IsNullOrWhiteSpace("  "));     // True