Come aggiungere più parametri al comando SQL in un'unica istruzione?

Question

Ho sei linee di parametri come questo:

cmd.Parameters.AddWithValue("@variable1", myvalue1); 
    cmd.Parameters.AddWithValue("@variable2", myvalue2); 
    cmd.Parameters.AddWithValue("@variable3", myvalue3); 

e così via.

C'è un modo per comprimere questo un po 'senza inserire direttamente in cmd.CommandText?

Modifica: Credo che avrei potuto usare un buon vecchio stile. Ho deciso di restare con questo però.

Answer 1

Per quanto ne so, il codice è il più compatto possibile in termini di numero di righe, tuttavia è possibile utilizzare lo List<SqlParameter> con la sintassi di inizializzatore dell'oggetto per avere solo una riga terminata da un punto e virgola per creare l'elenco di parametri, quindi passare che lista come la matrice di parametri attesi dal metodo AddRange

List<SqlParameter> prm = new List<SqlParameter>() 
{ 
    new SqlParameter("@variable1", SqlDbType.Int) {Value = myValue1}, 
    new SqlParameter("@variable2", SqlDbType.NVarChar) {Value = myValue2}, 
    new SqlParameter("@variable3", SqlDbType.DateTime) {Value = myValue3}, 
}; 
cmd.Parameters.AddRange(prm.ToArray()); 

si noti che con questo approccio è necessario definire correttamente il tipo di dati del parametro. Nel mio esempio ho usato alcuni tipi arbitrari per mostrare la sintassi corretta

Un po 'fuori tema, penso che in questo contesto generale sia interessante sottolineare che AddWithValue non è da considerare quando si vuole ottenere il migliore prestazione possibile.

In questo articolo su MSDN How data access code affects database perfomance è spiegato bene perché si dovrebbe evitare il metodo AddWithValue per motivi di prestazioni.
In breve, l'utilizzo di AddWithValue potrebbe essere un problema per lo Sql Server Optimizer perché i parametri della stringa di tipo vengono passati con la dimensione uguale alla lunghezza corrente della stringa. Ma questo costringerà lo Sql Server Optimizer a scartare il piano di query creato per una precedente chiamata identica ma con una stringa di lunghezza diversa.
È preferibile chiamare il costruttore SqlParameter specificando il tipo e la dimensione del parametro e non preoccuparsi di come effettuare il compress the size delle chiamate.

Answer 2

Solo per amor di discussione, utilizzando il codice di esempio che hai dato in cui le variabili proc memorizzati vengono letteralmente chiamati variabe1, variable2, ecc ... si potrebbe fare qualcosa di simile:

string[] myValues = new string[] { "myvalue1", "myvalue2", "myvalue3", "myvalue4", "myvalue5", "myvalue6" }; 
for (int i = 0; i < 6; i++) { cmd.Parameters.AddWithValue("@variable" + (i + 1),myValues[i]); } 

2 righe di codice brutto ... LOL

Un ciclo come questo può tornare utile se avessi detto 25-50 valori, anche se non lo vedo molto spesso. E si potrebbe utilizzare 2 campi, uno per i nomi delle variabili e uno per i valori, fino a quando gli indici corrispondono, allora questo dovrebbe funzionare:

string[] myVarNames = new string[] { "variable1", "variable2", "variableThree", "variable4our", "variableFIVE", "variableSIX" }; 
string[] myValues = new string[] { "myvalue1", "myvalue2", "myvalue3", "myvalue4", "myvalue5", "myvalue6" }; 

for (int i = 0; i < 6; i++) 
{ 
    cmd.Parameters.AddWithValue("@" + myVarNames[i], myValues[i]); 
} 

Answer 3

ho preso la questione letteralmente: " ...in una dichiarazione" :)

codice di Steve è bello, ma può essere semplificato un po 'di più con la più canonica SqlParameter costruttore e dichiarazione implicita array:

cmd.Parameters.AddRange(new [] 
    { 
     new SqlParameter("@variable1", myValue1}, 
     new SqlParameter("@variable2", myValue2}, 
     new SqlParameter("@variable3", myValue3}, 
    }); 

Answer 4

Penso che questa sarà leggere molto bene come un uno di linea come questa:

Usage:

// One liner to create and set SqlCommand parameters 
cmd.SetParameters(Parameter("@variable1", myvalue1), Parameter("@variable2", myvalue2), Parameter("@variable3", myvalue3)); 

per supportare l'uno di linea è necessario creare una funzione per avvolgere il parametro SQL come un fascio semantica (Tuple simili) come segue:

public SqlParameter Parameter(string name, object value) 
{ 
    return new SqlParameter(name, value); 
} 

Creare una classe statica con un metodo di estensione per darci lo zucchero sintattico che stiamo cercando. Si noti l'uso della parola chiave param. che consente di impostare i parametri multipli nella chiamata precedente a SetParameters.

public static class SqlDataUtils 
{ 
    public static void SetParameters(this SqlCommand command, params SqlParameter[] parameters) 
    { 
     command.Parameters.AddRange(parameters); 
    } 
} 

Questa risposta si ispira alla risposta accettata a Key value pairs in C# Params da Bryan Watts