टेस्ट अगर अपवादों को फेंकने के बिना एक गाइड है?

Question

मैं एक स्ट्रिंग को एक गाइड में बदलने की कोशिश करना चाहता हूं, लेकिन मैं अपवादों को पकड़ने पर भरोसा नहीं करना चाहता (

• प्रदर्शन के कारणों के लिए - अपवाद महंगे हैं
• प्रयोज्य कारणों के लिए - डिबगर पॉप अप करता है
• डिजाइन कारणों के लिए - अपेक्षित असाधारण नहीं है

दूसरे शब्दों में कोड:

public static Boolean TryStrToGuid(String s, out Guid value)
{
    try
    {
        value = new Guid(s);
        return true;
    }
    catch (FormatException)
    {
        value = Guid.Empty;
        return false;
    }
}

उपयुक्त नहीं है।

मैं RegEx का उपयोग करने की कोशिश करूंगा, लेकिन चूंकि गाइड कोष्ठक लपेटा जा सकता है, ब्रेस लिपटे, कोई भी लिपटे नहीं, यह कठिन बनाता है।

इसके अतिरिक्त, मुझे लगा कि कुछ दिशानिर्देश मान अमान्य हैं (?)

---

अपडेट १

क्रिश्चियनके को FormatExceptionसभी के बजाय केवल पकड़ने का एक अच्छा विचार था । सुझाव शामिल करने के लिए प्रश्न का कोड नमूना बदल दिया।

---

अपडेट २

फेक अपवादों की चिंता क्यों? क्या मैं वास्तव में उन सभी के बारे में अवैध GUIDs की उम्मीद कर रहा हूँ?

जवाब है हां । यही कारण है कि मैं TryStrToGuid का उपयोग कर रहा हूं - मैं खराब डेटा की उम्मीद कर रहा हूं ।

उदाहरण 1 नामस्थान एक्सटेंशनों को GUID को फ़ोल्डर नाम में जोड़कर निर्दिष्ट किया जा सकता है । मैं फ़ोल्डर नामों को पार्स कर रहा हूं, यह देखने के लिए कि क्या अंतिम के बाद पाठ है । एक गाइड है।

c:\Program Files
c:\Program Files.old
c:\Users
c:\Users.old
c:\UserManager.{CE7F5AA5-6832-43FE-BAE1-80D14CD8F666}
c:\Windows
c:\Windows.old

उदाहरण 2 मैं एक भारी उपयोग किया जा रहा वेब-सर्वर कुछ पोस्ट किए गए डेटा की वैधता की जांच करना चाहता हूं। मैं अवैध डेटा को संसाधनों को बांधने के लिए नहीं चाहता हूँ 2-3 परिमाण के ऑर्डर इससे अधिक होने चाहिए।

उदाहरण 3 मैं एक उपयोगकर्ता द्वारा दर्ज की गई खोज अभिव्यक्ति को पार्स कर सकता हूं।

यदि वे GUID में प्रवेश करते हैं, तो मैं उन्हें विशेष रूप से संसाधित करना चाहता हूं (जैसे कि विशेष रूप से उस वस्तु को खोजना, या प्रतिक्रिया पाठ में उस विशिष्ट खोज शब्द को हाइलाइट करना और प्रारूपित करना।)

---

अद्यतन 3 - प्रदर्शन बेंचमार्क

टेस्ट 10,000 अच्छे दोस्तों और 10,000 बुरे दोस्तों को परिवर्तित करता है।

Catch FormatException:
   10,000 good:     63,668 ticks
   10,000 bad:   6,435,609 ticks

Regex Pre-Screen with try-catch:
   10,000 good:    637,633 ticks
   10,000 bad:     717,894 ticks

COM Interop CLSIDFromString
   10,000 good:    126,120 ticks
   10,000 bad:      23,134 ticks

पीएस मुझे एक सवाल का औचित्य साबित नहीं करना चाहिए।

Comments

क्यों दुनिया में यह एक समुदाय विकि है?

— जेफ

आप सही हे; आपको किसी सवाल का औचित्य नहीं बनाना चाहिए । हालाँकि, मैं ब्याज के साथ औचित्य को पढ़ता हूं (क्योंकि यह बहुत ही समान है कि मैं यहां क्यों पढ़ रहा हूं)। तो, महान औचित्य के लिए धन्यवाद।

— bw

@ जेफ की संभावना के कारण ओपी ने इसे 10 से अधिक बार संपादित किया है - सामुदायिक विकि पर मेटा

— Marijn

कृपया इस पेज को Guide.TryParse या Guide.TryParseExact के साथ समाधान के लिए देखते रहें। .NET 4.0 + के साथ उपरोक्त समाधान

— dplante

@dplante जब मैंने मूल रूप से 2008 में सवाल पूछा था, तब कोई नहीं था 4.0। यही कारण है कि सवाल, और स्वीकृत उत्तर, वे जिस तरह से हैं।

— इयान बॉयड

Answer 1

प्रदर्शन बेंचमार्क

Catch exception:
   10,000 good:    63,668 ticks
   10,000 bad:  6,435,609 ticks

Regex Pre-Screen:
   10,000 good:   637,633 ticks
   10,000 bad:    717,894 ticks

COM Interop CLSIDFromString
   10,000 good:   126,120 ticks
   10,000 bad:     23,134 ticks

COM इंटरटॉप (सबसे तेज) उत्तर:

/// <summary>
/// Attempts to convert a string to a guid.
/// </summary>
/// <param name="s">The string to try to convert</param>
/// <param name="value">Upon return will contain the Guid</param>
/// <returns>Returns true if successful, otherwise false</returns>
public static Boolean TryStrToGuid(String s, out Guid value)
{
   //ClsidFromString returns the empty guid for null strings   
   if ((s == null) || (s == ""))   
   {      
      value = Guid.Empty;      
      return false;   
   }

   int hresult = PInvoke.ObjBase.CLSIDFromString(s, out value);
   if (hresult >= 0)
   {
      return true;
   }
   else
   {
      value = Guid.Empty;
      return false;
   }
}


namespace PInvoke
{
    class ObjBase
    {
        /// <summary>
        /// This function converts a string generated by the StringFromCLSID function back into the original class identifier.
        /// </summary>
        /// <param name="sz">String that represents the class identifier</param>
        /// <param name="clsid">On return will contain the class identifier</param>
        /// <returns>
        /// Positive or zero if class identifier was obtained successfully
        /// Negative if the call failed
        /// </returns>
        [DllImport("ole32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = true)]
        public static extern int CLSIDFromString(string sz, out Guid clsid);
    }
}

---

नीचे पंक्ति: यदि आपको यह जांचने की आवश्यकता है कि क्या एक स्ट्रिंग एक गाइड है, और आप प्रदर्शन की परवाह करते हैं, तो COM इंटरॉप का उपयोग करें।

यदि आपको एक गाइड में स्ट्रिंग गाइड को एक गाइड में बदलने की आवश्यकता है, तो उपयोग करें

new Guid(someString);

Comments

क्या आपने इन्हें डीबगर या ऑफ के साथ चलाया था? डिबगर संलग्न किए बिना अपवाद-फेंकने का प्रदर्शन कई गुना बेहतर होता है।

— डैनियल टी।

धन्यवाद। मैं खुद यह सवाल पूछने वाला था। खुशी है कि मुझे आपका जवाब मिल गया।

— डेविड

मैंने ऊपर से नामस्थान PInvoke कोड स्निपेट के साथ PInvoke.cs नामक एक नई फ़ाइल बनाई है, लेकिन मुझे काम करने के लिए कोड नहीं मिल सकता है। जब मैं डीबग करता हूं तो देखता हूं कि CLSIDFromString का परिणाम हमेशा नकारात्मक होता है। मैंने कॉलिंग लाइन बदलने की कोशिश की: int hresult = PInvoke.ObjBase.CLSIDFromString (Guide.NewGuid ()। ToString (), आउट वैल्यू); लेकिन यह अभी भी हमेशा नकारात्मक है। मैं क्या गलत कर रहा हूं?

— JALLRED

Answer 2

एक बार .net 4.0 उपलब्ध होने के बाद आप उपयोग कर सकते हैं Guid.TryParse()।

Comments

एक और भी तेज़ तरीका है। Guide.TryParseExact () विधि का उपयोग करके।

यदि गाइडिंग स्ट्रिंग्स को पार्स करना आपके आवेदन का सबसे धीमा हिस्सा है तो आप धन्य हैं।

— नो रिफंड्स नो रिटर्न

Answer 3

आप इसे पसंद नहीं करने जा रहे हैं लेकिन आपको क्या लगता है कि अपवाद को पकड़ना धीमा होने वाला है?

एक GUID पार्स करने के कितने असफल प्रयास सफल लोगों की तुलना में उम्मीद कर रहे हैं?

मेरी सलाह उस फ़ंक्शन का उपयोग करना है जो आपने अभी बनाया है और अपने कोड को प्रोफाइल करें। यदि आप पाते हैं कि यह फ़ंक्शन एक हॉटस्पॉट है, तो इसे ठीक कर लें, लेकिन पहले नहीं।

Comments

अच्छा जवाब, समय से पहले अनुकूलन सभी बुराई की जड़ है।

— केव

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

— इयान बॉयड

अनाम, आपके मूल प्रश्न ने प्रदर्शन को कारण बताया जो आप अपवादों से बचना चाहते थे। अगर ऐसा नहीं है, तो शायद आपको अपना सवाल पूछना चाहिए।

— एंथनीवजोन

अपवाद का उपयोग EXCEPTIONNAL मामलों में किया जाना चाहिए: जिसका अर्थ डेवलपर द्वारा प्रबंधित नहीं है। मैं Microsoft के सभी त्रुटियों को प्रबंधित करने के तरीके का विरोधी हूं। रक्षात्मक प्रोग्रामिंग नियम। कृपया Microsoft फ्रेमवर्क डेवेलपर्स को गाइड क्लास में 'ट्रायपर्स' जोड़ने पर विचार करें।

— मोस

मेरी स्वयं की टिप्पणी के जवाब में => Guide.TryParse को 4.0 में जोड़ा गया है --- msdn.microsoft.com/en-us/library/… --- इतनी त्वरित प्रतिक्रिया के लिए thxs MS;)

— Mose

Answer 4

.NET 4.0 में आप निम्नलिखित लिख सकते हैं:

public static bool IsValidGuid(string str)
{
    Guid guid;
    return Guid.TryParse(str, out guid);
}

Comments

यह वास्तव में शीर्ष उत्तरों में से एक होना चाहिए।

— टॉम लिंट

Answer 5

मैं कम से कम इसे फिर से लिखूंगा:

try
{
  value = new Guid(s);
  return true;
}
catch (FormatException)
{
  value = Guid.Empty;
  return false;
}

आप SEHException, ThreadAbortException या अन्य घातक या गैर-संबंधित सामान पर "अमान्य GUID" नहीं कहना चाहते हैं।

अपडेट : .NET 4.0 से शुरू होकर, गाइड के लिए उपलब्ध तरीकों का एक नया सेट है:

• Guid.TryParse
• Guid.TryParseExact

वास्तव में, उन लोगों का उपयोग किया जाना चाहिए (यदि केवल इस तथ्य के लिए, कि वे आंतरिक रूप से ट्राइ-कैच का उपयोग करके "भोलेपन से" लागू नहीं होते हैं)।

Answer 6

इंटरॉप केवल अपवाद को पकड़ने की तुलना में धीमा है:

खुश पथ में, 10,000 लोगों के साथ:

Exception:    26ms
Interop:   1,201ms

दुखी रास्ते में:

Exception: 1,150ms
  Interop: 1,201ms

यह अधिक सुसंगत है, लेकिन यह लगातार धीमा भी है। मुझे लगता है कि आप अपने डिबगर को केवल अखंडित अपवादों पर तोड़ने के लिए कॉन्फ़िगर करना बेहतर होगा।

Comments

"आपका डिबगर केवल अखंडित अपवादों पर टूटने के लिए" नहीं एक विकल्प।

— इयान बॉयड

@ इयान बॉयड - यदि आप वीएस संस्करणों (एक्सप्रेस सहित) में से किसी का उपयोग कर रहे हैं, तो यह एक विकल्प है। msdn.microsoft.com/en-us/library/038tzxdw.aspx ।

— मार्क ब्रैकेट

मेरा मतलब था कि यह एक संभव विकल्प नहीं है। जैसे, "असफलता कोई विकल्प नहीं है।" यह है एक विकल्प है, लेकिन एक है कि मैं का उपयोग नहीं करने जा रहा हूँ।

— इयान बॉयड

Answer 7

खैर, यहाँ regex आप की आवश्यकता होगी ...

^[A-Fa-f0-9]{32}$|^({|\\()?[A-Fa-f0-9]{8}-([A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}(}|\\))?$|^({)?[0xA-Fa-f0-9]{3,10}(, {0,1}[0xA-Fa-f0-9]{3,6}){2}, {0,1}({)([0xA-Fa-f0-9]{3,4}, {0,1}){7}[0xA-Fa-f0-9]{3,4}(}})$

लेकिन यह सिर्फ शुरुआत के लिए है। आपको यह भी सत्यापित करना होगा कि विभिन्न भाग जैसे दिनांक / समय स्वीकार्य सीमा के भीतर हैं। मैं यह किसी भी तेजी से होने की कोशिश नहीं कर सकता / पकड़ने की विधि से जिसे आपने पहले ही रेखांकित किया है। उम्मीद है कि आप इस प्रकार के चेक को वारंट करने के लिए कई अमान्य GUID नहीं प्राप्त कर रहे हैं!

Comments

उम, IIRC GUIDs जो एक समय टिकट से उत्पन्न होते हैं, उन्हें आमतौर पर एक बुरा विचार माना जाता है और दूसरी तरह (प्रकार 4) पूरी तरह से रैंडम हैं

— BCS

Answer 8

प्रयोज्य कारणों के लिए - डिबगर पॉप अप करता है

यदि आप ट्राइ / कैच अप्रोच के लिए जा रहे हैं तो आप [System.Diagnostics.DebuggerHidden] विशेषता को जोड़ सकते हैं, यह सुनिश्चित करने के लिए कि आपने इसे थ्रो पर ब्रेक करने के लिए सेट किया है तो भी डिबगर नहीं टूटेगा।

Answer 9

हालांकि यह है सच है कि त्रुटियों का उपयोग कर अधिक महंगा है, ज्यादातर लोगों का मानना है कि उनके GUIDs की एक बहुमत तो एक उत्पन्न कंप्यूटर होने जा रहे हैं TRY-CATCHबहुत महंगा नहीं है क्योंकि यह केवल पर लागत उत्पन्न करता है CATCH। आप इसे दो का एक सरल परीक्षण के साथ खुद को साबित कर सकते हैं (उपयोगकर्ता सार्वजनिक, कोई पासवर्ड नहीं) के हैं।

हेयर यू गो:

using System.Text.RegularExpressions;


 /// <summary>
  /// Validate that a string is a valid GUID
  /// </summary>
  /// <param name="GUIDCheck"></param>
  /// <returns></returns>
  private bool IsValidGUID(string GUIDCheck)
  {
   if (!string.IsNullOrEmpty(GUIDCheck))
   {
    return new Regex(@"^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$").IsMatch(GUIDCheck);
   }
   return false;
  }

Answer 10

मेरे पास एक समान स्थिति थी और मैंने देखा कि लगभग कभी भी 36 स्ट्रिंग लंबे अमान्य स्ट्रिंग नहीं थे। इसलिए इस तथ्य के आधार पर, मैंने आपका कोड थोड़ा बदल दिया ताकि बेहतर प्रदर्शन करते हुए बेहतर प्रदर्शन कर सकें।

public static Boolean TryStrToGuid(String s, out Guid value)
{

     // this is before the overhead of setting up the try/catch block.
     if(value == null || value.Length != 36)
     {  
        value = Guid.Empty;
        return false;
     }

    try
    {
        value = new Guid(s);
        return true;
    }
    catch (FormatException)
    {
        value = Guid.Empty;
        return false;
    }
}

Comments

गाइड अपने ctor में सिर्फ धराशायी स्ट्रिंग फॉर्म से ज्यादा स्वीकार करता है। GUIDs डैश के साथ घुंघराले ब्रेसिज़ के आसपास हो सकते हैं, या डैश या ब्रेसिज़ से मुक्त हो सकते हैं। यह कोड उन वैकल्पिकों द्वारा उपयोग किए जाने पर गलत नकारात्मक उत्पन्न करेगा, लेकिन पूरी तरह से वैध स्ट्रिंग रूप भी।

— क्रिस चाररुक

फॉलो-अप के लिए, स्ट्रिंग-फॉर्म GUID के लिए मान्य लंबाई क्रमशः 32, 36 और 38 है - शुद्ध हेक्स, धराशायी, और ब्रेस-विद-डैश।

— बजे क्रिस चारबारुक

@ क्रिस, आपकी बात मान्य है, लेकिन @JBrooks विचार की पवित्रता की कोशिश करने / पकड़ने में बाधा डालने से पहले भावी GUID की जाँच करने से समझ में आता है, खासकर अगर संदिग्ध इनपुट आम है। हो सकता है कि कुछ ऐसा हो अगर (मान == null || value.Length <30 || value.length> 40) {value = GuideEEmpty; गलत लौटें?}

— bw

वास्तव में, यह बेहतर होगा, हालांकि मैं 30.40 के बजाय सीमा को तंग रखूंगा, 32..38।

— क्रिस चरबारुक

Answer 11

जहाँ तक मुझे पता है, mscrolib में Guid.TryParse जैसी कोई चीज़ नहीं है। रेफरेंस सोर्स के अनुसार, गाइड टाइप में मेगा-कॉम्प्लेक्स कंस्ट्रक्टर होता है, जो सभी तरह के गाइड फॉर्मेट को चेक करता है और उन्हें पार्स करने की कोशिश करता है। कोई सहायक विधि नहीं है जिसे आप प्रतिबिंब के माध्यम से भी कॉल कर सकते हैं। मुझे लगता है कि आपको तीसरे पक्ष के गाइड पार्सर की तलाश करनी होगी, या अपना खुद का लिखना होगा।

Answer 12

संभावित GUID को फिर से चलाएं हालांकि एक RegEx या कुछ कस्टम कोड जो कि यह सुनिश्चित करने के लिए कि कम से कम स्ट्रिप GUID की तरह दिखता है और इसमें केवल मान्य वर्ण (और हो सकता है कि यह समग्र प्रारूप के अनुरूप हो) के लिए एक शुद्धता जाँच करता है। यदि यह पवित्रता की जाँच को पास नहीं करता है, तो एक त्रुटि लौटाता है - जो कि शायद अवैध तारों के विशाल बहुमत को मिटा देगा।

फिर स्ट्रिंग को परिवर्तित करें जैसा कि आपके पास ऊपर है, फिर भी कुछ अवैध तारों के लिए अपवाद को पकड़ता है जो कि पवित्रता जांच के माध्यम से मिलता है।

जॉन स्कीट ने पार्सिंग इन्ट्स के लिए कुछ इसी तरह का विश्लेषण किया (इससे पहले कि TryParse फ्रेमवर्क में था): यह जांचना कि क्या एक स्ट्रिंग को इंट 32 में बदला जा सकता है

हालांकि, जैसा कि एंथनीवजोन ने संकेत दिया है कि आपको शायद इस बारे में चिंता नहीं करनी चाहिए।

Answer 13

 bool IsProbablyGuid(string s)
    {
        int hexchars = 0;
        foreach(character c in string s)
        {
           if(IsValidHexChar(c)) 
               hexchars++;          
        }
        return hexchars==32;
    }

Comments

"-" "" {""} "(" और ")" मान्य वर्ण नहीं हैं, लेकिन एक गाइड स्ट्रिंग में मान्य हैं।

— प्रेस्टन गुइलोट

और यह कोड पूरी तरह से अच्छी तरह से काम करेगा यदि इनपुट

— गाइड

Answer 14

• प्रतिक्षेपक प्राप्त करें
• copy'n'paste मार्गदर्शिका .ctor (स्ट्रिंग)
• "वापस झूठे" के साथ "नया फेंकें ..." के हर संकट को बदलें।

गाइड का ctor बहुत अधिक संकलित रेगेक्स है, इस तरह आप अपवाद के ओवरहेड के बिना बिल्कुल वैसा ही व्यवहार प्राप्त करेंगे।

1. क्या यह एक रिवर्स इंजीनियरिंग का गठन करता है? मुझे लगता है कि यह ऐसा करता है, और जैसा कि अवैध हो सकता है।
2. अगर GUID फॉर्म बदलता है तो टूट जाएगा।

यहां तक ​​कि कूलर का समाधान गतिशील रूप से एक उपकरण होगा, मक्खी पर "फेंक नया" की जगह।

Comments

मैंने ctor से कोड चुराने की कोशिश की, लेकिन यह कई आंतरिक निजी वर्गों को अपना समर्थन कार्य करने के लिए संदर्भित करता है। मेरा विश्वास करो, वह मेरी पहली कोशिश थी।

— इयान बोयड

Answer 15

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

मुझे लगता है कि यह पूरी तरह से लंगड़ा है कि इस सवाल को इतना जटिल होना चाहिए। "या" या "के रूप में" कीवर्ड ठीक होगा यदि एक गाइड शून्य हो सकता है। लेकिन किसी कारण के लिए, भले ही SQL सर्वर इसके साथ ठीक है, .NET नहीं है। क्यों? गाइड का मूल्य क्या है। खाली यह केवल .NET के डिज़ाइन द्वारा बनाई गई एक मूर्खतापूर्ण समस्या है, और यह वास्तव में मुझे परेशान करता है जब किसी भाषा के कन्वेंशन अपने आप पर चलते हैं। अब तक का सबसे अच्छा प्रदर्शन करने वाला उत्तर COM इंटरॉप का उपयोग किया गया है क्योंकि फ्रेमवर्क इसे सुंदर रूप से नहीं संभालता है? "क्या यह स्ट्रिंग GUID हो सकती है?" ऐसा प्रश्न होना चाहिए जिसका उत्तर देना आसान हो।

अपवाद पर फेंक दिया जा रहा है ठीक है, जब तक कि ऐप इंटरनेट पर नहीं जाता है। उस समय मैंने सिर्फ सेवा हमले से इनकार के लिए खुद को स्थापित किया। यहां तक ​​कि अगर मुझे "हमला" नहीं होता है, तो मुझे पता है कि कुछ याहू यूआरएल के साथ बंदर जा रहा है, या शायद मेरा विपणन विभाग एक विकृत लिंक भेज देगा, और फिर मेरे आवेदन को काफी विषम प्रदर्शन का सामना करना पड़ता है जो COULD लाता है सर्वर डाउन होने के कारण मैंने SHOULDN'T होने वाली समस्या से निपटने के लिए अपना कोड नहीं लिखा था, लेकिन हम सभी जानते हैं कि यह क्या होगा।

यह लाइन को "अपवाद" पर थोड़ा सा धुंधला कर देता है - लेकिन नीचे की रेखा, भले ही समस्या कितनी ही बार क्यों न हो, अगर यह थोड़े समय में पर्याप्त बार हो सकती है कि आपका एप्लिकेशन सभी से कैच सर्विसिंग को क्रैश कर देता है, तो मुझे लगता है कि इसका अपवाद फेंकना है। बुरा रूप का।

TheRage3K

Answer 16

यदि TypeOf ctype (myvar, ऑब्जेक्ट) गाइड है तो .....

Answer 17

Private Function IsGuidWithOptionalBraces(ByRef strValue As String) As Boolean
    If String.IsNullOrEmpty(strValue) Then
        Return False
    End If

    Return System.Text.RegularExpressions.Regex.IsMatch(strValue, "^[\{]?[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}[\}]?$", System.Text.RegularExpressions.RegexOptions.IgnoreCase)
End Function


Private Function IsGuidWithoutBraces(ByRef strValue As String) As Boolean
    If String.IsNullOrEmpty(strValue) Then
        Return False
    End If

    Return System.Text.RegularExpressions.Regex.IsMatch(strValue, "^[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}$", System.Text.RegularExpressions.RegexOptions.IgnoreCase)
End Function


Private Function IsGuidWithBraces(ByRef strValue As String) As Boolean
    If String.IsNullOrEmpty(strValue) Then
        Return False
    End If

    Return System.Text.RegularExpressions.Regex.IsMatch(strValue, "^\{[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}\}$", System.Text.RegularExpressions.RegexOptions.IgnoreCase)
End Function

Answer 18

C # में एक विस्तार विधि के साथ

public static bool IsGUID(this string text)
{
    return Guid.TryParse(text, out Guid guid);
}