Soy muy nuevo en Entity Framework 6 y quiero implementar procedimientos almacenados en mi proyecto. Tengo un procedimiento almacenado de la siguiente manera:

ALTER PROCEDURE [dbo].[insert_department]
    @Name [varchar](100)
AS
BEGIN
    INSERT [dbo].[Departments]([Name])
    VALUES (@Name)

    DECLARE @DeptId int

    SELECT @DeptId = [DeptId]
    FROM [dbo].[Departments]
    WHERE @@ROWCOUNT > 0 AND [DeptId] = SCOPE_IDENTITY()

    SELECT t0.[DeptId]
    FROM [dbo].[Departments] AS t0
    WHERE @@ROWCOUNT > 0 AND t0.[DeptId] = @DeptId
END

Department clase:

public class Department
{
    public int DepartmentId { get; set; }       
    public string Name { get; set; }
}

modelBuilder 
.Entity<Department>() 
.MapToStoredProcedures(s => 
s.Update(u => u.HasName("modify_department") 
               .Parameter(b => b.Department, "department_id") 
               .Parameter(b => b.Name, "department_name")) 
 .Delete(d => d.HasName("delete_department") 
               .Parameter(b => b.DepartmentId, "department_id")) 
 .Insert(i => i.HasName("insert_department") 
               .Parameter(b => b.Name, "department_name")));

protected void btnSave_Click(object sender, EventArgs e)
{
    string department = txtDepartment.text.trim();

    // here I want to call the stored procedure to insert values
}

Mi problema es: ¿cómo puedo llamar al procedimiento almacenado y pasarle parámetros?

Puede llamar a un procedimiento almacenado en su DbContextclase de la siguiente manera.

this.Database.SqlQuery<YourEntityType>("storedProcedureName",params);

Pero si su procedimiento almacenado devuelve múltiples conjuntos de resultados como su código de muestra, puede ver este útil artículo en MSDN

Procedimientos almacenados con conjuntos de resultados múltiples

Todo lo que tiene que hacer es crear un objeto que tenga los mismos nombres de propiedad que los resultados devueltos por el procedimiento almacenado. Para el siguiente procedimiento almacenado:

    CREATE PROCEDURE [dbo].[GetResultsForCampaign]  
    @ClientId int   
    AS
    BEGIN
    SET NOCOUNT ON;

    SELECT AgeGroup, Gender, Payout
    FROM IntegrationResult
    WHERE ClientId = @ClientId
    END

crear una clase que se vea así:

    public class ResultForCampaign
    {
        public string AgeGroup { get; set; }

        public string Gender { get; set; }

        public decimal Payout { get; set; }
    }

y luego llame al procedimiento haciendo lo siguiente:

    using(var context = new DatabaseContext())
    {
            var clientIdParameter = new SqlParameter("@ClientId", 4);

            var result = context.Database
                .SqlQuery<ResultForCampaign>("GetResultsForCampaign @ClientId", clientIdParameter)
                .ToList();
    }

El resultado contendrá una lista de ResultForCampaignobjetos. Puede llamar SqlQueryutilizando tantos parámetros como sea necesario.

Lo resolví con ExecuteSqlCommand

Pon tu propio método como el mío en DbContext como tus propias instancias:

public void addmessage(<yourEntity> _msg)
{
    var date = new SqlParameter("@date", _msg.MDate);
    var subject = new SqlParameter("@subject", _msg.MSubject);
    var body = new SqlParameter("@body", _msg.MBody);
    var fid = new SqlParameter("@fid", _msg.FID);
    this.Database.ExecuteSqlCommand("exec messageinsert @Date , @Subject , @Body , @Fid", date,subject,body,fid);
}

para que pueda tener un método en su código subyacente como este:

[WebMethod] //this method is static and i use web method because i call this method from client side
public static void AddMessage(string Date, string Subject, string Body, string Follower, string Department)
{
    try
    {
        using (DBContext reposit = new DBContext())
        {
            msge <yourEntity> Newmsg = new msge();
            Newmsg.MDate = Date;
            Newmsg.MSubject = Subject.Trim();
            Newmsg.MBody = Body.Trim();
            Newmsg.FID= 5;
            reposit.addmessage(Newmsg);
        }
    }
    catch (Exception)
    {
        throw;
    }
}

este es mi SP:

Create PROCEDURE dbo.MessageInsert

    @Date nchar["size"],
    @Subject nchar["size"],
    @Body nchar["size"],
    @Fid int
AS
    insert into Msg (MDate,MSubject,MBody,FID) values (@Date,@Subject,@Body,@Fid)
    RETURN

la esperanza te ayudó

Usando su ejemplo, aquí hay dos formas de lograr esto:

1 - Usar mapeo de procedimiento almacenado

Tenga en cuenta que este código funcionará con o sin mapeo. Si desactiva la asignación en la entidad, EF generará una instrucción de inserción + selección.

protected void btnSave_Click(object sender, EventArgs e)
{
     using (var db = DepartmentContext() )
     {
        var department = new Department();

        department.Name = txtDepartment.text.trim();

        db.Departments.add(department);
        db.SaveChanges();

        // EF will populate department.DepartmentId
        int departmentID = department.DepartmentId;
     }
}

2 - Llamar directamente al procedimiento almacenado

protected void btnSave_Click(object sender, EventArgs e)
{
     using (var db = DepartmentContext() )
     {
        var name = new SqlParameter("@name", txtDepartment.text.trim());

        //to get this to work, you will need to change your select inside dbo.insert_department to include name in the resultset
        var department = db.Database.SqlQuery<Department>("dbo.insert_department @name", name).SingleOrDefault();

       //alternately, you can invoke SqlQuery on the DbSet itself:
       //var department = db.Departments.SqlQuery("dbo.insert_department @name", name).SingleOrDefault();

        int departmentID = department.DepartmentId;
     }
}

Recomiendo usar el primer enfoque, ya que puede trabajar con el objeto de departamento directamente y no tener que crear un montón de objetos SqlParameter.

Está utilizando lo MapToStoredProcedures()que indica que está asignando sus entidades a procedimientos almacenados, al hacer esto debe dejar de lado el hecho de que hay un procedimiento almacenado y usar el de contextforma normal. Algo como esto ( escrito en el navegador para que no se pruebe )

using(MyContext context = new MyContext())
{
    Department department = new Department()
    {
        Name = txtDepartment.text.trim()
    };
    context.Set<Department>().Add(department);
}

Si todo lo que realmente intenta hacer es llamar directamente a un procedimiento almacenado, entonces use SqlQuery

Ahora también puede usar una convención que creé que permite invocar procedimientos almacenados (incluidos los procedimientos almacenados que devuelven múltiples conjuntos de resultados), TVF y UDF escalares de forma nativa desde EF.

Hasta que se lanzó Entity Framework 6.1, las funciones de almacenamiento (es decir, Funciones con valores de tabla y Procedimientos almacenados) solo se podían usar en EF cuando se hacía primero la base de datos. Hubo algunas soluciones que permitieron invocar las funciones de la tienda en las aplicaciones de Code First, pero aún no podía usar TVF en las consultas de Linq, que era una de las mayores limitaciones. En EF 6.1, la API de mapeo se hizo pública, lo que (junto con algunos ajustes adicionales) hizo posible el uso de funciones de almacenamiento en sus aplicaciones Code First.

Lee mas

Presioné bastante durante las últimas dos semanas y aquí está: la versión beta de la convención que permite usar funciones de almacenamiento (es decir, procedimientos almacenados, funciones con valores de tabla, etc.) en aplicaciones que usan el enfoque Code First y Entity Framework 6.1.1 ( o mas nuevo). Estoy más que satisfecho con las correcciones y las nuevas funciones que se incluyen en esta versión.

Leer más .

object[] xparams = {
            new SqlParameter("@ParametterWithNummvalue", DBNull.Value),
            new SqlParameter("@In_Parameter", "Value"),
            new SqlParameter("@Out_Parameter", SqlDbType.Int) {Direction = ParameterDirection.Output}};

        YourDbContext.Database.ExecuteSqlCommand("exec StoreProcedure_Name @ParametterWithNummvalue, @In_Parameter, @Out_Parameter", xparams);
        var ReturnValue = ((SqlParameter)params[2]).Value;  

Esto funciona para mí retirando datos de un procedimiento almacenado mientras pasa un parámetro.

var param = new SqlParameter("@datetime", combinedTime);
var result = 
        _db.Database.SqlQuery<QAList>("dbo.GetQAListByDateTime @datetime", param).ToList();

_db es el dbContext

Eche un vistazo a este enlace que muestra cómo funciona la asignación de EF 6 con procedimientos almacenados para realizar una inserción, actualización y eliminación: http://msdn.microsoft.com/en-us/data/dn468673

Adición

Aquí hay un gran ejemplo para llamar a un procedimiento almacenado desde Code First:

Digamos que tiene que ejecutar un Procedimiento almacenado con un solo parámetro, y que el Procedimiento almacenado devuelve un conjunto de datos que coinciden con los Estados de entidad, por lo que tendremos esto:

var countryIso = "AR"; //Argentina

var statesFromArgentina = context.Countries.SqlQuery(
                                      "dbo.GetStatesFromCountry @p0", countryIso
                                                    );

Ahora digamos que queremos ejecutar otro procedimiento almacenado con dos parámetros:

var countryIso = "AR"; //Argentina
var stateIso = "RN"; //Río Negro

var citiesFromRioNegro = context.States.SqlQuery(
                            "dbo.GetCitiesFromState @p0, @p1", countryIso, stateIso
                          );

Observe que estamos usando nombres basados ​​en índices para los parámetros. Esto se debe a que Entity Framework envolverá estos parámetros como objetos DbParameter para evitar cualquier problema de inyección SQL.

Espero que este ejemplo ayude!

public IList<Models.StandardRecipeDetail> GetRequisitionDetailBySearchCriteria(Guid subGroupItemId, Guid groupItemId)
{
    var query = this.UnitOfWork.Context.Database.SqlQuery<Models.StandardRecipeDetail>("SP_GetRequisitionDetailBySearchCriteria @SubGroupItemId,@GroupItemId",
    new System.Data.SqlClient.SqlParameter("@SubGroupItemId", subGroupItemId),
    new System.Data.SqlClient.SqlParameter("@GroupItemId", groupItemId));
    return query.ToList();
}

Funciona para mí al código primero. Devuelve una lista con la propiedad coincidente del modelo de vista (StudentChapterCompletionViewModel)

var studentIdParameter = new SqlParameter
{
     ParameterName = "studentId",
     Direction = ParameterDirection.Input,
     SqlDbType = SqlDbType.BigInt,
     Value = studentId
 };

 var results = Context.Database.SqlQuery<StudentChapterCompletionViewModel>(
                "exec dbo.sp_StudentComplettion @studentId",
                 studentIdParameter
                ).ToList();

Actualizado para contexto

El contexto es la instancia de la clase que hereda DbContext como a continuación.

public class ApplicationDbContext : DbContext
{
    public DbSet<City> City { get; set; }
}

var Context = new  ApplicationDbContext();

El pasajero sin sentido tiene un proyecto que permite que se devuelvan conjuntos de resultados múltiples desde un proceso almacenado utilizando el marco de la entidad. Uno de sus ejemplos a continuación ...

using (testentities te = new testentities())
{
    //-------------------------------------------------------------
    // Simple stored proc
    //-------------------------------------------------------------
    var parms1 = new testone() { inparm = "abcd" };
    var results1 = te.CallStoredProc<testone>(te.testoneproc, parms1);
    var r1 = results1.ToList<TestOneResultSet>();
}

Puede pasar parámetros sp_GetByIdy obtener los resultados en ToList()oFirstOrDefault();

var param  = new SqlParameter("@id", 106);
var result = dbContext
               .Database
               .SqlQuery<Category>("dbo.sp_GetById @id", param)
               .FirstOrDefault();

si desea pasar parámetros de tabla al procedimiento almacenado, debe establecer necesariamente la propiedad TypeName para sus parámetros de tabla.

SqlParameter codesParam = new SqlParameter(CODES_PARAM, SqlDbType.Structured);
            SqlParameter factoriesParam = new SqlParameter(FACTORIES_PARAM, SqlDbType.Structured);

            codesParam.Value = tbCodes;
            codesParam.TypeName = "[dbo].[MES_CodesType]";
            factoriesParam.Value = tbfactories;
            factoriesParam.TypeName = "[dbo].[MES_FactoriesType]";


            var list = _context.Database.SqlQuery<MESGoodsRemain>($"{SP_NAME} {CODES_PARAM}, {FACTORIES_PARAM}"
                , new SqlParameter[] {
                   codesParam,
                   factoriesParam
                }
                ).ToList();

Esto es lo que EF (DB primero) genera en la clase DbContext:

public ObjectResult<int> Insert_Department(string department)
{
    var departmentParameter = new ObjectParameter("department", department);

    return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<int>("insert_department", departmentParameter);
}

Cuando EDMX cree este tiempo si selecciona almacenado procesado en la opción de selección de tabla, simplemente llame a la tienda procesada usando el nombre del procedimiento ...

var num1 = 1; 
var num2 = 2; 

var result = context.proc_name(num1,num2).tolist();// list or single you get here.. using same thing you can call insert,update or delete procedured.

Encontré que llamar a procedimientos almacenados en el enfoque de Code First no es conveniente. Prefiero usar Dapperen su lugar

El siguiente código fue escrito con Entity Framework:

var clientIdParameter = new SqlParameter("@ClientId", 4);

var result = context.Database
.SqlQuery<ResultForCampaign>("GetResultsForCampaign @ClientId", clientIdParameter)
.ToList();

El siguiente código fue escrito con Dapper:

return Database.Connection.Query<ResultForCampaign>(
            "GetResultsForCampaign ",
            new
            {
                ClientId = 4
            },
            commandType: CommandType.StoredProcedure);

Creo que la segunda parte del código es más simple de entender.

public static string ToSqlParamsString(this IDictionary<string, string> dict)
        {
            string result = string.Empty;
            foreach (var kvp in dict)
            {
                result += $"@{kvp.Key}='{kvp.Value}',";
            }
            return result.Trim(',', ' ');
        }

public static List<T> RunSproc<T>(string sprocName, IDictionary<string, string> parameters)
        {
            string command = $"exec {sprocName} {parameters.ToSqlParamsString()}";
            return Context.Database.SqlQuery<T>(command).ToList();
        }

Nada tiene que hacer ... cuando está creando dbcontext para el primer enfoque de código, inicialice el espacio de nombres debajo del área API fluida, haga una lista de sp y úsela en otro lugar donde desee.

public partial class JobScheduleSmsEntities : DbContext
{
    public JobScheduleSmsEntities()
        : base("name=JobScheduleSmsEntities")
    {
        Database.SetInitializer<JobScheduleSmsEntities>(new CreateDatabaseIfNotExists<JobScheduleSmsEntities>());
    }

    public virtual DbSet<Customer> Customers { get; set; }
    public virtual DbSet<ReachargeDetail> ReachargeDetails { get; set; }
    public virtual DbSet<RoleMaster> RoleMasters { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        //modelBuilder.Types().Configure(t => t.MapToStoredProcedures());

        //modelBuilder.Entity<RoleMaster>()
        //     .HasMany(e => e.Customers)
        //     .WithRequired(e => e.RoleMaster)
        //     .HasForeignKey(e => e.RoleID)
        //     .WillCascadeOnDelete(false);
    }
    public virtual List<Sp_CustomerDetails02> Sp_CustomerDetails()
    {
        //return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<Sp_CustomerDetails02>("Sp_CustomerDetails");
        //  this.Database.SqlQuery<Sp_CustomerDetails02>("Sp_CustomerDetails");
        using (JobScheduleSmsEntities db = new JobScheduleSmsEntities())
        {
           return db.Database.SqlQuery<Sp_CustomerDetails02>("Sp_CustomerDetails").ToList();

        }

    }

}

}

public partial class Sp_CustomerDetails02
{
    public long? ID { get; set; }
    public string Name { get; set; }
    public string CustomerID { get; set; }
    public long? CustID { get; set; }
    public long? Customer_ID { get; set; }
    public decimal? Amount { get; set; }
    public DateTime? StartDate { get; set; }
    public DateTime? EndDate { get; set; }
    public int? CountDay { get; set; }
    public int? EndDateCountDay { get; set; }
    public DateTime? RenewDate { get; set; }
    public bool? IsSMS { get; set; }
    public bool? IsActive { get; set; }
    public string Contact { get; set; }
}

Usando MySql y Entity Framework Code primer enfoque:

public class Vw_EMIcount
{
    public int EmiCount { get; set; }
    public string Satus { get; set; }
}

var result = context.Database.SqlQuery<Vw_EMIcount>("call EMIStatus('2018-3-01' ,'2019-05-30')").ToList();

Crear procedimiento en MYsql.

delimiter //
create procedure SP_Dasboarddata(fromdate date, todate date)
begin
select count(Id) as count,date,status,sum(amount) as amount from 
details
where (Emidate between fromdate and todate)
group by date ,status;
END;
//

Crear clase que contiene valores de conjunto de resultados de retorno de procedimientos almacenados

[Table("SP_reslutclass")]
public  class SP_reslutclass
{
    [Key]
    public int emicount { get; set; }
    public DateTime Emidate { get; set; }
    public int ? Emistatus { get; set; }
    public int emiamount { get; set; }

}

Agregar clase en Dbcontext

  public  class ABCDbContext:DbContext
{
    public ABCDbContext(DbContextOptions<ABCDbContext> options)
       : base(options)
    {

    }

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

Entidad de llamada en repositorio

   var counts = _Dbcontext.SP_reslutclass.FromSql("call SP_Dasboarddata 
                    ('2019-12-03','2019-12-31')").ToList();