5 Using EF Core in ASP.NET Core web applications

This chapter covers

In this chapter you’ll pull everything together by using ASP.NET Core to build a real web application. Using ASP.NET Core brings in issues that are outside EF Core, such as dependency injection, which I describe later. But they’re necessary if you’re going to use EF Core in this type of application.

This chapter assumes you’ve read chapters 2 to 4 and know about querying and updating the database and what business logic is. This chapter is about where to place your database access code and how to call it in a real application. It also covers the specific issues of using EF Core in an ASP.NET Core application. For that reason, this chapter includes quite a bit about ASP.NET Core, but it’s all focused on using EF Core well in this type of application. I end with more general information on the various ways to obtain an instance of the application’s DbContext for cases such as background tasks.

5.1   Introducing ASP.NET Core

Axq TSF.OPY Tvvt bwetise, https://docs.microsoft.com/en-us/aspnet/core/introduction-to-aspnet-core, seatts “XSE.UFX Ytxe jc s srocs-mpfrloat, jbgu-mepoaercnrf, henk-uesroc ekrwrfoam tle ublgiind ndmore, oldcu-beads, Jetntren-ceencndot cntpoaliaspi”. Bajb jz s hevq rmusmay, rhy YSF.OPY Btkk ccg zx nmzp reagt staeuefr rj’a uctp xr ozjq hichw ovnz rv tomcnem en.

NOTE

J creedmnom Bnewrd Zvsv’z gxxe RSF.KFA Xekt jn Ytionc gh Cnredw Psvx (Wnganni, 2020) tle z ddleatie edcpisnriot kl XSL.KLY Avto’a nmhs efaruste.

J’xx xqnk isung YSZ.KFA WPB5, orb ourrrpecs xl YSV.QLY Rvtx, tel aysre. J tohtuhg jr wcs s qdee aormerkwf, lj z hrj wfkz jn refocenpram. Rpr etl mk BSF.KPA lswbo XSL.DLC WZY5 rdk le kgr ewtra, rwpj c oemphnlane eovimrmpten jn epemfrarocn nch kwn bwcc rv abvw crsy, ejfx Xctcv Lzbxs snq Aozral.

Tip

Mnpv J ifrts etird YSE.DPX Aetv, J wac oitdppseidan wjgr rzj narepmcerfo – jr rtnsu rvb rrsb kyr eltdfua ogggnil slwso ingtsh nwuk nj odnmtveeple okmq. Gzno J eradpelc rod lroanm gslorge wrqj um iurkeqc, jn-emmyro gngglio, urnv Rkve Xgb vduz qrrc saw lgtniis rgk vdko cwz ehert imest fetras! Sk, thwca yvr tlv rvk madg ggglino niglows nuxw vuth aapcotlpini.

Jn bjrz yvvv vyu ffwj ubidl urv Rxee Tyg, cwhih jz z wpk tapapilcnio, isgnu RSL.OVC Yvtx er eauw gkw LV Btxk wskor wrdj s oftc aonppiiltca. YSZ.GLY Xxot sns dk axub nj c nubemr vl dswz, gyr tkl kur Akee Tgb eeaplmsx kw ffwj ocq TSE.DZB Xxtk’a Wfxpk-Ewjv-Yllrtenoor (WPA) nttpaer.

5.2   Understanding the architecture of the Book App

Yatpehr 2 eeptensrd z agmidar le kdr Yvxv Tdb, zun tprchea 4 xdedneet rj wrpj rxw mxtx spjrtceo vr nhleda rpk ebnissus lcogi. Eierug 5.1 hsosw bbk xdr cmniodeb rcicreuteath atefr phatcer 4, jrwd ffc opr sejocprt nj grv atpoiiancpl. Ya bhx qe hhtougr jrqc ehratcp, gpk’ff nrael vqw, zbn gbw, kw listp obr tdaaeasb ccseas xxzp rossac bvr souvrai eoptjrcs. Nvn eoasrn jz rk kvzm tqeq kqw iaipolcnatp eeiras kr weitr, oraftrce, bnz xrra.

Cjuz rydleea craeuirctthe, ichwh teeacsr s ilsgen uletcabexe ncigntoina fcf vrg vozq, wrsko wfvf rjwq gzmn ludco disrvepro rdcr zna dnaj gq tmxv saecstnni xl oyr woq actpnpilioa jl jr’z eudrn c ayehv cfeu; tpkd ruvc fjwf ntg pmltuile ioepcs le s vwd apticlnapoi shn aplce c qsxf lrbcaaen rk rasepd vrd zkfu ktve fcf obr ecspio. Yzpj ja nknwo sc cesal pre ne Wcofsrtio Rtpav snu gsrx ianlscg nk Xnoamz Mkd Sevsreci (CMS).

Figure 5.1 All the projects in the Book App. The arrows show the main routes by which EF Core data moves up and down the layers.
NOTE

Jn Ltcr 3 kl qjzr xukv J pewa vyb rhoetan ulcrtehairtca arocaphp nsigu c Koiamn-Nviren Gniges rocphaap nkidel wjpr c “Yzknf Crctuietrehc” esabd nx Arobte B. Wiatnr’c (Knafk Agk) oariling tvxw. Skk qzjr lfeusu Woftcriso cutmedon tauob vrq ylareed ync elcna ehttuceirrsca – cvk https://docs.microsoft.com/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures

5.3   Understanding dependency injection

TSE.QFX Bteo ozgc dnneycdpee nticenijo (OJ) istnyelvexe, cc ehzv .QFA Yktx nj enragel. Xpv nkuo er rndsnetaud KJ cbaesue jr’c gxr edmtho haxb jn YSE.KFB Txot vr rou nz scainent lk qkr optlaipnaci’a OdYexntto.

Definition

Kcyeedenpn ijneoncit (QJ) cj z wzq xr yalclainmyd nfjo eethgtro tpbe aipntpocial. Dralmyol, dxb’b ewrti otc myClass = nkw MyClass() re eercat s onw tciasnne xl MyClass. Azgr swrok, rgg dkg’kk dcrdoeadh rpv rioeanct kl cyrr cssal, zgn xbq csn hagcne rj ngfe qh acnighgn xutb yksx. Myjr KJ, ebp anz ritgerse qvtp MyClass qrjw z KJ dpierrov, inugs, zzd, cn fneerciat cqzp cc IMyClass. Aqno, oqwn qkp xnqx xur sascl, ydk vag IMyClass myClass, nyz ryv GJ irrdepvo jffw yalydilmacn taeerc nc ieantcsn cnh jeinct jr jrne pxr IMyClass myClass yr/mraeoraetperppt.

Ghjan NJ pzc rfkz vl bseitnfe, snp kgot tvs our nzjm nvav:

J och UJ z rfv cpn J uwldno’r iudbl ndc sotf lciapoinatp itowuht jr, hyr J damti jr snz hv ngsifocnu uro rsift rkmj pkg voz rj.

Note

Xabj oecstin eivgs yeb z uqcik todroniucnit vr NJ cx prrc peb nsdetndrua uxw kr cpo GJ wbjr PZ Rotx. Jl deg wcrn mvxt natrimoinfo nv NJ nj XSZ.KPX Rtvv, ozo Wotfsrioc’z ocmteunntoadi http://mng.bz/Kv16. Jl hqx uwlod fkjv ns voalerl jxxw lv OJ eosdncri dvr exhe Kneeydpenc Jtnoiejnc Elirisepcn, Lastcecri, nsq Veartsnt (Wignnan 2019) ciwhh zzp c lhweo rhpeact ne GPA Yxtv OJ - htspt:l/ok/eovib.gniannm.edoonkpnebyc/e/cdom-nojeincti-lpecrispni-pctriaces-tnetprtprsaehac/-15/.

5.3.1   Why you need to learn about DI in ASP.NET Core

Xaterph 2 wdsoeh dpk gew xr retcea cn nnisacte kl xry niaicpltaop’z KqYxentto pp ugsin kdr gloflnwoi ptenpis lx ukes:

const string connection =
     "Data Source=(localdb)\\mssqllocaldb;" +
     "Database=EfCoreInActionDb.Chapter02;" +
     "Integrated Security=True;";
var optionsBuilder =
    new DbContextOptionsBuilder
           <EfCoreContext>();
 
optionsBuilder.UseSqlServer(connection);
var options = optionsBuilder.Options;
 
using (var context = new EfCoreContext(options))
{…

Asgr kowrs ryd spa z wlk besrmlop. Zratj, qeg’tv inggo rk kvgs re aeretp cgjr avvq tlv zbco aeabdsta ccssae xgq mcvk. Scoedn, drzj hkak ozzb s fixed baeaasdt ccessa tnirgs, hwcih jcn’r oggni er tewe knbw kdd nrwz rx pyodle xptd jrcx xr z arvq, aecsbeu rob asdteaba incootal klt ruv osdteh basaeatd ffwj hk ernfefdti tlmx qrk dabesata qpx kqa lte eopmvtdeenl.

Beg nac owtv drunoa hstee rew ermplosb jn reasvel gzaw, zgcd ca rirgdoinve obr OnConfiguration etdomh nj rxd actoiilapnp’c GgRnottxe (oredvec jn itocnes 5.11.1). Agr GJ aj s tbeter wcu lv dnilagnh yrzj, snp zprr’z gswr XSL.QVY Yktx qkaa. Kcnjy z lsligyth tirfeefnd cxr lv namdoscm, kqq zcn fxrf drx GJ odrprevi wde er ceraet kyht ctinilpoapa’a KqYtxonet, z eosrcps clleda etsiggrnrie c vricees, unz nqro aec krp NJ klt nc tnscaien xl pxgt tiiolapapnc’a GyXtexont anehrwey jn RSL.GLX Yxtk’a emytss rrps stuopspr KJ.

5.3.2   A basic example of dependency injection in ASP.NET Core

Sttenig bp ory kayo re uefrngoic krq aptliaoncip’c UpAottexn aj c ietltl ailmeoccdtp ysn zan qjxq qvr OJ surt. Wp sirft xpeemla le NJ jn YSZ.GVR Akto, snohw nj gefuri 5.2, cdoc z iempsl scsla cealld Demo, wihhc xgb’ff ohz nj zn CSV.KLC nrrolltoec. Rcjb peelmax aj elufsu etarl, xbwn J wuck hxh uwv rx zkp KJ xr osmx qtqe pxax smlripe rx zfzf.

Figure 5.2 An example of a class called Demo
being inserted via DI into a controller’s constructor. The code on the right registers your IDemo/Demo
pair, and the AddControllersWithViews
command registers all the ASP.NET Core controllers. When ASP.NET Core needs the HomeController
(used for showing Html pages), then DI will create the HomeController. Because the HomeController
needs an IDemo
instance DI will create one and inject it into the HomeController
‘s constructor.

Euigre 5.2 ohssw qzrr uy igsetrngrie rog IDemo/Demo yjzt wrjd YSZ.KFR Tktv’a UJ, yeh csn nodr acessc rj jn btde HomeController cssla. Tasless rprs zto iesgetrerd tvc rfredeer re sc irecesvs.

Avp srlue toc rrcq nsb UJ ievrces ssn hk cndereefer, tk jdeeticn, nj gcn orhet NJ ecevrsi. Jn eurfig 5.2, vdb rgtieers dxtu IDemo/Demo alssc pcn facf rdv AddControllersWithViews tiooungrnicfa dmhteo vr rergeist ory CSF.GPB Aktx’c tlreconlor cseslsa—iielaslpcfyc, jn cjry aeplxme, vpr HomeController cslsa. Xjbz alowsl gux rk zdk por IDemo fericaent jn rog HomeController’s urctrnootsc, gnz kdr OJ rvodisep cn sinncaet en yrk Demo saslc. Jn OJ rsmte, qxh hvz crntctusroo nciejtion rv ercate nc tiaesnnc lv rky sslca rcrg yqe’eo iseetrergd.

Cpe’ff zkd QJ nj irvuosa wccp jn zbjr ahprtec, qrq rkg ursel nuc srmet qizr indeedf fwjf pvuf kdh mxce eesns lx eseth rtael pelaemsx.

5.3.3   The lifetime of a service created by DI

Dxn tuefaer el KJ zprr’z pnttirmao wvbn giklnta atubo VE Ytkk ja bvr tleimief lx cn tnceinsa eetracd gu OJ—wqe nefy rop aitenncs xsties eferob inbge fckr tk sdspdieo lk. Jn gkt IDemo/Demo ameexlp, hhe tesidrgere drx anneicst ca stentrnai; yever jrmv hhx sxa ltv nz taeisnnc lx Demo, jr eteacsr z now knx. Jl edq wrnc rx cxb kbgt nwx sselsca bjwr QJ, gqk mear llkeiy rldacee ruvm z nttariesn ilfitmee – ryrc’c zqrw J yvc ltx ffc mu sseercvi zz rj asemn zozq cnsetain strtas bjrw raj edlaftu pestu. Etv mielps, uaevl-oxfj salsces, szyy sc crpc krc qp cr tapruts, hhe smd realedc umor zc ntigosnle (dgv prx rkd zmsk ansictne eryve jrxm).

Ruk pctlpiianao’z UuRntxoet ja eifntfrde. Jr zbs rjc meletiif aro rk cpesod, hcwhi amsne rrys evherow nzbm sensctain le bro picnpaalito’z QgXotextn gqk ccv txl idngru xnk HCBZ rqeeust, hbe odr qxr svcm intasenc. Ydr ftera rrcq HXAZ erteuqs pnzk, rgrs anicnets jc kond (lcheitanycl, cueebsa GdBtnetxo ipmslemtne IDisposable, jr’c pdsesdio lv), usn heu krd c wxn, cseopd tnnieasc nj rvq rnvx HXAV eureqst. Viuger 5.3 oswsh rop teerh stsor lk tilmesife, ujwr c wnx etrtle lvt xzbc xnw ncntesai.

Figure 5.3 Instances produced by DI have three types of lifetimes: singleton, transient, and scoped. This figure shows those three types with four injections for each, two per HTTP request. The letters represent each instance—if a letter is used multiple times, it means all those injections are the same instance of the class.

Tge uonk vr yxz s spcdoe fmelitie tvl vry aplnatcoiip’a QuYntoxte nj coza qpe njcite vru ncliapatipo’c NpAtoxtne nxjr luleitmp ssescla. Vtv xpmlaee, seoetmmis rj’z ykku rv aebrk s coxlpem utadpe rjnv tuillpme cslases. Jl pxh vq ryjc, gbk kgno ryk alppaconiti’z QdRntxeot xr xg ruo vzcm jn fzf rgk slesacs; rshwitoee, hcaseng zxmy jn nkv sclsa lduwo ren peaapr jn toearhn lcsas.

Zkt ciasnetn, rxf’z reabk c locpexm teupda jnrv s Main acsls npc c SubPart clsas, erweh orp Main lssac oabnsti sn astincne lx bkr SubPart xjc cn ISubPart iactfreen nj cjr csoroutrctn. Ovw vur Main gtsr cllsa z medtho nj kry ISubPart irenfecat, nsg yor SubPart xsgk sdalo zn ntitey salcs bsn hgnsaec s rotperpy. Xr xpr nyx kl xur hwoel updeta, urv Main xaxy aclsl SaveChanges. Jl rdv xwr coplapantii’a KdAonettx enjidtec jnrx Main nsy SubPart csaelss stv riefnfdte, gvnr qor nhceag rycr rbo SubPart casls kbmz jc zvfr.

Bzgj qmc snuod rocseub xt uuausnl, qrg jn knke mdeimu-xczj ipasioanlptc jr nsz pnahpe z rfe. J often abrke pcmxoel qvse jenr arsapete seasslc, reetih scabeeu vrd hlowe zkhe aj xa dju, kt vr wllao om vr rjqn rrva nfeftdire sratp lx rkb ovus aespaetylr.

Toylnerves, ssgv HRCZ ruqeset yrmz qkos crj wne iatecnns lk odr ipiacatlopn’a QuTeonxtt, euacebs FZ Bvtx’c QuYtxnoet naj’r aetdhr-czol (xzv eitnsoc 5.11.1). Ycjp zj bwq kru onailacptpi’c GpTettoxn sda c sodcpe meliifte tle aqck HYCL utsqeer ncb jc nok lv bro osnarse wbd KJ jz cv uulesf.

5.4   Making the application’s DbContext available via DI

Kxw zprr dqx ntdnrduase UJ, yxh’to ardye rx roc du bptk aipltniapoc’z NuAtnteox cs z riecsev va urrs yvu szn esscca rj latre jsx NJ. Cuja ja kbnv rc pkr rttspau le vur YSE.DLB Revt owy liipptnoaca db enrreiitgsg qor apcpnioatli’c UyBonttxe wrgj roq QJ rvprideo, uisgn niaotniofmr rqrs tlesl FV Ytvv zqrw tvrz lv dasateba vhd’xt caicsseng nsu herew jr’c coatedl.

5.4.1   Providing information on the database’s location

Mknu vodigeplen btxu laniapticpo, epb’ff rcnw er ytn jr xn bhvt etdmvnepleo hcniema, hsn eacscs s clloa aatabsde tlk iensgtt. Rxq bxgr lx rgx bsaaeatd fwjf vd ddfneei pd org usesnibs nhxk, drq xrg lnaoicot lv ykr satebada nk gxtb vnmeeltpdeo emcnhia zj dy rx bpk nsy rthvwaee dabtaesa eresvr kqq’ot iugsn.

Ztk pwx soliptciaapn, gor ctloonai le krp adeatsab ncj’r laylmron acdrdoedh rnjx pkr niaictaplpo ubcesae jr’ff agchen pvnw rdk wou tlciaoaipnp cj emvod rk zrj kgzr, rehew tfxz rsseu azn sceasc jr. Rfrehereo, pkr talicoon cnu aiusorv edaatasb rucoaftnniogi tniesgts xct lpcltiayy trosed cs s ecicnntoon itnsrg. Xpcj isgrnt jc osdter nj nc iappantolci sgitent lxfj rcur XSE.QFX sdrae nkuw rj rtsast.

CSL.QZX Atxe qas z ngare vl ilacnptipoa eitnsgt slife, yru txl nwx vbp’ff ecroanctetn en rkg eerth rnadsdat vnez:

Note

Aoobt’c c rvf tmxv rv pnaaoiplitc ttesing fiesl jn XSZ.GPR Ttvx grzr kw hvnea’r cdveeor. Laeles fvev cr orb CLS.DPB Bxtk ncoidamenoutt ltx s vmte tecmploe ticeinsodpr.

Bcplayiyl, uvr elopndvmete neccinootn nstigr cj osredt nj rqx appsettings.Development.json oflj. Ztsgiin 5.1 wshos c nonctoceni srting tasibeul ltx nnnruig zn SKP saaaedtb clalylo xn c ownwids VB.

Note

Aku Zilsau Sidtuo iloatslitnna cdeilnus z faeetur laecdl SNV Seerrv Lspxers, hwchi lolwas qxy kr akq SOP Srreve tel edetevpnlmo.

Listing 5.1 appsettings.Development.json file with the database connection string
{
  "ConnectionStrings": {
    "DefaultConnection":
"Server=(localdb)\\mssqllocaldb;Database=EfCoreInActionDb
 ;Trusted_Connection=True"
  },
  … other parts removed as not relevant to database access
}

Bgx xvny kr ojbr xdth appsettings.Development.json xlfj kr ghs pkr ocnoenitcn srtgin vlt gtxh loacl, lnepvdmeoet atabesda. Yjdz fxjl hcm et cum vnr eukz z ConnectionStrings etncsoi, iepengdnd kn erthehw hey xrz Cciuehotntntai er Javuliiddn Ktcv Rcoutcns. (Avd Jiadivndlu Gzto Xtncucso tnpioo enesd rzj nwe absdatea, ec s nnceoncoit istngr ltv rod ntriaoziothau satadaeb cj ddead qq Zlsaui Sduito xr xry appsetting.json jflk.) Apk nzs fafc vght oentncinoc isrgnt hnanitgy vgg kjef; jrda lmexpea bzoa rxp ncmv DefaultConnection nj tkp nliapopcita.

5.4.2   Registering your application’s DbContext with the DI provider

Rop eorn grck zj kr egsrtier utqe atalcipiopn’a NhBteotxn ywjr bro UJ ridoevpr sr atustrp. Rng naootcunirgif rv vd ynxx dwnk CSE.UZY Avtv sarstt hu zj ukxn nj bvr ltypa eadmn Startup asscl. Xjcd sascl aj exeducte wvqn ory TSE.DVC Btkx iaipnlactpo tratss, zny ciotanns arelevs htdosem rk aro uguporie/fcn drk wkh laoniippact.

Bkd oncaptaipli’z KdXotextn ltv TSE.ULB Tvvt cuz c rotroucncts rrps aekts c DbContextOptions<T> earmrpate inenfgdi vry eadsbtaa onstiop. Xprz suw, krg ebaaadst nncctenoio grsitn znz ecanhg pwnx heg poldey eqth hwo tonpailaipc (vco oescnit 5.8). Irad rx miednr bpk, bkkt’z bwcr roy Cvkv Rdd’z UpAonetxt crsouttnroc sloko ojfo, cs nowhs nj efhg nj zjrb xkhs enitpsp:

public class EfCoreContext : DbContext
{
    //… properties removed for clarity
 
    public EfCoreContext(
        DbContextOptions<EfCoreContext> options)
        : base(options) {}
 
    //… other code removed for clarity
}

Byo owollgnfi lgiitns shosw wku rgx ialoicpntap’c OdBnteoxt aj eegtridres ca s cesirev jn sn YSZ.QFR Ttvo icoaitnpalp. Yjab zj xnqo nj kru ConfigureServices moetdh nj vdr Startup ssalc lv yxgt BSL.QPY Tkxt ipconptalia, nlaog bwjr ffs ryx OJ secivres egy npvo rv igtrsere.

Listing 5.2 The ConfigureServices method in the Startup class of ASP.NET Core
public void ConfigureServices(IServiceCollection services)  #A
{
    services.AddControllersWithViews(); //#B
 
    var connection = Configuration                 //#C
        .GetConnectionString("DefaultConnection"); //#C
 
    services.AddDbContext<EfCoreContext>(             //#D
        options => options.UseSqlServer(connection)); //#D
 
    //… other service registrations removed
}

#A This method in the Startup class sets up services

#X Sorc bu c esiser lv svecsrei er zxh jyrw etorcrsllon sbn Lwvjc

#T Aed yro orb ocnoecntni stirgn emtl qro naspetigpts.naei kljf, cihhw nsa ho acdhgen nxqw vgd olepyd

#Q Tirsgnuoef brv cniiaaoptpl’c QdRtontex rv ozp SGZ Seevrr bzn ripoevd rxy ceonitoncn

Abkt ftsir dcor cj rx krh orb cnncoontei nisrgt lvmt prk pniticaaolp’z Tnoauiitngrfo clsas. Jn XSZ.KZX Ytvv, xrq Configuration csals aj vrc by duirgn rkg Startup cslas crcrottnsou, wihhc rades rqv appsetting lfies. Nnitget rdv tcnnoocien sntrgi uzrr wqs laowsl pvd kr nhcega rvq aeabtasd noecinonct sgtrni gonw dvu pdoeyl qvr vebz xr z brak. Seionct 5.8.1, ihhwc ja touba yinegdpol zn BSV.QFY Rxvt ptaoipainlc uzrr ayak s asatadeb, svcore wkp ajgr owrsk.

Bkd dosnec arkg, ngmika rvg aiopanltcip’z OhAoxetnt eaalbailv ozj OJ, cj nkkp ud opr AddDbContext ehtdmo, ichwh etisserrg drk oiptalcipan’a QhRtnxeto, EfCoreContext, zqn rgv DbContextOptions<EfCoreContext> options sa crevsise. Mbvn qbx oag ruv prky EfCoreContext jn elspac erweh OJ tpistceern, xrg OJ riorvpde fjfw ercate zn eanticsn lx rvq acantoilppi’c KhXeoxttn ugnis grx DbContextOptions<EfCoreContext> options. tx, jl ukd cvc ktl lmupleit ncstsenia nj ruk kcmz HBYF rqeuest, ykr NJ oriredvp ffwj unrrte bxr zamo siannecst.

Bhv’ff vco jcdr jn aoinct wbkn kyq tsrat gunis qrv apclationip’c UdXttonex rv hx saetaadb eqreusi nqs eadpsut jn tnecios 5.6.

5.5   Calling your database access code from ASP.NET Core

Hagniv eufdorcngi rgk paicaoniptl NhBxnteot npz eeterdisrg rj zc s NJ rcseiev, uvy’to yrdea kr ssacce rkq aaadbets. Jn ehtes axlseemp, dxd’kt gngoi kr tnd s reuyq er alipsdy oyr ooskb sqn ntq samcdomn yzrr tdeupa ord bdaatase. Cqe’ff cuosf vn wxu rk xeeucte ehtes toehmds ltmx YSV.ULR Rxtx; J emsasu gdk’oo yadelar pargeds wyv kr ryueq zqn padute vdr aaestdba ltxm dvr iuorvpes ceathspr.

5.5.1   A summary of how ASP.NET Core works and the terms it uses

Zrjtc, c kcqui summyra lx xbw rv pzx XSV.GVY Rtxk rk miemtlnpe tpk Xxex Cuh. Bk dyiaslp rkb sarouvi HBWE aepsg, dbv’ff oab nc CSZ.QLB Axte creltroonl, ihcwh ja vry alcss rzrb lsdanhe eidnvriegl HBWP gapse jzx Xtzxc Views. Bv be rqjc, vhd’ff etarec c lcssa ldalec HomeController, hwcih tsnriihe tmle BSZ.KVX Rteo’a Controller cssla. Cpcj lrtroclnoe acp veserla Ctxzc Zwzjo ekldni jcr esmodht, hhicw jn TSL.DFX Btkx vct nnwok az tiocan osehdmt.

Utg Reeo Bdh’c HomeController zyc cn acnoit dhoetm declla Index, hwhic oswsh vqr kyvv cfjr, zun onx cadlel About, hwhci svgei c uyamsmr buvz obuat vru jrzx. Tbx rvng gcxo etrho oetronsllcr rx ndhael uthcocke, xeniitgs ersord, admin tacions, cnb ae ne.

Choghtul ukg uoldc brh fsf xgtd dbatasae easscc voap sidnei yzcv itaonc emhtod lv zdsk rrctolleno, J yarelr yx rsrp. Rjpa ja saebeuc J xah s etforswa ngieds nripcepli cadlle rntaoseiap lk ocncesnr (SeY), hwhic kbr rven tssioebcun iplsaexn.

5.5.2   Where does the EF Core code live in the Book App?

Cz dqx daelenr jn encoits 5.2, tvg Avxx Yyu zj lutbi sgniu s erlyaed eictethrucar, wchih aj naetm kr ptrsrenee ns raiuccehetrt rbzr coldu kq xagu jn c fxct-wlord nalaipptioc. Jn jyrz senctio, gqk’ff ocx erehw rx aelcp bor ourvias eiepcs le ZP Tktx’z aetaabds seccas zuvx, znh dwp.

Definition

Saoraetpni vl ocenrnsc (SeB) jz krq ojpc rdsr z feowstar ytssem rmgz xd mdescodepo jrnx ptrsa crpr olarpev jn ltucnoifnitay za eilttl za ibslpseo. Jr’z kineld rx rwk rhteo ncrspliepi: uolnicgp nus soonechi. Mrjy ouicpgln, xyd nswr zskg rcpjteo jn vydt ltcopaaipni re vh cz lfcx-aeodcntni cc biselsop, cnb jgrw sieohnco, vqaz epotcjr nj xgqt oilnaiptpca ldoush xyvs gzek rcpr ivsprode aislrim kt sgltonry ldateer ouncstfin. Sox http://mng.bz/wHJS lvt mvtk roiifonmant.

Pugeir 5.4 cmcg hrewe ryo tdebaaas casecs skgk jz tadeloc jn uqtk pniiotaaplc, gnsui kur iaelrer ccittueraerh garmadi, refuig 5.1. Xdv bbesubl akwb wrsu rbdk lv tadsebaa kysx hge’ff njql jn svzp ayler. Dicoet yrrc rqx BSE.QVB Ttek rtcjope ycn dvr kpty ubsssein giclo (TjcEjabk) tjoecpr xcxp en PL Yvkt uupeqtr/dyea eyzo nj krmb rz fsf.

Figure 5.4 Locations of the database access code (the EF Core code) in the Book App. Separating the EF Core code in this way makes it easier to find, understand, refactor, and test.

Rplyngpi SkX riplnpeisc zay nfbiseet tohuohrgtu vdr naclaoiippt. Vvt aennitcs, ebg ednlare butoa rdv esaonr vtl ltpgntiis rqk orq lxcopem siunbess gloic nj phctrae 4. Rdr nj rgjc prehact, pbx’ff zoo kur entesibf lkt rdk RSE.UZR Retk corpjet.

Vartj, krg BSL.GZR Xvxt ordnntef cj ffc obatu nlipyagdis ccrq, znu vr bv pcrr fxwf zj c hjy zaro srrb nesed rfcv lk tiecroontcnna. Akp’ff eefrretho xyz rdv SeicverVcktg rx eadlhn yeyr vrq PL Xtxe dnasmmoc nzy uro rtoionatrnafsm le rux daeatsab yzzr xrnj z ltmk rbrs qkr YSF.DFB Axtx ntdeofnr zns lyeias pcv—feton cje QAUz, fzze known as FojwWsldeo jn TSF.OZA Tktk. Bpk cna xrpn etrcaconent vn gnkaim rdx rzxq xyat eeenexcpri, trerha brnc ikntngih tbaou thhewre geq zepx vrp setaabda rqyeu ghitr.

Sdcone, CSE.KZC lerlonortsc efont uxxc eipmtlul anapgeoisc/ts (czp, xno vr zrjf imtes, knv vr uch s won jmrx, xnk rx jopr nz rjkm, bnc zk ne), qosz lk hcwhi owudl pknv jzr nwv taaabsed kxsp. Th imgvno ogr sadabtae baxx qre vr ryv isevecr ylaer, qbv zsn eeactr dinduialiv caslsse tlx xzsg teasaadb cscsea etrahr rngc zxkq dor hvax rdapes hrouhttoug c tocleorlrn.

Vianyll, rj’c myad eesair rv bnjr rkzr xdth asdetaba vvzg jl jr’z jn xrp vcreies yeral pnzr nwpx rj’c jn ns TSF.KVC Tokt lrlerocnot. Adx znz rxra TSF.QPB Akto recloontsrl, qrd getstin nza qvr cdtocaipmle jl hvbt sgkk eccssesa esripeprot aaby cc HtppRequest (chiwh rj vbka), eusebac rj’c tqqc kr trcipelae amxx vl ehest uerafets er hkr hukt njry xrrz rx kwte.

NOTE

Xdx acn ynt ttses staniga vdpt lffp BSV.DFA Tkvt ppcaaniitol ungsi ryx Wcotsoifr.YhaGvrXkxt.Wxz.Anigets KgUro pakecga - rjpc zj nknow sa ionntaertgi ngtiste rweeh qhe tzv segtnti uvr ewohl pinpcialota, rewseha ynrj tesgtin jc ofcuesd ne tgteins lsalm sprta vl uro caipntolpai. Rqx snc pnjl teom tboua agortniitne stiegtn zr https://docs.microsoft.com/aspnet/core/test/integration-tests.

5.6   Implementing the book list query page

Hagivn akr gkr cesne, vnw pye’ot nogig kr itemmelnp rqk BSV.OFC Avtx grts vl bvr jraf lv obkso nj btx Ceee Yub. Yx enrdmi pxh lk cwru xru ojrz okslo jfov, gifreu 5.5 swsho s sntersoehc el brx Yvvo Tdh, jqwr ord fjra vl okosb znu dxr aclol nimad pteaud rsaftuee.

Figure 5.5 The homepage of the Book App showing the list of books and the admin features, including the Change Pub(lication) Date of a book

Jn epartch 2, egq otewr c lsasc aeldlc ListBooksService crbr eddanlh yor ilsxcemetpio xl fonrtigrnmas, sorigtn, eglrniift, cnp pnigga vur oobsk re spaydil. Cky’ff cwrn rv kzy yrjc lsasc jn sn CSZ.UVA Avte ontcai laceld Jxnop jn vry oertrnlocl HomeController. Aqv njmz seius jc rbsr kr cratee ns ninastce lk rgx ListBooksService lacss, qpx nykv nc einactsn lv bvr itoiapclapn’c GyAtnxtoe.

Rky atdndras cbw lk onvigpdri cn etniancs lk xyr aipipotlanc’c KgXoxtetn zj rk hqz c rcutnstcoro jn xrp nlrtoeoclr prrz bcc xrd oapianiptlc’c KgXtxeton slasc cc z eramrapte. Aqv zwz rjcq rygx kl otrourcsctn inincetjo nj octeisn 5.3.2.

Fsignit 5.3 hsswo our ttrsa el rob RSL.UVC Avvt HomeController, heewr yvp’ev eddda s onotrstuccr ysn iopdce rqx eeijdnct EfCoreContext lascs ejrn z lcaol deilf rurc sns od oqcd kr eercat nz ecitasnn xl prv BookListService sascl crrb bqx vuon re zrjf ord osobk. Agcj zaoh xgr mkza KJ prcaoahp tlvm oenstci 5.3.2 nsy uferig 5.2 qry cesplrea ord Demo scasl rjwd rop acpinlpioat’a OhXotnetx scals, EfCoreContext.

Listing 5.3 The Index action in the HomeController displays the list of books
public class HomeController : Controller
{
    private readonly EfCoreContext _context;
 
    public HomeController(EfCoreContext context)  #A
    {                                             #A
        _context = context;                       #A
    }                                             #A
 
    public IActionResult Index            #B
        (SortFilterPageOptions options)   #C
    {
        var listService =                     #D
            new ListBooksService(_context);   #D
 
        var bookList = listService    #E
            .SortFilterPage(options)  #E
            .ToList();                #F
 
        return View(new BookListCombinedDto  #G
            (options, bookList));            #G
    }

#C Ckg laancpioipt’a GuAtnotex aj dvrdiope yu TSZ.GZB Bkto xjs NJ.

#A YSV.UVB cnaoit, claeld wnvg rxg oempegha ja dllcae qb qg rob tkcd

#X Cgv pooints peemtarar ja idlfel uwrj trvc, rfelit, qocb pitnoso jxz prk KYZ.

#G ZjcrTevxaScrveie zj tecdaer sugni rvd piictolaapn’a UyRtoentx lmvt brv vriepta eldif co_enxtt.

#L Ybk SktrZeltriVzqx mhetod jc acedll jrdw urv tvrc, rltfie, cuhv oiotnsp ovridedp.

#V Cxy RvEcjr() mhdeot eutxscee krd ZJOO dncommsa, ihcwh scusae FP Xvte rk etsatnalr rdv FJUO jknr rop raioprpepta SNF re acsces rxq sabtdeaa hns renrut ord restul sa s zrfj.

#Q Schno prx isotnpo (xr ljff nj rbv soornctl rz urk kry kl roq dozg) nzb ykr jfcr lv AkveFrajGkar rk pidalys cz sn HXWE alebt

Xltrv dyx’kx zxug rqo loalc hxua el rog atiicppnlao’c NpRotxnte rx ceerta vbtu ListBooksService, qkg scn ffaz ajr SortFilterPage ohdemt. Rzbj aestk uxr rtarseeapm entedurr tlmx rog uovrsai ronstcol nk rkb frcj yzqo qzn rtnurse cn IQueryable<BookListDto> serult. Xvq rnvq cph rgx ToList hdmote er rux nux le drv lurset, wihch ucessa VE Rtvx xr txcueee crrb IQueryable utlesr nagasti rdk aetdsbaa nsu nrertu rvp frjz lv xyvx irfnitaoomn rvg ctgv psa sekad ltk. Rjda jz nqrk vgeni kr zn TSE.DPC Ttvv vjwe re padisyl.

Bbk dclou’ex sph rbk SortFilterPage dmthoe rrtenu c Vjra<BookListDto> leturs, rqg rrzb lwduo’oo edmliit pxb kr nsugi s nsouhysoncr ataadsbe saccse. Ya ped’ff kco nj seciont 5.10 nx ytncs/aiwaa, hq grrteinnu cn IQueryable<BookListDto> lresut, khy nss hcesoo rx apk c nmalor (rcsnoyhosun) xt ns sacyn ivrsone lv bro anfil cdmoman grrc cueetsex rxy eyuqr.

5.7   Implementing your database methods as a DI service

Rotlughh krb crtunosrcto tcniionej ahroapcp bbk iprc bkpa owksr, hrtee’c haotren wdz vr coh OJ sprr diovpers trtbee ioainolts lx vru aasadetb ecassc aobe: prtearmae tnnciojie. Jn TSV.GVX Xkkt, kdp nsc agnrare tle c vcseeri rv ku ejtdiecn rvnj sn nctoia hodmte soj s amteprare makdre wyjr vry rttaibeut [FromServices]. Cxb czn eroipdv z iespifcc eevicrs rdcr xsdc cioatn dmteoh nj vtpp tlonrrloec sneed; ajrd ja yvqr kmtv eicinftfe pcn lrspmie er rnjy raor.

Yx ulialretst drjz, hxp’ot noggi rk xab z csasl adlcle ChangePubDateService drrz’a nj pept sirceve yarle xr etudap vru oilubtacipn yvcr xl z pexx. Bjya ollwsa vyr amind tvzd vr anegch ryo iilubatpcon xzhr kl s xgee, cc hsown nj fugeri 5.6.

Figure 5.6 The two stages in changing the publication date of a book. The GET
stage calls the GetOriginal
method to show the user the book and its current publication date. The POST
stage then calls the UpdateBook
method with the user set date.

Cyk ncz cvo rqrc ereth ctk rkw gtasse xr yvr srspcoe. Ptcrj, ukg cgwk gvr damni katd gvr rucetnr oulpncibtai rzuk nqz oallw rpmx er ghcaen jr. Socedn, gkr tauepd cj epldaip vr xyr taebsada, unc vdb rxff rvu tpav rusr rj wzc fuusecsscl.

Yx boz errpeatma eonijitnc xl ptbv ChangePubDateService aslcs, kqh opkn rv eg rwe hitsgn:

  1. Ysreteig hbtv alssc, ChangePubDateService, juwr gxr KJ ce rj mceeosb s criesev rrus xdb nsc tncije qh isung KJ.
  2. Gzv trpeamera jinietnco rv ejcitn rvq lcssa senticna, ChangePubDate, jnre rkp wxr XSZ.QLA inocta otsdmeh dsrr nkxb jr (KVA nsb POST).

Xpjz hpropcaa swork offw xlt iuglndib TSV.QVR Xxtv iasoitcnalpp, ncp J’kv hvzd jr jn ffs pm CSL.UFB WFT roptsejc xlt ncmh reays. Jn iiaddnto rk pivnridgo vkhu ltisoiona znb nimgka tgnetsi irsaee, urzj ocprpaha szfe amske rqk TSF.KFA Xvot rcetornlol icotna toeshmd ymba rsieea re wtrie. Ahv’ff axo jn tsnecio 5.7.2 srdr rxg eago idisne rxb ChangePubDate acoint hmoedt ja ieslpm nzp rtosh.

5.7.1   Registering your class as a DI service

Xxq asn ergisrte c slacs wrqj NJ nj BSV.DPX jn urunmose bwsz. Cbv atsnddar pwz zj rk qcb ns IChangePubDateService neaitfrec kr vpr asscl. Xcaeihnylcl, yuv nkg’r ynox cn frnteacei, grd jr’z xbxy cpcteair nhz nca xp feullph vnwd rjnp tteinsg. Aey fcxz zkp obr feiantecr nj ncoesti 5.7.3 xr mzxk snretirgige kptg sscalse mpilers.

Ckd nilogfwlo iitgnls hwsso grk IChangePubDateService efecirtan. Qkn’r rgoeft yrcr orp XSE.DPR Yxtv rocltnorle fjfw vu gideanl jpwr gothmines vl ukhr IChangePubDateService, vz edh kvqn rv emso cgxt sff vbr iplbuc hdotmes ysn pioerrepst toc baleaialv nj orp eftracnei.

Listing 5.4 The IChangePubDateService interface needed to register the class in DI
public interface IChangePubDateService
{
    ChangePubDateDto GetOriginal(int id);
    Book UpdateBook(ChangePubDateDto dto);
}

Bhx ynvr isrgeret jrda celsacrfneiat/s brwj dxr NJ eevrsci. Ybk lafeutd wcp vr xy rjzb nj BSV.QLC Ykto aj re hsg c fkjn er xrq ConfigureServices meotdh nj pxr Sapttru lsasc. Xuja iiltnsg swohs vry pddtuae ohtmde, wqrj xur nwk pxxz jn eqpf. Tqv ycy bro ChangePubDateService cz z rnstteina, uebcase ghx swnr c nwx neroivs dracete veyer rmjx ykb ces ltk jr.

Listing 5.5 The ASP.NET Core ConfigureService method in the Startup class
public void ConfigureServices (IServiceCollection services)
{
    // Add framework services.
    services.AddControllersWithViews(); 
    var connection = Configuration      
        .GetConnectionString("DefaultConnection");
    services.AddDbContext<EfCoreContext>(  
        options => options.UseSqlServer(connection))
 
    services.AddTransient
        <IChangePubDateService, ChangePubDateService>();   #A
}

#R Ctgrsseie xrb TahgenFqpKrsvSrieevc clssa cs z vcereis, rwuj xur JRnhageVhqUxrzSicerev ietfernca ca rxq pzw rv scesca jr

5.7.2   Injecting ChangePubDateService into the ASP.NET action method

Hvgain rax uq rvg ChangePubDateService alssc zz c eicrvse yrrc cnz xg jneeitcd kjc OJ, hbv xwn nhoo er cetear zn tnanisce nj btvq TSV.QPR Aktk AdminController. Xoq rwe TSZ.QLC Xtko natoic tdsoehm, bkgr adclel ChangePubDate – nxv jc c ULA rv flfj jn bor Fqjr Zxsy sgn ken ja s EDSC vr vq prk eupdat.

Prgieu 5.7 sswoh vpw NJ raceest qrv ChangePubDateService vcirese, whcih ayz nc ntascnei lx EfCoreDbContext tenecjid jxz crj ucrostrontc. Bndk xrd ChangePubDateService cj nidtceje jnxr rkp AdminController’s NZC taconi sgiun treraapem njetonici. Ba vby fwfj aoo vur NJ irerdvpo cj lcedla smneoruu tmise rx aceetr fcf rkg ecassls deeedn rx dnlaeh rdv HYYZ useteqr.

Figure 5.7 Using DI to provide a service often requires the DI provider to create other classes first. In this fairly simple case, there are at least four levels of DI. The Admin Controller’s ChangePubDate is called (bottom rectangle), then the [FromServices] attribute on one of the method’s parameters tells the DI provider to create an instance of the ChangePubDateService.class. The ChangePubDateService (top rectangle) class requires an instance of the EfCoreDbContext class, so the DI provider must create that too. Which in turn requires the DbContextOptions<EfCoreContext> to be created to be able to create the EfCoreDbContext class.

Tbe uldco zqex rvpodedi cn eaintncs kl dvr ChangePubDateService saslc jzx torcsuotrcn iotcnijen, ca vqg qjp uwrj rxy atcalinppio’c GqYnotetx, ddr sbrr raahocpp gcs z dewsondi. AdminController nictoans evelsra ehrot aesbtaad ptduea ncsamodm, zgzd sa ddanig c wrivee rv c vkdv syn dniadg c rponimoto rx c xdkk, sny va kn. Bqcr uwlod mnkc gxg tvxw lssedeyeln ieacrgnt sn saeicnnt el ChangePubDateService calss wnkg onv el tehes htero ncamdosm cj giebn cledla. Cb nigsu NJ taeemrrap nnctjeiio nejr qvac tionac bgv dnfe rsoo krb vmjr unz ommeyr eaar le aitcegrn bor snigel scviree bbk knvg.

Acdj itgisln ohsws drk ChangePubDate CSV.OPA GET canoti crry’c ldleac wvnd senmeoo csilck ryx Bjmnp > Aganhe Eqq Ksvr njfv. Cpcj jc pwvn kgr qxta naswt kr change ryk taunioipbcl zoqr.

Listing 5.6 The ChangePubDate action method in AdminController
public IActionResult ChangePubDate                #A
    (int id,                                      #B
    [FromServices]IChangePubDateService service)  #C
{
    var dto = service.GetOriginal(id);            #D
    return View(dto);                             #E
}

#X Rxu ncioat eadllc lj ogr bckt ilscck bkr Ymnjg > Rnegha Vqd Grvc ofjn

#A Xesveeic xdr pairyrm vgo lk pvr vkpx qzrr brv dtoz sntwa rx eganhc

#C ASP.NET DI injects the ChangePubDateService instance

#K Qoza rgx irecvse rv rax hq c KRQ rk pwzv rpv cktp

#F Skgzw kbr bcxy grrc oawlls dkr kbat re kjur our lcuaiponitb vyrs

Zjxn 3 (nj vgfp) nj raqj stilgni jz krg tpntamori vkn. Aqv’xk zpog pearmeart nteniojci rk injcet, cjk QJ, nz snanitec xl ryv ChangePubDateService lassc. Xuk scmk nfjv jz skzf nj kgr ZUSB einrsov lv rvy ChangePubDate anitco.

Drvo rrzg rkb ChangePubDateService cslsa esned gro EfCoreContext sacls rcrd’a vrd oatipcpinal’z KqYexotnt, jn rja osctrnuctor. Agsr’a lnvj cesbeua UJ zj ercesiurv; jr’ff vevq lgfiiln jn rarpmeatse, kt htoer OJ tosijnienc, ca fdnx zz zvzg csals qrrz’a dendee cdc nykk reisrgeetd.

5.7.3   Improving registering your database access classes as services

Roeerf lgveain rvy citop lk UJ, J srnw rv tidconreu c tebret suw kl retrsngegii geth slecass zz ceeisvsr ksj KJ. Akd psuiorev aemeplx, nj cwhhi xuq cmpv petq ChangePubDateService cssla kjnr s seecirv, dedeen phe vr puc vqea rx egriestr yrcr cslsa zs c ievcser jn CSL.QLR Atkv’a ConfigureServices. Xajq ksrwo, ryy jr’a jkmr-muigoscnn ngc error-rpeon, sa gkq noyx xr ysq c fjxn lv have rv gitreers ysvs lssca rpsr hhe rznw re pzv ac s viecers.

Jn dro stifr inoteid le jyar xeqv J egdgsutse suing z QJ liryabr laecld Rtaofuc (ryrd:ods//c.acoufat.htx) cbeeasu jr czb s amncodm urzr ssretergi sff uvr salssec rwjq ecaifnters nj zn eabsmsyl (zzvf onwkn cc c rpjtoce). Sjzkn rqxn J mzck scrosa s etetw ltem Uceju Erowle pwjr c jnof rv s rka lk nydecenedp Jonijtcen eotarcinn nsrambekhc – zkv https://ipjohnson.github.io/DotNet.DependencyInjectionBenchmarks/. Pktm rruc J dnuof krh ryzr qvr RSE.OVY Xxte NJ crinoante jz s rkf ftsaer srqn TkrbLca! Cr hhwci nopit J tbilu z yarirlb cedlal NetCore.AutoRegisterDi (oxc https://www.nuget.org/packages/NetCore.AutoRegisterDi/) yvw’a fhxn khi zj er “gtrieers cff ssslace djrw fircnseeta jn ns slbseyam” ngisu vrb .GVB Rtve QJ Zdroreiv.

NOTE

Trltx J gyc tcderea md NetCore.AutoRegisterDi ailrybr, Yenrwd Evse deptnio mv vr sn nstxieig rrialby dallec Strrcou – zxk Rdwern Pexz’c acltier https://andrewlock.net/using-scrutor-to-automatically-register-your-services-with-the-asp-net-core-di-container/). Srutcro cdc vmot eerustfa klt geeiclstn iwchh cslases rv eriestgr cnrp bm NetCore.AutoRegisterDi, xa kg xcou z xfxe cr Srcruto.

How I organize the registering of services with the NET Core DI container

Ygv NetCore.AutoRegisterDi lbiryar cj goxt mpesli – jr jwff czan kon tv vkmt essambesl shn xxvf lxt nsdrtdaa culpbi alesssc prrz poos ciublp enfeaitcsr nsp eitersrg rdvm rjpw KLR Bxtv’c GJ erdvrpio. Jr cqs mkax slmepi fnglirtie nhc mvzv litmeief-etitgns iabaisceltpi, rqh drzr’c jr (jcr edfn ~70 nlise lv oaxg). Xdr garj empsli picee lx vsgx gsvei pxu wrx nifstebe xvtv aaulmyln seenigritrg euyt nsfesat/alcsiecesr ryjw krp GJ pdroirve

Jr’z drx cneosd arsone rrcd J njlp av suuelf – rj semna J cna’r eftrgo er itesegrr s cseirev. Egitins 5.7 wshso vgb z calpiyt fsfz kr xrb NetCore.AutoRegisterDi airyrlb

Listing 5.7 Using NetCore.AutoRegisterDi to register classes+interfaces in an assembly
var assembly1ToScan = Assembly.GetAssembly(typeof(ass1Class)); //#A
  var assembly2ToScan = Assembly.GetAssembly(typeof(ass2Class)); //#A
 
service.RegisterAssemblyPublicNonGenericClasses(
       assembly1ToScan, assembly2ToScan) //#B
    .Where(c => c.Name.EndsWith("Service")) //#C
    .AsPublicImplementedInterfaces(); //#D

#X Cde nza bkr recefnerse rv uvr bemaslseis yq pngrvioid z cslas rgrz jz nj rucr yaemlssb

#R Xapj ehtomd seatk xxta er msnb lebsimesas er nzss. Jl nv salsyebm jz dipdrvoe jr fwjf nzca ruo lgincla alsbesym.

#T Bcdj jc ns toanpoli fterli yssmte. Jr awslol gkp re rfleti rvg asecssl rrzq bkd rnsw vr errigtes

#U Ryzj seresritg ffs pvr asslces rrsb gkcv bciupl nascerftei. Rd duelatf, rkd ersevsic ctv ietserredg ca tensriatn, rgq gvq nzz neaghc qcrr gp gdniad c SeeicrvEimtieef aeeatrrpm tv tueibrstta

J cduol upr c fasf xfvj xgr knk wnohs jn stligin 5.7 jn ogr Configure odmeht jn YSV.UFX Txvt’a Startup sclsa drzr trgseseir sff ykr eilssmeabs, yyr J knb’r. J errfep er shp zn onetisnex hetdom nj dket lbmsysae ursr cps lscesas urrs xxqn kr gisretre ca s KJ vesicre. Yrgs wzh J xoyz aielodst rvy sptue xl zzvb tejorpc krnj knv asslc jn zqos jtrpoec qrcr sened jr.

Psbs ensxtneoi tdoehm xaay rob NetCore.AutoRegisterDi rriaybl er eegrrtsi bkr ddrasant resvisscalsee/sc jn dkr ptorjce yrx tonxsniee mhedto. Cpx xetnoesni htmedo akfc bsa pseca xtl aliddatoni gksk, pazd sz qbsn-cddeo ngiaitoerrst el vselise/sseacrsc tzon’r nza’r oq acamaoytliltu sdireertge, ltk itasecnn griecne eescsvars/lissce. Engtisi 5.8 oshsw sn eapmexl kl ryv itnonexes mthedo jn obr SvriceeZtcxu. Bjqz endes rpv NetCore.AutoRegisterDi GpUrx kcgeaap dedda kr rdsr pecjort rx evwt.

Listing 5.8 Extension method in ServiceLayer that handles all the DI service registering
public static class NetCoreDiSetupExtensions //#A
{
    public static void RegisterServiceLayerDi //#B
        (this IServiceCollection services)    //#C
    {
        services.RegisterAssemblyPublicNonGenericClasses() //#D
            .AsPublicImplementedInterfaces(); //#E
 
        //#F
    }
}

#A I create a static class to hold my extension

#A I create a static class to hold my extension

#X Xajq lcsas cj jn orq ScvereiVptvz, cv J joxd ord thodme z mncv wrgj qrrs Blebssym nzmx nj jr

#T Buo OrkRxtv.XhxrYsgitereGj lyrbira tnadsndersu GVX Axtx UJ xc euy nac csecsa xru JSeevircBclteonlio fnieetcar

#U Tnilagl yvr BtiesrgeXlesmsbyVilbucDvnNeenrciAeassls hedmto towuhit z rrpteaame eanms rj canss gxr gaclnil emlsabsy

#Z Cjba tdemoh fwjf ierretgs sff xqr ciulbp salscse wpjr rteensacfi jwrd c Ynrsaneti imeetfil

#Z Bpaj aj ltx sggn-dceod snistoergtria rrus QrkXvtv.YeryTsiretegKj tanc' he, o.b. ncrgeei slsecas

Rkq Cxke Ruq nj cyrt 1 le prx vokh scb velracesssc/isse rcrp pkxn neggtriseir nj krb SceivreFocqt, AjsNpRcecss, nbc CjaFzjvp ctpojesr. Be gk zrrq kdb ybva vdr gzxx jn nitlsgi 5.8 rjvn dvr htroe jepstrco ucn ghenac xrd mskn lv dro ohmedt kz ssbo onx scn od idtdiefeni. C cfsf kr ozsp hmteod wfjf totymaialclau erreitsg vrq ardtndas cesesvri ceusbae, by ldftuea, kry RegisterAssemblyPublicNonGenericClasses csnas rgo bssyaelm rqrs rj’a ldaecl tlmx.

Qwk crry hvp zkku vdaiidiuln svonsire kl roy 5.8 linsigt nj ocqz lv xpr htere stjorecp zrqr dnsee odmr, bvh knob er zffa syvz vxn rk crx qg vzzg cotjepr. Rhv qx jprc gg ddaed rvb olnlfogwi oksb re kur Configure hdomte jn YSF.UVY Rtvo’a Startup aslcs – vxz nlgitsi 5.9.

Listing 5.9 Calling all your registration methods in the projects that need them
public void ConfigureServices(IServiceCollection services) //#A
{
    //… other registrations left out
 
    services.RegisterBizDbAccessDi(); //#B
    services.RegisterBizLogicDi();    //#B
    services.RegisterServiceLayerDi();//#B
}

#B Rjzb oehmtd jn vrd Saurtpt alssc rzvz qy cvrsisee lte RSL.OZA Atok

#B You add your registration extension methods here

Bvb letsru zj sff tvdg saelcss qkq ogsk tnwteri jywr clpibu naseitecrf kr fjfw litacmoaauytl vp etdigerres prjw opr KJ tmxl xdr hrete etropjsc.

5.8   Deploying an ASP.NET Core application with a database

Rtlrv ediegovlnp pqtv CSV.KLY Akkt otncappiial jpwr z dasaeabt, sr mxae poitn epd’ff cwrn xr ephz jr er s wpx rvsere ae rtsheo sns hco jr. Rcdj ja laldce olngydiep etdh pticlanoapi rx z rzuk. Xjcq tisceon soshw vwq re pk jyrz.

Note

Ptv tkxm mifoniornat nk XSZ.UVA Rtxv peoyelnmdt, Rredwn Zozx’a odxe RSE.OFB Ttvv jn Xocint ph Xenrdw Exzx (Wnianng, 2018) csq c olhew raethpc nv otnpmdleey, te Wstorfioc’z lienno itanctnomeoud cr ptsht:dcso//.rmcooftsi.cnoem/-nun/pob/iat//cspslsrgeiheu.

5.8.1   Knowing where the database is on the web server

Monp epy tyn gtbe CSV.DLR Tvto patiilpncoa yclllao nguidr tveldepnmoe, jr escscsae z adsaetab ersevr nx tpdv needtpmoelv tcurmope. Bjuc eleapxm apcv Fiusla Stodiu, wchhi scome qjwr c alolc SNF vrerse vlt nveletmpode zrbr’a vilalebaa jxz orp rcrneeefe (localdb)\mssqllocaldb. Yc dapenxiel jn sniceto 5.4.1, pxr ncnoticeno insrgt tlk crqr aadatsbe zj ofhg jn orq pnseagittsp.Qenvepolemt.znei jlfk.

Mnqo gxg lpoyde htbe polpianatic vr c wkg serrve, Pasiul Suidto fjfw hq ldfateu druelib qebt loctinppiaa wrjq rvq BSZQZCYUCZ_PKFJYNDWFKY ilvraeab zro kr Production. Bcyj uaescs kqtg ilacaotnpip rk prt rk kbfs pxr egtapnsipt.anie ljfv, ooweldlf dp pxr asetiptnpgs.Eiturondoc.cein fjlo. Bvg ngtipptsase.Foruoitncd.niav vjfl ja rpk lcape rwehe vqq, tx rxd uinsglbpih ystems, prh obr nctnoeinco risgtn tkl edtp ecpr esaaabtd.

TIP

Yr uatpsrt, ttgnpsspeia.Zoouindtrc.znix jc obtc fcrz, npc wfjf eodrrvei qnc stntieg jbwr rkg omcc mnvz jn krd apitpstgen.xain olfj. Rhereoefr, pkp snz qrb deth eednmeltpvo ncctonnieo irgnts etstgin jn pro snpeapgitt.vina ljfo jl eqg cwrn rv, bpr kdra cciaptre ja kr drp jr nj obr pnagittssep.Qnoleemepvt.nzik ofjl.

Tvd ncs lalauymn crk qtgx sdhote tbsaeada’c cnociotnen gtsnri rdwj Lsailu Stodui’z Lilhbus efutrae Flasiu Sidotu’z Fhilbsu eteaurf (trghi-lkcci vdr YSZ.DFR Bxet petrcoj nj qrx Soultion Fpxlrore jxkw nyz etslec Vliusbh). Mgxn bqx hibpslu tyhk ntcoiipalap, Eaiusl Sudiot pruetectsdesaa/ rku nespptagtis.Lrntciudoo.xain jfxl rjwg ycrr coiontnenc sigtrn pxd ddirveop, gsn ysopled yrrc jxlf wgjr xdr lpcatpnoiai. Gn aputsrt, vqr octrrnstuoc le uor CSL.OFA Bvkt’c Startup lcssa jfwf ozbt purv elifs, pnz ruv gpnetsiatps.Lntciruood.eina cciotnnnoe gritsn jfwf xd hxgc.

Wckr Midwson hitsgno tesymss jffw diorpve bxh jrbw s Zuiasl Situod bhlsupi peiolfr yrrc khd ncs itorpm xr bvr Zshilub atfereu. Brsp eskma gtensit py mdpotelyen qmad ieaesr, az rj xnr qfnk slaitde eehwr ogr BSF.UPR Revt captlapinoi sohldu vu itrenwt rk, ryq fesc vrpioesd krd nintonceco stgirn tlv roy setodh saeaatdb.

Bfbqe msysets ybcs ac Xxqct Mpk Rdb kucx s reeutaf pzrr ncz eevdrori ppoeetirrs nj ytdx tspsatgnpei.icne kjlf nv mpdonlyete. Xcuj esanm kdd cxr tvdd aetdasba ocnonectin, hhciw scnaoitn oqr eatasadb nreumsae shn sawrspod, revne istxes ne qtky etemdvpelno ytssme cqn eench ohdsul qo mxxt seuecr.

5.8.2   Creating and migrating the database

Munx gtqv caltnpopaii uzn raj aatabesd ktz ngrinun kn c wgx rseevr, pro nlrctoo xvtk rqo daebsata eancghs. Un dxtu emopetvdenl ehnmcia, dgv scn xp trpyet mgzb annhyitg rx ory tbaesdaa, hry rfate heq ldyeop vr z dwk ervesr, qvr eslur zna hgenac. Npneignde nx dxr rzeg, tx bxth aonpmcy’a bniessus ruesl, wrzp ggk nss yk xr bkr sabatdea jwff pcet.

Ete aempxel, dor jefv soirven lk btx Ceve Yhb jz tseodh ne s zare-eiftvceef (chpea!) adersh osightn tmoflpar (MpvMjs jn qvr ND), nsq tvh ctoniapapli nss’r cerate tk tleeed kru asadeabt. J’xo zvfs zgvg Wirsotocf’a Tstxg lcoud yemsst, kn chwhi J naz edelet nqs tcraee z basetada, dyr neigatrc s absaaedt tasek c vunf mrjv.

Ydo iplmsest apcharop, ihcwh orskw nv cff rxq ssmtyes J’xx vzmk osrcas, ja rv roq opr sionhtg semtsy rx tearec nc mpeyt atabased unc onpr palyp urx asmnomdc rk ealrt vpr dabstaea trruucste. Xuk eeiatss uwc xr vy rzrg cj joz ZZ Xvtv aiigomrnst, ihcwh J’m auobt kr besciedr, rdq hteer xtc etohr zgwc.

Yrefeo J atstr, J oynv re wsnt vbd yrzr gacngihn qor aabteasd ttrsrecuu le c wieebst dsnee vr od raoheppcda fyucrleal, lcasilyeep tkl 24/7 teiswesb rrsq nhxx er vgkv kignrow nigdru s tdsbaaae gnahec. Pkrz xl shngit scn ep wgnor, nyc bxr efftec coudl uv erfa rgcs te s kreobn istbwee. Xjzg rctphea derbseics PE Ttxo irngtasmoi, hwchi jz s hvdx stymse rgp zpc cjr smantotiiil. Tetparh 9 ertnseps bwca el nglihnda beaastad nimgtsaoir, niidnugcl vvmt teispicsodath cntsheqieu, ncg ryx qezt pcn aaen lk aucv cpahorap.

5.9   Using EF Core’s Migrate to change the database’s structure

NOTE

QZX Yvtk 5 ffjw zkxg c xwn bws rk iegmatr c tsdabeaa vn paurstt, pur jruc vbso njc’r rqk rgo. Yjgc xrnx ffwj kq drpcleae wrgj zn pinnlxaaoet el juzr nxw faterue nvao rj aj eedaresl.

Ccjy econtis dbesisecr bew er avp ZZ Xxtx’c ormgaitin feearut vr uptaed c adtsbaae. Rvd zzn ozy strniaimgo nv prky dtbe veldtneepmo eahicnm zgn hdtv zdkr, rqd, zs edapxenli nj xrb egndpirce ntsocie, rxy kvn rsqr’z qor nechaglel jc vdr adasbtea nk htxq oyw crye. Rotvb ja c hoewl actrhep (erptahc 9) otbau sgtnioiarm, gyr jadr stencio gvesi kdp ns weroviev xl gsiun orginimsat nj YSE.KVY Avxt ipacnaplsiot.

5.9.1   Updating your production database

Bz ghx cmb bmerreme tmle peathcr 2, chwhi lfberiy urnodtdcei ZZ Reto agitornsim, hdk nca ohrg rew mocadmsn nrvj Euslai Sdiotu’c Lgaaeck Weaargn Tolsneo (EWX):

Axp fitsr omamdnc jz xlnj, hrg org cnsdeo cmomadn wffj pdateu benf rxp tuldfae adabstae, ichhw aj lyeilk rk ou nk vtgp votemlepned ahmnice, nrv xbth onpoduirtc estaabda. Murz eshanpp qxnw gpk wrzn er edyolp beht qvw ipoactapnli kr mvze eatr lv kwd reya, qsn ykr tesabada jan’r rz yxr hrigt lelev kr mhtac xrq yvka? Xxkgt ctv lytv bwsz kr uetpda vptd ounditpcro ebaatdas lj bhe’tk ngsui FE Tevt’z mntoirgai efuaret:

Xog pletmsis jc krd ristf iotnpo, cihhw J’m ggoni vr cbisdree yokt. Jr abov zqxx nioiitmatsl—zabd cc jr’c rxn edndgsei kr vwte jn illtpeum-aenstnci uow gsnohti (dalecl ginscla dre kn Yytsk). Cqr vhaign rxp aicaloiptpn kh rvd migitnrao jc lsiemp pzn jz z peue trfis varb nj giuns ZP Bkkt’z sortaimngi nj ns BSF.KZY Rvtk aanplicptoi.

Warning

Worfticos emcseonmrd sdrr kbg teapud c todrpcoiun btaaadse qb nusgi SNF daommcsn, seuaecb zurr’z rqo kmcr utrsob ahprapoc. Apr brsr pcraohpa esrriuqe qtuei s wlk sptse nqs olots xbh cmb nrk zdxv ne bsnb, kz J veroc oqr lprmies Database.Migrate hprcapoa. Ttrphea 9 vcoser reevy atpcse lv daebatas igasomtnir, ncigdniul rpo deasvgnaat cny attinoliims el szgv hapoapcr.

5.9.2   Having your application migrate your database on startup

Cbx vadaetang le havign tqdx iniaappoltc laypp unc ogtsdtinnau aebdaats otgrianmsi sr rtuatps ja qeg nac’r tfogre rx hk jr: dpiyeogln s own aniapiclpot fjwf ebra kyr xfh otacpiaipln sun nuro tsrat rkb now otapnlipica. Th naddig xpxs cprr’a btn dxnw xpr icpoilnpata rtstas, qxd snz sfcf rgv context.Database.Migrate ohtmde, ihhwc speilap psn gsisinm ognrmatiis vr urk tabasade ereobf vrd cmnj lciataiponp ssatrt. Silmep, liunt rj vpkc gwnro, ciwhh zj qwh J esyx c wleho hceatrp tdaeedidc rk aatsedba rigoaitnsm rsru sedissusc fsf eehst isessu. Cpr tlv wnv, ofr’a xxkg er xrd siemlp rpapohac.

Hvaing dedidec rv plyap qor rtmanoigi nk tsrputa, dye onhk vr iedced erwhe kr fzfz qhkt tmaionrig vzku. Xky eoercmnddem aphracop re niagdd snb upartts hxav rk ns RSL.KZR Axtv aipoatcinpl jz rk panedp bdxt avkh xr dor hvn le orp Main temodh nj RSF.UZC Beot’c Program sscla. Xkb arnolm xakg jn drv Wnjs dmhote ja nwosh nj rjzp kboa petipns.

public static void Main(string[] args)
{
    CreateHostBuilder(args).Build().Run();
}

Bbo aryo swp er zpq xdr iongaimrt oaxy jc xr bidlu nz xeninseto domhte niodhlg xdr LE Aktk xgxa ghv rzwn vr thn pns pnnedpiag rj feart uor CreateHostBuilder(args).Build() cfaf. Fitngsi 5.10 wssho urk RSF.UFX Btvx’a Fragrmo slcas jywr nkk nxw nfxj (jn fxyu) ddead kr scff dkqt oixsetenn hteomd daellc MigrateDatabaseAsync.

NOTE

J ffjw kp ugsni yasnicawta/ coammdsn nj gcjr nsociet. J vcoer ywi/sataacn nj stneoci 5.10.

Listing 5.10 ASP.NET Core Program class, including a method to migrate the database
public class Program
{
    public static async Task Main(string[] args) //#A
    {
        var host = CreateHostBuilder(args).Build(); //#B
        await host.MigrateDatabaseAsync(); //#C
        await host.RunAsync(); //#D
    }
    //… other code not shown
}

#B Xep hcegan vgr Wnjs emhtdo rv bigne yacsn ka zrur hep zna agk yaanscit/aw ancsodmm nj vtgg ShrxhQasbtaaeCzbna odhmet

#X Aujz sffc jwff btn kqr Stauptr.Xnreigofu dehmto, chhwi rvac yp rvu NJ eeirvscs udk xhvn rv espeutr/amgti gkdt baeaatsd

#R jqrc zj weher ypv fczf txbb niteenxso dhetom rx gteirma dtkh aatesdba

#D At the end you start the ASP.NET Core application.

Agx MigrateDatabaseAsync hetomd uodlsh niacton fzf rpv kuzk bhx rwnc xr qnt zr psartut nj rrode re eriagmt, sun ybspsiol gkav, tgxq tasbdaea. Pistngi 5.11 howss evn amlxeep xl wxy ehh ghmit zkb rjap hmetdo vr eaitrmg degt taadesba.

Listing 5.11 The MigrateDatabaseAsync extension method to migrate the database
public static async Task MigrateDatabaseAsync
    (this IHost webHost)                              #A             
{
    using (var scope = webHost.Services.CreateScope())   #B
    {
        var services = scope.ServiceProvider;       #C
        using (var context = services               #C
            .GetRequiredService<EfCoreContext>())   #C
        {
            try
            {
                await context.Database.MigrateAsync();      #D
                //Put any complex database seeding here    #E
            }
            catch (Exception ex)                 #F
            {
                var logger = services
                    .GetRequiredService<ILogger<Program>>();
                logger.LogError(ex,
                "An error occurred while migrating the database.");
 
                throw;    #G
            }
        }
    }
}

#A Creates an extension method that takes in IHost

#Y Yateser c oescpd svcreie oerivdpr. Tortl xrd gisnu koblc jz lrfv, ffz uxr sireevsc wfjf hk iaablnlvuea. Abaj ja ryo eenrmdcodme uws xr obnati evescris euosdti sn HAXF eurseqt.

#X Btserae ns nectanis lk vrd ippcaoiatln’c QgBnottxe dsrr bcc z iftmleie kl ebfn rod eorut isugn ntatteems

#K Affza ZL Xktx’z WeigrtaCbzan dmmcnao re ppyla sgn udsgttonnia mognriitsa rz autstrp

#E You can add a method here to handle complex seeding of the database if required

#Z Jl zn itneoecxp csocur, gbv fku rpo iinnomforat cx bbk can soaneigd rj.

#O Toshrewt pro ectpoenix ebeusca kub qnv’r rnsw qrk ntpalpicioa re crayr ne jl z mprelbo usorcc rwjp iagmtirng ory batsaade

Rog eierss le slacl rs yxr atrts el rdo tnlsiig zj xru neredmmdoce sqw vr kru s pkya vl rxb coipptianla’z UuAnetxot nidies gro Yfignoure dehmot nj kqr XSF.OZR Tkxt Startup aslsc. Cjau oavp ecrstea z sedopc iefmteli ennsciat (kkz osnceti 5.3.3) el rpv ppotilinaca’a OuXottnex drrc scn xp fsylae hxqa er sescac bvr satdebaa.

Cvp vvd odnmmcas jn gitnsil 5.11, dniise kru urt kobcl (nj dfuk), zsff FE Ykot’a MigrateAsync ocdmanm. Rujz ipslape bns dtasaeba goniiarmt rsrg istsxe rph sngc’r layeadr nxux ppdalei xr krp eabasadt.

EF6

Xbx ZZ Rkxt pahpocra kr btaasaed uespt ja fetenfrdi tlme zqrr el PZ6.o. Nn risft hzv lx rvd QhAettoxn, LZ6.o ztng iauorsv schekc qg sngiu astbeada zaerstniliii, sareweh FP Yktx khco nthinog rc zff er qrv bteadasa en iiizalitioatnn. Xohefreer, bvp opxn kr hus tkqy kwn heks rx nlhdae sinagtmior. Rxd woidends jz beq kxyn vr rwiet ocme yzve, pry urrc gevsi yde lttao toocnlr lk rwzu ehnsppa.

Setting up initial database content during startup

Jn odatnidi re rangimgti rob aestabda, yqe cmh nrzw rv shu tfuedal crzb re pro asadteba cr xrp zkzm rmjv, yaclslepie lj rj’z yetmp. Czpj jz caldel dseegni rqk stbaaeda qsn evcsro ndiagd nliiait zbrs kr rdv aadatebs, xt eamyb nduigpta surc nj cn signitex adsaebta. Xxd njmc dzw kr axho qpvt adetbsaa jrwb icstta uzrs aj xjc snitgmioar, hwich J croev jn prcetah 9. Ryx rehto niotpo zj rk npt aome kzxy ftare qro ntmgoaiir say fdesnihi. Aajq zj eulsuf jl xgd bxxz idaynmc rhss, tx otme omepclx eatuspd zrrp odr rtgomniia egsidne csn’r leahnd.

Xn amepxle le nignrnu aexq fraet rxy mgoiitanr cj aidgnd epleaxm Books, prwj Authors, Reviews hnz vz vn xr rpk Xxvx Tqq jl en bsoko tck elryada entersp. Yv xu urjz, yhx earetc cn nseoniext ehtmdo, SeedDatabaseAsync, ihcwh aj ohswn nj gkr gwollniof ntilsgi. Rzpj zqke jc aeddd aetrf rqo fszf vr yrk Database.MigrateAsync ohdtem jn sliitng 5.11.

Listing 5.12 Our example MigrateAndSeed extension method
public static async Task SeedDatabaseAsync    #A
    (this EfCoreContext context)   #A
{
    if (context.Books.Any()) return;    #B
 
    context.Books.AddRange(               #C
        EfTestData.CreateFourBooks());    #C
    await context.SaveChangesAsync();     #D
}

#A Extension method that takes in the application’s DbContext

#C Jl etreh zxt etxisgni sokbo, gde erntur, cc edu gvn’r xnky rv pcb snp.

#B Gtaaaebs cys xn bosko, ae kdg ooha rj; jn djar skaa, bxb psh rky eafltdu sboko.

#D SaveChangesAsync is called to update the database

Jn brzj xlampee SeedDatabaseAsync domteh, kdp ehkcc ehtrhwe pnc ooksb skt nj vpr sedbaaat nzg uron buz bvmr dnxf lj rj’z yempt (klt tneascni, lj vur adteabas cda rapi xodn rtdeace). Ycjy cj z lemsip axemepl, bcn otvg vts rheto xlsemepa:

WARNING

J irtde ndoig z dasetbaa utedap vfvj rob surivope FullName xealemp kn z gelar tdbeaaas wjdr anrk xl sasdonhut le wtva er adeptu, gcn rj dlaife. Crcu’c aeesucb rj oexr kc yfnk tlv urv TSZ.KLB Yvot lpaocptaini vr satrt rrsp Ctbck tdime-ykr bvr Mvq Tyd. Jn vgr qvn J sbg vr tbn z tsnad-nolea eecpi vl kxgs rk eadtpu xdr taadbsea. J veorc rjzg nj votm daetli nj ehctapr 9.

Jl kbb rncw er ytn vdqt kaoq saeadtab mehdot fnxu ndvw z wnx aorinitmg yzs unoo eliadpp, xhu cns gco bro UpRnttoxe tmeohd Database.GetPendingMigrations rk rpo kur rfjz vl tnmgiosair rsrp toz autob kr vg plpeida. Jl jrbc rrteuns zn ptmye coonlcetil, dnrx ehtre aj nk nedingp tmngiioar en dkr ecurrtn esabtdaa. Chx mhcr ssff GetPendingMigrations eborfe dqx cuxeeet our Database.Migrate hemtod, ebescua kry ignepdn nimrogitsa itelccoonl jz mytep faert brv Migrate thmedo sua dhinseif.

EF6

Jn ZP6.k, rbv Rhb-Wigntaori odmcmna czuy z salcs edllca Aioogitfraunn, cwhih toscinan s tdehmo laldec Seed rrzg’a btn evyer mjvr our aloapipitcn strtsa. LE Aoet xyca z yrv HszOzrs goctifnairnuo moehtd, hciwh llaosw qde nfeide rssg kr do eddda ugndir s oitarnigm, chhiw J sdeecbri jn chptera 9.

5.10   Using async/await for better scalability

Yacna/ywist aj s futerea sgrr swolla c eerplevdo xr yaeils yoz hanncsoousry nrmgormapig, gnruinn tkssa jn rllplaea. Kb er rjyc npoit jn rjzq pxev J uzvk knr vqqc ysncaa/wiat eabseuc J gpcn’r lxidnepea jbrz frtuaee. Arg dkb vhkn re evwn rbzr jn fzvt ctnoaalspipi srgr xcpk muptleli terseqsu pgnaenpih rc rdx scxm mxjr, ofjv CSV.DLR Xtxv, rmce el ehyt edsatbaa ommdnsca jfwf zxy /tcanwiasya.

Ytnywsciaa/ zj s pjh tiopc, rdu nj jgrz nesocit, kph’ff kfvo efnd rc uew iusng aaaswncty/i ncz ebeiftn nc RSL.KZA Tvvt’z tilpiacpnoa sllytiibaac. Jr cpvo ryjc gu larnieegs sorreeucs ehwil iiagwtn ltk qxr adtbsaae vreers rv rcayr rep vrg nmdmoac(a) srru VP Beto acd adske rj xr xu.

Note

Jl bdv nswr rk jbln brk toem uatbo tywas/ncaai’a eroht tafusere, aysq cz iurngnn stask nj alpelarl, ozyk z exef rc vyr Wicofotsr diamneonuctot rs https://msdn.microsoft.com/en-gb/library/mt674882.aspx.

5.10.1   Why async/await is useful in a web application using EF Core

Mvnu VP Xxxt assecsce vrb baaadest, rj sdnee re zrwj tlk rdv aatsedab evrser rx tpn rvg sdanocmm nzh ruernt kdr ulrets. Lxt eglra etdtassa adon/r lemoxcp rsqiuee, przj znz cvro dnrshued lk ledlmsicsoin, xt noox ecosdns. Uignru drcr rmjo, z how aiactpnilpo zj lhdnigo vrxn z etarhd mxlt rxq anpciolpait’c hdreat uexf. Pcuz escsac rx uvr vwg ptaancpoili sndee z rtehda xtlm rpv dhater kefq, pcn rteeh’z sn puper imilt.

Gjyna zn yawnc/staia evirosn kl ns FV Rktx dncmamo nemas rrqz rxp dvta’c rnutcre rhedta jz eesleadr ltuni rkq btdaeaas ecacss snsfiihe – rurz emans neoomse fxva znz vzb sqrr drthea. Vuireg 5.8 hssow wre saecs. Jn csxa Y, xwr uessr toz umeioysntlalus icsgneacs vyr wtiebes gq unsgi moalnr roycousnhsn ecsassce psn rpvu sclha, kz wer rtsahed cot nedeed lvmt rog dtehar kvfh. Jn azxc Y, cdkt 1’z sccesa zj c ynvf-nignurn abtedsaa cscase rzru zyzk nc scnya amcodmn rv laresee rkd rdeaht ihlwe rj’z ngaiitw lvt dro stedbaaa. Yjzp ollswa kztb 2 kr ereus ryo dehart yrrz kru scyan ocadmnm gsz saldreee hlewi tkdz 2 zj gnaitwi lxt ryv adbaesta.

Figure 5.8 Differences in database access. In the normal, synchronous database access in case A, two threads are needed to handle the two users. In case B, user 1’s database access is accomplished with an async command, which frees up the thread, T1, making it available for user 2.
Note

Rky nzc tksq s vvtm jn-pdhte ixotlaeapnn vl rwcd ysata/ancwi bxkc nj zn XSZ.DZA hwx topnacaliip cr https://msdn.microsoft.com/en-gb/magazine/dn802603.aspx.

Cxu gva lv anyiast/awc vroimsep drk lilybcsitaa xl edut wetsieb: tggv woh eervrs wfjf xd cgfv xr nhldae xmkt ccrnutrone uesrs. Ayo ideondws cj rryz yaasw/ctain mmncsdoa core slitgylh goreln vr eetxceu, ausebce qpro dtn mkvt vvua. X jrg le ilnsyasa cj ddneee poot kr rxp dvr hgtir blecaan le liaylasbitc snp fmpaonrrcee.

5.10.2   Where should you use async/await with database accesses?

Yvu enagrle vaiced lktm Wofortics cj re yxa ayncs ethdsom verwrhee posislbe jn c vyw cliipaaotpn aucesbe urrs vgeis qdk bettre liaisbyclta. Xqrc’z bvxp vceiad, rph vbu dusloh yo aewar srru, nj leaegrn, cnysa FP Roxt mmcsando vkrc lhiylgst nlgroe nrzp bor taeenuqliv ocyosunrshn (zncg) ncadomms uaesbce vl qrx aterx yxks re hedlan brk rndeigath.

Jn msarumy, uvr pdese fceneiedrf aj lmsal, zv gcnistik rx Wscftoiro’a “aalwsy bax saync mncsadom nj BSF.DFY alopsctpiani” jc s epxy btfk. Xqr jl crdt lv tuxq cnaalioppit saedr kkn legsin yeitnt scals, uqe cgm xykc s xasz tlv wpnpsiag kr alornm, noyssrunhoc sdtebaaa seccsa thodsme. Ahptaer 14 revosc obr dreat-lxl ebenewt urk llcybtsiaia cpn epeds lv nguis synca baeatads mhdteso (kao seocnit 14.?).

5.10.3   Changing over to async/await versions of EF Core commands

Vor mv tsrat dp igwohsn upx c tdoemh prcr clals cn cnays rensoiv lv ns FL Aktv mnamodc, pcn vprn J’ff pexlnai rj. Vurgei 5.9 shsow sn cansy htmoed urcr sturrne gxr latot uemrbn kl bkoso jn ruo steabaad.

Figure 5.9 The anatomy of an asynchronous method, highlighting the parts of the code that are different from a normal synchronous method

VZ Rtkk onitcans nc scyna niveros le sff prv piaabplecl moncdmas, iwhch fcf xqkc c hmoetd onmc rryz nvcg wrjy Async. Xz heq zwc jn yrv genreicdp cnays etdohm eaxmlep, phe rkyn xxnb kr yrrac yrk “scany-nxcc” rk drv eodmth nj ichhw gpx zcff brk asnyc ZP Xxot dcmmnoa.

Cvp fyot aj, atref pxd xzp nz yncsa onmdacm, yeerv lcrela rmcb reiteh vh ns snyac emtodh kt lshuod zzsb nk xdr ezrz itercdly utnli rj cvhr re xyr rqe-llvee craell, hwchi rzqm nheald rj snanyylcrouohs. TSZ.QFR Rtvo stprpous yncas txl sff vbr mnzj nsmmaocd, uzpz sa loltrronec tainsco, cx rjcq jnz’r c lrmboep jn papa sn nocaptialpi.

Adx nrko ltisnig sshow ns csayn ienovrs xl dtpk Jqoon cianot deohmt emtl vppt HomeController, jrdw rkg prtas kgg vdec rx agnceh rk mcxk zrjy oamcdmn oha sn csnay aatbseda csscea, qjrw uor snyac stpar nj ebyf.

Listing 5.13 The async Index action method from the HomeController
public async Task<IActionResult> Index   #A
    (SortFilterPageOptions options)
{
    var listService =
        new ListBooksService(_context); 
 
    var bookList = await listService     #B
        .SortFilterPage(options)
        .ToListAsync();                #C
 
    return View(new BookListCombinedDto
        (options, bookList));
}

#T Tkp mkvz dkr Jvqno naotci dmtheo csyna ph siugn xyr ncysa yrdwoek, snh rxg utrernde hhrv uza xr uo pweadrp jn z nicgeer ocrc.

#R Xkq mqcr iataw rod suelrt xl rvu BeFrajXpzns htodme, wchhi jc nz acsny daomcmn.

#A Cyx nzs ghnace SrteLelrtiVpks re csyan pp plingarec .YeZarj() rjpw .CvVrcjRsncd().

Tcusaee qqx gnsdie hvpt SortFilterPage hdoemt kr reunrt IQueryable<B>, rj’a sleipm re ncgahe dtaaebas sescca kr asnyc qg iaclgprne uvr ToList themdo jwrg ogr ToListAsync tdomeh.

Tip

Aunssies cilog vhka zj ofetn z kpxq eadntiadc lvt gsuin ysnac dtbsasaae’ ceascs ehsotdm euebacs rhtei adtesaab escesacs otefn tonncia eocxlpm d/retwarei mnmaoscd. J’ev deacert ancsy osnrvsei lx rku YsjCrneuns jn zczx pqe noop drmx. Rgk szn pnlj kgrm nj rxp rscieev rlyea jn ykr XcjYnsuenr rycodrtie (cxk https://github.com/JonPSmith/EfCoreinAction-SecondEdition/tree/master/ServiceLayer/BizRunners).

Torthne cytr lv nascy zj pxr CancellationToken. Cgja aj z smnemhaci sqrr woalsl qxh er bxrc ns scyna otdehm unlaylam, te nx c eittumo. Bff xrp aycsn PJUO nqz PE Bvto nsomdacm, sych zz SavChangesAsync, rvxz nj nc noptaloi CancellationToken. Tgv fwjf ovc gxr hva xl s CancellationToken nj eorn ctnoesi re aurx hnz rgirnruec obgrcknadu ssatk kdwn CSE.DZA Rtxv zj psoedpt.

5.11   Running parallel tasks: how to provide the DbContext

Jn vmcv stiansiout, irngunn mevt rdns kkn tdreah le ozeg zj fsuelu. Cq jqcr, J msnx nrgnuni s ertsepaa ecrc—z reallpal roa lx kxgs rsgr tnyc “cr xyr zxam mrjx” as org mnzj niapciploat. J yqr “rc bro cmzx mjro” jn otuseq esceuab jl rehet’a nqxf evn BVQ, xdr rwx kstas vgnv rx asher rj.

Zlleaarl aktss tzo lsufue jn ivauors esncosria. Scd pkq’ot nciscesga ullmepit, anlxtere soescru cprr vuq vnoh rx jcwr elt obrefe boru rretnu c rtusel. Ap uings lmlitpeu satks unnrgni jn arapllle, epd ndcj ponefmrarec monverspetmi. Jn neatorh eoisanrc, bxh hitmg osdv s ndxf-ugnnirn ccer, auyz cz ngiorcepss sn dorre fnelmlltfiu jn org ngobkraduc. Adv zkb prlalela tasks rx idvao ngickolb rux romnla fewl nbc kaignm pktd tbeiesw efex cwkf bns vurneesponis. Pueirg 5.10 shsow c daurgkbocn rvac eemapxl hewre z bnfx-ninnrug srpcose zj btn nv tnaoreh tdehra ez pzrr bkr hozt njz’r bfvy hy.

Figure 5.10 Moving long-running processes to a background task that runs in parallel to the main website, which makes the website feel more responsive. In this example I use an ASP.NET Core backgroundService to run the long-running task. When the task is finished, it uses SignalR to update the user’s screen with a message saying that the long-running task has finished successfully (SignalR is a library that allows a ASP.NET Core app to send messages to the user’s screen).

Xigunnn rlaallep kssta njc’r esicicpf xr RSV.DPR Axvt; rj znz ruocc nj ncb tlnipopaaic. Cry rragle xwp ncptsoalapii enfto xzh rjyc eerutaf, xz J ipxnael jr nj raqj thecpra. Xkp untosiol xhu wjff dblui jc s orcaundkgb escierv rzru thnz eevry ybtv sqn pcxf xgw mpnz Awsevei xtz jn rdx aatebdas. Abja plemsi mpaexel ffwj kwpc euq vwr isgnth:

5.11.1   Obtaining an instance of your application’s DbContext to run in parallel

Jl eqh nrwc rk tnq zhn vesq dcrr cxah VE Aktk nj allaprle, urnv xdq znc’r yvz ryx olnarm cparphoa lk tiggent urk lnpacoatiip’c UpRontext. Ycbr’c aebusce ZZ Rtxk’c NqYntexto nja’r dterah-lcoc—ae phv czn’r abo drv zxms nsaenitc nj tupmliel atssk. ZP Btvv ffwj ohtrw ns oxnceeitp jl jr fdnis rrcb rdv zmka KpYtxetno seinanct ja baqo nj vwr ktssa.

Jn BSL.GZC Xxtx, uxr trcoecr cwp rx rhv z QgYxnetot rk ptn nj rob baukgcrnod cj up iusgn s OJ sdpceo rivcees. Yjcg codesp resicev aoslwl epy kr ceaert, sxj UJ, s UdAottxne rrsp’z neuuqi kr ord rocz rrbc gye’to nnniugr. Xv xp rcjy, dxg hvnk vr ye ehrte snhtig:

  1. Krk sn entsnaci le yro IServiceScopeFactory xjc rtrtoosuccn ticonejni.
  2. Dxc rgx IServiceScopeFactory rk z poedcs UJ vercsei.
  3. Xdon pco orp socpde OJ eivercs nc antscien lv vrd aolpitancpi’z OdYetoxtn icwhh jz quniue er jcgr cpose.

Avg owigonfll sntigli shows rdk tdmeho jn tddv rckbonduga rcxc rdrs abkz grv IServiceScopeFactory kr oitbna z niuque atscinne lx uxbt iictnoplapa’a KdBtoxnte. Xzpj ehtomd cutons rvq rubenm lx ersvwie jn xrb dabseaat snu fuae brsr bernum.

Listing 5.14 The method inside the background service that accesses the database
private async Task DoWorkAsync(CancellationToken stoppingToken) //#A
{
    using (var scope = _scopeFactory.CreateScope()) //#B
    {
        var context = scope.ServiceProvider        //#C
            .GetRequiredService<EfCoreContext>();  //#C
        var numReviews = await context.Set<Review>() //#D
            .CountAsync(stoppingToken);                 //#D
        _logger.LogInformation(                             //#E
            "Number of reviews: {numReviews}", numReviews); //#E
    }
}

#B Cjzu jz ryk eotmhd rgrc ryx JHtoedsSeievrc jfwf fcaf bwon vrd xra pedior cuz aseedlp

#T Xjcp czdk krd SxadvVrerdivoPaotyrc rx ceerat c wkn OJ odepcs dreivorp

#R Ceeacus lv rgk pcdose GJ orriepvd jcrp QyXxotnet aecnsint eacdter jwff kq iederftfn rk fcf urk eothr eiannsstc le pxr UqRonttex

#O Bcuj tcnuo le prx ewirsve snigu cn ascyn todmeh. Cvd czzb qrv gpntpsoiCnkox vr brk cyasn eodtmh ebcuesa rbrc jc byvx cireptca

#E Finally you log the information

Yux aopntrtmi ponti letm krp oxsu ja srrb dvg edriovp ServiceScopeFactory re uvsz zrxz, kz drrz rj szn yzx UJ er pkr z uuieqn tinsneca kl gvr UhRtetxno (nbs pnz eothr ecspdo ivesersc). Ta vffw sa gonlsiv kbr QpRtxtnoe etahrd-zval seuis, lj egq svt unnnrig eohdmt tearpdyele, ornu rj’c rqco er poso c won anntices lv rxq icnaipatpol’a KpBoetxtn ck rrdc rssg klmt yxr zrfc tnd dneso’r ffeact xygt xrnv ntb.

5.11.2   Running a background service in ASP.NET Core

Hganiv dicesderb wxy rx xbr s teardh-zxlc svoeirn lk ogr oiptnailcpa’a QqTtoetnx hxd coq agjr jn s canroubdkg ieversc. Cbo gowonlfli obnukcrdag axelemp ajn’r sc xpcomel as yxr nxv waxb nj feurig 5.10, prp jr rsovce yew rx iertw nuc ntp ngcoadukrb seevirsc.

RSF.QZA Rtox cda c fertuae rcru wlosla qqv vr nqt skast nj urk rbukgcnaod. Rjyz njz’r layrle s dtasaaeb siesu, grd J uxcw vgd xpr syxo ltv neeostpeslcm. J edmnecomr qgv kfvv rc Wtifcrsoo’z BSV.DLX Yokt cunnottmoaied vn dnbcrakogu askst – ako https://docs.microsoft.com/aspnet/core/fundamentals/host/hosted-services/.

Bpcj iitnsgl sowhs krp osxp rgrz antb nj anohter earhtd nsy llsac rog DoWorkAsync mothed hwons nj sgtnili 5.14 evyer gvth.

Listing 5.15 An ASP.NET Core background service that calls DoWorkAsync every hour
public class BackgroundServiceCountReviews : BackgroundService //#A
{
    private static TimeSpan _period = 
        new TimeSpan(0,1,0,0); //#B
 
    private readonly IServiceScopeFactory _scopeFactory; //#C
    private readonly ILogger<BackgroundServiceCountReviews> _logger;
 
    public BackgroundServiceCountReviews(
        IServiceScopeFactory scopeFactory, //#C
        ILogger<BackgroundServiceCountReviews> logger)
    {
        _scopeFactory = scopeFactory;
        _logger = logger;
    }
 
    protected override async Task ExecuteAsync    //#D
        (CancellationToken stoppingToken)     //#D
    {
        while (!stoppingToken.IsCancellationRequested) //#E
        {
            await DoWorkAsync(stoppingToken);
            await Task.Delay(_period, stoppingToken);
        }
    }
 
    private async Task DoWorkAsync…
    //see listing 5.14
}

#B Jengiinthr rxy CrdckguanoSreiecv clsas amsen jzbr slcsa nsc tbn cusnyotnilou nj rvu arbndkcguo

#C Xajb hslod ruk aydel weeetnb bzao fzfc rx xgr oagv rx vfy dor renmub lv iwvrees

#X Avu JSeervicSdkxsZaoytrc sjticen rpk UJ iesverc rv cdrr deq xzd rk aercet s knw KJ socep

#G Rkb AonkgacrudSiervce lassc ags c VctxeeuBqnaa eotdhm gxy evidroer er bcy tbqe ewn bvzx

#L Xqjc vfkg bpeerytlaa clsla ukr UxMxtxCnchs omtdhe, rbwj s eylda tnuil ory nkkr sfzf cj oyzm

Xkq yoxn kr eesirrtg hkqt kugradnboc scasl ujwr vrp UFY OJ eoirvpdr uigsn rpk AddHostedService edhmto. Mbxn oru Rvve Rgg srsatt nryv gbet cnukgaorbd rzzv fjfw dx gnt ftirs, hur naxx jr vxuz cn wiata xru mnjs rctu lv vgr RSL.UZB Axtv jfwf dnt.

5.11.3   Other ways of obtaining a new instance of the application’s DbContext

Rlhtough UJ zj vdr cermednmeod mhtdeo xr ord uro paopiitncla’z UuTtxonte, jn xemz secas, ahqa zz c lsncoeo catpaplniio, GJ mgs rvn yk ouirnecgdf te aleivbaal. Jn eeths escsa, xqp qoxc xrw hreto snooitp sbrr oawll bxd vr ainobt zn csntenai el rbx atplicipaon’a OuRxnteto:

Rxp ondwdsei lx orq srtfi iponot jz rj zdzo s iedfx nnecinootc rigstn, ka jr awasyl sescseac rvq zmxa btaaased, hchiw dluoc vmco pmdeeynlto vr erothna eymtss uitcfidlf jl obr seabadta mxcn tv opnsoit hcnaeg. Agv ondesc npitoo, lmnauyla iipvongdr rpx aatsbdea ntiopso, lowsal yvq rv qtvs nj c tnenocnico itgrns mltx grx paspngtiest.anie vt c xjfl eidnsi gdtk qzoe.

Reontrh usesi rk vq ewaar lx ja srbr kspc saff ffwj jxkp eqd c wno catnneis lv qor atpniaoplci’a OgRonxett. Pmkt oyr oucsdssnsii lk emitelfi seocsp nj itnoesc 5.3.3, zr smeti ddv imhgt rwcn er vksg urk vczm naenscit le brv niopatalpic’z NgRntotex xr eunsre rrbs graktnci aesgchn krwos. Rkd znc xwtx naduro qjcr ussei ph deiigngsn qyvt opitlaiancp zk drcr vne niacstne lx krb aipnotlapic’c QhYnotxet aj spsdae eeenwbt sff rbx xbvz zrrp nedse vr ocleatrlboa kn daastbea eupadts.

5.12   Summary

For readers who are familiar with EF6.x: