Tutorial zur Verwendung von Dapper zum Erzielen von Paging-Effekten

Dieser Artikel stellt hauptsächlich den Paging-Effekt basierend auf Dapper vor. Er unterstützt Filterung, Sortierung, Gesamtzahl von Ergebnismengen, Abfragen mit mehreren Tabellen und hat einen bestimmten Referenzwert

Einführung

Ich habe im Voraus nach der Implementierung von Dapper Paging gesucht, aber sie basieren entweder auf gespeicherten Prozeduren oder unterstützen Paging. aber nicht. Sortierung wird unterstützt, oder Suchkriterien sind nicht so einfach zu pflegen.

Methodendefinition

Das Folgende ist meine Paging-Implementierung. Obwohl sie nicht generisch ist (aufgrund der Where-Bedingungen und SQL-Anweisungskombinationen), sollte sie berücksichtigt werden Allgemeiner ist die Methode wie folgt definiert:

public Tuple<IEnumerable<Log>, int> Find(LogSearchCriteria criteria
      , int pageIndex
      , int pageSize
      , string[] asc
      , string[] desc);

Die obige Funktionsdefinition ist ein Beispiel für die Abfrage von Log. In den zurückgegebenen Ergebnissen ist der erste Wert von Tuple die Ergebnismenge und der zweite Wert die Gesamtzahl der Zeilen (Zum Beispiel gibt es insgesamt 100 Datensätze, 10 pro Seite und die aktuelle erste Seite, dann beträgt der erste Wert 10 Datensätze und der zweite Wert 100)

Im Beispiel Projekt, ich verwende zwei Die Methode implementiert Paging:

1. Die erste Methode besteht darin, die Gesamtzahl abzurufen, und die zweite Methode besteht darin, die Ergebnismenge abzurufen.

2. Die zweite basiert auf der Abfrage 1 und verwendet Offest/Fetch von SQLServer, sodass nur SQL Server 2012+ unterstützt wird. Sie können also je nach verwendeter SQL Server-Version unterschiedliche Implementierungen auswählen ist natürlich Die zweite Implementierung ist effizienter.

Führen Sie das Beispiel aus

1 Gehen Sie nach dem Herunterladen oder Klonen des Github-Repos in das Datenbankverzeichnis und dekomprimieren Sie Database.7z

2. Standardmäßig verwende ich SQL Server LocalDB und die Verbindungszeichenfolge lautet Data Source=(localdb)MSSQLLocalDB;Initial Catalog=DapperPagingSample;integrated security=True; Wenn Sie LocalDB nicht verwenden, ändern Sie bitte die Verbindungszeichenfolge von App.Config entsprechend .

3. Strg+F5 zum Ausführen des Programms. Im Beispielprojekt habe ich ein einfaches WinForm-Programm verwendet, aber es sollte den Paging-Effekt besser demonstrieren können.

Unterstützung mehrerer Tabellen

Beispiele zur Unterstützung von Abfragen mit mehreren Tabellen hinzugefügt, zum Beispiel gibt es zwei Protokolltabellen und eine Ebenentabelle , Log Das LevelId-Feld bezieht sich auf das Level-Id-Feld. Mit der folgenden Abfrage können Sie Paging, Sortierung und Filterung von Abfragen mit mehreren Tabellen realisieren:

Die erste ist ein Beispiel für zwei Abfragen (unterstützt grundsätzlich alle). Versionen von SQL Server):

public Tuple<IEnumerable<Log>, int> Find(LogSearchCriteria criteria
      , int pageIndex
      , int pageSize
      , string[] asc
      , string[] desc)
    {
      using (IDbConnection connection = base.OpenConnection())
      {
        const string countQuery = @"SELECT COUNT(1)
                      FROM   [Log] l
                      INNER JOIN [Level] lv ON l.LevelId = lv.Id
                      /**where**/";

        const string selectQuery = @" SELECT *
              FROM  ( SELECT  ROW_NUMBER() OVER ( /**orderby**/ ) AS RowNum, l.*, lv.Name as [Level]
                   FROM   [Log] l
                   INNER JOIN [Level] lv ON l.LevelId = lv.Id
                   /**where**/
                  ) AS RowConstrainedResult
              WHERE  RowNum >= (@PageIndex * @PageSize + 1 )
                AND RowNum <= (@PageIndex + 1) * @PageSize
              ORDER BY RowNum";

        SqlBuilder builder = new SqlBuilder();

        var count = builder.AddTemplate(countQuery);
        var selector = builder.AddTemplate(selectQuery, new { PageIndex = pageIndex, PageSize = pageSize });

        if (!string.IsNullOrEmpty(criteria.Level))
          builder.Where("lv.Name= @Level", new { Level = criteria.Level });

        if (!string.IsNullOrEmpty(criteria.Message))
        {
          var msg = "%" + criteria.Message + "%";
          builder.Where("l.Message Like @Message", new { Message = msg });
        }

        foreach (var a in asc)
        {
          if(!string.IsNullOrWhiteSpace(a))
            builder.OrderBy(a);
        }

        foreach (var d in desc)
        {
          if (!string.IsNullOrWhiteSpace(d))
            builder.OrderBy(d + " desc");
        }

        var totalCount = connection.Query<int>(count.RawSql, count.Parameters).Single();
        var rows = connection.Query<Log>(selector.RawSql, selector.Parameters);

        return new Tuple<IEnumerable<Log>, int>(rows, totalCount);
      }
    }

Das zweite Beispiel erfolgt durch Offset/Fetch-Abfrage (unterstützt SQL Server 2012+)

public Tuple<IEnumerable<Log>, int> FindWithOffsetFetch(LogSearchCriteria criteria
                        , int pageIndex
                        , int pageSize
                        , string[] asc
                        , string[] desc)
    {
      using (IDbConnection connection = base.OpenConnection())
      {
        
        const string selectQuery = @" ;WITH _data AS (
                      SELECT l.*, lv.Name AS [Level]
                      FROM   [Log] l
                      INNER JOIN [Level] lv ON l.LevelId = lv.Id
                      /**where**/
                    ),
                      _count AS (
                        SELECT COUNT(1) AS TotalCount FROM _data
                    )
                    SELECT * FROM _data CROSS APPLY _count /**orderby**/ OFFSET @PageIndex * @PageSize ROWS FETCH NEXT @PageSize ROWS ONLY";

        SqlBuilder builder = new SqlBuilder();
        
        var selector = builder.AddTemplate(selectQuery, new { PageIndex = pageIndex, PageSize = pageSize });

        if (!string.IsNullOrEmpty(criteria.Level))
          builder.Where("lv.Name = @Level", new { Level = criteria.Level });

        if (!string.IsNullOrEmpty(criteria.Message))
        {
          var msg = "%" + criteria.Message + "%";
          builder.Where("l.Message Like @Message", new { Message = msg });
        }
        
        foreach (var a in asc)
        {
          if (!string.IsNullOrWhiteSpace(a))
            builder.OrderBy(a);
        }

        foreach (var d in desc)
        {
          if (!string.IsNullOrWhiteSpace(d))
            builder.OrderBy(d + " desc");
        }
        
        var rows = connection.Query<Log>(selector.RawSql, selector.Parameters).ToList();

        if(rows.Count == 0)
          return new Tuple<IEnumerable<Log>, int>(rows, 0);
        

        return new Tuple<IEnumerable<Log>, int>(rows, rows[0].TotalCount);
        
      }
    }

Das obige ist der detaillierte Inhalt vonTutorial zur Verwendung von Dapper zum Erzielen von Paging-Effekten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!