Mehrere Suchparameter mit LINQ

Ich bin das schreiben, was ich glauben sollte ein relativ straight-forward-Windows Form app. Ich bin mit LINQ to SQL, aber ich habe es nie benutzt, bevor. Wir haben eine SQL Server-Datenbank, und ich bin die Schaffung eines front-end-Zugriff auf die Datenbank. Ich versuche, herauszufinden, den effizientesten Weg zu suchen, für mehrere (beliebig viele) Suche nach Parametern mit ihm.

In der windows-form, die ich erstellen ein Wörterbuch mit jeder Suche Schlüssel und dessen Wert zu suchen, und übergeben Sie in meine search () - Methode. Ich versuche einen Weg zu finden, um die Datenbank zu durchsuchen, die mit jeder dieser Schlüssel und die dazugehörigen Werte. Hier ist, was ich versuche zu tun:

public IQueryable<Product> Search(Dictionary<string, string> searchParams)
{
   DBDataContext dc = new DBDataContext();
   var query = dc.Products;

   foreach (KeyValuePair<string, string> temp in searchParams)
   {
      query = query.Where(x => x.(temp.Key) == temp.Value);
   }

   return query;
}

Merke ich, dass syntaktisch x.(temp.Schlüssel) ist falsch, aber ich hoffe, das veranschaulicht, was ich versuche zu tun. Ich Frage mich, ob es einen anderen Weg zu gehen über das, was ich versuche zu tun, ohne zu tun, eine riesige switch-Anweisung (if/else if-Struktur).

BEARBEITEN

So, ich überarbeitete es ein wenig, aber ich bin immer noch Probleme mit ihm. Hier ist, was ich derzeit habe:

public IQueryable<Product> Search(Dictionary<string, string> searchParams)
{
    DBDataContext dc = new DBDataContext();

    string sQuery = "";
    foreach (KeyValuePair<string, string> temp in searchParams)
    {
        sQuery += temp.Key + "=" + temp.Value + " AND ";
    }

    var query = dc.Products.Where(sQuery);

    return query;
}

Entsprechend der LINQ Dynamic Query Library-Artikel, das sollte OK sein. Hier ist der Fehler, die ich immer bin:

Den Typ der Argumente für die Methode 'System.Linq -.Queryable.Wo(System.Linq -.IQueryable, System.Linq -.Ausdrücke.Ausdruck>)' kann nicht abgeleitet werden aus der Nutzung. Versuchen Sie, den Typ der Argumente explizit.

Gibt es einen Grund, dass die Such-parameter der Methode muss ein Wörterbuch eher als eine Func - <Produkt -, bool> ???
Nicht ganz sicher, was du damit meinst... könntest du das bitte klären?
Jeden Schlüssel im dictionary enthält die Parameter für die Suche (und jedem Parameter Wert zu suchen).
Gemäß Ihrer dynamischen Abfrage-generator Beispiel, ich habe einen edit in Bezug auf das "UND" am Ende unten, das wird sich hoffentlich lösen es für Sie.

InformationsquelleAutor jnevelson | 2010-10-28

c#linq-to-sql

3

Hier ein Beispiel das funktioniert (habe es gerade getestet), mit der Dynamische LINQ-Abfrage Bibliothek.
```
using System.Linq.Dynamic;
//...

Dictionary<string, string> searchParams = new Dictionary<string,string>();

searchParams.Add("EmployeeID", "78");
searchParams.Add("EmpType", "\"my emp type\"");

IQueryable<Employee> query = context.Employees;

foreach (KeyValuePair<string, string> keyValuePair in searchParams)
{
    query = query.Where(string.Format("{0} = {1}", keyValuePair.Key,  keyValuePair.Value));
}

List<Employee> employees = query.ToList();
```
Und, um es absolut klar, dass dieser code tatsächlich funktioniert hier ist die tatsächlichen generierten SQL:
```
FROM [HumanResources].[Employee] AS [t0]
WHERE ([t0].[EmpType] = @p0) AND ([t0].[EmployeeID] = @p1)',N'@p0 nvarchar(11),@p1 int',@p0=N'my emp type',@p1=78
```
- Naja es schließlich kompiliert, das ist also ein großer Erster Schritt. Vielen DANK an Sie und Kevin Nelson. Anderes problem jetzt: Wenn ich in einen Wert zu suchen, wird eine Ausnahme geworfen, die DynamicLibrary, dass keine Eigenschaft oder das Feld [Wert, den ich gesucht] existiert in 'Produkte'. So scheint es, dass eher als die Suche nach dem Wert in jedem Eintrag ist der Schlüssel, es ist suchen, jeder Eintrag für ein Feld das ist der Wert, den ich suchen will. Wenn ich bin auf der Suche nach ein Vorname, es ist auf der Suche nach Mitarbeiter.jonathan = first_name, sondern als Mitarbeiter.first_name = jonathan.
- Ich habe versucht, schalten Sie die Reihenfolge der query string query = query.Wo(string.Format("{0} = {1}", keyValuePair.Wert, keyValuePair.Key)); und es immer noch wirft den gleichen Ausnahme.
- Im debugger scheint es, dass egal, die Reihenfolge der Schlüssel und Wert in das Wörterbuch, DynamicLibrary sucht immer gegen den Wert, sondern als der Schlüssel.
- Hmmm, es ist schwer zu sagen, ohne zu sehen, Ihre tatsächlichen code. Umschalten-Taste und der Wert wird nicht helfen. Eine Strategie ist nur vorübergehend fest Ihre query-string in der Where() zu beseitigen, string-building-Fehler, und stellen Sie sicher, es funktioniert erstmal so. Wie: query = query.Wo("EmployeeID = 78"); und so weiter.
- Auch, möchten Sie vielleicht verwenden Sie SQL Server Profiler, um zu überprüfen, die generierte SQL-Abfrage. Wenn ich mich Recht erinnere, ist der VS-debugger nicht in der Lage, zeigen Sie die SQL wenn Sie mit Dynamischen.
- Du bist jetzt offen für alle Arten von SQL-injections. Sie nicht entkommen können Werte, die Sie nicht zitieren, Streicher. Letzteres ist wahrscheinlich die Ursache der Ausnahmen. SELECT * FROM Produkte WHERE name = lecker Kuchen?
- Injektionen: Dynamische LINQ-Prozesse den input-string weiter zu verhindern-Injektionen. Siehe Dritten Kommentar von Scott Gu sich auf die Dynamische LINQ-Seite, die ich verlinkt in meiner Antwort. Ich habe das ist generiert die SQL auf meine Antwort. ich habe getestet und überprüft, ob der code in meiner Antwort (ich immer tun) und es funktioniert, wie ich vorgeschlagen haben.
- OK, tut mir Leid. Dynamische LINQ zu sein scheint schlauer, als ich dachte. 🙂 Trotzdem, es ist wie mit einem Dampf-hammer zum Nüsse knacken... ich weiß nicht, warum Jonathan beharrt auf der Verwendung von Paaren von strings Zugriff auf Werte.
InformationsquelleAutor shaunmartin
2

Wenn das Wörterbuch ist nicht erforderlich, für einige Grund, würde ich die Suche-Methode wie folgt:
```
public IQueryable<Product> Search( Func<Product, bool> isMatch )
{
   DBDataContext dc = new DBDataContext();
   return dc.Products.Where( isMatch ).AsQueryable();
}
```
Dann würden Sie die Methode verwenden, etwa so:
```
Obj.Search( item => item.Property1 == "Hello" && item.Property2 == "World" );
```
Gibt es irgendein Grund, dass Sie nicht tun können?

[Edit: Hinzugefügt AsQueryable()]

[Edit: für Dynamische Abfragen mit strings]

Schauen Sie hier und sehen, ob das hilft. Ich habe Sie noch nicht benutzt, aber sieht aus wie es ist, was du suchst:
http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx

Persönlich würde ich es bevorzugen in der Regel die Typ-sicheren Ausdruck> Ansatz, da dies wird Ihnen compile-Zeit-Fehler...aber wenn strings benötigt werden, sieht dann aus wie der beste Weg, es zu tun.

Basierend auf den obigen link, sieht aus wie Sie sollten in der Lage sein zu tun:
```
query = query.Where( String.Format("{0}={1}",dict.Key,dict.Value) );
```
[Edit: String-Gebäude Beispiel]

So, eines der Probleme ist, dass Sie Ihre sql-Abfrage wird zu Ende gehen mit ein UND am Ende der Zeichenkette, aber keine Bedingung nach es...also, vielleicht versuchen Sie dieses... - syntax vielleicht etwas ab, aber sollte richtig sein:
```
public IQueryable<Product> Search(Dictionary<string, string> searchParams)
{
    DBDataContext dc = new DBDataContext();

    StringBuilder sQuery = new StringBuilder();
    foreach (KeyValuePair<string, string> temp in searchParams)
    {
        if( sQuery.Length > 0 ) sQuery.Append(" AND ");
        sQuery.AppendFormat("{0}={1}",temp.Key,temp.Value);
    }

    var query = dc.Products.Where(sQuery.ToString());

    return query;
}
```
Diese werden nur mit "UND" über die Bedingungen nach dem ersten. Hoffe, es hilft...

FYI - Es ist off-topic, aber 'warum' ich verwendet StringBuilder ist, dass die string-Verkettung, die Art und Weise, die Sie hatten, würde das Ergebnis in der string zerstört wird und eine neue Zeichenfolge erstellt werden die in-memory-4 mal pro loop...so geändert, um ein StringBuilder-da schaffen, einen Puffer, der gefüllt werden kann und nur geändert werden, wenn notwendig.
- Ihre Funktion zurück IEnumerable, nicht IQueryable, so dass der code nicht kompiliert. Des weiteren Zeilen aus der Datenbank gefiltert werden, die in C# - code nicht in der Datenbank-Schicht. Es wird langsamer und benötigt mehr Speicher.
- Hinzugefügt AsQueryable (), so dass es sollte kompilieren
- Klingt wie Athari weiß etwas über den Ausdruck<> Aspekt, jedoch, dass ich nicht...also wohl am besten zu gehen mit seiner Antwort.
InformationsquelleAutor Kevin Nelson
0

Anstelle von Wörterbuch Sie können diese Methode verwenden:
```
using System.Linq.Expressions;
//...

public static IQueryable<Product> Search(Expression<Func<Product, bool>> search)
{
    DBDataContext dc = new DBDataContext();
    return dc.Products.Where(search);
}
```
Können Sie es verwenden, wie diese:
```
Search(p => p.Name == "Name" && p.Id == 0);
```
Du auch nicht begrenzt werden, um string-Eigenschaften.
- Also, was Sie sagen, ist, dass für Linq to SQL, die Sie verwenden müssen, um die Meinungsfreiheit in der Reihenfolge für die Ausführung der query in der DB? Nur tun Func<> ausführen in C#?
- Dieser hat immer noch die gleiche inhärente Einschränkung, die ich versuche zu vermeiden. Ich muss noch explizit geben die Eigenschaft p.Namen, anstatt es durch die dynamisch generiert werden, basierend auf was auch immer Schlüssel vorhanden sind, im Wörterbuch (S.[SCHLÜSSEL] = [WERT]). Ich bin in keiner Weise gebunden oder verbunden mit einem Wörterbuch, aber das schien mir die einzige Methode der Speicherung von Schlüsseln zu suchen und Ihren Werten.
- Okay, also das Wörterbuch war wichtig..., fügte ich einen link zu meiner Antwort auf die Verwendung von Zeichenfolgen mit Hilfe von MS Dynamic Query Library
- Dies ist der Fehler, ich bekomme mit, dass: "Fehler 1 Die typargumente für die Methode 'System.Linq -.Queryable.Wo<TSource>(System.Linq -.IQueryable<TSource> System.Linq -.Ausdrücke.Ausdruck<System.Func<TSource,bool>>)' kann nicht abgeleitet werden aus der Nutzung. Versuchen Sie, den Typ der Argumente ausdrücklich."
InformationsquelleAutor Athari
0

haben u versuchen Sie, setzen Sie einfache Anführungszeichen für den string?
basierend auf Ihren foreach-Schleife, es werden zusätzliche 'UND' am Ende der Abfrage

versuchen, diese stattdessen
```
string sQuery = searchParam.Select(entry => string.Format("{0} = '{1}'", entry.Key, entry.Value)).Aggregate((current, next) => current + " AND " next);
```
InformationsquelleAutor Bonshington

wenn Sie bereit sind, um ein Wörterbuch zu erstellen von suchbaren Begriffe, als die, die ich verwendet habe, etwas in der Nähe der Ansatz unten. Ich habe angepasst, was zu tun ich mehr eng fit in, wie Sie waren, Dinge zu tun, habe ich auch geändert die Namen der Tabellen, um zu passen ein datacontext-Objekt-Modell, das ich zur Verfügung habe, um mich.

Die Idee ist, erstellen Sie ein keyed Liste der Begriffe, die Abfrage unterstützt die Suche, nach. Dann fügen Sie Funktionen, die einen Ausdruck übermittelt werden können, die in der where-Klausel der Abfrage.

Sollten Sie natürlich fügen Sie einige Fehlerbehandlung für ungültige keys etc.

public IQueryable<Person> Search(Dictionary<string, string> searchParams)
{
    DBDataContext dc = new DBDataContext();
    var query = dc.Persons.Where(p => true); //do an 'empty predicate' because you want 'query' to be an iqueryable<Person> not a Table<Person>

    //build a list of the types of things you can filter on.
    var criteriaDefinitions = new Dictionary<string,Func<string,Expression<Func<Person,bool>>>>();
    criteriaDefinitions.Add("FirstName",s => p => p.FirstName == s);
    criteriaDefinitions.Add("LastName",s => p => p.LastName == s);

    //you can do operations other than just equals
    criteriaDefinitions.Add("EmailContains",s => p => p.Email.Contains(s));

    //you can even create expressions that integrate joins.
    criteriaDefinitions.Add("HasContactInCity",s => p => p.Contacts.Any(c => c.City == s));


    foreach (KeyValuePair<string, string> temp in searchParams)
    {
        //grab the correct function out of the dictionary
        var func = criteriaDefinitions[temp.Key];

        //evaluating the function will return an expression which can passed into the where clause.
        var expr = func(temp.Value);
        query = query.Where(expr);
    }

    return query;
}

InformationsquelleAutor eoldre

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.