Función o método para excluir parámetros con valores nulos en Dapper

c# dapper sql

Pregunta

Quiero pasar tres valores y obtener un resultado de acuerdo con eso usando Dapper, pero otros atributos en esa clase toman valores nulos automáticamente y quiero descuidar esos parámetros. Ahora solo estoy aprobando decir param1 e intentando obtener un resultado. Sin embargo mi objeto como param2 y param3

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

El whereConditions es un objeto con param1, param2 y param3. Sin embargo, el resultado usa where cláusula de param que tiene valores e ignora los nulos

[ACTUALIZAR]

Consulta

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

Ahora, desde la interfaz de usuario, no estoy seguro de si recibiré el nombre de usuario o pantalla o acción. Puedo obtener cualquiera de ellos de los tres. Mi consulta tiene que cambiar en consecuencia

Si creo un objeto anonymus

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

Funciona bien, pero en el caso de otro parámetro, necesito pasarlo como

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

Entonces necesito entender cómo se puede pasar el objeto anónimo como condición de dónde.

Espero que esto ayude

Respuesta popular

Un enfoque simple (que solo funcionaría si los valores de los criterios en blanco siempre pueden ignorarse, que comúnmente es el caso cuando estos valores se originan en un formulario UI) sería pasar siempre los tres argumentos pero construir una cláusula WHERE que salte valores en blanco - p.ej.

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

entonces pasaría los tres valores, independientemente de si eran nulos / en blanco o no

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 ?? ""
    }
);

Si envuelve esto dentro de un método con argumentos opcionales como este:

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 ?? ""
            }
        );
    }
}

Entonces podría hacer que el código de llamada pareciera bastante natural para diferentes números de argumentos, por ej.

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

Sin embargo, si las solicitudes siempre tienen los tres valores (nombre de usuario, pantalla y logAcción) y solo quiere que se ignoren los valores nulos / en blanco, puede, por supuesto, simplemente llamar

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


Licencia bajo: CC-BY-SA with attribution
No afiliado con Stack Overflow
¿Es esto KB legal? Sí, aprende por qué
Licencia bajo: CC-BY-SA with attribution
No afiliado con Stack Overflow
¿Es esto KB legal? Sí, aprende por qué