Uji apakah string adalah panduan tanpa melemparkan pengecualian?

Saya ingin mencoba mengubah string menjadi Guid, tetapi saya tidak ingin bergantung pada menangkap pengecualian (

• karena alasan kinerja - pengecualian mahal
• untuk alasan kegunaan - debugger akan muncul
• untuk alasan desain - yang diharapkan tidak luar biasa

Dengan kata lain kodenya:

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

tidak cocok.

Saya akan mencoba menggunakan RegEx, tetapi karena panduan dapat dibungkus tanda kurung, dibungkus kurung, tidak ada yang dibungkus, membuatnya sulit.

Selain itu, saya pikir nilai Guid tertentu tidak valid (?)

Perbarui 1

ChristianK punya ide bagus untuk menangkap saja FormatException, daripada semua. Mengubah contoh kode pertanyaan untuk menyertakan saran.

Perbarui 2

Mengapa khawatir tentang pengecualian yang dilemparkan? Apakah saya benar-benar mengharapkan GUID tidak valid sesering itu?

Jawabannya adalah ya . Itulah mengapa saya menggunakan TryStrToGuid - Saya sedang mengharapkan data yang buruk.

Contoh 1 Ekstensi ruang nama dapat ditentukan dengan menambahkan GUID ke nama folder . Saya mungkin parsing nama folder, memeriksa untuk melihat apakah teks setelah final . adalah 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

Contoh 2 Saya mungkin menjalankan server web yang banyak digunakan ingin memeriksa validitas beberapa data yang diposkan kembali. Saya tidak ingin data yang tidak valid mengikat sumber daya 2-3 pesanan lebih besar dari yang seharusnya.

Contoh 3 Saya mungkin mem-parsing ekspresi pencarian yang dimasukkan oleh pengguna.

Jika mereka memasukkan GUID, saya ingin memprosesnya secara khusus (seperti mencari objek itu secara khusus, atau menyorot dan memformat istilah pencarian tertentu dalam teks respons.)

Perbarui 3 - Tolok ukur kinerja

Uji konversi 10.000 Panduan yang baik, dan 10.000 Panduan yang buruk.

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

ps saya tidak perlu membenarkan pertanyaan.

Tolok Ukur Kinerja

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 Intertop (Tercepat) Jawaban:

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

Intinya: Jika Anda perlu memeriksa apakah string adalah panduan, dan Anda peduli tentang kinerja, gunakan COM Interop.

Jika Anda perlu mengonversi panduan dalam representasi String ke Panduan, gunakan

new Guid(someString);

Setelah .net 4.0 tersedia, Anda dapat menggunakan Guid.TryParse().

Anda tidak akan menyukai ini, tetapi apa yang membuat Anda berpikir bahwa menangkap pengecualian akan menjadi lebih lambat?

Berapa banyak upaya gagal untuk menguraikan GUID yang Anda harapkan dibandingkan dengan yang berhasil?

Saran saya adalah gunakan fungsi yang baru saja Anda buat dan profil kode Anda. Jika Anda menemukan bahwa fungsi ini benar-benar hotspot maka perbaiki tetapi tidak sebelumnya.

Di .NET 4.0 Anda dapat menulis sebagai berikut:

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

Setidaknya saya akan menulis ulang sebagai:

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

Anda tidak ingin mengatakan "GUID tidak valid" pada SEHException, ThreadAbortException atau hal-hal fatal atau tidak terkait lainnya.

Pembaruan : Dimulai dengan .NET 4.0, ada serangkaian metode baru yang tersedia untuk Guid:

• Guid.TryParse
• Guid.TryParseExact

Sungguh, itu harus digunakan (jika hanya untuk fakta, bahwa mereka tidak "naif" diimplementasikan menggunakan try-catch secara internal).

Interop lebih lambat dari sekedar menangkap pengecualian:

Di jalan yang bahagia, dengan 10.000 Panduan:

Exception:    26ms
Interop:   1,201ms

Di jalan yang tidak bahagia:

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

Ini lebih konsisten, tetapi juga lebih lambat secara konsisten. Menurut saya, Anda sebaiknya mengkonfigurasi debugger Anda hanya untuk istirahat pada pengecualian yang tidak tertangani.

Nah, inilah regex yang Anda butuhkan ...

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

Tapi itu hanya untuk pemula. Anda juga harus memverifikasi bahwa berbagai bagian seperti tanggal / waktu berada dalam rentang yang dapat diterima. Saya tidak bisa membayangkan ini menjadi lebih cepat daripada metode coba / tangkap yang telah Anda uraikan. Semoga Anda tidak menerima banyak GUID yang tidak valid untuk menjamin jenis cek ini!

untuk alasan kegunaan - debugger akan muncul

Jika Anda akan mencoba pendekatan coba / tangkap, Anda dapat menambahkan atribut [System.Diagnostics.DebuggerHidden] untuk memastikan debugger tidak merusak bahkan jika Anda telah menetapkannya untuk istirahat saat melempar.

Sementara itu adalah benar bahwa menggunakan kesalahan lebih mahal, kebanyakan orang percaya bahwa mayoritas GUID mereka akan menjadi komputer yang dihasilkan sehingga TRY-CATCHtidak terlalu mahal karena hanya menghasilkan biaya pada CATCH. Anda dapat membuktikan ini pada diri sendiri dengan tes sederhana keduanya (pengguna publik, tanpa kata sandi).

Ini dia:

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

Saya memiliki situasi yang sama dan saya perhatikan bahwa hampir tidak pernah ada string 36 karakter yang tidak valid. Jadi berdasarkan fakta ini, saya sedikit mengubah kode Anda untuk mendapatkan kinerja yang lebih baik sambil tetap membuatnya sederhana.

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

Sejauh yang saya tahu, tidak ada sesuatu seperti Guid.TryParse di mscrolib. Menurut Sumber Referensi, tipe Guid memiliki konstruktor mega-kompleks yang memeriksa semua jenis format panduan dan mencoba untuk menguraikannya. Tidak ada metode pembantu yang bisa Anda panggil, bahkan melalui refleksi. Saya pikir Anda harus mencari parser Guid pihak ketiga, atau menulis sendiri.

Jalankan potensi GUID melalui RegEx atau beberapa kode kustom yang melakukan pemeriksaan kewarasan untuk memastikan strig setidaknya terlihat seperti GUID dan hanya terdiri dari karakter yang valid (dan mungkin sepertinya cocok dengan format keseluruhan). Jika tidak lulus pemeriksaan kewarasan, kembalikan kesalahan - yang mungkin akan menyingkirkan sebagian besar string tidak valid.

Kemudian konversi string seperti yang Anda miliki di atas, masih menangkap pengecualian untuk beberapa string tidak valid yang melewati pemeriksaan kewarasan.

Jon Skeet melakukan analisis untuk sesuatu yang mirip dengan parsing Ints (sebelum TryParse ada dalam Framework): Memeriksa apakah string dapat dikonversi ke Int32

Namun, seperti yang ditunjukkan AnthonyWJones Anda mungkin tidak perlu khawatir tentang ini.

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

• Dapatkan Reflektor
• copy'n'paste Guid's .tor (String)
• ganti setiap kejadian "throw new ..." dengan "return false".

Ctor Guid adalah regex yang dikompilasi, sehingga Anda akan mendapatkan perilaku yang sama persis tanpa pengecualian.

1. Apakah ini merupakan rekayasa terbalik? Saya pikir itu benar, dan karena itu mungkin ilegal.
2. Akan pecah jika bentuk GUID berubah.

Bahkan solusi yang lebih keren adalah dengan instrumen dinamis metode, dengan mengganti "melemparkan baru" dengan cepat.

Saya memilih tautan GuidTryParse yang diposting di atas oleh Jon atau solusi serupa (IsProbablyGuid). Saya akan menulis yang seperti itu untuk perpustakaan Konversi saya.

Saya pikir itu benar-benar lumpuh bahwa pertanyaan ini harus sangat rumit. Kata kunci "is" atau "as" akan baik-baik saja JIKA seorang Guid bisa menjadi nol. Tetapi untuk beberapa alasan, meskipun SQL Server tidak masalah dengan itu, .NET tidak. Mengapa? Berapa nilai Guid.Empty? Ini hanya masalah konyol yang dibuat oleh desain. NET, dan itu benar-benar mengganggu saya ketika konvensi bahasa menginjak dirinya sendiri. Jawaban berkinerja terbaik sejauh ini telah menggunakan COM Interop karena Framework tidak menanganinya dengan anggun? "Bisakah string ini menjadi GUID?" harus menjadi pertanyaan yang mudah dijawab.

Mengandalkan pengecualian yang dilemparkan tidak apa-apa, sampai aplikasi berjalan di internet. Pada saat itu saya hanya mengatur diri saya untuk penolakan serangan layanan. Bahkan jika saya tidak "diserang", saya tahu beberapa yahoo akan mengunggah URL, atau mungkin departemen pemasaran saya akan mengirimkan tautan yang salah, dan kemudian aplikasi saya harus mengalami kinerja yang lumayan kuat yang BISA dibawa ke server karena saya tidak menulis kode saya untuk menangani masalah yang TIDAK HARUS terjadi, tetapi kita semua tahu AKAN TERJADI.

Ini mengaburkan garis sedikit pada "Pengecualian" - tetapi intinya, bahkan jika masalahnya jarang terjadi, jika itu bisa terjadi cukup banyak dalam jangka waktu pendek sehingga aplikasi Anda crash melayani tangkapan dari itu semua, maka saya pikir melempar pengecualian adalah bentuk buruk.

TheRage3K

jika Typet dari ctype (myvar, Object) Is Guid maka .....

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

Dengan metode ekstensi dalam C #

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