Каков самый элегантный способ использования хранимых процедур?

Question

Я переписываю встроенный SQL в моем классе репозитория вместо использования хранимых процедур (требование безопасности). После использования Fluent NHibernate и Linq2Sql в прошлом я нахожу его чрезвычайно громоздким и неэлегантным.

EDIT: Чтобы уточнить, я не ищу решение ORM, которое работает с хранимыми процедурами. Я просто хочу, чтобы некоторые советы о том, как написать код ниже.

Существуют ли какие-либо стратегии для того, чтобы сделать такой код максимально элегантным?

 string commandText = "dbo.Save"; 

     using (SqlConnection sql = new SqlConnection(_connString.ConnectionString)) 
     using (SqlCommand cmd = sql.CreateCommand()) 
     { 
      cmd.CommandText = commandText; 
      cmd.CommandType = CommandType.StoredProcedure; 

      SqlParameter idParam = new SqlParameter("identity", item.Identity); 
      idParam.Direction = ParameterDirection.Input; 

      SqlParameter nameParam = new SqlParameter("name", item.Name); 
      nameParam.Direction = ParameterDirection.Input; 

      SqlParameter descParam = new SqlParameter("desc", item.Description); 
      descParam.Direction = ParameterDirection.Input; 

      SqlParameter titleParam = new SqlParameter("title", item.) 
      descParam.Direction = ParameterDirection.Input; 

      //SNIP More parameters 

      cmd.Parameters.Add(idParam); 
      cmd.Parameters.Add(descParam); 
      cmd.Parameters.Add(titleParam); 
      //SNIP etc 

      sql.Open(); 

      cmd.ExecuteNonQuery(); 

      //Get out parameters 
     } 

     return item; 

Answer 1

В наших внутренних приложений, которые мы обычно используем класс SqlHelper, который можно найти по следующей ссылке (скачать и описание): http://www.microsoft.com/downloads/details.aspx?familyid=f63d1f0a-9877-4a7b-88ec-0426b48df275&displaylang=en

По существу класс SqlHelper отнимает часть необходимости объявлять объекты соединения, команды и т.д. и позволяет вызывать методы возвращают объекты, такие как DataSet

затем вы можете использовать SqlHelper как таковые:

public static int UpdateItem(int parameter1, int parameter2, string parameter3) 
    { 
     SqlParameter[] arParam = new SqlParameter[3]; 
     arParam[0] = new SqlParameter("@Parameter1", lotId); 
     arParam[1] = new SqlParameter("@Parameter2", saleId); 
     arParam[2] = new SqlParameter("@Parameter3", lotNumber); 


     return int.Parse(SqlHelper.ExecuteScalar(connString, CommandType.StoredProcedure, "spName", arParam).ToString(), CultureInfo.InvariantCulture); 
    } 

Надеется, что это помогает :)

Answer 2

Вы можете использовать SubSonic в качестве ORM слоя между вашим классом и хранимыми процедурами. Вот базовый example. У Фила Хаака есть хороший article.

В this other question есть хорошая информация.

EDIT: Поскольку вы обновили свой вопрос, указав, что вы не хотите использовать ORM, SubSonic не для вас. Тем не менее, я оставлю ответ здесь для других людей, которые используют хранимые процедуры. :) Вы также должны посмотреть, есть ли возможность использовать его.

Answer 3

Вы можете сократить вдвое линейный счет, выведя свой собственный InputSqlParameter из SqlParameter и указав направление ввода в конструктор.

Это позволит вам написать

cmd.Parameters.Add(new InputSqlParameter("title", item.title)); 
    cmd.Parameters.Add(new InputSqlParameter("property", item.property)); 

Это показывает шаблон, и позволяет вам настроить список имен параметров и полей элементов и сделать параметр, добавив в для цикла.

Answer 4

Храните каждый параметр для данной хранимой процедуры в «классе данных». Используйте аннотации, чтобы указать такие параметры, как «in» или «out» sproc.

Затем вы можете загрузить класс из клиентского кода, затем использовать отражение для построения всех параметров для sproc, выполнить sproc и загрузить выходные параметры обратно в класс данных.

Немного более чистый: иметь один класс для входов и другой для выходов (даже если некоторые из них находятся в/из). Таким образом, понятно (к клиентскому коду), какие параметры необходимо заполнять по пути и которые возвращаются. Также это устраняет необходимость в этих аннотациях.

Answer 5

using (var conn = new SqlConnection(ConnectionString)) 
using (var cmd = conn.CreateCommand()) 
{ 
    cmd.CommandText = "[dbo].[Save]"; 
    cmd.CommandType = CommandType.StoredProcedure; 

    cmd.Parameters.Add(new SqlParameter(
     "Identity", SqlDbType.Int) { Value = item.Identity }); 

    cmd.Parameters.Add(new SqlParameter(
     "Name", SqlDbType.NVarChar, 50) { Value = item.Name }); 

    cmd.Parameters.Add(new SqlParameter(
     "Title", SqlDbType.NVarChar, 100) { Value = item.Title }); 

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

Вот как это может выглядеть с Ent Lib:

// Note, that you don't need to specify connection string here, 
// it will be automatically taken from a configuration file 
var db = DatabaseFactory.CreateDatabase(); 

using (var cmd = db.GetStoredProcCommand("[dbo].[Save]")) 
{ 
    db.AddInParameter(cmd, "Identity", DbType.Int32, item.Identity); 
    db.AddInParameter(cmd, "Name", DbType.String, item.Name); 
    db.AddInParameter(cmd, "Title", DbType.String, item.Title); 
    db.ExecuteNonQuery(cmd); 
} 

Вы также можете использовать метод SqlHelper из Enterprise Library, чтобы упростить этот синтаксис.

SqlHelper.ExecuteNonQuery(connectinString, 
    CommandType.StoredProcedure, "[dbo].[Save]", new SqlParameter[] 
     { 
      new SqlParameter("Identity", item.Identity), 
      new SqlParameter("Name", item.Name), 
      new SqlParameter("Title", item.Title) 
     }); 

Answer 6

Thats funny, я остро спросил этот же вопрос. Все еще ищут хорошее решение.

Which ORM is the best when using Stored Procedures

Answer 7

захватить копию Enterprise Library. Это хорошая обложка вокруг ADO. Например:

using System.Data.Common; 
using System.Globalization; 
using Microsoft.Practices.EnterpriseLibrary.Data; 

Database db = DatabaseFactory.CreateDatabase(DatabaseType.MyDatabase.ToString()); 

using (DbCommand dbCommand = db.GetStoredProcCommand("dbo.MyStoredProc")) { 
    db.AddInParameter(dbCommand, "identity", DbType.Int32, item.Identity); 
    db.AddInParameter(dbCommand, "name", DbType.String, item.Name); 
    db.AddInParameter(dbCommand, "desc", DbType.String, item.Description); 
    db.AddInParameter(dbCommand, "title", DbType.String, item.Title); 

    db.ExecuteNonQuery(dbCommand); 
} // using dbCommand 

Answer 8

Я бы рекомендовал использовать объект SqlHelper приложений Microsoft Application Blocks.

Для справки, подобной приведенной выше, я могу сделать следующее.

SqlHelper.ExecuteNonQuery(_connectionString, "MyProcName", 1, "NameValue", "Description", "Title"); 

В основном SQL-помощник выполняет несколько параметров.

1. Строка соединения для подключения к БД
2. Имя хранимой процедуры
3. Массив значений параметров, в том порядке, в котором они появляются в хранимой процедуре.

Существует очень незначительный недостаток в производительности с помощью этого метода, явно создавая каждый параметр, но экономия времени обычно превосходит его, поскольку он настолько мал.

Answer 9

Я обычно использую некоторые вариации в следующем примере, в зависимости от окружающей среды, конечно:

Мои основные вспомогательные методы, которые я называю на протяжении всего моего кода

public static SqlCommand CreateStoredProcCmd(string name, SqlConnection con) 
{ 
    var cmd = new SqlCommand(name, con); 
    cmd.CommandType = CommandType.StoredProcedure; 
    return cmd; 
} 

public static void AddParams(this SqlCommand cmdObject, Params SqlParameter[] parameters) 
{ 
    foreach(SqlParameter param in parameters) 
    { 
    cmdObject.Parameters.add(param); 
    } 
} 

/* Any overloaded methods to create params receiving my param definitions 
in any manner that the usual new SqlParameter() constructor doesn't handle */ 
public static SqlParameter CreateSqlParam(string ParamName, 
              SqlDbType ParamType, 
              object value) 
{ 
    return CreateSqlParam(ParamName, ParamType, ParameterDirection.Input, value); 
} 

public static SqlParameter CreateSqlParam(string ParamName, 
              SqlDbType ParamType, 
              ParameterDirection ParamDir) 
{ 
    return CreateSqlParam(ParamName, ParamType, ParamDir, null; 
}       

public static SqlParameter CreateSqlParam(string ParamName, 
              SqlDbType ParamType, 
              ParameterDirection ParamDir, 
              object value) 
{ 
    var parm = new SqlParameter(ParamName, ParamType); 
    parm.Direction = ParamDir; 
    parm.Value = value; 
    return parm; 
} 

Теперь вот как я установил вверх по моим сохраненным процессам и добавить все мои параметры элегантно

public static string DoStuff() 
{ 
    using (var oCon = new SqlConnection("MyConnectionString")) 
    { 
     oCon.Open(); 
     var oCmd = CreateStoredProcCmd("sp_Name", oCon).AddParams(
      CreateSqlParam("Param1", SqlDBType.Int, 3), 
      CreateSqlParam("Param2", SqlDBType.VarChar, "Hello World"), 
      CreateSqlParam("Param3", SqlDBType.VarChar, ParameterDirection.Output) 
     ); 
     oCmd.Prepare(); 
     oCmd.ExecuteNonQuery(); 
     object outVal = oCmd.Parameters["Param3"]; 
     return null != outVal ? outVal.ToString() : String.Empty; 
    } 
} 

Answer 10

Чтобы сделать код немного менее многословным я всегда добавлен параметрами с помощью

cmd.Parameters.AddWithValue("name", item.Name); 
cmd.Parameters.AddWithValue("title", item.Title); 
// and so on 

Answer 11

входа является направлением по умолчанию, и вы можете сократить параметр добавления и, вероятно, хочет объявить SqlDBTypes, а также ...

cmd.Parameters.Add("identity", SqlDBType.???).Value = item.Identity; 
cmd.Parameters.Add("desc", SqlDbType.???, ?size?).Value = item.Description; 
cmd.Parameters.Add("title", SqlDBType.???, ?size?).Value = item.Title; 

//Output params generally don't need a value so... 
cmd.Parameters.Add("someOut", SqlDBType.???).Direction = ParameterDirection.Output;