O Entity Framework (EF) é uma poderosa ferramenta ORM (Object-Relational Mapping) para .NET que facilita a interação com bancos de dados relacionais. Uma das funcionalidades que o EF suporta é a execução de stored procedures. Neste artigo vamos explorar como executar stored procedures com e sem parâmetros.
O que são stored procedures?
Stored procedures, ou procedimentos armazenados, são conjuntos de instruções SQL que são armazenadas no servidor de banco de dados e podem ser executadas conforme necessário. Elas permitem que os desenvolvedores escrevam uma vez um conjunto de comandos SQL e os reutilizem em diferentes partes da aplicação, promovendo a reutilização de código e facilitando a manutenção.
Benefícios na utilização do stored procedure
Redução de tráfego na rede: em vez de enviar vários comandos SQL do aplicativo para o banco de dados, podemos enviar uma única chamada para um stored procedure que executa todos os comandos necessários no servidor. Isso reduz o tráfego na rede e melhora a eficiência da comunicação entre o aplicativo e o banco de dados.
Segurança: stored procedures podem ser usados para restringir o acesso direto às tabelas do banco de dados. Em vez de conceder permissões de leitura/escrita diretamente nas tabelas, podemos conceder permissões para executar stored procedures específicos. Isso adiciona uma camada extra de segurança, garantindo que os usuários finais só possam executar operações autorizadas.
Manutenção e reutilização de código: com stored procedures, a lógica de negócios pode ser centralizada no banco de dados, facilitando a manutenção e a atualização do código. Se uma regra de negócios mudar, podemos atualizar o stored procedure correspondente em vez de modificar o código em várias partes da aplicação.
Preparando o ambiente
Antes de começarmos, certifique-se de ter um banco de dados SQL Server e um projeto .NET configurado com Entity Framework. Aqui também vamos assumir que você já tem um “DbContext” configurado.
No SQLServer crie uma tabela chamada Clientes e adicione as colunas “Id”, “Nome”, “Sobrenome” e “DataNascimento”. Após criada, você pode clicar com o botão direito do mouse no banco que deseja criar o stored procedure e selecionar “new Query”. No campo que abriu, nós vamos escrever os nossos stored procedures.
No seu código C#, os stored procedures são chamados usando o “DbContext”. Normalmente, essa lógica é implementada em uma camada de repositório ou serviço.
Procedure sem parâmetros e com retorno
Vamos começar com um exemplo simples de como criar e executar um stored procedure que busca todos os clientes de um banco de dados. No SQL Server, você pode executar o seguinte script, que cria o procedure no banco de dados:
CREATE PROCEDURE ConsultarClientes
AS
BEGIN
SELECT * FROM Clientes
END
Este stored procedure não aceita parâmetros e retorna todos os registros da tabela “Clientes”.
Para executá-lo e obter os resultados no Entity Framework, você pode usar o método “FromSqlRaw” que permite que você execute uma consulta SQL bruta e mapeie o resultado para um conjunto de entidades do tipo especificado. Aqui está como você pode fazer isso em um método dentro de um repositório ou serviço:
public List<Cliente> ListarClientes()
{
var clientes = _context.Clientes
.FromSqlRaw("EXEC ConsultarClientes")
.ToList();
return clientes;
}
O método “ListarClientes” chama o stored procedure “ConsultarClientes” usando o método “FromSqlRaw” do Entity Framework. Ele executa o stored procedure e converte o conjunto de resultados retornado em uma lista de objetos “Cliente”.
Procedure com parâmetros e sem retorno
Agora, vamos criar um stored procedure que aceita um parâmetro e não retorna valores. Suponha que queremos excluir um cliente com base no “Id” fornecido:
CREATE PROCEDURE ExcluirCliente
@ClienteId INT
AS
BEGIN
DELETE FROM Clientes WHERE Id = @ClienteId
END
Este stored procedure aceita um parâmetro “@ClienteId” e exclui o cliente com o “Id” correspondente da tabela “Clientes”. Não retorna valores, apenas executa a ação de exclusão. Dessa vez, no código C# precisaremos usar o método ExecuteSqlRaw, da seguinte forma:
public void ExcluirCliente(int id)
{
_context.Database.ExecuteSqlRaw("EXEC ExcluirCliente @ClienteId", new
SqlParameter("@ClienteId", id));
}
O método “ExcluirCliente” chama o stored procedure “ExcluirCliente” usando o método “ExecuteSqlRaw” do Entity Framework, que executa um comando SQL direto no banco de dados e não retorna qualquer resultado (como uma lista de entidades). Em vez disso, ele retorna o número de linhas afetadas pelo comando SQL executado. Ele executa a stored procedure com o parâmetro “@ClienteId” para excluir o cliente correspondente do banco de dados.
Procedure com parâmetros e com retorno
Finalmente, vamos criar um stored procedure que aceita um parâmetro e retorna um conjunto de resultados. Suponha que queremos obter clientes com base no nome fornecido:
CREATE PROCEDURE ObterClientesPorNome
@Nome NVARCHAR(100)
AS
BEGIN
SELECT * FROM Clientes WHERE Nome = @Nome
END
Este stored procedure aceita um parâmetro “@Nome” e retorna todos os registros da tabela “Clientes” cujo nome coincide com o valor fornecido. para executá-lo, usamos novamente o método “FromSqlRaw”, porém agora passando um parâmetro:
public List<Cliente> BuscarClientesPorNome(string nomeCliente)
{
var clientes = _context.Clientes
.FromSqlRaw("EXEC ObterClientesPorNome @Nome", new SqlParameter("@Nome", nomeCliente))
.ToList();
return clientes;
}
O método “BuscarClientesPorNome” chama o stored procedure “ObterClientesPorNome” usando o método “FromSqlRaw” do Entity Framework. Ele executa o stored procedure com o parâmetro “@Nome” e converte o conjunto de resultados retornado em uma lista de objetos “Cliente”.
Procedure com vários parâmetros
Nos exemplos anteriores vimos como executar um procedure que recebe apenas um parâmetro. Caso você precise executar um procedure que espera vários parâmetros, pode também usar o método “ExecuteSqlRaw” e passar os parâmetros separados por vírgula. Por exemplo, vamos considerar o seguinte stored procedure que atualiza um registro no banco de dados:
CREATE PROCEDURE AtualizarCliente
@ClienteId INT,
@Nome NVARCHAR(100),
@Sobrenome NVARCHAR(100),
@DataNascimento DATE
AS
BEGIN
UPDATE Clientes
SET Nome = @Nome,
Sobrenome = @Sobrenome,
DataNascimento = @DataNascimento
WHERE Id = @ClienteId
END
Para executá-lo precisamos fornecer valores para todos os parâmetros, caso contrário teremos um erro informando que o número de parâmetros fornecido é diferente do esperado. Isso pode ser feito da seguinte forma:
public Cliente AtualizarCliente(Cliente cliente)
{
_context.Database.ExecuteSqlRaw(
"EXEC AtualizarCliente @ClienteId, @Nome, @Sobrenome, @DataNascimento",
new SqlParameter("@ClienteId", cliente.Id),
new SqlParameter("@Nome", cliente.Nome),
new SqlParameter("@Sobrenome", cliente.Sobrenome),
new SqlParameter("@DataNascimento", cliente.DataNascimento)
);
return cliente;
}
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
Neste artigo exploramos como executar stored procedures no SQL Server usando o Entity Framework e percebemos que são uma ferramenta que pode melhorar a eficiência e a segurança das suas operações de banco de dados. Aproveite esses exemplos para começar a implementar stored procedures em seus projetos .NET com Entity Framework.