Wie schreibe ich eine asynchrone LINQ-Abfrage?

Nachdem ich gelesen habe eine Reihe von LINQ-related stuff, plötzlich merkte ich, dass keine Artikel einführen, wie Sie zum schreiben asynchroner LINQ-Abfrage.

Nehmen wir an, wir verwenden von LINQ to SQL, unterhalb Aussage ist klar. Allerdings, wenn der SQL-Datenbank langsam reagiert, dann wird der thread mit dieser code-block würde behindert werden.

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

Scheint, dass die aktuellen LINQ-query-Spezifikation nicht unterstützen.

Gibt es eine Möglichkeit, um asynchrone Programmierung LINQ? Es funktioniert, wie es ist ein callback
Benachrichtigung, wenn die Ergebnisse sind einsatzbereit-ohne blocking-delay auf der I/O.

InformationsquelleAutor der Frage Morgan Cheng | 2008-10-31

asynchronous c#linq linq-to-sql

Während LINQ nicht wirklich per se der Rahmen selbst nicht... Sie können einfach Rollen Sie Ihre eigenen asynchrone Abfrage Testamentsvollstrecker in 30 Zeilen oder so... In der Tat, ich warf gerade diese für Sie zusammen 🙂

EDIT: Durch das schreiben dieses, ich habe entdeckt, warum Sie nicht umsetzen. Es nicht in den Griff anonyme Typen, da Sie den Gültigkeitsbereich lokaler. So haben Sie keine Möglichkeit zum definieren der callback-Funktion. Dies ist eine ziemlich große Sache, da eine Menge von linq to sql-Inhalte erstellt, werden Sie in der select-Klausel. Einer der folgenden Vorschläge, die das gleiche Schicksal erleiden, also ich immer noch denke, das ist am einfachsten zu verwenden!

EDIT: Die einzige Lösung ist nicht zu verwenden, anonyme Typen. Sie können erklären, den Rückruf als nur IEnumerable (kein Typ args), und verwenden Sie reflektion, um auf die Felder (ICK!!). Ein anderer Weg wäre zu erklären, den Rückruf als "dynamische"... oh... warte... Das ist noch nicht aus. 🙂 Das ist ein anderes anständiges Beispiel, wie dynamische verwendet werden könnten. Manche nennen es Missbrauch.

Werfen Sie diese in Ihrem utilities-Bibliothek:

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

Und Sie können es verwenden, wie diese:

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

}

Gehen, setzen Sie diese auf meinem blog nun, ziemlich praktisch.

InformationsquelleAutor der Antwort TheSoftwareJedi

13

TheSoftwareJedi und ulrikb's(aka user316318) Lösungen sind gut für alle LINQ-Typ, aber (wie bereits von Chris Moschini) tun, NICHT delegieren zu Grunde liegenden asynchrone Aufrufe, die nutzen Windows I/O Completion Ports.

Wesley Bakker ist Asynchrone DataContext post (ausgelöst durch ein blog-post von Scott Hanselman ) beschreiben Klassen für LINQ to SQL verwendet sqlCommand.BeginExecuteReader/sqlCommand.EndExecuteReader, die nutzen Windows I/O Completion Ports.

I/O completion ports bieten eine effiziente threading-Modell für die Verarbeitung von mehreren asynchronen I/O-Anfragen auf einem Multiprozessor-system.

InformationsquelleAutor der Antwort Michael Freidgeim

Basierend auf Michael Freidgeim Antwort und erwähnt blog-post von Scott Hansellman und die Tatsache, dass Sie verwenden können async/awaitdie Sie umsetzen können wiederverwendbare ExecuteAsync<T>(...) Methode, die ausgeführt wird, zugrunde liegenden SqlCommand asynchron:

protected static async Task<IEnumerable<T>> ExecuteAsync<T>(IQueryable<T> query,
    DataContext ctx,
    CancellationToken token = default(CancellationToken))
{
    var cmd = (SqlCommand)ctx.GetCommand(query);

    if (cmd.Connection.State == ConnectionState.Closed)
        await cmd.Connection.OpenAsync(token);
    var reader = await cmd.ExecuteReaderAsync(token);

    return ctx.Translate<T>(reader);
}

Und dann können Sie (wieder -) verwenden Sie es wie diese:

public async Task WriteNamesToConsoleAsync(string connectionString, CancellationToken token = default(CancellationToken))
{
    using (var ctx = new DataContext(connectionString))
    {
        var query = from item in Products where item.Price > 3 select item.Name;
        var result = await ExecuteAsync(query, ctx, token);
        foreach (var name in result)
        {
            Console.WriteLine(name);
        }
    }
}

InformationsquelleAutor der Antwort Nenad

3

Begann ich eine einfache github-Projekt mit dem Namen Asynq asynchrone LINQ-to-SQL-Abfrageausführung. Die Idee ist ganz einfach-wenn auch "spröde" zu diesem Zeitpunkt (wie von 8/16/2011):
1. Lassen LINQ-to-SQL-die "schwere" Arbeit der übersetzung Ihrer IQueryable in eine DbCommand über die DataContext.GetCommand().
2. Für SQL-200[058], verschlägt es von der abstrakten DbCommand Instanz, die Sie von GetCommand() zu bekommen SqlCommand. Wenn Sie mit SQL-CE-Sie haben Pech, da SqlCeCommand nicht aussetzen async-pattern für BeginExecuteReader und EndExecuteReader.
3. Verwenden BeginExecuteReader und EndExecuteReader aus der SqlCommand mit dem standard .NET framework asynchrone I/O-Muster, um sich selbst ein DbDataReader im Abschluss callback-Delegaten, den Sie an die BeginExecuteReader Methode.
4. Jetzt haben wir eine DbDataReader denen wir keine Ahnung haben, welche Spalten es enthält noch, wie die Zuordnung dieser Werte zu sichern, um die IQueryable's ElementType (die meisten wahrscheinlich ein anonymer Typ im Falle von joins). Sicher, an diesem Punkt könnten Sie hand-schreiben Sie Ihre eigene Spalte mapper materialisiert seine Ergebnisse wieder in Ihren anonymen Typ oder was auch immer. Sie müssten, um ein neues zu schreiben pro Abfrage-Ergebnis geben, je nachdem, wie LINQ-to-SQL behandelt Ihre IQueryable und was SQL-code, den es erzeugt. Dies ist eine ziemlich Fiese option, und ich empfehle es nicht, da es nicht verwaltbar es wäre auch nicht immer richtig. LINQ-to-SQL kann ändern Sie Ihre Abfrage, Formular, je nachdem die Werte der parameter, den Sie übergeben, zum Beispiel query.Take(10).Skip(0) produziert verschiedene SQL als query.Take(10).Skip(10)und vielleicht einen anderen resultset-schema. Ihre beste Wette ist, um diese zu bewältigen Materialisierung problem programmatisch:
5. "Re-Implementierung" eine vereinfachte runtime-Objekt materializer, zieht Spalten aus der DbDataReader in einer definierten Reihenfolge nach dem LINQ-to-SQL-mapping von Attributen des ElementType Typ für die IQueryable. Die Umsetzung dieser korrekt ist wohl der schwierigste Teil dieser Lösung.
Als andere entdeckt haben, die DataContext.Translate() Methode nicht behandeln, anonyme Typen und kann nur eine Karte DbDataReader direkt an eine ordnungsgemäß zurückgeführt LINQ-to-SQL-proxy-Objekt. Da die meisten Abfragen Wert, schriftlich in LINQ gehen, um komplexe joins, die unausweichlich, dass anonyme Typen für die abschließende select-Klausel, es ist ziemlich sinnlos, diese zu verwenden, vorausgesetzt verwässerten DataContext.Translate() Methode sowieso.

Gibt es ein paar kleine Nachteile bei dieser Lösung, wenn die Nutzung der bestehenden Reifen LINQ-to-SQL, das IQueryable-Anbieter:
1. Sie nicht zuordnen kann ein einzelnes Objekt-Instanz auf mehrere anonyme Typ-Eigenschaften in der abschließenden select-Klausel der IQueryable z.B. from x in db.Table1 select new { a = x, b = x }. LINQ-to-SQL-intern verfolgt die Spalte Ordnungszahlen Karte, um die Eigenschaften; ist es nicht aussetzen diese Informationen, um die Endbenutzer-also Sie haben keine Ahnung, welche Spalten in der DbDataReader wiederverwendet werden und die "distinct".
2. Sie nicht sind Konstante Werte, die in der endgültigen select-Klausel - diese nicht übersetzt werden in die SQL-und abwesend sein wird aus der DbDataReader so hätten Sie zum erstellen von benutzerdefinierten Logik zu ziehen, diese Konstanten Werte aus der IQueryable's Expression Baum, das wäre ziemlich mühsam und ist einfach nicht vertretbar.
Ich bin sicher, es gibt andere Abfrage-Muster, die vielleicht brechen, aber diese sind die zwei größten die ich mir vorstellen könnte, dass könnte zu Problemen führen, in eine bestehende LINQ-to-SQL-data-access-layer.

Diese Probleme sind leicht zu besiegen - einfach nicht tun Sie in Ihren Abfragen, da es keine Muster gibt keinen Vorteil, um das Ergebnis der Abfrage. Hoffentlich wird dieser Rat gilt für alle query-Muster, die potenziell zu Objekt Materialisierung Probleme :-P. Es ist ein schwieriges problem zu lösen, dass Sie keinen Zugang zu LINQ-to-SQL-Spalte mapping-Informationen.

Mehr "komplett" Ansatz zur Lösung des Problems wäre, um effektiv zu re-implementieren fast alle LINQ-to-SQL, das ist ein bisschen mehr Zeit in Anspruch :-P. ab einer Qualität, open-source-LINQ-to-SQL-provider-Implementierung wäre ein guter Weg, hier zu gehen. Der Grund, warum Sie brauchen, um zu implementieren ist es so, dass Sie hätten Zugang zu allen von der Spalte mapping-Informationen verwendet, um zu materialisieren, die DbDataReader Ergebnisse wieder bis auf ein Objekt-Instanz, ohne den Verlust von Informationen.

InformationsquelleAutor der Antwort James Dunne

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.