C# c IDataReader ExecuteReader（） { 尝试 { var连接=新的SqlConnection（_连接）； var cmd=connection.CreateCommand（）； 配置命令（cmd）； 人口参数（cmd）； connection.Open（）； var reader=cmd.ExecuteReader（CommandBehavior.CloseConnection）； 返回读取器； } 捕获（例外情况除外） { _例外行为（ex）； } 返回null； } 公共ISqlExecutor AddParameters（object@params） { var type=@params.GetType（）； var props=type.GetProperties（）； foreach（道具中的var propertyInfo） { var param=new-SqlParameter（“@”+propertyInfo.Name，propertyInfo.GetValue（@params，null））； 参数方向=参数方向输入； _输入参数。添加（参数）； } 归还这个； } 不带outParams（）的公共ISqlExecutor { 归还这个； } 专用void配置命令（SqlCommand cmd） { cmd.CommandText=_sqltext； cmd.CommandType=_CommandType； } 私有void PopulateParameters（SqlCommand cmd） { cmd.Parameters.AddRange（_inParams.ToArray（））； } 私有静态void DefaultExceptionBehavior（异常e） { //做点什么 } } } 公共接口ISqlCommandTypeSelector { ISqlParameterManager GetTextCommandFor（字符串文本）； ISqlParameterManager GetProcCommandFor（字符串过程）； } 公共接口ISqlExecutor { ISqlExecutor OneException（操作）； void ExecuteNonQuery（）； T ExecuteScalar（）； IDataReader ExecuteReader（）； } 公共接口ISqlParameterManager { ISqlExecutor AddParameters（object@params）； 不带outParams（）的ISqlExecutor； }

如果你真的讨厌重复的代码，那么可能会有一些重复的代码需要重构。这只是一个有趣的练习，但可能不是您希望如何进行数据访问。这也不支持在编写时输出参数。

+1-刚刚将此代码编写成post，几乎一字不差。这看起来是一个非常干净的解决方案，谢谢！如果打开一个

SqlDataReader

，是否可以执行类似的操作？@chezy525：我以前有两种方法。对于

ExecuteDataReader

和

ExecuteScalar

基本上。如果使用输出参数，还需要一个稍微不同的解决方案。如果您需要很大的灵活性，可以选择上面提到的企业库；我正在考虑返回

SqlDataReader

，由于连接将被关闭，它显然无法工作。我只需要使用

SqlDataAdapter

来填充数据集。再次感谢@chezy525：如果你想变得非常时髦，你可以对SqlDataReader one使用

yield return

。不过，我不确定是否要推荐它：）除了使用

SqlCommand

的块之外，与原始代码没有太大区别。虽然您指出了一个最佳实践，但它并没有解决实际问题？代码块后的文本是OP提出的问题的直接答案。此外，通过参数列表循环，您无法很容易地定义参数大小，这是另一个好的实践。看起来不错。爱流畅的界面

void RunStoredProc1(object arg1)
{
  using(SqlConnection conn = new SqlConnection(connStr)){
    try{
      SqlCommand cmd = new SqlCommand("storedProc1", conn);
      cmd.CommandType = CommandType.StoredProcedure;
      cmd.Parameters.AddWithValue("@input1", arg1);

      conn.Open();
      cmd.ExecuteNonQuery();
    } catch (Exception ex){
      //handle the exception appropriately.
    }
  }
}

void RunStoredProc1(object arg1)
{
    try
    {
        using(SqlConnection conn = new SqlConnection(connStr))
        {
            using SqlCommand cmd = new SqlCommand("storedProc1", conn))
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.AddWithValue("@input1", arg1);

                conn.Open();
                cmd.ExecuteNonQuery();
            }
        }
    } 
    catch (Exception ex)
    {
      //handle the exception appropriately.
    }
}

void RunStoredProc(string storedProcName, IDictionary<string, object> args)
{
    using (SqlConnection conn = new SqlConnection(connStr))
    using (SqlCommand cmd = conn.CreateCommand())
    {
        cmd.CommandText = storedProcName;
        cmd.CommandType = CommandType.StoredProcedure;

        foreach (KeyValuePair<string, object> kvp in args)
        {
            cmd.Parameters.AddWithValue(kvp.Key, kvp.Value);
        }

        conn.Open();
        cmd.ExecuteNonQuery();
    }
}

void RunStoredProc1(object input1)
{
    var args = new Dictionary<string, object>()
               {
                   { "input1", input1 }
               };

    try
    {
        RunStoredProc("storedProc1", args);
    }
    catch (Exception ex)
    {
        // Handle exception properly
    }
}

    public DataTable GetRiskFactorsForPatient( int patientID )
    {
        dbo_GetRiskbyPatient sp = new dbo_GetRiskbyPatient( CONNECT_STRING_ID ) ;
        int                  rc = sp.Exec( patientID ) ;
        DataTable            dt = sp.ResultSet ;

        if ( dt == null ) throw new InvalidOperationException( "nothing returned from stored procedure" ) ;
        return dt ;
    }

    int i = Sql.UsingConnection("sample")
        .GetTextCommandFor("Select Top 1 ActorID From Actor Where FirstName = @fname")
        .AddParameters(new {fname = "Bob"})
        .OnException(e => Console.WriteLine(e.Message))
        .ExecuteScalar<int>();

    var q = Sql.UsingConnection("sample")
        .GetTextCommandFor("Select * From Actor Where FirstName=@fname and ActorID > @id")
        .AddParameters(new {id = 1000, fname = "Bob"});

    using(var reader = q.ExecuteReader())
    {
        while(reader.Read())
        {
            // do something
        }
    }

public class Sql
{
    public static ISqlCommandTypeSelector UsingConnection(string connection)
    {
        return new SqlBuilder(connection);
    }

    private class SqlBuilder : ISqlCommandTypeSelector, ISqlParameterManager, ISqlExecutor
    {
        private string _connection;
        private string _sqltext;
        private CommandType _commandtype;
        private Action<Exception> _exceptionBehavior = DefaultExceptionBehavior;

        private IList<SqlParameter> _inParams;


        public SqlBuilder(string connection)
        {
            _connection = ConfigurationManager.ConnectionStrings[connection].ConnectionString;
            _inParams = new List<SqlParameter>();
        }

        public ISqlParameterManager GetTextCommandFor(string text)
        {
            _sqltext = text;
            _commandtype = CommandType.Text;
            return this;
        }

        public ISqlParameterManager GetProcCommandFor(string proc)
        {
            _sqltext = proc;
            _commandtype = CommandType.StoredProcedure;
            return this;
        }

        public ISqlExecutor OnException(Action<Exception> action)
        {
            _exceptionBehavior = action;
            return this;
        }

        public void ExecuteNonQuery()
        {
            try
            {
                using (var connection = new SqlConnection(_connection))
                using (var cmd = connection.CreateCommand())
                {
                    ConfigureCommand(cmd);
                    PopulateParameters(cmd);
                    connection.Open();
                    cmd.ExecuteNonQuery();
                }
            }
            catch(Exception ex)
            {
                _exceptionBehavior(ex);
            }
        }

        public T ExecuteScalar<T>()
        {
            T result = default(T);
            try
            {
                using (var connection = new SqlConnection(_connection))
                using (var cmd = connection.CreateCommand())
                {
                    ConfigureCommand(cmd);
                    PopulateParameters(cmd);
                    connection.Open();
                    result = (T) cmd.ExecuteScalar();
                    return result;
                }
            }
            catch(InvalidCastException ex)
            {
                // rethrow?
            }
            catch(Exception ex)
            {
                _exceptionBehavior(ex);
            }
            return result;
        }

        public IDataReader ExecuteReader()
        {
            try
            {
                var connection = new SqlConnection(_connection);
                var cmd = connection.CreateCommand();
                ConfigureCommand(cmd);
                PopulateParameters(cmd);
                connection.Open();
                var reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return reader;
            }
            catch(Exception ex)
            {
                _exceptionBehavior(ex);
            }
            return null;
        }

        public ISqlExecutor AddParameters(object @params)
        {
            var type = @params.GetType();
            var props = type.GetProperties();
            foreach (var propertyInfo in props)
            {
                var param = new SqlParameter("@" + propertyInfo.Name, propertyInfo.GetValue(@params, null));
                param.Direction = ParameterDirection.Input;
                _inParams.Add(param);
            }
            return this;
        }

        public ISqlExecutor WithoutParams()
        {
            return this;
        }

        private void ConfigureCommand(SqlCommand cmd)
        {
            cmd.CommandText = _sqltext;
            cmd.CommandType = _commandtype;
        }

        private void PopulateParameters(SqlCommand cmd)
        {
            cmd.Parameters.AddRange(_inParams.ToArray());
        }

        private static void DefaultExceptionBehavior(Exception e)
        {
            // do something
        }
    }


}

public interface ISqlCommandTypeSelector
{
    ISqlParameterManager GetTextCommandFor(string text);
    ISqlParameterManager GetProcCommandFor(string proc);
}

public interface ISqlExecutor
{
    ISqlExecutor OnException(Action<Exception> action);

    void ExecuteNonQuery();
    T ExecuteScalar<T>();
    IDataReader ExecuteReader();
}

public interface ISqlParameterManager
{
    ISqlExecutor AddParameters(object @params);
    ISqlExecutor WithoutParams();
}