Wie rufe ich eine gespeicherte Prozedur in Entity Framework 6 (Code-First) auf?

259

Ich bin sehr neu in Entity Framework 6 und möchte gespeicherte Prozeduren in meinem Projekt implementieren. Ich habe eine gespeicherte Prozedur wie folgt:

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 Klasse:

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
}

Mein Problem ist: Wie kann ich die gespeicherte Prozedur aufrufen und Parameter übergeben?

Jaan
quelle
Das interessiert mich auch. Im Idealfall würde ich EF komplett überspringen und ALLES nur durch gespeicherte Prozeduren ausführen. Ich bin ein SQL-Experte, aber die Implementierung von EF war sehr frustrierend.
David Britz

Antworten:

247

Sie können eine gespeicherte Prozedur in Ihrer DbContextKlasse wie folgt aufrufen .

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

Wenn Ihre gespeicherte Prozedur jedoch mehrere Ergebnismengen als Beispielcode zurückgibt, wird dieser hilfreiche Artikel zu MSDN angezeigt

Gespeicherte Prozeduren mit mehreren Ergebnismengen

Alborz
quelle
2
Danke @Alborz. Können Sie mir bitte einige Links zu verschiedenen Implementierungen von gespeicherten Prozeduren in Entity Framework 6 Code First bereitstellen? Ich habe überall im Web gesucht, aber keinen Artikel erhalten, in dem ich eine gespeicherte Prozedur für IN- und OUT-Parameter direkt aufrufen kann. Vielen Dank für Ihre wertvolle Zeit.
Jaan
2
Dieser Artikel vielleicht hilfreich blogs.msdn.com/b/diego/archive/2012/01/10/…
Alborz
8
Dies scheint mit Parametern nicht zu funktionieren. Es scheint notwendig zu sein, die Parameter als Teil der Abfrage explizit aufzulisten.
Mark
6
Ja, Sie müssen die Parameter als Teil der Abfrage angeben "storedProcedureName @param1, @param2". Auch die Art von paramsist System.Data.SqlClient.SqlParameter[].
Oppa Gingham Style
6
this.Database.SqlQuery<YourEntityType>("storedProcedureName @param1", new System.Data.SqlClient.SqlParameter("@param1", YourParam));
Ppp
152

Sie müssen lediglich ein Objekt erstellen, das dieselben Eigenschaftsnamen wie die von der gespeicherten Prozedur zurückgegebenen Ergebnisse hat. Für die folgende gespeicherte Prozedur:

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

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

Erstellen Sie eine Klasse, die wie folgt aussieht:

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

        public string Gender { get; set; }

        public decimal Payout { get; set; }
    }

Rufen Sie dann die Prozedur wie folgt auf:

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

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

Das Ergebnis enthält eine Liste von ResultForCampaignObjekten. Sie können SqlQuerymit so vielen Parametern wie nötig aufrufen .

Filipe Leite
quelle
2
Für einmalige Situationen würde dies großartig funktionieren. Ich finde, dass die SProc-Definition eng mit der Klasse gekoppelt sein sollte, die von DBContext erbt, anstatt in den "Weizenfeldern" des Produkts.
GoldBishop
50

Ich habe es mit gelöst ExecuteSqlCommand

Fügen Sie Ihre eigene Methode wie meine in DbContext als Ihre eigenen Instanzen ein:

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);
}

So können Sie eine Methode in Ihrem Code-Behind wie folgt haben:

[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;
    }
}

das ist mein 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

Hoffnung hat dir geholfen

Mahdi Ghafoorian
quelle
2
Sie müssen eine Länge für die nchar-Parameter Ihrer gespeicherten Prozedur angeben - andernfalls sind sie, wie Sie festgestellt haben, nur ein Zeichen lang.
Dave W
@ Mahdighafoorian Dies ist eine sehr nützliche Antwort, vielen Dank! :)
Komengem
Diese Syntax erfordert keine Änderung der Reihenfolge der SProc-Parameter, dh der ordinalen Positionierung.
GoldBishop
21

Anhand Ihres Beispiels haben Sie zwei Möglichkeiten, dies zu erreichen:

1 - Verwenden Sie die Zuordnung gespeicherter Prozeduren

Beachten Sie, dass dieser Code mit oder ohne Zuordnung funktioniert. Wenn Sie die Zuordnung für die Entität deaktivieren, generiert EF eine Anweisung insert + select.

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 - Rufen Sie die gespeicherte Prozedur direkt auf

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;
     }
}

Ich empfehle den ersten Ansatz, da Sie direkt mit dem Abteilungsobjekt arbeiten können und keine Reihe von SqlParameter-Objekten erstellen müssen.

Brian Vander Plaats
quelle
3
Seien Sie vorsichtig, ist das zweite Beispiel, dass die Änderung nicht vom dbContext
edtruant
EDIT.Verwenden Sie stattdessen System.Data.Entity.DbSet <TEntity> .SqlQuery (String, Object []).
Edtruant
@edtruant Der dbContext scheint die Änderung zu verfolgen. Zum Testen habe ich mir db. <DbSet> .Count () vor und nach der insert-Anweisung angesehen. Bei beiden Methoden wurde die Anzahl um eins erhöht. Der Vollständigkeit halber habe ich dem Beispiel die alternative Methode hinzugefügt.
Brian Vander Plaats
1
Ich sehe im ersten Beispiel keinen Verweis auf die gespeicherte Prozedur.
xr280xr
2
@ xr280xr Auf die insert_department wird im modelBuilder-Ausdruck in der OP-Frage verwiesen. Das ist der Vorteil, wenn Sie die Dinge auf diese Weise zuordnen, da sie effektiv genauso funktionieren, als ob Sie EF die Anweisungen zum Einfügen / Aktualisieren / Löschen generieren lassen würden
Brian Vander Plaats
15

Sie verwenden, MapToStoredProcedures()was darauf hinweist, dass Sie Ihre Entitäten gespeicherten Prozeduren zuordnen. Dabei müssen Sie die Tatsache loslassen, dass eine gespeicherte Prozedur vorhanden ist, und die contextwie gewohnt verwenden. So etwas ( in den Browser geschrieben, also nicht getestet )

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

Wenn Sie wirklich nur versuchen, eine gespeicherte Prozedur direkt aufzurufen, verwenden Sie SqlQuery

qujck
quelle
2
Danke qujck. Aber ich möchte eine gespeicherte Prozedur verwenden. Ich habe nur einen Beispielcode angegeben, damit Sie ihn bequem verstehen können.
Jaan
4
@Jaan - Der obige Code wird die gespeicherte Prozedur verwenden. Meinen Sie damit, dass Sie die gespeicherte Prozedur direkt aufrufen möchten?
Qujck
Ja. Kannst du mir bitte sagen, welcher Weg der bessere ist? Rufen Sie direkt die gespeicherte Prozedur oder den oben angegebenen Code auf?
Jaan
6
@Jaan Verwenden Sie den Code, den ich gezeigt habe - das ORM soll die zugrunde liegende Implementierung verbergen -. Verwenden Sie den obigen Code, um sicherzustellen, dass es für den Rest Ihres Codes keine Rolle spielt, ob eine gespeicherte Prozedur vorhanden ist oder nicht. Sie können sogar die Modellzuordnung auf eine andere gespeicherte Prozedur ändern oder keine gespeicherte Prozedur sein, ohne etwas anderes zu ändern.
Qujck
4
@ Chazt3n Die Frage zeigt die gespeicherten Prozeduren, die über die Zeile konfiguriert werden .MapToStoredProcedures(s => . Ein Anruf zu Addsollte sich auf.Insert(i => i.HasName("insert_department")
qujck
12

Sie können jetzt auch eine von mir erstellte Konvention verwenden, mit der gespeicherte Prozeduren (einschließlich gespeicherter Prozeduren, die mehrere Ergebnismengen zurückgeben), TVFs und skalare UDFs nativ von EF aufgerufen werden können.

Bis zur Veröffentlichung von Entity Framework 6.1 konnten Speicherfunktionen (dh Funktionen mit Tabellenwert und gespeicherte Prozeduren) in EF nur verwendet werden, wenn Database First ausgeführt wird. Es gab einige Problemumgehungen, die es ermöglichten, Speicherfunktionen in Code First-Apps aufzurufen, aber Sie konnten TVFs in Linq-Abfragen immer noch nicht verwenden, was eine der größten Einschränkungen war. In EF 6.1 wurde die Mapping-API veröffentlicht, die es (zusammen mit einigen zusätzlichen Verbesserungen) ermöglichte, Speicherfunktionen in Ihren Code First-Apps zu verwenden.

Weiterlesen

Ich habe in den letzten zwei Wochen ziemlich viel Druck gemacht und hier ist es - die Beta-Version der Konvention, die die Verwendung von Speicherfunktionen (dh gespeicherte Prozeduren, Funktionen mit Tabellenwerten usw.) in Anwendungen ermöglicht, die den Code First-Ansatz und Entity Framework 6.1.1 verwenden ( oder neuer). Ich bin mehr als zufrieden mit den Korrekturen und neuen Funktionen, die in dieser Version enthalten sind.

Lesen Sie mehr .

Pawel
quelle
Tatsächlich könnten Sie seit 4.0 SProcs ohne das Modell ausführen. Sie mussten Raw SQL-Anweisungen anstelle der Objekteigenschaft ausführen. Selbst mit 6.1.x müssen Sie entweder SqlQuery <T> oder ExecuteSqlCommand verwenden, um einen ähnlichen Effekt zu erzielen.
GoldBishop
10
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;  
Shiraj Momin
quelle
1
params ist eine Kennung, die einen anderen Namen verwendet.
Yogihosting
2
Das SaveChanges () hier ist nicht erforderlich. Änderungen werden beim Aufruf von ExecuteSqlCommand () festgeschrieben.
Xavier Poinas
10

Dies funktioniert bei mir, indem Daten aus einer gespeicherten Prozedur zurückgezogen werden, während ein Parameter übergeben wird.

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

_db ist der dbContext

Tom Stickel
quelle
9

Schauen Sie sich diesen Link an, der zeigt, wie die Zuordnung von EF 6 mit gespeicherten Prozeduren zum Einfügen, Aktualisieren und Löschen funktioniert: http://msdn.microsoft.com/en-us/data/dn468673

Zusatz

Hier ist ein gutes Beispiel, um eine gespeicherte Prozedur von Code First aus aufzurufen:

Nehmen wir an, Sie müssen eine gespeicherte Prozedur mit einem einzelnen Parameter ausführen, und diese gespeicherte Prozedur gibt einen Datensatz zurück, der mit den Entitätszuständen übereinstimmt. Wir haben also Folgendes:

var countryIso = "AR"; //Argentina

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

Nehmen wir nun an, wir möchten eine andere gespeicherte Prozedur mit zwei Parametern ausführen:

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

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

Beachten Sie, dass wir für Parameter eine indexbasierte Benennung verwenden. Dies liegt daran, dass Entity Framework diese Parameter als DbParameter-Objekte für Sie zusammenfasst, um SQL-Injection-Probleme zu vermeiden.

Hoffe dieses Beispiel hilft!

Gabriel Andrés Brancolini
quelle
6
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();
}
Md. Delower Hossain
quelle
4

Es funktioniert für mich zuerst im Code. Es wird eine Liste mit der übereinstimmenden Eigenschaft des Ansichtsmodells zurückgegeben (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();

Für den Kontext aktualisiert

Context ist die Instanz der Klasse, die DbContext wie unten erbt.

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

var Context = new  ApplicationDbContext();
reza.cse08
quelle
Hallo, ich kann diese Context.Database.SqlQuery <Modell> nicht finden, wo ich diese Context.TableName.SqlQuery (ProcName) ausführen kann. Das gibt mir Probleme
Marshall
@ Marshall, vielleicht verwenden Sie das erste Design der Datenbank. Bitte überprüfen Sie diesen Link stackoverflow.com/questions/11792018/…
reza.cse08
1

Mindless Passenger hat ein Projekt, mit dem mehrere Ergebnismengen von einem gespeicherten Prozess mithilfe des Entity Frameworks zurückgegeben werden können. Eines seiner Beispiele unten ....

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>();
}
Dib
quelle
1

Sie können Parameter an oder übergeben sp_GetByIdund die Ergebnisse entweder in ToList()oder abrufenFirstOrDefault();

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

Wenn Sie Tabellenparameter an gespeicherte Prozeduren übergeben möchten, müssen Sie die TypeName-Eigenschaft für Ihre Tabellenparameter festlegen.

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();
Trueboroda
quelle
0

Folgendes generiert EF (DB zuerst) in der DbContext-Klasse:

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

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

Wenn EDMX dieses Mal erstellt, wenn Sie die Option zum Speichern der in der Tabelle gespeicherten Prozedur auswählen, rufen Sie einfach die Prozedur zum Speichern der Prozedur mit dem Namen der Prozedur auf ...

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.
Shafiq Rabbi
quelle
0

Ich fand, dass das Aufrufen gespeicherter Prozeduren im Code First-Ansatz nicht bequem ist. Ich bevorzuge es Dapperstattdessen zu verwenden

Der folgende Code wurde geschrieben mit Entity Framework:

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

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

Der folgende Code wurde geschrieben mit Dapper:

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

Ich glaube, der zweite Code ist einfacher zu verstehen.

Vladislav Furdak
quelle
0
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();
        }
mattylantz
quelle
0

Nichts muss zu tun sein ... Wenn Sie dbcontext für Code erstellen, initialisieren Sie zuerst den Namespace unterhalb des fließenden API-Bereichs, erstellen Sie eine Liste von sp und verwenden Sie ihn an einer anderen Stelle, an der Sie möchten.

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; }
}
SHUBHASIS MAHATA
quelle
0

Zuerst MySQL- und Entity-Framework-Code verwenden Ansatz:

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();
Hari Lakkakula
quelle
0

Prozedur in MYsql erstellen.

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;
//

Erstellen Sie eine Klasse, die gespeicherte Prozeduren enthält, die Ergebnismengenwerte zurückgeben

[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; }

}

Klasse in Dbcontext hinzufügen

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

    }

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

Rufen Sie die Entität im Repository auf

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