Test czy string jest guid bez rzucania WYJĄTKÓW?

Po udostępnieniu. NET 4.0 możesz użyć Guid.TryParse().

Nie spodoba ci się to, ale co sprawia, że myślisz, że łapanie wyjątku będzie wolniejsze?

Ile nieudanych prób parsowania GUID oczekujesz w porównaniu z udanymi?

Radzę użyć funkcji, którą właśnie stworzyłeś i profilować swój kod. Jeśli okaże się, że ta funkcja jest naprawdę hotspotem , to napraw ją, ale nie wcześniej.

W. NET 4.0 można pisać w następujący sposób:

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

Napisałbym to przynajmniej jako:

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

Nie chcesz powiedzieć "invalid GUID" na SEHException, ThreadAbortException lub innych fatalnych lub niezwiązanych z nimi rzeczy.

Update : począwszy od. NET 4.0, dostępny jest nowy zestaw metod dla Guid:

• Guid.TryParse
• Guid.TryParseExact

Naprawdę, powinny one być używane (choćby dlatego, że nie są" naiwnie " zaimplementowane wewnętrznie przy użyciu try-catch).

Interop jest wolniejszy niż wyłapywanie wyjątku:

Na szczęśliwej ścieżce, z 10 000 Guidami:

Exception:    26ms
Interop:   1,201ms

Na nieszczęśliwej drodze:

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

Cóż, oto regex, którego będziesz potrzebować...

^[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}(}})$

Ze względów użyteczności-debugger wyskakuje

Jeśli wybierasz podejście try / catch, możesz dodać [System.Diagnostyka.DebuggerHidden] atrybut, aby upewnić się, że debugger nie pęka, nawet jeśli Ustawiłeś go na break na throw.

Chociażjest prawdą, że używanie błędów jest droższe, większość ludzi wierzy, że większość ich GUID zostanie wygenerowana komputerowo, więc TRY-CATCH nie jest zbyt droga, ponieważ generuje tylko koszty na CATCH. Możesz to udowodnić sobie za pomocą prostego testu dwóch (użytkownik publiczny, bez hasła).

Proszę bardzo:

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

Miałem podobną sytuację i zauważyłem, że prawie nigdy nie był nieprawidłowy ciąg 36 znaków. Bazując na tym fakcie, zmieniłem trochę Twój kod, aby uzyskać lepszą wydajność, a jednocześnie zachować prostotę.

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

Z tego co wiem, nie ma czegoś takiego jak Guid.Spróbuj w mscrolib. Zgodnie ze źródłem odniesienia, Typ Guid ma mega-złożony konstruktor, który sprawdza wszystkie rodzaje formatów guid i próbuje je przeanalizować. Nie ma metody pomocniczej, którą można wywołać, nawet poprzez odbicie. Myślę, że trzeba szukać 3rd party Guid parsery, lub napisać swój własny.

Uruchom potencjalny identyfikator GUID za pomocą RegEx lub niestandardowego kodu, który sprawdza rozsądność, aby upewnić się, że strig przynajmniej wygląda jak GUID i składa się tylko z ważnych znaków (i może wydaje się pasować do ogólnego formatu). Jeśli nie przejdzie przez sanity check zwróć błąd - to prawdopodobnie usunie zdecydowaną większość nieprawidłowych ciągów.

Następnie przekonwertuj łańcuch jak powyżej, wciąż łapiąc wyjątek dla kilku nieprawidłowych łańcuchów, które przechodzą przez sanity szach.

Jon Skeet zrobił analizę dla czegoś podobnego do parsowania Ints (zanim TryParse był w frameworku): sprawdzanie, czy łańcuch znaków może być przekonwertowany na Int32

Jednak, jak AnthonyWJones wskazała, że prawdopodobnie nie powinieneś się tym martwić.

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

• Pobierz Reflektor
Copy ' n 'Paste Guid' s .ctor (String)
• zastąp każde wystąpienie " rzucaj nowe ..."z "return false".

Ctor Guida jest w zasadzie skompilowanym regexem, w ten sposób uzyskasz dokładnie to samo zachowanie bez narzutu wyjątku.

Czy to jest inżynieria odwrotna? Myślę, że tak, i jako takie może być nielegalne.
1. złamie się, jeśli zmieni się formularz GUID.

Jeszcze chłodniejszym rozwiązaniem byłoby dynamicznie instrument metody, zastępując "throw new" w locie.

Głosuję za linkiem GuidTryParse zamieszczonym powyżej przez Jon lub podobnym rozwiązaniem (IsProbablyGuid). Będę pisał takie jak te dla mojej biblioteki konwersji.

Myślę, że to beznadziejne, że to pytanie musi być tak skomplikowane. Słowo kluczowe " is " Lub " as " byłoby w porządku, gdyby identyfikator Guid mógł być null. Ale z jakiegoś powodu, nawet jeśli SQL Server jest w porządku z tym,. NET nie jest. Dlaczego? Jaka jest wartość Guid.Pusty? Jest to po prostu głupi problem stworzony przez projekt. NET, i to naprawdę denerwuje mnie, gdy konwencje języka krok na siebie. Jak do tej pory najlepszą odpowiedzią było użycie COM Interop, bo Framework nie radzi sobie z tym z gracją? "Czy ten ciąg może być GUID?"powinno być to pytanie, na które łatwo odpowiedzieć.

Opieranie się na rzucanym wyjątku jest OK, dopóki aplikacja nie przejdzie do Internetu. W tym momencie ustawiłem się na atak typu odmowa usługi. Nawet jak mnie nie "zaatakują" to Wiem, że jakiś yahoo będzie małpą z URL, a może mój dział marketingu wyśle nieprawidłowy link, a potem moja aplikacja musi cierpieć dość silny hit wydajności, który może zniszczyć serwer, ponieważ nie napisałem kodu, aby poradzić sobie z problemem, który nie powinien się zdarzyć, ale wszyscy wiemy, że się stanie.

To zaciera linię nieco na "wyjątek" - ale podsumowując, nawet jeśli problem jest rzadki, jeśli może się zdarzyć wystarczająco dużo razy w krótkim czasie, że aplikacja zawiesza się obsługując połowy z tego wszystkiego, więc myślę, że rzucanie WYJĄTKÓW to zła forma.

TheRage3K

If TypeOf ctype (myvar,Object) Is Guid then .....

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

Z metodą rozszerzenia w C #

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