看了一堆LINQ相关的东西，突然发现没有文章介绍如何写异步LINQ查询。

假设我们使用 LINQ to SQL，下面的语句很清楚。但是，如果 SQL 数据库响应缓慢，则使用该代码块的线程将受到阻碍。

var result = from item in Products where item.Price > 3 select item.Name;
foreach (var name in result)
{
    Console.WriteLine(name);
}

似乎当前的 LINQ 查询规范不对此提供支持。

LINQ 有什么办法可以做异步编程吗？就像有回调一样工作 结果准备好使用时发出通知，不会对 I/O 造成任何阻塞延迟。

最佳答案

虽然 LINQ 本身并没有这个功能，但框架本身有...您可以轻松地在 30 行左右的范围内滚动您自己的异步查询执行程序...事实上，我只是为您把它放在一起 :)

编辑:通过写这篇文章，我发现了为什么他们没有实现它。它不能处理匿名类型，因为它们是局部范围的。因此，您无法定义回调函数。 这是一件非常重要的事情，因为很多 linq to sql 的东西在 select 子句中创建它们。以下任何一个建议都会遭遇同样的命运，所以我仍然认为这个是最容易使用的!

编辑:唯一的解决方案是不使用匿名类型。您可以将回调声明为仅采用 IEnumerable(无类型参数)，并使用反射来访问字段(ICK!!)。另一种方法是将回调声明为“动态”……哦……等等……那还没有出来。 :) 这是另一个如何使用动态的不错的例子。有些人可能称之为滥用。

将其放入您的实用程序库中:

public static class AsynchronousQueryExecutor
{
    public static void Call<T>(IEnumerable<T> query, Action<IEnumerable<T>> callback, Action<Exception> errorCallback)
    {
        Func<IEnumerable<T>, IEnumerable<T>> func =
            new Func<IEnumerable<T>, IEnumerable<T>>(InnerEnumerate<T>);
        IEnumerable<T> result = null;
        IAsyncResult ar = func.BeginInvoke(
                            query,
                            new AsyncCallback(delegate(IAsyncResult arr)
                            {
                                try
                                {
                                    result = ((Func<IEnumerable<T>, IEnumerable<T>>)((AsyncResult)arr).AsyncDelegate).EndInvoke(arr);
                                }
                                catch (Exception ex)
                                {
                                    if (errorCallback != null)
                                    {
                                        errorCallback(ex);
                                    }
                                    return;
                                }
                                //errors from inside here are the callbacks problem
                                //I think it would be confusing to report them
                                callback(result);
                            }),
                            null);
    }
    private static IEnumerable<T> InnerEnumerate<T>(IEnumerable<T> query)
    {
        foreach (var item in query) //the method hangs here while the query executes
        {
            yield return item;
        }
    }
}

你可以这样使用它:

class Program
{

    public static void Main(string[] args)
    {
        //this could be your linq query
        var qry = TestSlowLoadingEnumerable();

        //We begin the call and give it our callback delegate
        //and a delegate to an error handler
        AsynchronousQueryExecutor.Call(qry, HandleResults, HandleError);

        Console.WriteLine("Call began on seperate thread, execution continued");
        Console.ReadLine();
    }

    public static void HandleResults(IEnumerable<int> results)
    {
        //the results are available in here
        foreach (var item in results)
        {
            Console.WriteLine(item);
        }
    }

    public static void HandleError(Exception ex)
    {
        Console.WriteLine("error");
    }

    //just a sample lazy loading enumerable
    public static IEnumerable<int> TestSlowLoadingEnumerable()
    {
        Thread.Sleep(5000);
        foreach (var i in new int[] { 1, 2, 3, 4, 5, 6 })
        {
            yield return i;
        }
    }

}

现在打算把它放在我的博客上，非常方便。

关于c# - 如何编写异步 LINQ 查询？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/252355/