Funktion oder Methode zum Ausschließen von Parametern mit Nullwerten in Dapper

Question

Ich möchte drei Werte übergeben und erhalten Ergebnis entsprechend Dapper, aber andere Attribute in dieser Klasse automatisch null Werte und ich möchte diese Parameter vernachlässigen. Jetzt bin ich gerade vorbei Param1 sagen und versuchen, das Ergebnis zu erhalten. Aber mein Ziel als param2 und param3

connection.Query<T>("Query statement", whereConditions) 

Die whereConditions ist Objekt mit param1, param2 und param3. Doch das Ergebnis Verwendung where-Klausel aus param die Werte hat und ignorieren die nulls

[UPDATE]

Abfrage

select ID, UserName, Screen, Url, LogAction from LogTable 
Where UserName = 'Joe' and Screen = 'edit' and LogAction = 'delete' 

Sie jetzt von der Benutzeroberfläche, ich bin nicht sicher, ob ich Benutzername oder Bildschirm erhalten oder Aktion. Ich kann jeden von ihnen bekommen. Meine Anfrage hat entsprechend

ändern Wenn ich ein anonymus Objekt erstellen

var whereConditions = new { UserName = "Joe", Screen = "edit" } 

Es funktioniert gut, aber im Falle eines anderen Parameters Ich muss es passieren, wie

var whereConditions = new { UserName = "Joe", Screen = "edit", LogAction = "save" } 

also muss ich verstehen Wie kann das anonyme Objekt als Bedingung übergeben werden?

Hope this Hilfe

Answer 1

Ein einfacher Ansatz (die immer ignoriert werden kann, wenn leere Kriterienwerte nur funktionieren würde, was häufig der Fall ist, wenn diese Werte von einem UI-Formular stammen) wäre immer alle drei Argumente zu übergeben aber um eine WHERE-Klausel zu konstruieren, die leere Werte überspringt - z.

select ID, UserName, Screen, Url, LogAction 
from LogTable 
Where (@UserName = '' or UserName = @UserName) 
and (@Screen = '' or Screen = @Screen) 
and (@LogAction = '' or LogAction = @LogAction) 

dann würden Sie alle drei Werte, unabhängig davon, ob für sie null/leer oder nicht

return conn.Query<Result>(
    @" 
     select ID, UserName, Screen, Url, LogAction 
     from LogTable 
     Where (@UserName = '' or UserName = @UserName) 
     and (@Screen = '' or Screen = @Screen) 
     and (@LogAction = '' or LogAction = @LogAction) 
    ", 
    new 
    { 
     UserName = userName?? "", 
     Screen = screen ?? "", 
     LogAction = logAction ?? "" 
    } 
); 

Wenn Sie diese in einem Verfahren mit optionalen Argumenten eingewickelt wie folgt aus:

private IEnumerable<Result> GetData(
    string userName = null, 
    string screen = null, 
    string logAction = null) 
{ 
    using (var conn = GetConnection()) 
    { 
     return conn.Query<Result>(
      @" 
       select ID, UserName, Screen, Url, LogAction 
       from LogTable 
       Where (@UserName = '' or UserName = @UserName) 
       and (@Screen = '' or Screen = @Screen) 
       and (@LogAction = '' or LogAction = @LogAction) 
      ", 
      new 
      { 
       UserName = userName ?? "", 
       Screen = screen ?? "", 
       LogAction = logAction ?? "" 
      } 
     ); 
    } 
} 

Dann könnten Sie den aufrufenden Code für unterschiedliche Anzahlen von Argumenten ganz natürlich aussehen lassen - zB.

var joeData = GetData(userName: "Joe"); 
var joeEditData = GetData(userName: "Joe", screen: "save"); 

Wenn Sie jedoch Anfragen immer die drei Werte (Benutzername, Bildschirm und logAction), und Sie wollen nur die null/leer Werte ignoriert werden, dann können Sie, natürlich, rufen Sie einfach

var data = GetData(request.UserName, request.Screen, request.LogAction);