重复的SQL连接，我应该创建一个类吗？

Question

I'm still quite new to c# and I have multiple count queries on a single page. I don't need to use these queries anywhere else so have avoided creating a class. Still though, I can help but think there must be a more efficient approach but I was wondering what that would be!

Here's an example

    private void cntUp() {
    Dictionary<string, string> crd = getCredentials(Session["secure"].ToString());
    Label UserUpcoming = frmDash.FindControl("lblUserReviewUp") as Label;

    using (SqlConnection con = new SqlConnection(WebConfigurationManager.ConnectionStrings["CS"].ConnectionString))
    {
        con.Open();
        try
        {
            using (SqlCommand countUpcoming = new SqlCommand("SELECT COUNT(*) FROM vw_dash_user_upcoming WHERE Employee_ID = @employee_id", con))
            {
                countUpcoming.Parameters.Add(new SqlParameter("employee_id",     crd["employee_id"].ToString()));
                SqlDataReader readerUpcoming = countUpcoming.ExecuteReader();
                while (readerUpcoming.Read())
                {
                    UserUpcoming.Text = readerUpcoming.GetInt32(0).ToString();
                }
            }
            con.Close();
        }
        catch
        {
            Response.Redirect(this.ErrorPage);
        }
    }
}

Answer 1

The following Repository works with SQL Server.

Basically, you can either issue a regular or parameterized query. You can pass in your parameters as all strings, or just as objects if you are going to use models with strongly typed numbers and dates.

You can take out the Release mode info if you don't use such a construct in developement, this is just to make it easier to switch between development and production databases without coding a change.

An example usage would be :

      var updateStatement = "UPDATE OCCHistoryHeaders SET ValidatingUsername=@pUsername,ValidatingWorkstation=@pWorkstation,CurrentState = @pCurrentStatus,RejectionReason = @pRejectionReason, AutomatedValidation = '0' WHERE BatchId = @pBatchId";

                var parameters = new Dictionary<string, object>
                    {
                        {"pUsername", Environment.UserName},
                        {"pWorkstation", Environment.MachineName},
                        {"pCurrentStatus", currentStatus},
                        {"pRejectionReason", rejectionReason},
                        {"pBatchId", batchId}
                    };

var absRowsUpdated = _occDb.ExecuteParameterizedNonQueryObjects(updateStatement, parameters);

Here is the class...

public class SomeRepository 
        {
            private  string _connectionString { get; set; }
            private  SqlConnection _sqlConnection { get; set; }

            public SomeRepository()
            {
                switch (AppSettings.ReleaseMode)
                {
                    case ReleaseMode.DEV:
                        _connectionString = "server=;database=;User Id=;Password=";
                        break;
                    case ReleaseMode.PRODUCTION:
                        _connectionString = "server=;database=;User Id=;Password=";
                        break;
                }            
            }     

            public  DataTable ExecuteQuery(string commandText)
            {
                var dataTable = new DataTable();
                var _sqlConnection = new SqlConnection(_connectionString);
                var cmd = new SqlCommand(commandText, _sqlConnection);
                var da = new SqlDataAdapter(cmd);

                try
                {              
                    _sqlConnection.Open();
                    da.Fill(dataTable);                             
                }
                catch (Exception ex)
                {
                    var errorText = string.Format("Occ Repository ExecuteQuery Error : QueryString={0} :: Error={1}", commandText, ex.Message);
                    throw new Exception(errorText, ex);
                }
                finally
                {                
                    da.Dispose();
                    _sqlConnection.Dispose();
                }

                return dataTable;
            }

            public DataTable ExecuteParameterizedQuery(string commandText, Dictionary<string, string> parameters)
            {
                var dataTable = new DataTable();
                var _sqlConnection = new SqlConnection(_connectionString);
                var cmd = new SqlCommand(commandText, _sqlConnection);

                var da = new SqlDataAdapter(cmd);
                foreach (var entry in parameters)
                {
                    cmd.Parameters.Add(entry.Key, entry.Value);
                }

                try
                {
                    _sqlConnection.Open();
                    da.Fill(dataTable);
                }
                catch (Exception ex)
                {
                    var errorText = string.Format("Occ Repository ExecuteQuery Error : QueryString={0} :: Error={1}", commandText, ex.Message);
                    throw new Exception(errorText, ex);
                }
                finally
                {
                    da.Dispose();
                    _sqlConnection.Dispose();
                }

                return dataTable;
            }

            public DataTable ExecuteParameterizedQueryObjects(string commandText, Dictionary<string, object> parameters)
            {
                var dataTable = new DataTable();
                var _sqlConnection = new SqlConnection(_connectionString);
                var cmd = new SqlCommand(commandText, _sqlConnection);

                var da = new SqlDataAdapter(cmd);
                foreach (var entry in parameters)
                {
                    cmd.Parameters.Add(entry.Key, entry.Value);
                }

                try
                {
                    _sqlConnection.Open();
                    da.Fill(dataTable);
                }
                catch (Exception ex)
                {
                    var errorText = string.Format("Occ Repository ExecuteQuery Error : QueryString={0} :: Error={1}", commandText, ex.Message);
                    throw new Exception(errorText, ex);
                }
                finally
                {
                    da.Dispose();
                    _sqlConnection.Dispose();
                }

                return dataTable;
            }

            public int ExecuteNonQuery(string commandText)
            {          
                var _sqlConnection = new SqlConnection(_connectionString);
                var rowsAffected = 0;

                try
                {              
                    var cmd = new SqlCommand(commandText, _sqlConnection);
                    _sqlConnection.Open();
                    rowsAffected = cmd.ExecuteNonQuery();
                }
                catch (Exception ex)
                {
                    var errorText = string.Format("Occ Repository ExecuteNonQuery Error : Command={0} :: Error={1}", commandText, ex.Message);
                    throw new Exception(errorText, ex);
                }
                finally
                {
                    _sqlConnection.Dispose();
                }

                return rowsAffected;
            }

            public int ExecuteParameterizedNonQuery(string commandText, Dictionary<string, string> parameters)
            {
                var _sqlConnection = new SqlConnection(_connectionString);
                var rowsAffected = 0;
                var cmd = new SqlCommand(commandText, _sqlConnection);

                foreach (var entry in parameters)
                {
                    cmd.Parameters.Add(entry.Key, entry.Value);
                }

                try
                {               
                    _sqlConnection.Open();
                    rowsAffected = cmd.ExecuteNonQuery();
                }
                catch (Exception ex)
                {
                    var errorText = string.Format("Occ Repository ExecuteNonQuery Error : Command={0} :: Error={1}", commandText, ex.Message);
                    throw new Exception(errorText, ex);
                }
                finally
                {
                    _sqlConnection.Dispose();
                }

                return rowsAffected;
            }

            public int ExecuteParameterizedNonQueryObjects(string commandText, Dictionary<string, object> parameters)
            {
                var _sqlConnection = new SqlConnection(_connectionString);
                var rowsAffected = 0;
                var cmd = new SqlCommand(commandText, _sqlConnection);

                foreach (var entry in parameters)
                {
                    cmd.Parameters.Add(entry.Key, entry.Value);
                }

                try
                {
                    _sqlConnection.Open();
                    rowsAffected = cmd.ExecuteNonQuery();
                }
                catch (Exception ex)
                {
                    var errorText = string.Format("Occ Repository ExecuteNonQuery Error : Command={0} :: Error={1}", commandText, ex.Message);
                    throw new Exception(errorText, ex);
                }
                finally
                {
                    _sqlConnection.Dispose();
                }

                return rowsAffected;
            }

        }

Answer 2

If you only do stuff 1 place, generally you'd make everything less readable. So I would probably avoid it. It's a common pattern, however, to you would do yourself a favor writing a utility class with some functions for this.

//requires query parameters to have names @0, @1 etc in string
public static List<object[]> Query(String query, params String[] parameters) //no injection check on this string, be careful.
{
    using(SqlConnection conn = new SqlConnection(_CONN_STRING_))
    {
        conn.Open()
        using(SqlCommand cmd = new SqlCommand(query, conn))
        {
            AddSqlParams(cmd, parameters);
            return Query(cmd);
        }

    }
}

/// <summary>Generic SQL query. Requires open connection.</summary>
/// <param name="cmd">SqlCommand object with all necessary fields configured.</param>
/// <returns>A list of Object arrays (each array is one row).</returns>
private static List<Object[]> Query(SqlCommand cmd)
{
    List<Object[]> results = new List<Object[]>();
    using (SqlDataReader rdr = cmd.ExecuteReader())
    {
        while (rdr.Read())
        {
            Object[] row = new Object[rdr.VisibleFieldCount];
            rdr.GetValues(row);
            results.Add(row);
        }
        return results;
    }
}

private static void AddSqlParams(SqlCommand cmd, params String[] sqlParams)
{
    for (Int32 i = 0; i < sqlParams.Length; i++)
        cmd.Parameters.AddWithValue("@" + i, (Object)sqlParams[i] ?? DBNull.Value);
}

Then use like

UserUpcoming.Text = Query("SELECT COUNT(*) FROM vw_dash_user_upcoming WHERE Employee_ID = @0", crd["employee_id"].ToString())[0][0];

Answer 3

I like to have a separate class for each table in the database. In your case I would have a separate class called vw_dash_user_upcoming, this would have a static method something like...

public static int CountEmployees(int employeeId) {
    int returnValue;
    // do database stuff here
    return returnValue;
}

I usually create a folder and namespace in my project called "database" and all the database stuff goes in there. Nothing goes in there that's not database access. For me this really helps keep things organized, especially in a large project.

Answer 4

Personally I would create a separate class, simply because it's not a good idea to keep pieces of code with totally different responsibilities in one class. When divided into small classes code is easier to read and maintain.

Communication with database should be separated anyway to make it easier to switch between datasources (eg different database servers).