SERİ ile ilgili bir şeyler okuduktan sonra, aniden makaleler asenkron SERİ sorgu yazmak nasıl tanıtmak olduğunu fark etti.

SERİ net bir açıklama aşağıda SQL, kullanmak varsayalım. Eğer SQL veritabanı yavaş yanıt verirse, ancak o zaman konu bu kod bloğunu kullanarak engel olurdu.

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

Görünen geçerli ETMENİZ sorgu spec buna destek vermez.

Zaman uyumsuz programlama ETMENİZ yapmak için herhangi bir yolu var mı? Bir geri arama var gibi çalışıyor sonuçlar üzerinde herhangi bir engelleme gecikme olmadan kullanıma hazır olduğunda bildirim O./

Süre ETMENİZ yok aslında bu başlı başına, çerçeve kendisi yapar... kolay top kendi zaman uyumsuz sorgu uygulamakla 30 çizgiler ya da öylesine... aslında, ben sadece attı bu arada senin için :)

EDİT: bu yazı Aracılığıyla, bu uygulamaya neden yapmadıklarını fark ettim. Olamaz yerel kapsamlı olduklarından, anonim türleri. Bu nedenle, geri arama işlevini tanımlamak mümkün.Bu sql şeyler bu seri çok select yan tümcesi onları yarattığı için oldukça önemli bir şeydir. Öneriler altında aynı kaderi, ben hala bu kullanımı en kolay olduğunu düşünüyorum!

EDİT: tek çözüm anonim türleri kullanmaktır. Sadece IEnumerable (tip argüman) olarak geri bildirmek ve yansıma alanları erişmek için kullanabilirsiniz (!! İCK). Başka bir yol geri olarak ilan olur ""... ah... henüz değil. dinamik :) Bu nasıl kullanılabileceğine dair iyi bir örnektir. Bazıları bunu istismar diyebilir.

Bu yararlı programlar kütüphane: at

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

Ve bu gibi kullanabilirsiniz:

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

}

Gidip blogumda bu şimdi, çok elinizin altında.