调试 .NET 动态方法

发布于 2024-07-07 21:36:40 字数 251 浏览 12 评论 0原文

我们在我们的系统中非常广泛地使用 LINQ。特别是 LINQ 到对象。因此，在某些地方，我们最终会在内存中使用一些巨大的表达式构建 LINQ 查询。当表达式中存在一些错误时，问题就会出现。因此，我们得到 NullReferenceException，并且堆栈跟踪无法引导我们（到达 [轻量级函数]）。异常是在 LINQ 生成的动态方法内引发的。

有没有简单的方法来调试这种动态方法？还是我必须牺牲自己来学习WinDBG？ :-)

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

智商已欠费 2024-07-14 21:36:40

如果您正在构建自己的表达式并编译它们，或者使用 AsQueryable，那么是的； LINQ 生成的方法调试起来会非常痛苦。

您可以通过使用实际方法的小片段来减轻一些痛苦 - 至少在堆栈跟踪中会显示一些有用的东西...

另一个考虑因素是：如果您可以菊花链，而不是使用一个巨大的表达式事情多一点，您可能会更清楚（从堆栈跟踪）它失败的地方。缺点是性能 -Where(foo).Where(bar) 是两个委托调用，where-asWhere(foo && bar) 可以是一个。

一种选择可能是交换扩展方法的调试版本；不幸的是，这有点不方便，因为 IQueryable 和 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;
            }
        }
    }
}

If you are building your own expressions and compiling them, or using AsQueryable, then yes; the LINQ-generated methods will be a royal pain to debug.

You can save some pain by using small fragements of actual methods - at least something useful will show in the stack trace...

Another consideration is: rather than having one huge expression, if you can daisy-chain things a bit more you might have more idea (from the stack trace) where it is failing. The downside is performance - a Where(foo).Where(bar) is two delegate invokes, where-as Where(foo && bar) can be one.

One option might be to swap in a debug version of the extension methods; unfortunately it is a little inconvenient because IQueryable<T> and Queryable are in the same namespace... this works, though...

Output first:

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

Code:

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

回复收藏 0 原文