Prepared statements and the built-in connection pool in .NET

I have a long-running service with several threads calling the following method hundreds of times per second:

void TheMethod()
{
    using (var c = new SqlConnection("..."))
    {
        c.Open();

        var ret1 = PrepareAndExecuteStatement1(c, args1);
        // some code
        var ret2 = PrepareAndExecuteStatement2(c, args2);
        // more code
    }
}

PrepareAndExecuteStatement is something like this:

void PrepareAndExecuteStatement*(SqlConnection c, args)
{
    var cmd = new SqlCommand("query", c);
    cmd.Parameters.Add("@param", type);
    cmd.Prepare();
    cm开发者_如何学编程d.Parameters["@param"] = args;

    return cmd.execute().read().etc();
}

I want reuse the prepared statements, preparing once per connection and executing them until the connection breaks. I hope this will improve performance.

Can I use the built-in connection pool to achieve this? Ideally every time a new connection is made, all statements should be automatically prepared, and I need to have access to the SqlCommand objects of these statements.

Suggest taking a slightly modified approach. Close your connection immedately after use. You can certainly re-use your SqlConnection.

The work being done at //some code may take a long time. Are you interacting with other network resources, disk resources, or spending any amount of time with calculations? Could you ever, in the future, need to do so? Perhaps the intervals between executing statement are/could be so long that you'd want to reopen that connection. Regardless, the Connection should be opened late and closed early.

using (var c = new SqlConnection("..."))
{
    c.Open();
    PrepareAndExecuteStatement1(c, args);
    c.Close();
    // some code
    c.Open();
    PrepareAndExecuteStatement2(c, args);
    c.Close();
    // more code
}

Open Late, Close Early as MSDN Magazine by John Papa.

Obviously we've now got a bunch of code duplication here. Consider refactoring your Prepare...() method to perform the opening and closing operations.

Perhaps you'd consider something like this:

using (var c = new SqlConnection("..."))
{
    var cmd1 = PrepareAndCreateCommand(c, args);

    // some code
    var cmd2 = PrepareAndCreateCommand(c, args);

    c.Open();
    cmd1.ExecuteNonQuery();
    cmd2.ExecuteNonQuery();
    c.Close();
    // more code
}