C# 消除代码重复（使用数据库）

我编写了一个dll来执行SQL命令。 我的公共方法中有一些代码重复。有没有办法避免代码重复

方法1：

    public Object ExecuteScalar(String command)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            SqlCommand commandScalar = GetSqlCommand(strCommand: command);

            object result = new object();
            using (commandScalar)
            {
                try
                {
                    connection.StatisticsEnabled = statisticsEnabled;
                    connection.Open();
                    result = commandScalar.ExecuteScalar();
                }
                catch (Exception exception)
                {
                    throw new Exception(String.Format("Не удалось выполнить команду: {0}", commandScalar.CommandText), exception);
                }
                finally
                {
                    connection.Close();
                }
            }
            return result;

            if (connection.StatisticsEnabled)
                AddDictionary(connection.RetrieveStatistics());

            return result;
        }
    }

方法2：

    public void ExecuteNonQuery(String command, List<SqlParameter> lsParams = null)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            SqlCommand commandNonQuery = GetSqlCommand(strCommand: command, lsParams: lsParams, log: logger);

            using(commandNonQuery)
            {
                try
                {
                    connection.StatisticsEnabled = statisticsEnabled;
                    connection.Open();
                    commandNonQuery.ExecuteNonQuery();
                }
                catch (Exception exception)
                {
                    throw new Exception(String.Format("Не удалось выполнить команду: {0}", commandNonQuery.CommandText), exception);
                }
                finally
                {
                    connection.Close();
                }
            }

            if (connection.StatisticsEnabled)
                AddDictionary(connection.RetrieveStatistics());
        }
    }

public void ExecuteNonQuery（String命令，List lsParams=null）
{
使用（SqlConnection连接=新的SqlConnection（connectionString））
{
SqlCommand commandNonQuery=GetSqlCommand（strCommand:command，lsParams:lsParams，log:logger）；
使用（commandNonQuery）
{
尝试
{
connection.StatisticsEnabled=StatisticsEnabled；
connection.Open（）；
commandNonQuery.ExecuteOnQuery（）；
}
捕获（异常）
{
抛出新的异常（String.Format（字符串格式）（commandNonQuery.CommandText，异常）；
}
最后
{
connection.Close（）；
}
}
if（已启用连接统计）
AddDictionary（connection.RetrieveStatistics（））；
}
}

方法3：

    public List<IDataRecord> ExecuteReader(String strCommand, List<SqlParameter> lsParams = null)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            SqlCommand sqlCommandRead = GetSqlCommand(strCommand: strCommand, lsParams: lsParams, log: logger);

            List<IDataRecord> lsDataRecord = new List<IDataRecord>();
            using (sqlCommandRead)
            {
                try
                {
                    connection.StatisticsEnabled = statisticsEnabled;
                    connection.Open();

                    using (SqlDataReader sqlDataReader = sqlCommandRead.ExecuteReader())
                    {
                        while (sqlDataReader.Read())
                        {
                            lsDataRecord.Add((IDataRecord)sqlDataReader);
                        }
                    }
                }
                catch (Exception exception)
                {
                    throw new Exception(String.Format("Не удалось выполнить команду: {0}", sqlCommandRead.CommandText), exception);
                }
                finally
                {
                    connection.Close();
                }
            }

            if (connection.StatisticsEnabled)
                this.AddDictionary(connection.RetrieveStatistics());

            return lsDataRecord;
        }
    }

公共列表ExecuteReader（字符串strCommand，列表lsParams=null） { 使用（SqlConnection连接=新的SqlConnection（connectionString）） { SqlCommand-sqlCommandRead=GetSqlCommand（strCommand:strCommand，lsParams:lsParams，log:logger）； List lsDataRecord=新列表（）； 使用（sqlCommandRead） { 尝试 { connection.StatisticsEnabled=StatisticsEnabled； connection.Open（）； 使用（SqlDataReader SqlDataReader=sqlCommandRead.ExecuteReader（）） { while（sqlDataReader.Read（）） { 添加（（IDataRecord）sqlDataReader）； } } } 捕获（异常） { 抛出新异常（String.Format（字符串.Format:{0}，sqlCommandRead.CommandText），异常）； } 最后 { connection.Close（）； } } if（已启用连接统计） this.AddDictionary（connection.RetrieveStatistics（））； 返回lsDataRecord； } } 生成要执行的SQL命令的方法：

    private static SqlCommand GetSqlCommand(string strCommand, List<SqlParameter> lsParams = null, Logger log = null)
    {
        lsParams = null ?? new List<SqlParameter>(); 
        log = null ?? LogManager.GetLogger("noname");

        if (strCommand == null || strCommand == "")
        {
            throw new ArgumentException("Передан пустой (или null) текст команды.", "strCommand");
        }

        int parametersRequired = strCommand.Split('@').Length - 1;
        if (parametersRequired != lsParams.Count)
        {
            String strParameters = null;
            foreach (var item in lsParams)
            {
                strParameters += item.ParameterName + " : " + item.Value + "\n";
            }
            strParameters = null ?? "No parameters";
            throw new ArgumentException(String.Format("При формировании SQL - команды выявлено, что число требуемых параметров: {0} не соответствует числу переданных: {1}\n"
                + "Команда:\n{2}\nПараметры:\n{3}", parametersRequired, lsParams.Count, strCommand, strParameters), "lsParams");
        }

        SqlCommand sqlCommand = new SqlCommand(strCommand);

        foreach (var item in lsParams)
        {
            sqlCommand.Parameters.Add(item);
        }

        return sqlCommand;
    }

private static SqlCommand GetSqlCommand（字符串strCommand，List lsParams=null，Logger log=null）
{
lsParams=null？？新列表（）；
log=null？？LogManager.GetLogger（“noname”）；
if（strCommand==null | | strCommand==“”）
{
抛出新的ArgumentException（“ПцаааПаааа（ааnull）ааааааа；
}
int参数required=strCommand.Split（'@'）.Length-1；
if（参数required！=lsParams.Count）
{
字符串strParameters=null；
foreach（lsParams中的变量项）
{
strParameters+=item.ParameterName+“：“+item.Value+”\n”；
}
strParameters=null？？“无参数”；
抛出新的ArgumentException（String.Format（“Прфааиааааааааааааааааааааааааааааааа
+“参数要求，lsParams.Count，strCommand，strParameters），“lsParams”）；
}
SqlCommand SqlCommand=新的SqlCommand（strCommand）；
foreach（lsParams中的变量项）
{
sqlCommand.Parameters.Add（项）；
}
返回sqlCommand；
}

公共类SqlHelper
{
私有只读布尔统计已启用；
公共SqlHelper（启用bool统计）
{
this.statisticsEnabled=statisticsEnabled；
}
public T ExecuteSqalar（SqlCommand命令）
{
返回Execute（命令，c=>（T）c.ExecuteScalar（））；
}
public void ExecuteNonQuery（SqlCommand）
{
Execute（命令，c=>c.ExecuteNonQuery（））；
}
公共列表执行器阅读器（SqlCommand）
{
返回Execute（命令，c=>
{
var lsDataRecord=新列表（）；
使用（SqlDataReader SqlDataReader=command.ExecuteReader（））
{
while（sqlDataReader.Read（））
{
添加（sqlDataReader）；
}
}
});
}
public T Execute（SqlCommand命令，Func processFunction）
{
使用（var connection=newsqlconnection（“connection\u STRING”））
{
对象结果=新对象（）；
使用（命令）
{
尝试
{
connection.StatisticsEnabled=StatisticsEnabled；
connection.Open（）；
结果=处理函数（命令）；
}
捕获（异常）
{
抛出新的异常（String.Format（字符串格式）（“Бааааааааааааааааа；
}
最后
{
connection.Close（）；
}
}
if（已启用连接统计）
AddDictionary（connection.RetrieveStatistics（））；
返回（T）结果；
}
}
专用void AddDictionary（IDictionary retrieveStatistics）
{
//待办事项：
}

}

Wo

public class SqlHelper
{
    private readonly bool statisticsEnabled;

    public SqlHelper(bool statisticsEnabled)
    {
        this.statisticsEnabled = statisticsEnabled;
    }

    public T ExecuteSqalar<T>(SqlCommand command)
    {
        return Execute(command, c => (T) c.ExecuteScalar());
    }

    public void ExecuteNonQuery(SqlCommand command)
    {
        Execute(command, c => c.ExecuteNonQuery());
    }

    public List<IDataRecord> ExecuteReader(SqlCommand command)
    {
        return Execute<List<IDataRecord>>(command, c =>
        {
            var lsDataRecord = new List<IDataRecord>();
            using (SqlDataReader sqlDataReader = command.ExecuteReader())
            {
                while (sqlDataReader.Read())
                {
                    lsDataRecord.Add(sqlDataReader);
                }
            }
        });
    }

    public T Execute<T>(SqlCommand command, Func<SqlCommand, T> processFunction)
    {
        using (var connection = new SqlConnection("CONNECTION_STRING"))
        {
            object result = new object();
            using (command)
            {
                try
                {
                    connection.StatisticsEnabled = statisticsEnabled;
                    connection.Open();
                    result = processFunction(command);
                }
                catch (Exception exception)
                {
                    throw new Exception(String.Format("Не удалось выполнить команду: {0}",     command.CommandText), exception);
                }
                finally
                {
                    connection.Close();
                }
            }

            if (connection.StatisticsEnabled)
                AddDictionary(connection.RetrieveStatistics());

            return (T)result;
        }
    }

    private void AddDictionary(IDictionary retrieveStatistics)
    {
        // TODO:
    }