Envelopper plusieurs requêtes avec plusieurs sorties

Question

Envelopper plusieurs requêtes avec plusieurs sorties

c# dapper generics refactoring sql

Question

J'ai cette classe, dans laquelle je suis en train d'appeler des appels pimpants pour faire quelque chose comme

var results = SqlWrapper.ExecuteQuery<Product,Customer>("SELECT id FROM Products; SELECT id FROM Customers;");

Où

results[0] = List<Product>
results[1] = List<Customer>

Je supporte les objets de sortie 1,2,3, mais voudrais arbitraire. La classe est également laide et pleine de code copie et collé. Je tiens compte si je veux réutiliser une connexion en passant éventuellement une connexion, mais le code semble simplement malpropre. Ce que je voudrais vraiment, c’est un moyen de définir les params T[] mais, si je comprends bien, cela ne fonctionne pas. Est-ce que ce code peut être nettoyé / raccourci?

using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using Dapper;

namespace SqlWrapper
{
    public static class SqlWrapper
    {
        private const string SqlConnectionString = "Server=localhost;Database=TTDS;User Id=sa;Password=sa;";


        public static List<T> ExecuteQuery<T>(string sql, object param = null, SqlConnection sqlConnection = null)
        {
            if (sqlConnection != null)
            {
                return sqlConnection.Query<T>(sql, param).ToList();
            }

            using (var tempSqlConnection = new SqlConnection(SqlConnectionString))
            {
                tempSqlConnection.Open();
                return tempSqlConnection.Query<T>(sql, param).ToList();
            }
        }


        public static List<dynamic> ExecuteQuery<T1, T2>(string sql, object param = null, SqlConnection sqlConnection = null)
        {
            if (sqlConnection != null)
            {
                return MultiQuery<T1, T2>(sqlConnection, sql, param);
            }

            using (var tempSqlConnection = new SqlConnection(SqlConnectionString))
            {
                return MultiQuery<T1, T2>(tempSqlConnection, sql, param);
            }
        }

        public static List<dynamic> ExecuteQuery<T1, T2, T3>(string sql, object param = null,
            SqlConnection sqlConnection = null)
        {
            if (sqlConnection != null)
            {
                return MultiQuery<T1, T2, T3>(sqlConnection, sql, param);
            }

            using (var tempSqlConnection = new SqlConnection(SqlConnectionString))
            {
                return MultiQuery<T1, T2, T3>(tempSqlConnection, sql, param);
            }
        }

        private static List<dynamic> MultiQuery<T1, T2>(SqlConnection sqlConnection, string sql, object param = null)
        {
            var rv = new List<dynamic>();

            using (var grid = sqlConnection.QueryMultiple(sql, param))
            {
                rv.Add(grid.Read<T1>().ToList());
                rv.Add(grid.Read<T2>().ToList());
            }

            return rv;
        }

        private static List<dynamic> MultiQuery<T1, T2, T3>(SqlConnection sqlConnection, string sql, object param = null)
        {
            var rv = new List<dynamic>();

            using (var grid = sqlConnection.QueryMultiple(sql, param))
            {
                rv.Add(grid.Read<T1>().ToList());
                rv.Add(grid.Read<T2>().ToList());
                rv.Add(grid.Read<T3>().ToList());
            }

            return rv;
        }


        public static void ExecuteNonQuery(SqlConnection sqlConnection, string sql, object param, int? timeout = null)
        {
            if (sqlConnection != null)
            {
                sqlConnection.Execute(sql, param, commandTimeout: timeout);
            }
            else
            {
                using (var tempSqlConnection = new SqlConnection(SqlConnectionString))
                {
                    tempSqlConnection.Open();
                    tempSqlConnection.Execute(sql, param, commandTimeout: timeout);
                }
            }
        }
    }
}

ParoX

Voir plus sur Stack Overflow

Grax32 · Accepted Answer · 10/13/2015 4:25:30 AM

Voici un code non testé qui montre quelques idées que j'avais.

Bien que "using" soit assez génial, vous pouvez en réduire le code si vous créez d'abord la connexion, puis, si nécessaire, supprimez le sqlConnection dans un bloc finally.
Si vous retournez un Tuple<List<T>,List<U>,List<V>> vous pouvez avoir des valeurs de retour fortement typées que vous pouvez facilement utiliser
Si vous appelez votre fonction la plus complexe parmi celles qui sont moins complexes, vous pouvez minimiser votre code dupliqué.

public static class SqlWrapper
{
    private const string SqlConnectionString = "Server=localhost;Database=TTDS;User Id=sa;Password=sa;";

    private class NoResult { }

    public static List<T1> ExecuteQuery<T1>(string sql, object param = null, SqlConnection sqlConnection = null)
    {
        return ExecuteQuery<T1, NoResult, NoResult>(sql, param, sqlConnection).Item1;
    }

    public static Tuple<List<T1>, List<T2>> ExecuteQuery<T1, T2>(string sql, object param = null, SqlConnection sqlConnection = null)
    {
        var result = ExecuteQuery<T1, T2, NoResult>(sql, param, sqlConnection);
        return Tuple.Create(result.Item1, result.Item2);
    }

    public static Tuple<List<T1>, List<T2>, List<T3>> ExecuteQuery<T1, T2, T3>(string sql, object param = null, SqlConnection sqlConnection = null)
    {
        List<T1> list1;
        List<T2> list2 = null;
        List<T3> list3 = null;
        bool needsDisposed = false;

        if (sqlConnection == null)
        {
            sqlConnection = new SqlConnection(SqlConnectionString);
            sqlConnection.Open();
            needsDisposed = true;
        }

        try
        {
            using (var grid = sqlConnection.QueryMultiple(sql, param))
            {
                list1 = grid.Read<T1>().ToList();
                if (typeof(T2) != typeof(NoResult))
                {
                    list2 = grid.Read<T2>().ToList();
                }
                if (typeof(T3) != typeof(NoResult))
                {
                    list3 = grid.Read<T3>().ToList();
                }

                return Tuple.Create(list1, list2, list3);
            }
        }
        finally { if (needsDisposed) sqlConnection.Dispose(); }
    }


    public static void ExecuteNonQuery(SqlConnection sqlConnection, string sql, object param, int? timeout = null)
    {
        bool needsDisposed = false;

        if (sqlConnection == null)
        {
            sqlConnection = new SqlConnection(SqlConnectionString);
            sqlConnection.Open();
            needsDisposed = true;
        }

        try { sqlConnection.Execute(sql, param, commandTimeout: timeout); }
        finally { if (needsDisposed) sqlConnection.Dispose(); }
    }
}

Envelopper plusieurs requêtes avec plusieurs sorties

Question

Fastest Dapper Plus Extensions

Réponse acceptée

Performance

Expression Evaluator