PROCEDIMIENTOS ALMACENADOS ENTITY FRAMEWORK CORE

Definición: 

Un procedimiento almacenado es una tarea almacenada directamente en la base de datos. La virtud de esto es que no debemos cargar los datos en la aplicación para manipularlos, se puede hacer una consulta específica, muy útil a la hora de cargar vistas. También se puede usar en varias aplicaciones a la vez puesto que es una consulta  cargada en la base de datos.  

En este ejercicio vamos a llamar a procedimientos almacenados en la base de datos, esto quiere decir que: 

• Debemos tener conexión a la base de datos desde SQL Server para crear los procedimientos 
• En Visual Studio: 
  • Utilizaremos EntityFramework mediante el nuget y el mapeo de tablas para acceder a la base de datos 
  • Al hacer el proyecto en core, la cadena de conexión se gestionará creando un nuevo fichero appSettings.json 
• A la hora de llamar a los procedimientos debemos seguir los siguientes pasos: 
  • Se utilizan estos métodos para ejecutar sentencias en función de la sentencia del procedimiento: 
    • FromSql(«SQL»)  En el caso de ser una sentencia de selección (SELECT) 
    • ExecuteSqlCommand(«SQL») En caso de ser sentencia de acción (DELETE, UPDATE,CREATE) 
  • Si el procedimiento incluye parametros se utiliza la clase SqlParameters de System.Data.SqlClient  
    • SqlParameter nombreParametro = new SqlParameter(«@NombreParamProcedimiento», VariableLocal);  
     
    

[tutorial] 

1. Para comenzar, desde nuestro gestor de BBDD (SQL Server), sobre una base de datos creada(Usaré Peliculas, se incluye scrips en github), crearemos unos procedimientos almacenado: 

CREATE PROCEDURE MOSTRARPELICULAS 

AS 

SELECT * FROM Peliculas 

GO 

CREATE PROCEDURE MOSTRARPELICULA (@ID INT) 

AS 

SELECT * FROM Peliculas WHERE IdPelicula = @ID 

GO 

1. Pasamos al Visual Studio, Creamos un proyecto en Core 
2. Agregamos el nuget de EntityFramework 
   1. Click derecho sobre la solución 
   2. Administrar paquetes nuGet 
   3. En la pestaña Examinar buscamos EntityFramework 

Creamos el fichero de configuración AppSettings.json 

1. Sobre la solución, hacemos click derecho 
2. Agregar > Nuevo Elemento 
3. En el buscador buscamos AppSettings 

1. Sin cambiar el nombre, lo creamos 
2. Incluimos nuestra cadena de conexión 

{ 

  «ConnectionStrings»: { 

    «CadenaPeliculas»: «Data Source=LOCALHOST\\sqlexpress;Initial Catalog=Peliculas;Integrated Security=True» 

  } 

} 

1. Creamos una carpeta Models y dentro una clase Peliculas para mapear la tabla de la base de datos: 

    [Table(«Peliculas»)] 

    public class Peliculas 

    { 

            [Key] 

            [DatabaseGenerated(DatabaseGeneratedOption.None)] 

            [Column(«IdPelicula»)] 

            public int IdPeliucula { get; set; } 

            [Column(«Titulo»)] 

            public String Titulo { get; set; } 

            [Column(«Argumento»)] 

            public String Argumento { get; set; } 

    } 

Sobre la carpeta Models creamos PeliculasContext y hacemos que herede de DbContext 

El constructor recibe DbContextOptions que se resuelven en la clase StartUp, lo haremos más adelante         

public PeliculasContext(DbContextOptions options) : base(options) { }         

public DbSet<Peliculas> Peliculas { get; set; } 

Aquí tratamos los procedimientos: 

 //ejemplo sin parametros

 public List<Peliculas> MostrarPeliculas()        

{             

String sql = «MOSTRARPELICULAS»;  

           return this.Peliculas.FromSql(sql).ToList();

         }

//ejemplo con parametros

         public Peliculas MostrarPelicula(int id)

         {

             String sql = «MOSTRARPELICULA @ID»;

             SqlParameter pamid = new SqlParameter(«@ID», id); 

            return this.Peliculas.FromSql(sql,pamid).SingleOrDefault();

         }

  //ejemplo con sentencia de accion

         public int CambiarTitulo(int id, string titulo)

         {

             String sql = «CAMBIARTITULO @ID , @TITULO»;

             SqlParameter pamid = new SqlParameter(«@ID», id);

             SqlParameter pamtit = new SqlParameter(«@TITULO», titulo);

             return this.Database.ExecuteSqlCommand(sql, pamid,pamtit); 

          }

Creamos la carpeta Repositorios y la clase RepositorioPeliculas donde haremos las llamadas al contexto 

Por lo que instanciamos el contexto

PeliculasContext context; 

       public RepositoryPeliculas(PeliculasContext context)        

{             this.context = context;         }

Para llamarlo desde los metodos:  

//ejemplo de metodo de repositorio 

public Peliculas MostrarPelicula(int id) 

        { 

            return this.context.MostrarPelicula(id); 

        } 

Unicamente queda crear el controlador con sus vistas: 

Instanciamos al repositorio para poder llamarlo:

         RepositoryPeliculas repo;

           public PeliculasController(RepositoryPeliculas repo) 

        {             this.repo = repo;         }

Creamos un par de vistas pasando por parametro modelos cuando sea oportuno:  

//ejemplo de metodo de controlador

         public IActionResult Index() 

        {                          return View(this.repo.MostrarPeliculas());         }  

Para acabar resolvemos las dependencias al contexto en la clase startUp  

Instanciamos IConfigure:         

IConfiguration configuration;

           public Startup(IConfiguration configuration)         {             this.configuration = configuration;         }  

Resolvemos dependencia:

 public void ConfigureServices(IServiceCollection services)         { 

            String cadenaPeliculas = this.configuration.GetConnectionString(«CadenaPeliculas»);

               services.AddDbContext<PeliculasContext>                 (options => options.UseSqlServer(cadenaPeliculas));

               services.AddTransient<RepositoryPeliculas>();

               services.AddMvc();

         } 

Autor: Enrique Gonzalez

Curso: Microsoft MCSA Web Applications + Microsoft MCSD App Builder + Xamarin 

Centro: Tajamar 

Año académico: 2018-2019 

Código / recursos utilizados / Otros datos de interés:

GitHub:
https://github.com/EnriqueGonzalezGonzalezVelez/ProcedimientosAlmacenados