.NET गतिशील विधियों को डिबग करना

Question

हम LINQ का उपयोग हमारे सिस्टम में बहुत व्यापक रूप से कर रहे हैं। विशेष रूप से LINQ-to-ऑब्जेक्ट्स। तो कुछ स्थानों पर हम स्मृति में एक LINQ क्वेरी को समाप्त करते हैं जो कुछ विशाल अभिव्यक्तियों से बनता है। समस्या तब आती है जब अभिव्यक्तियों में कुछ बग होता है। तो हमें NullReferenceException मिलता है और स्टैक ट्रेस हमें कहीं भी नहीं ले जाता है ([हल्के फ़ंक्शन] तक)। अपवाद को LINQ द्वारा उत्पन्न गतिशील विधि के अंदर फेंक दिया गया था।

क्या ऐसी गतिशील विधियों को डीबग करने का कोई आसान तरीका है? या मुझे WinDBG सीखने के लिए खुद को बलिदान देना है? :-)

Answer 1

यदि आप अपनी अभिव्यक्तियां बना रहे हैं और उन्हें संकलित कर रहे हैं, या AsQueryable का उपयोग कर रहे हैं, तो हाँ; LINQ- जेनरेट की गई विधियां डीबग करने के लिए शाही दर्द होगी।

आप वास्तविक तरीकों के छोटे fragements का उपयोग करके कुछ दर्द को बचा सकता है - कम से कम उपयोगी स्टैक ट्रेस में दिखाई देंगे कुछ ...

एक अन्य विचार है: बल्कि एक विशाल अभिव्यक्ति की तुलना में, यदि आप कर सकते हैं डेज़ी-चेन चीजें थोड़ा और अधिक हो सकती हैं (स्टैक ट्रेस से) जहां यह असफल हो रही है। नकारात्मक प्रदर्शन प्रदर्शन है - एक कहां (foo)। जहां (बार) दो प्रतिनिधि आवेदक हैं, जहां-जहां (foo & & बार) एक हो सकता है।

एक विकल्प विस्तार विधियों के डीबग संस्करण में स्वैप करना हो सकता है; दुर्भाग्य से यह एक छोटे असुविधाजनक है, क्योंकि IQueryable<T> और Queryable एक ही नाम स्थान में रहे हैं ... यह, काम करता है हालांकि ...

आउटपुट पहले:

>Where: x => ((x % 2) = 0) 
<Where: x => ((x % 2) = 0) 
>Count 
'WindowsFormsApplication2.vshost.exe' (Managed): Loaded 'Anonymously Hosted DynamicMethods Assembly' 
<Count 

कोड:

using System; 
using System.Diagnostics; 
using System.Linq.Expressions; 

namespace Demo 
{ 
    using DebugLinq; 
    static class Program 
    { 
     static void Main() 
     { 
      var data = System.Linq.Queryable.AsQueryable(new[] { 1, 2, 3, 4, 5 }); 
      data.Where(x => x % 2 == 0).Count(); 
     } 
    } 
} 
namespace DebugLinq 
{ 
    public static class DebugQueryable 
    { 
     public static int Count<T>(this System.Linq.IQueryable<T> source) 
     { 
      return Wrap(() => System.Linq.Queryable.Count(source), "Count"); 
     } 

     public static System.Linq.IQueryable<T> Where<T>(this System.Linq.IQueryable<T> source, Expression<Func<T, bool>> predicate) 
     { 
      return Wrap(() => System.Linq.Queryable.Where(source, predicate), "Where: " + predicate); 
     } 
     static TResult Wrap<TResult>(Func<TResult> func, string caption) 
     { 
      Debug.WriteLine(">" + caption); 
      try 
      { 
       TResult result = func(); 
       Debug.WriteLine("<" + caption); 
       return result; 
      } 
      catch 
      { 
       Debug.WriteLine("!" + caption); 
       throw; 
      } 
     } 
    } 
} 

Answer 2

यदि आप LINQ से ऑब्जेक्ट्स का उपयोग कर रहे हैं, तो मुझे गतिशील विधियां बनाने की उम्मीद नहीं होगी। मैं उन्हें LINQ से SQL के साथ अपेक्षा करता हूं। क्या आप एक उदाहरण दे सकते हैं जहां आप इसे देख रहे हैं?

LINQ की बात होने पर मेरे पास वास्तव में कोई अच्छी डीबगिंग युक्तियाँ नहीं हैं, लेकिन मुझे यकीन है कि एमएस दर्द के बिंदु के बारे में इस बारे में जानता है। क्या मैं सुझाव दे सकता हूं कि आप VS2010 CTP आज़माएं और देखें कि यह बेहतर है या नहीं? आपकी तत्काल समस्या को हल करने के लिए वीएस में सुधार के लिए और अधिक, स्वीकार्य रूप से।

Answer 3

एक ले लो मूल रूप से Haibo Luo द्वारा विकसित गतिशील विधियों के लिए debug visualizer पर देखें और Roy Osherove