इकाई फ्रेमवर्क 6 (कोड-प्रथम) में संग्रहीत प्रक्रिया को कैसे कॉल करें?

259

मैं एंटिटी फ्रेमवर्क 6 में बहुत नया हूं और मैं अपनी परियोजना में संग्रहीत प्रक्रियाओं को लागू करना चाहता हूं। मेरे पास एक संग्रहित प्रक्रिया इस प्रकार है:

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 वर्ग:

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
}

मेरी समस्या यह है: मैं संग्रहीत प्रक्रिया को कैसे कॉल कर सकता हूं और इसमें पैरामीटर पारित कर सकता हूं?

c#  entity-framework  stored-procedures 
— जान
स्रोत
मुझे भी यह जानने में दिलचस्पी है। आदर्श रूप से मैं EF को पूरी तरह से छोड़ दूंगा और कभी भी संग्रहीत प्रक्रियाओं के माध्यम से EVERYTHING नहीं चलाऊंगा। मैं SQL का विशेषज्ञ हूं, लेकिन EF को लागू करने के लिए बहुत निराशा मिली है।
— डेविड ब्रिटज़

जवाबों:

247

आप अपनी DbContextकक्षा में संग्रहित प्रक्रिया को निम्नानुसार कह सकते हैं।

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

लेकिन अगर आपकी संग्रहीत प्रक्रिया आपके परिणाम कोड के रूप में कई परिणाम सेट लौटाती है, तो आप MSDN पर इस सहायक लेख को देख सकते हैं

एकाधिक परिणाम सेट के साथ संग्रहीत कार्यविधियाँ

— alborz
स्रोत
2
धन्यवाद @ अलबोर्ज़ क्या आप मुझे एंटिटी फ्रेमवर्क 6 कोड प्रथम में संग्रहित प्रक्रिया के विभिन्न कार्यान्वयन के बारे में कुछ लिंक प्रदान कर सकते हैं। मैंने वेब पर हर जगह खोज की, लेकिन ऐसा कोई भी लेख नहीं मिला, जहाँ मैं सीधे IN और OUT मापदंडों के लिए संग्रहीत कार्यविधि कह सकूँ। आपके बहुमूल्य समय के लिए धन्यवाद।
— जान
2
यह लेख शायद उपयोगी ब्लॉगों .msdn.com
— Alborz
8
यह मापदंडों के साथ काम नहीं करता है। ऐसा लगता है कि क्वेरी के भाग के रूप में मापदंडों को स्पष्ट रूप से सूचीबद्ध करना होगा।
— मार्क
6
हाँ, आपको क्वेरी के भाग के रूप में परमेस को निर्दिष्ट करने की आवश्यकता है - "storedProcedureName @param1, @param2"। का प्रकार भी paramsहै System.Data.SqlClient.SqlParameter[]।
— ओप्पा गिंगम स्टाइल
6
this.Database.SqlQuery<YourEntityType>("storedProcedureName @param1", new System.Data.SqlClient.SqlParameter("@param1", YourParam));
— पीपीपी
152

आपको बस एक ऐसी वस्तु बनानी है, जिसमें समान संपत्ति के नाम हैं जो संग्रहीत कार्यविधि द्वारा वापस किए गए परिणाम हैं। निम्नलिखित संग्रहीत कार्यविधि के लिए:

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

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

ऐसा वर्ग बनाएं जो दिखता है:

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

        public string Gender { get; set; }

        public decimal Payout { get; set; }
    }

और फिर निम्न कार्य करके प्रक्रिया को कॉल करें:

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

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

परिणाम में ResultForCampaignवस्तुओं की एक सूची होगी । आप SqlQueryआवश्यकतानुसार कई मापदंडों का उपयोग करके कॉल कर सकते हैं ।

— फ़िलिप लीटे
स्रोत
2
एक बंद स्थितियों के लिए, यह बहुत अच्छा काम करेगा। मुझे लगता है कि SProc परिभाषा को उस वर्ग के साथ कसकर जोड़ा जाना चाहिए जो उत्पाद के "गेहूं के खेतों" में बाहर जाने के बजाय DBContext से विरासत में मिला है।
— GoldBishop
50

मैंने इसे हल किया ExecuteSqlCommand

अपने खुद के उदाहरण के रूप में DbContext में मेरा अपना तरीका रखो:

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

तो आप इस तरह से अपने कोड के पीछे एक विधि रख सकते हैं:

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

यह मेरा एसपी है:

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

आशा ने आपकी मदद की

— महदी गफूरियां
स्रोत
2
आपको अपनी संग्रहीत प्रक्रिया के लिए nchar मापदंडों पर एक लंबाई निर्दिष्ट करने की आवश्यकता है - अन्यथा वे सिर्फ एक वर्ण लंबे हैं, जैसा कि आपने पाया है।
— डेव डब्ल्यू
@Mahdighafoorian यह एक बहुत ही उपयोगी जवाब है, बहुत बहुत धन्यवाद! :)
— कोमेंगैम
इस सिंटैक्स को अन्य शब्दों में, ऑर्डिनल पोजिशनिंग में SProc के पैरामीटर्स के क्रम में कोई संशोधन की आवश्यकता नहीं है।
— गोल्डबिशप
21

अपने उदाहरण का उपयोग करते हुए, इसे पूरा करने के दो तरीके यहां दिए गए हैं:

1 - संग्रहित प्रक्रिया मानचित्रण का उपयोग करें

ध्यान दें कि यह कोड मैपिंग के साथ या उसके बिना काम करेगा। यदि आप इकाई पर मैपिंग बंद कर देते हैं, तो EF एक इंसर्ट + चयन विवरण उत्पन्न करेगा।

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 - सीधे संग्रहीत प्रक्रिया को कॉल करें

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

मैं पहले दृष्टिकोण का उपयोग करने की सलाह देता हूं, क्योंकि आप सीधे विभाग की वस्तु के साथ काम कर सकते हैं और SqlParameter ऑब्जेक्ट का एक गुच्छा नहीं बनाना होगा।

— ब्रायन वेंडर प्लाट्स
स्रोत
3
सावधान रहें, क्या दूसरा उदाहरण
— dbContext
EDIT.Use System.ata.Entity.DbSet <TEntity> .SqlQuery (स्ट्रिंग, ऑब्जेक्ट []) इसके बजाय।
— edtruant
@edtruant dbContext परिवर्तन को ट्रैक करने के लिए प्रकट होता है। परीक्षण करने के लिए, मैंने डीबेट स्टेटमेंट से पहले और बाद में db। <DbSet> .Count () को देखा। दोनों तरीकों में, गिनती एक से बढ़ गई। पूर्णता के लिए मैंने उदाहरण के लिए वैकल्पिक विधि को जोड़ा।
— ब्रायन वेंडर प्लाट्स
1
मैं पहले उदाहरण में संग्रहीत प्रक्रिया का कोई संदर्भ नहीं देखता हूं।
— xr280xr
2
@ xr280xr insert_depbox को ओपी के प्रश्न में मॉडलब्यूलेर अभिव्यक्ति में संदर्भित किया गया है। इस तरह से चीजों को मैप करने का यह फायदा है क्योंकि यह प्रभावी रूप से उसी तरह काम करता है जैसे कि आप ईएफ को इंसर्ट / अपडेट / डिलीट स्टेटमेंट जेनरेट करने दे रहे हैं
— ब्रायन वेंडर प्लाट्स
15

आप उपयोग कर रहे हैं MapToStoredProcedures()जो इंगित करता है कि आप अपनी संस्थाओं को संग्रहीत प्रक्रियाओं के लिए मैप कर रहे हैं, ऐसा करते समय आपको इस तथ्य से अवगत कराने की आवश्यकता है कि संग्रहीत प्रक्रिया है और contextसामान्य रूप से उपयोग करें । कुछ इस तरह से ( ब्राउज़र में लिखा है इसलिए परीक्षण नहीं किया गया )

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

यदि आप वास्तव में करने की कोशिश कर रहे हैं तो एक संग्रहीत प्रक्रिया को सीधे कॉल करें SqlQuery

— qujck
स्रोत
2
धन्यवाद qujck लेकिन मैं संग्रहीत प्रक्रिया का उपयोग करना चाहता हूं। मैंने समझने के लिए सुविधाजनक के लिए सिर्फ एक नमूना कोड दिया है।
— जान
4
@ जान - उपरोक्त कोड संग्रहित प्रक्रिया का उपयोग करेगा । क्या आपका मतलब है कि आप सीधे संग्रहीत प्रक्रिया को कॉल करना चाहते हैं?
— 15
हाँ। क्या आप मुझे बता सकते हैं कि कौन सा तरीका बेहतर है। सीधे संग्रहीत प्रक्रिया या आपके द्वारा दिए गए उपरोक्त कोड को कॉल करना?
— जाने
6
@Jaan ने मेरे द्वारा दिखाए गए कोड का उपयोग किया है - ORM अंतर्निहित कार्यान्वयन को छिपाने के लिए है - ऊपर दिए गए कोड का उपयोग करके यह सुनिश्चित करता है कि आपके कोड के बाकी हिस्सों पर कोई फर्क नहीं पड़ता कि कोई संग्रहीत प्रक्रिया है या नहीं। आप किसी अन्य संग्रहित प्रक्रिया में मॉडल मैपिंग को बदल भी सकते हैं या किसी अन्य चीज़ को बदले बिना संग्रहीत प्रक्रिया नहीं कर सकते।
— qujck
4
@ Chazt3n प्रश्न पंक्ति से संग्रहीत प्रक्रियाओं को दिखाता है .MapToStoredProcedures(s => । एक कॉल के लिए Addसंकल्प करना चाहिए.Insert(i => i.HasName("insert_department")
— qujck
12

अब आप मेरे द्वारा बनाए गए एक कन्वेंशन का भी उपयोग कर सकते हैं जो संग्रहीत प्रक्रियाओं (कई परिणाम लौटाते हुए संग्रहीत प्रक्रियाओं सहित), टीवीएफ और स्केलर यूडीएफ को मूल रूप से ईएफ से सक्षम करने में सक्षम बनाता है।

जब तक एंटिटी फ्रेमवर्क 6.1 जारी नहीं किया गया था तब स्टोर फ़ंक्शंस (यानी टेबल वेल्यूड फंक्शंस और स्टोरेड प्रोसीजर) का इस्तेमाल केवल पहले डेटाबेस में करते समय ईएफ में किया जा सकता है। कुछ वर्कअराउंड थे जिन्होंने कोड फर्स्ट ऐप में स्टोर फ़ंक्शंस को लागू करना संभव बना दिया था, लेकिन आप अभी भी लिनक प्रश्नों में टीवीएफ का उपयोग नहीं कर सकते थे जो सबसे बड़ी सीमाओं में से एक था। EF 6.1 में मैपिंग एपीआई को सार्वजनिक किया गया था (कुछ अतिरिक्त ट्विक्स के साथ) आपके कोड फ़र्स्ट ऐप में स्टोर फ़ंक्शंस का उपयोग करना संभव बना दिया।

अधिक पढ़ें

मैंने पिछले दो हफ्तों के लिए काफी मेहनत की है और यहाँ यह है - सम्मेलन का बीटा संस्करण जो कोड फ़र्स्ट एप्रोच और एंटिटी फ्रेमवर्क ६.१.१ का उपयोग करने वाले अनुप्रयोगों में स्टोर फ़ंक्शंस (अर्थात संग्रहीत कार्यविधियाँ, टेबल वैल्यू फ़ंक्शंस इत्यादि) का उपयोग करने में सक्षम बनाता है। या नया)। मैं इस रिलीज़ में शामिल फ़िक्सेस और नई सुविधाओं से अधिक खुश हूँ।

और अधिक पढ़ें ।

— पावेल
स्रोत
वास्तव में 4.0 के बाद से, आप मॉडल के बिना SProcs निष्पादित कर सकते हैं। आपको ऑब्जेक्ट प्रॉपर्टी के बजाय रॉ एसक्यूएल स्टेटमेंट को निष्पादित करने की आवश्यकता है। 6.1.x के साथ भी, आपको एक समान प्रभाव प्राप्त करने के लिए SqlQuery <T> या ExecuteSqlCommand का उपयोग करना होगा।
— 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;
— शिराज मोमिन
स्रोत
1
params एक पहचानकर्ता एक अलग नाम का उपयोग है।
— 13
2
यहां SaveChanges () आवश्यक नहीं है। परिवर्तन ExecuteSqlCommand () कॉल पर प्रतिबद्ध हैं।
— जेवियर पोइनास
10

यह एक पैरामीटर में गुजरते समय एक संग्रहीत प्रक्रिया से डेटा वापस खींचकर मेरे लिए काम करता है। 

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

_db dbContext है

— टॉम स्टिकेल
स्रोत
9

इस लिंक पर एक नज़र डालें जो दिखाता है कि एक सम्मिलित, अद्यतन और हटाने के लिए संग्रहीत प्रक्रियाओं के साथ EF 6 की मैपिंग कैसे काम करती है: http://msdn.microsoft.com/en-us/data/dn468673

इसके अलावा

यहाँ पर कोड फर्स्ट से संग्रहित प्रक्रिया को कॉल करने का एक शानदार उदाहरण है:

कहते हैं कि आपको एक एकल पैरामीटर के साथ एक संग्रहीत प्रक्रिया को निष्पादित करना होगा, और यह कि संग्रहीत प्रक्रिया डेटा का एक सेट लौटाती है जो इकाई राज्यों के साथ मेल खाती है, इसलिए हमारे पास यह होगा:

var countryIso = "AR"; //Argentina

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

अब हम कहते हैं कि हम दो मापदंडों के साथ एक और संग्रहीत कार्यविधि निष्पादित करना चाहते हैं:

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

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

ध्यान दें कि हम मापदंडों के लिए सूचकांक आधारित नामकरण का उपयोग कर रहे हैं। इसका कारण यह है कि एंटिटी फ्रेमवर्क इन मापदंडों को लपेटेगा क्योंकि DbParameter ऑब्जेक्ट किसी भी SQL इंजेक्शन मुद्दों से बचने के लिए आपको फ्रॉस्ट करता है।

आशा है कि यह उदाहरण मदद करता है!

— गेब्रियल एंड्रेस ब्रानकोलिनी
स्रोत
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();
}
— मोद। डेलोवर हुसैन
स्रोत
4

यह मेरे लिए पहले कोड पर काम करता है। यह दृश्य मॉडल के मिलान गुण के साथ एक सूची लौटाता है (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();

प्रसंग के लिए अद्यतन किया गया

प्रसंग उस वर्ग का उदाहरण है जिसे Inherit DbContext नीचे पसंद करता है।

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

var Context = new  ApplicationDbContext();
— reza.cse08
स्रोत
नमस्ते, मैं यह Context.Database.SqlQuery <Model> नहीं ढूँढ सकता, जहाँ मैं यह Context.TableName.SqlQuery (ProcName) कर सकता हूँ। जो मुझे मुद्दों दे रहा है
— मार्शल
@ मार्शाल, हो सकता है कि आप डेटाबेस पहले डिजाइन का उपयोग कर रहे हों। कृपया इस लिंक की जाँच करें stackoverflow.com/questions/11792018/…
— reza.cse08
1

माइंडलेस पैसेंजर के पास एक ऐसी परियोजना है, जो इकाई रूपरेखा का उपयोग करके संग्रहीत परिणाम से कई परिणाम सेटों को वापस करने की अनुमति देती है। नीचे उनका एक उदाहरण…।

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>();
}
— डीआईबी
स्रोत
1

आप sp_GetByIdया तो में ToList()या परिणाम लाने के लिए पैरामीटर पास कर सकते हैंFirstOrDefault();

var param  = new SqlParameter("@id", 106);
var result = dbContext
               .Database
               .SqlQuery<Category>("dbo.sp_GetById @id", param)
               .FirstOrDefault();
— awais
स्रोत
0

यदि आप टेबल परम्स को स्टोर की गई प्रक्रिया में पास करना चाहते हैं, तो आपको अपने टेबल के लिए टाइपनाम प्रॉपर्टी को सेट करना होगा।

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
स्रोत
0

यह वही है जो EF (DB प्रथम) DbContext वर्ग में उत्पन्न होता है:

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

    return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<int>("insert_department", departmentParameter);
}
— IngoB
स्रोत
0

जब ईडीएमएक्स इस बार बनाता है यदि आप संग्रहीत प्रक्रिया का चयन तालिका चयनित विकल्प में करते हैं, तो प्रक्रियागत नाम का उपयोग करके प्रोसेस किए गए स्टोर को कॉल करें ...

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.
— शफीक रब्बी
स्रोत
0

मैंने पाया कि कोड प्रथम दृष्टिकोण में संग्रहीत कार्यविधियों को कॉल करना सुविधाजनक नहीं है। मैं Dapperइसके बजाय उपयोग करना पसंद करता हूं

निम्न कोड के साथ लिखा गया था Entity Framework:

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

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

निम्न कोड के साथ लिखा गया था Dapper:

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

मेरा मानना ​​है कि कोड का दूसरा टुकड़ा समझने में सरल है।

— व्लादिस्लाव फर्दक
स्रोत
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
स्रोत
0

कुछ भी नहीं करना है ... जब आप पहली बार कोड के लिए dbcontext बना रहे हैं, तो धाराप्रवाह एपीआई क्षेत्र के नीचे नामस्थान को आरंभ करें, सपा की सूची बनाएं और इसे दूसरी जगह उपयोग करें जहां आप चाहते हैं। 

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; }
}
— शुभाशीष महता
स्रोत
0

MySql और Entity फ्रेमवर्क कोड का उपयोग पहले दृष्टिकोण:

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();
— हरि लक्ककुला
स्रोत
0

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

वर्ग बनाएँ जिसमें संग्रहीत कार्यविधि वापसी परिणाम सेट मान हो

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

}

Dbcontext में क्लास जोड़ें

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

    }

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

रिपॉजिटरी में कॉल इकाई

   var counts = _Dbcontext.SP_reslutclass.FromSql("call SP_Dasboarddata 
                    ('2019-12-03','2019-12-31')").ToList();
— हरि लक्ककुला
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.