Блог

Я не понимаю, почему я должен создавать объект DbCommand каждый раз, когда мне нужно вызвать хранимую процедуру. Итак, я пытаюсь придумать способ сделать это. Я протестировал свой код (см. Ниже). Но я хотел бы уточнить у сообщества, есть ли что-то, что я пропустил. Я бы использовал его с в ASP.NET приложение. Является ли этот код потокобезопасным?

SharedDbCommand — завершает создание и хранение объекта DbCommand

Db — оболочка для базы данных, использует SharedDbCommand через статическое поле и атрибут ThreadStatic

Program — консольное приложение, которое запускает потоки и использует объект Db, который

 // SharedDbCommand.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Data.Common;
using System.Data.SqlClient;
using System.Data;

namespace TestCmdPrepare {
    public class SharedDbCommand {
        [ThreadStatic]
        static DbCommand cmd;

        public SharedDbCommand(string procedureName, ConnectionStringSettings dbConfig) {
            var factory = DbProviderFactories.GetFactory(dbConfig.ProviderName);
            cmd = factory.CreateCommand();
            cmd.Connection = factory.CreateConnection();
            cmd.Connection.ConnectionString = dbConfig.ConnectionString;
            cmd.CommandText = procedureName;
            cmd.CommandType = System.Data.CommandType.StoredProcedure;
            if (cmd is SqlCommand) {
                try {
                    cmd.Connection.Open();
                    SqlCommandBuilder.DeriveParameters(cmd as SqlCommand);
                } finally {
                    if (cmd != null amp;amp; cmd.Connection != null) 
                        cmd.Connection.Close();
                }
            }
        }

        public DbParameter this[string name] {
            get {
                return cmd.Parameters[name];
            }
        }

        public IDataReader ExecuteReader() {
            try {
                cmd.Connection.Open();
                return cmd.ExecuteReader(CommandBehavior.CloseConnection);
            } finally {
                cmd.Connection.Close();
            }
        }

        public void ExecuteNonQuery() {
            try {
                cmd.Connection.Open();
                cmd.ExecuteNonQuery();
            } finally {
                cmd.Connection.Close();
            }
        }
    }
}

// Db.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Data.Common;
using System.Data;
using System.Data.SqlClient;
using System.Threading;
using System.Diagnostics;

namespace TestCmdPrepare {
    public class Db {
        ConnectionStringSettings dbSettings;
        DbProviderFactory factory;
        public Db() {
            dbSettings = ConfigurationManager.ConnectionStrings["db"];
            factory = DbProviderFactories.GetFactory(dbSettings.ProviderName);
        }
        IDataReader ExecuteReader(DbCommand cmd) {
            cmd.Connection.Open();
            return cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }

        private DbConnection CreateConnection() {
            var c = factory.CreateConnection();
            c.ConnectionString = dbSettings.ConnectionString;
            return c;
        }

        DbCommand CreateCommand(string procedureName) {
            var cmd = factory.CreateCommand();
            cmd.Connection = CreateConnection();
            cmd.CommandText = "get_stuff";
            cmd.CommandType = CommandType.StoredProcedure;
            if (cmd is SqlCommand) {
                try {
                    cmd.Connection.Open();
                    SqlCommandBuilder.DeriveParameters(cmd as SqlCommand);
                } finally {
                    cmd.Connection.Close();
                }
            }
            return cmd;
        }


        [ThreadStatic]
        static DbCommand get_stuff;

        DbCommand GetStuffCmd {
            get {
                if (get_stuff == null)
                    get_stuff = CreateCommand("get_stuff");
                return get_stuff;
            }
        }

        public string GetStuff(int id) {
            GetStuffCmd.Parameters["@id"].Value = id;
            using (var reader = ExecuteReader(GetStuffCmd)) {
                if (reader.Read()) {
                    return reader.GetString(reader.GetOrdinal("bar"));
                }
            }
            return null;
        }

        [ThreadStatic]
        static SharedDbCommand get_stuff2;
        public string GetStuff2(int id) {
            if (get_stuff2 == null)
                get_stuff2 = new SharedDbCommand("get_stuff", dbSettings);
            get_stuff2["@id"].Value = id;
            using (var reader = get_stuff2.ExecuteReader()) {
                if (reader.Read()) {
                    Thread.Sleep(1000);
                    return reader.GetString(reader.GetOrdinal("bar"));
                }
            }
            return null;
        }
    }
}


// Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Common;
using System.Configuration;
using System.Data.SqlClient;
using System.Threading;

namespace TestCmdPrepare {
    class Program {
        static void Main(string[] args) {
            var db = new Db();
            var threads = new List<Thread>();
            for (int i = 0; i < 4; i  ) {
                var one = new Thread(Run2);
                var two = new Thread(Run1);

                threads.Add(one);
                threads.Add(two);
                one.Start();
                two.Start();

                Write(db, 1);
                Write(db, 2);
            }
            Console.WriteLine("Joining");
            foreach (var thread in threads) {
                thread.Join();
            }
            Console.WriteLine();
            Console.WriteLine("DONE");
            Console.ReadLine();
            return;
        }

        static void Write(Db db, int id) {


       Console.WriteLine("2:{0}:{1}", Thread.CurrentThread.ManagedThreadId, db.GetStuff2(id));
        Console.WriteLine("1:{0}:{1}", Thread.CurrentThread.ManagedThreadId, db.GetStuff(id));
    }

    static void Run1() {
        var db = new Db();
        Write(db, 1);
    }

    static void Run2() {
        var db = new Db();
        Write(db, 2);
    }

    }
}
  

Плохая идея по многим причинам. Другие упоминали некоторые из них, но я приведу вам один, специфичный для вашей реализации: использование ThreadStatic в ASP.NET в конечном итоге это вас укусит (смотрите здесь). Вы не управляете конвейером, поэтому возможно, что несколько потоков в конечном итоге будут обслуживать один запрос (подумайте, между обработчиками событий на странице и т.д. — Сколько выполняется кода, который не является вашим?). Также легко удалить данные из потока запроса, которым вы не владеете, из-за необработанных исключений. Возможно, это не проблема с остановкой показа, но в лучшем случае вы столкнулись с утечкой памяти и повышенным использованием ресурсов сервера, в то время как ваше соединение просто находится там…

Я бы рекомендовал вам просто позволить ConnectionPool выполнять свою работу — у него есть некоторые недостатки, но производительность не является одним из них по сравнению с тем, что еще происходит в ASP.NET конвейер. Если вы действительно хотите это сделать, по крайней мере, рассмотрите возможность сохранения объекта connection в HttpContext.Current .Товары. Вероятно, вы можете заставить это работать в ограниченных обстоятельствах, но всегда будут ошибки, особенно если вы когда-нибудь начнете писать параллельный код.

Всего за 0.02 доллара от парня, который был там. 🙂

Это не очень хорошая практика для сохранения созданной DbCommand. Кроме того, это делает ваше приложение очень сложным из-за логики обработки потоков.

Как предлагает Microsoft, вы должны создавать и утилизировать объекты connection и command сразу после выполнения вашего запроса. Они очень легкие в создании. Нет необходимости сохранять память, используемую с ними — утилизируйте их, когда выполнение вашего запроса завершено и вы получили все результаты.