Como passar parâmetros para o método DbContext.Database.ExecuteSqlCommand?

Vamos supor que eu tenha uma necessidade válida de executar diretamente um comando sql no Entity Framework. Estou tendo problemas para descobrir como usar parâmetros na minha instrução sql. O exemplo a seguir (não o meu exemplo real) não funciona.

var firstName = "John";
var id = 12;
var sql = @"Update [User] SET FirstName = @FirstName WHERE Id = @Id";
ctx.Database.ExecuteSqlCommand(sql, firstName, id);

O método ExecuteSqlCommand não permite que você transmita parâmetros nomeados como no ADO.Net e a documentação desse método não fornece exemplos de como executar uma consulta parametrizada.

Como especifico os parâmetros corretamente?

Tente o seguinte:

var sql = @"Update [User] SET FirstName = @FirstName WHERE Id = @Id";

ctx.Database.ExecuteSqlCommand(
    sql,
    new SqlParameter("@FirstName", firstname),
    new SqlParameter("@Id", id));

Acontece que isso funciona.

var firstName = "John";
var id = 12;
var sql = "Update [User] SET FirstName = {0} WHERE Id = {1}";
ctx.Database.ExecuteSqlCommand(sql, firstName, id);

Você também pode:

1) Passe argumentos brutos e use a sintaxe {0}. Por exemplo:

DbContext.Database.SqlQuery("StoredProcedureName {0}", paramName);

2) Passe argumentos da subclasse DbParameter e use a sintaxe @ParamName.

DbContext.Database.SqlQuery("StoredProcedureName @ParamName", 
                                   new SqlParameter("@ParamName", paramValue);

Se você usar a primeira sintaxe, o EF encerrará seus argumentos com as classes DbParamater, atribuirá nomes a eles e substituirá {0} pelo nome do parâmetro gerado.

A primeira sintaxe, se preferir, porque você não precisa usar uma fábrica ou saber que tipo de DbParamaters criar (SqlParameter, OracleParamter, etc.).

As outras respostas não funcionam ao usar o Oracle. Você precisa usar em :vez de @.

var sql = "Update [User] SET FirstName = :FirstName WHERE Id = :Id";

context.Database.ExecuteSqlCommand(
   sql,
   new OracleParameter(":FirstName", firstName), 
   new OracleParameter(":Id", id));

Tente isto (editado):

ctx.Database.ExecuteSqlCommand(sql, new SqlParameter("FirstName", firstName), 
                                    new SqlParameter("Id", id));

A ideia anterior estava errada.

Para a entidade Framework Core 2.0 ou superior, a maneira correta de fazer isso é:

var firstName = "John";
var id = 12;
ctx.Database.ExecuteSqlCommand($"Update [User] SET FirstName = {firstName} WHERE Id = {id}";

Observe que o Entity Framework produzirá os dois parâmetros para você, para que você esteja protegido contra a injeção de SQL.

Observe também que NÃO é:

var firstName = "John";
var id = 12;
var sql = $"Update [User] SET FirstName = {firstName} WHERE Id = {id}";
ctx.Database.ExecuteSqlCommand(sql);

porque isso NÃO o protege da injeção SQL e nenhum parâmetro é produzido.

Veja isso para mais.

Versão simplificada para Oracle. Se você não deseja criar OracleParameter

var sql = "Update [User] SET FirstName = :p0 WHERE Id = :p1";
context.Database.ExecuteSqlCommand(sql, firstName, id);

var firstName = "John";
var id = 12;

ctx.Database.ExecuteSqlCommand(@"Update [User] SET FirstName = {0} WHERE Id = {1}"
, new object[]{ firstName, id });

Isso é tão simples !!!

Imagem para conhecer a referência de parâmetro

Para o método async ("ExecuteSqlCommandAsync"), você pode usá-lo assim:

var sql = @"Update [User] SET FirstName = @FirstName WHERE Id = @Id";

await ctx.Database.ExecuteSqlCommandAsync(
    sql,
    parameters: new[]{
        new SqlParameter("@FirstName", firstname),
        new SqlParameter("@Id", id)
    });

Se seus tipos de dados de banco de dados subjacentes são varchar, você deve seguir a abordagem abaixo. Caso contrário, a consulta teria um enorme impacto no desempenho.

var firstName = new SqlParameter("@firstName", System.Data.SqlDbType.VarChar, 20)
                            {
                                Value = "whatever"
                            };

var id = new SqlParameter("@id", System.Data.SqlDbType.Int)
                            {
                                Value = 1
                            };
ctx.Database.ExecuteSqlCommand(@"Update [User] SET FirstName = @firstName WHERE Id = @id"
                               , firstName, id);

Você pode verificar o Sql Profiler para ver a diferença.

public static class DbEx {
    public static IEnumerable<T> SqlQueryPrm<T>(this System.Data.Entity.Database database, string sql, object parameters) {
        using (var tmp_cmd = database.Connection.CreateCommand()) {
            var dict = ToDictionary(parameters);
            int i = 0;
            var arr = new object[dict.Count];
            foreach (var one_kvp in dict) {
                var param = tmp_cmd.CreateParameter();
                param.ParameterName = one_kvp.Key;
                if (one_kvp.Value == null) {
                    param.Value = DBNull.Value;
                } else {
                    param.Value = one_kvp.Value;
                }
                arr[i] = param;
                i++;
            }
            return database.SqlQuery<T>(sql, arr);
        }
    }
    private static IDictionary<string, object> ToDictionary(object data) {
        var attr = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance;
        var dict = new Dictionary<string, object>();
        foreach (var property in data.GetType().GetProperties(attr)) {
            if (property.CanRead) {
                dict.Add(property.Name, property.GetValue(data, null));
            }
        }
        return dict;
    }
}

Uso:

var names = db.Database.SqlQueryPrm<string>("select name from position_category where id_key=@id_key", new { id_key = "mgr" }).ToList();

Vários parâmetros em um procedimento armazenado que possui vários parâmetros na vb:

Dim result= db.Database.ExecuteSqlCommand("StoredProcedureName @a,@b,@c,@d,@e", a, b, c, d, e)

Procedimentos armazenados podem ser executados como abaixo

 string cmd = Constants.StoredProcs.usp_AddRoles.ToString() + " @userId, @roleIdList";
                        int result = db.Database
                                       .ExecuteSqlCommand
                                       (
                                          cmd,
                                           new SqlParameter("@userId", userId),
                                           new SqlParameter("@roleIdList", roleId)
                                       );

Para o .NET Core 2.2, você pode usar FormattableStringo SQL dinâmico.

//Assuming this is your dynamic value and this not coming from user input
var tableName = "LogTable"; 
// let's say target date is coming from user input
var targetDate = DateTime.Now.Date.AddDays(-30);
var param = new SqlParameter("@targetDate", targetDate);  
var sql = string.Format("Delete From {0} Where CreatedDate < @targetDate", tableName);
var froamttedSql = FormattableStringFactory.Create(sql, param);
_db.Database.ExecuteSqlCommand(froamttedSql);