Dapper Query in Modell deserialisieren

Ich habe zwei Modelle:

 public class RuleValidation
{
    public int RuleId { get; set; }
    public string RuleName { get; set; }
    public int ClientId { get; set; }
    public string ClientName { get; set; }
    public List<RuleException> RuleExcpetions { get; set; }
}

und:

 public class RuleException
{
    public int ExceptionId { get; set; }
    public int RuleId { get; set; }
    public string ExceptionValue { get; set; }
    public string ExcpetionResult { get; set; }
}

Ich verwende die folgende Abfrage, um die Modelle zu laden:

 public async Task<RuleValidation> GetRulesByClient(string clientId)
    {
        using (IDbConnection conn = Connection)
        {
            string sQuery = @"SELECT 
                                    Client.Id as 'ClientName',
                                    Client.ClientName, 
                                    Rules.Id,
                                    Rules.RuleName,
                                    Rules.Code, 
                                    RuleException.ExceptionValue, 
                                    RuleException.ExceptionResult
                              FROM 
                                    Rules 
                              LEFT OUTER JOIN
                                    RuleException ON Rules.Id = RuleException.RuleId 
                              RIGHT OUTER JOIN
                                    Client ON Rules.Id = Client.RuleId
                              WHERE
                                    Client.ClientName = @CLIENTID";
            conn.Open();
            var result = await conn.QueryAsync<RuleValidation>(sQuery, new { CLIENTID = clientId });
            return (RuleValidation)result;
        }
    }

Dies scheint die Abfrage in ein RuleValidation-Objekt zu deserialisieren, aber das RuleException-Objekt wird für die Datensätze mit Ausnahmen nicht geladen. Also habe ich versucht, die Rückgabe wie folgt zu ändern:

 var return= conn.QueryAsync<RuleValidation, RuleException>(
                sQuery,
                (ruleValidation, ruleException) =>
                {
                    ruleValidion.RuleException = ruleException;
                    return return;
                },
                splitOn: "RuleId");

Aber ich bekomme eine Fehlermeldung:

IDBCOnnection enthält keine Definition für QueryAsync und es konnte keine zugängliche Erweiterungsmethode gefunden werden, die ein erstes Argument vom Typ 'IDBConnection' akzeptiert

So richte ich meine Verbindung ein (dies funktioniert für die erste Abfrage)

 public IDbConnection Connection
    {
        get
        {
            return new SqlConnection(_configuration.GetConnectionString("ValidationRulesConnectionString"));
        }
    }

Ich bin neu in Dapper und habe kein Problem damit, aber dies ist das erste Problem, für das ich in den adretten Tutorials oder beim Online-Suchen keine Lösung zu finden scheint.