Enable explicit connection pooling on Save()

While ADO.NET's built-in connection pooling _should_ be sufficient, with the new handling of unresolved references, it's easy to maintain an open connection for the duration of the recursive save. For most cases, where the save isn't recursive, this won't impact performance one way or the other. For recursive saves of large topic graphs, however, it eliminates some overhead of opening and closing a connection for every `Topic` in the topic graph.

Author: JeremyCaney

OnTopic.Data.Sql/SqlTopicRepository.cs

@@ -269,22 +269,27 @@ public override int Save([NotNull]Topic topic, bool isRecursive = false, bool is
       | Establish dependencies
       \-----------------------------------------------------------------------------------------------------------------------*/
       var unresolvedTopics      = new List<Topic>();
+      var connection            = new SqlConnection(_connectionString);
+
+      connection.Open();
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Handle first pass
       \-----------------------------------------------------------------------------------------------------------------------*/
-      var topicId = Save(topic, isRecursive, isDraft, unresolvedTopics);
+      var topicId = Save(topic, isRecursive, isDraft, connection, unresolvedTopics);
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Attempt to resolve outstanding relationships
       \-----------------------------------------------------------------------------------------------------------------------*/
       foreach (var unresolvedTopic in unresolvedTopics) {
-        Save(unresolvedTopic, false, isDraft, new List<Topic>());
+        Save(unresolvedTopic, false, isDraft, connection, new List<Topic>());
       }
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Return value
       \-----------------------------------------------------------------------------------------------------------------------*/
+      connection.Close();
+      connection.Dispose();
       return topicId;
 
     }
@@ -303,15 +308,22 @@ public override int Save([NotNull]Topic topic, bool isRecursive = false, bool is
     ///     that include such references. This adds some overhead due to the duplicate <see cref="Save"/>, but helps avoid
     ///     potential data loss when working with complex topic graphs.
     ///   </para>
+    ///   <para>
+    ///     The connection sharing probably doesn't provide that much of a gain in that .NET does a good job of connection
+    ///     pooling. Nevertheless, there is some overhead to opening a new connection, so sharing an open connection when we
+    ///     doing a recursive save could potentially provide some performance benefit.
+    ///   </para>
     /// </remarks>
     /// <param name="topic">The source <see cref="Topic"/> to save.</param>
     /// <param name="isRecursive">Determines whether or not to recursively save <see cref="Topic.Children"/>.</param>
     /// <param name="isDraft">Determines if the <see cref="Topic"/> should be saved as a draft version.</param>
+    /// <param name="connection">The open <see cref="SqlConnection"/> to use for executing <see cref="SqlCommand"/>s.</param>
     /// <param name="unresolvedRelationships">A list of <see cref="Topic"/>s with unresolved topic references.</param>
     private int Save(
       [NotNull]Topic topic,
       bool isRecursive,
       bool isDraft,
+      SqlConnection connection,
       List<Topic> unresolvedRelationships
     ) {
 
@@ -406,7 +418,6 @@ void addUnmatchedAttribute(string key) {
       | Establish database connection
       \-----------------------------------------------------------------------------------------------------------------------*/
       var isNew                 = topic.Id == -1;
-      var connection            = new SqlConnection(_connectionString);
       var procedureName         = isNew? "CreateTopic" : "UpdateTopic";
       var command               = new SqlCommand(procedureName, connection) {
         CommandType             = CommandType.StoredProcedure
@@ -446,7 +457,6 @@ void addUnmatchedAttribute(string key) {
       \-----------------------------------------------------------------------------------------------------------------------*/
       try {
 
-        connection.Open();
         command.ExecuteNonQuery();
 
         topic.Id                = command.GetReturnCode();
@@ -466,6 +476,7 @@ void addUnmatchedAttribute(string key) {
       | Catch exception
       \-----------------------------------------------------------------------------------------------------------------------*/
       catch (SqlException exception) {
+        connection?.Dispose();
         throw new TopicRepositoryException(
           $"Failed to save Topic '{topic.Key}' ({topic.Id}) via '{_connectionString}': '{exception.Message}'",
           exception
@@ -477,7 +488,6 @@ void addUnmatchedAttribute(string key) {
       \-----------------------------------------------------------------------------------------------------------------------*/
       finally {
         command?.Dispose();
-        connection?.Dispose();
         attributes.Dispose();
       }
 
@@ -487,7 +497,7 @@ void addUnmatchedAttribute(string key) {
       if (isRecursive) {
         foreach (var childTopic in topic.Children) {
           childTopic.Attributes.SetValue("ParentID", topic.Id.ToString(CultureInfo.InvariantCulture));
-          Save(childTopic, isRecursive, isDraft, unresolvedRelationships);
+          Save(childTopic, isRecursive, isDraft, connection, unresolvedRelationships);
         }
       }
 
@@ -697,7 +707,7 @@ private static string PersistRelations(Topic topic, SqlConnection connection, bo
       finally {
         command?.Dispose();
         targetIds.Dispose();
-        //Since the SQL connection is being passed in, do not close connection; this allows command pooling.
+        //Since the SQL connection is being passed in, do not close connection; this allows connection pooling.
       }
 
       /*------------------------------------------------------------------------------------------------------------------------