Marahil ang isang bihirang panayam sa ASP.NET ay hindi kumpleto nang walang tanong tungkol sa ikot ng buhay ng isang pahina sa ASP.NET Web Forms (mula rito ay tinutukoy bilang ASP.NET para sa maikli). Subukan nating maunawaan ang isyung ito. Hinati ko sa dalawa ang topic. Sa artikulong ito susuriin natin ang mga yugto ikot ng buhay mga pahina sa ASP.NET.
Pangkalahatang Plano ng Lifecycle ng isang ASP.NET Page- pagtanggap at pagproseso ng kahilingan sa pahina ng IIS web server
- karagdagang pagpasa sa kahilingan sa ASP.NET runtime
runtime:
* nilo-load ang klase ng tinatawag na page * itinatakda ang mga katangian ng klase ng page * bubuo ng puno ng mga elemento * pinupunan ang mga katangian ng Request and Response * tinatawag ang ```IHttpHandler.ProcessRequest``` method
Mayroong 8 pangunahing yugto. Ito ay malinaw na ipinakita ng sumusunod na diagram
| Pahina ng kahilingan | Ang kahilingan sa pahina ay nangyayari bago magsimula ang ikot ng buhay ng pahina. Gumagawa ng kahilingan ang user, at tinutukoy ng runtime ng ASP.NET kung dapat i-compile ang page at simulan ang lifecycle nito, o kung maaari itong maghatid ng naka-cache na page bilang tugon nang hindi ine-execute ang page. |
| Simulan ang pagproseso | Sa yugtong ito, ang mga katangian ng Tugon at Kahilingan at ang pag-aari ng UIculture ay nakatakda. Tinutukoy din ng hakbang na ito kung hiniling ang page na ito bilang resulta ng isang postback at itinatakda ang IsPostBack property nang naaayon. |
| Pagsisimula ng pahina | Sa oras na masimulan ang page, lahat ng child user mga kontrol Nagawa na at naitakda na ang UniqueID property. Sa oras na ito, inilalapat ang mga tema sa pahina. Kung tinawag ang pahina bilang resulta ng isang postback, ang data na ipinadala sa server ay hindi pa nai-load sa mga katangian ng mga kontrol sa puntong ito. | Kung ang pahina ay tinawag bilang isang resulta ng isang postback, pagkatapos ay sa yugtong ito ang mga katangian ng mga kontrol ay itinakda batay sa impormasyon ng estado (ViewState at ControlState). |
| Pagpapatunay | Ang Validate() method ay tinatawag para sa lahat ng validators sa page. |
| Pagproseso ng postback | Ang mga tagapangasiwa ng kaganapan ay tinatawag kung may naganap na postback. |
| Nagre-render | Ang impormasyon ng estado ay nai-save, pagkatapos ay tinatawag ng klase ng pahina ang mga naaangkop na pamamaraan elemento ng bata mga kontrol upang bumuo ng isang representasyon ng HTML at ipasa ito sa Response.OutputStream. |
| Nagbabawas ng karga | Nagaganap ang pag-unload pagkatapos malikha ang representasyon ng HTML para sa buong pahina. |
Ipinapakilala ang ASP.NET 2.0 Panimula
Sa bawat oras na bumuo ka ng isang proyekto at lumikha ng isang Web application, ginagamit mo sa pamamagitan ng iba't ibang paraan upang lumikha ng isang arkitektura ng application, i-edit ang code at i-publish ang mga resulta ng iyong trabaho sa isang Web server. Kasabay nito, para sa end user, ang isang Web application ng anumang kumplikado ay nananatiling isang hanay ng mga HTML na pahina, na bawat isa ay may sariling natatanging URL. Sa pangkalahatan, walang pakialam ang user kung saang platform o teknolohiya nilikha ang application. Ang gumagamit ay may layunin na nais niyang makamit at unibersal na lunas, halos lahat ng Web browser na ginagamit niya. Ito ay isang malaking bentahe ng mga aplikasyon para sa Internet kumpara sa mga aplikasyon para sa mga desktop system– ang pagkakaroon ng karaniwang tinatanggap na “wika ng komunikasyon,” HTML code. Upang mag-deploy ng isang Web application, sapat na upang mai-install ito sa server, pagkatapos kung saan ang application ay maaaring ma-access ng sinumang kliyente na may naka-install na Web browser. Sa kasamaang palad, mayroon ding malinaw na problema dito Pagproseso ng HTML code mula sa mga browser mula sa iba't ibang mga tagagawa.
Ang gawain ng developer ay lumikha ng isang application na bumubuo ng HTML code na pinakamainam para sa karamihan ng mga browser na ginagamit ng end user. Ang bawat teknolohiyang ginamit upang lumikha ng isang Web application ay nagbibigay-daan sa iyo upang makabuo ng HTML code, kaya, sa huli, ang pagpili ng teknolohiya kung saan upang lumikha ng isang Web application ay nakasalalay lamang sa kaginhawahan at bilis ng pag-unlad at kadalian ng pag-deploy at suporta ng panghuling produkto.
Ang bentahe ng teknolohiya ng ASP.NET sa iba ay ang mataas na antas ng abstraction na binuo sa itaas karaniwang HTML code: ang paggamit ng isang object-oriented paradigm, suporta para sa ilang mga programming language, ang pagkakaroon ng isang unibersal na pundasyon na naglalaman ng libu-libong solusyon na handa nang gamitin sa mga proyekto - ang Microsoft .NET Framework.
Bukod dito, upang bumuo ng isang application, anumang development environment o kahit isang text editor ay maaaring gamitin, na nagpapahintulot sa iyo na lumikha, mag-edit at mag-save mga text file. Kung nais ng developer na samantalahin ang buong kapangyarihan ng Microsoft. NET Framework at ASP.NET at, sa parehong oras, gumugol ng kaunting pagsisikap hangga't maaari, pagkatapos ay kailangan niyang gumamit ng kapaligiran sa pag-unlad na angkop para sa kanyang mga gawain. Isa sa pinaka epektibong paraan paggawa ng ASP.NET Web application ay Microsoft Visual Studio. Ang suporta ng ASP.NET 2.0 ay kasama sa Visual Studio 2005.
Ang artikulong ito ay maikling ipinakilala ang karamihan sa mga bagong feature sa ASP.NET 2.0, ang bagong bersyon ng ASP.NET framework.
Paggamit ng maramihang mga programming language Sinusuportahan ng Microsoft .NET Framework at Visual Studio 2005 ang ilang mga programming language gaya ng Visual Basic, Visual C#, Visual C++, Visual J#. Dahil ang mga wikang ito ay gumagamit ng isang karaniwang CLR (Common Language Runtime) at sumusunod karaniwang pamantayan
CLS (Common Language Specification), pagkatapos ay isang pagpupulong na ginawa gamit ang isa sa mga .NET na wika ay maaaring gamitin sa isang proyekto na binuo sa ibang programming language, tulad ng kung ang pagpupulong na ito at ang application ay nakasulat sa parehong wika. Sa paglabas ng Microsoft .NET Framework 2.0 naging posible na gamitin sa parehong proyekto iba't ibang wika
programming. Ang katotohanan na ang isang ASP.NET Web application ay maaaring isulat sa ilang mga programming language ay napaka-maginhawa kung mayroon nang mga napatunayang solusyon sa isa sa mga wika, at ang proyekto ay isinulat gamit ang ibang wika, o kung ang koponan ay may mga developer na gumagamit ng iba't ibang mga programming language. Maaari mong basahin ang tungkol sa kung paano gumamit ng iba't ibang mga wika sa isang proyekto sa artikulong ito.
Teknolohiya sa pagbabahagi ng code
Ang core ng lahat ng bagay sa isang Web application ay ang page. Ang gumagamit, gamit ang isang browser, ay gumagalaw sa pagitan ng mga pahina, pana-panahong bumabalik sa mga dating natingnang pahina, naglalagay ng ilang data sa mga HTML na form at nakakakuha ng ilang resulta. Sa ASP.NET, ang isang pahina ay kadalasang isang Web form na naglalaman ng iba't ibang mga kontrol na tumutugon sa mga kaganapang nabuo ng user. Binibigyang-daan ka ng ASP.NET 1.x na paghiwalayin ang logic code mula sa presentation code, iyon ay, ilagay ang page program logic code sa isang .cs o .vb file, hiwalay sa page code mismo, na inilagay sa isang .aspx file. Ang teknolohiyang ito ay tinatawag na Code-Behind. Kaya, ang disenyo ng pahina ay maaaring baguhin nang hindi naaapektuhan ang code ng pahina, na nagbibigay-daan sa iyo na ibahagi ang responsibilidad para sa
Ngunit upang suportahan ang pag-edit sa gamit ang Microsoft Ang Visual Studio .NET sa isang pahina ng ASP.NET ay dapat tukuyin ang klase na naaayon sa pahinang ito at ang file kung saan matatagpuan ang code para sa klase na ito. Upang gawin ito, ang direktiba ng Pahina ay kino-convert gamit ang Codebenind at Inherits na mga keyword.
Gumagamit ang ASP.NET 2.0 ng ibang mekanismo ng paghihiwalay ng code. Sa direktiba ng Pahina, dapat kang gumamit ng iba pang mga keyword: CodeFile at Inherits.
Sa kasong ito, ang code ng page program logic class ay ilalagay sa file na tinukoy sa CodeFile attribute. Dapat tandaan na ang Visual Studio 2005 ay gumagamit ng mga bahagyang klase.
Pampublikong partial class Default: System.Web.UI.Page ( protected void Page_Load(object sender, EventArgs e) ( ) )
Samakatuwid, ang isang developer ay maaaring maglagay ng code ng isang klase sa ilang mga file, ngunit ang naturang dispersal ng code ay ginagawang napakalaki ng application at mahirap mapanatili at bumuo.
Ang modelong Code-Behind na ginamit sa Visual Studio 2003 ay may ilang napakalaking pagkukulang. Una sa lahat, gamit ang Visual Studio, dapat i-compile ng isang developer ang proyekto bago i-publish dahil ang ASP.NET ay nag-compile ng mga pahina lamang kung ang Src attribute ay tinukoy, na hindi ginagamit ng Visual Studio. Bukod dito, dahil nakita ng kapaligiran ng ASP.NET ang isang pagbabago sa petsa ng paglikha ng pagpupulong, pagkatapos ng bawat pagpapalit ng lumang pagpupulong sa direktoryo ng bin, ang domain ng aplikasyon ay na-restart, na nagreresulta sa isang pansamantalang "paghina" sa application.
Gumagamit ang Visual Studio 2005 ng bago mga keyword, suportado ng ASP.NET 2.0 runtime, at ang runtime naman ay gumagamit bagong teknolohiya compilation ng mga pahina. Pinapayagan ka nitong malutas ang problema ng pagpapalit ng pagpupulong ng isang mas bago.
Sa kabila nito, pinapayagan ka pa rin ng Visual Studio 2005 na lumayo sa paghahati ng code at ilagay ang logic code ng program sa mismong file ng pahina, at gamitin ang . Bukod dito, bilang default, ang Visual Studio ay lumilikha ng mga pahina nang walang paghahati ng code.
Ihambing natin ang mga pagkilos na ginagawa ng ASP.NET 2.0 at ASP.NET 1.0 kapag humiling ang isang user ng file na may extension na .aspx. Sa ASP.NET 1.x, pinapa-parse ng runtime ang direktiba Mga pahina ng pahina, naghahanap ng kaukulang klase sa pagpupulong ng aplikasyon, pagkatapos ay batay sa code ng pahina, isang klase ang nilikha na hinango mula sa klase ng logic ng page program. Kung ang pagpupulong ay nawawala, ang program logic file na tinukoy sa Src attribute ng Page directive ay hahanapin. Kung ang file ay natagpuan, ang pagpupulong ay pinagsama-sama kung hindi, ASP.NET throws ng isang exception.
Sa ASP.NET 2.0, pinapa-parse din ng runtime ang mga direktiba ng Pahina, naghahanap ng isang pagpupulong na tumutugma sa klase ng logic ng page, at pagkatapos ay gagawa ng klase ng page. Hindi tulad ng ASP.NET 1.x, ang parent class para sa page class ay System.Web.UI.Page, dahil ang dynamic na klase na nilikha ay ang page class mismo (gamit ang partial classes para sa page class at application logic class) , at hindi isang inapo ng lohika ng klase ng aplikasyon. Samakatuwid, kung sa ASP.NET 1.x ang klase ng Web form ay maaaring tawaging kapareho ng mismong Web form.
... public class frmDefault: System.Web.UI.Page ( protected void Page_Load(object sender, EventArgs e) ( ) )
Sa ASP.NET 2.0, hindi ito pinapayagan dahil ang System.Web.UI.Form control ay miyembro ng isang klase.
Ang pangunahing bentahe ng ASP.NET ay kung walang kinakailangang pagpupulong upang patakbuhin ang pahina, ang logic file lamang ng pahina ang pinagsama-sama, nang hindi muling kino-compile ang buong pagpupulong. Dahil mayroong dynamic na compilation, kinakailangang magbigay ng kakayahang gumawa ng code na karaniwan sa lahat ng page ng application. Para sa layuning ito, sa ASP.NET 2.0 mayroong mga espesyal na direktoryo na mga direktoryo ng bata ng direktoryo ng ugat ng application, isa na rito ang App_Code, na ginagamit upang mag-imbak ng mga file na naglalaman ng pangkalahatang code
para sa lahat ng pahina. Kapag isinagawa ang dynamic na compilation, ang code mula sa direktoryo ng App_Code ay pinagsama-sama at ginawang magagamit sa lahat ng mga pahina ng Web application. Kasabay nito, sinusuportahan ng Visual Studio 2005 ang code na matatagpuan sa direktoryo ng App_Code, kaya gumagana ang syntax highlighting at IntelliSense.
Kung kailangan mong i-compile ang proyekto nang maaga, bago ito i-deploy sa server sa ASP.NET 2.0, posibleng ganap o bahagyang i-precompile ang Web application. Maaari kang magbasa nang higit pa tungkol sa precompilation sa artikulong ito.
Mga pagbabago sa istruktura ng proyekto ng Visual StudioHindi na naglalaman ang Visual Studio 2005 ng mga .csproj o .vbproj na file na dati nang ginawa para sa bawat uri ng proyekto ng ASP.NET. Sa halip na mga file ng proyekto, ang Visual Studio ay gumagamit ng istraktura ng direktoryo, kaya upang isama ang isang umiiral na file sa isang proyekto, kopyahin lamang ito sa direktoryo ng proyekto.
Dapat tandaan na kung ang isang file o direktoryo ay tinanggal mula sa puno ng file ng proyekto sa window ng Solution Explorer, ang file o direktoryo ay pisikal na tinanggal mula sa file system.ASP.NET 2.0 Page @Page Directive
Upang magdala ng mga bagong feature sa ASP.NET 2.0, kinakailangan na gumawa ng mga pagbabago at pagdaragdag sa klase ng Page. Dahil ang mga katangian ng direktiba ng Pahina ay ginagamit upang itakda ang mga katangian ng pahina sa oras ng disenyo, ang mga bagong katangian na lumitaw upang ipatupad ang mga mekanismo ng pag-personalize, mga template ng disenyo, layout at asynchronous na operasyon ng mga pahina ay tatalakayin dito. Higit pang impormasyon tungkol sa pagtatalaga ng mga bagong katangian ay matatagpuan sa bahagi ng artikulong nakatuon sa mga bagong katangian at pamamaraan ng klase ng Pahina.
Async
Isinasaad kung alin sa IHttpHandler o IHttpAsyncHandler ang nag-interface ng page class na ipinapatupad.
Pagkatapos itakda ang attribute na ito sa true, ang dynamic na nabuong klase ng page ay magpapatupad ng IHttpAsyncHandler, kung hindi, ang klase ay magpapatupad ng IHttpHandler. Kung ang klase ng page ay nagpapatupad ng IHttpAsyncHandler, kung gayon ang page code ay maaaring isagawa nang asynchronously hanggang sa isang bagong kaganapan ang mangyari sa PreRender page lifecycle, kung saan ang HTML code ay naka-synchronize at inihanda para sa pagpapadala sa client browser.
AsyncTimeOut
Binibigyang-daan kang magtakda ng limitasyon sa oras para sa pagsasagawa ng mga asynchronous na operasyon. Bilang default, ang setting na ito ay 45 segundo.
Kultura
Itinatakda ang Culture set na ginamit para sa page.
Paganahin angTheming
Binibigyang-daan kang paganahin o huwag paganahin ang suporta sa tema. Pinagana bilang default.
MasterPageFile
Tinutukoy ang landas patungo sa template na gagamitin upang bumuo ng code para sa pahinang ito. StyleSheetTheme disenyo (sa Theme attribute o sa web.confg file). Sa ganitong paraan, maaari kang magtakda ng pangkalahatang tema para sa buong site, at gamitin ang katangian ng StyleSheetTheme upang gumawa ng ilang pagbabago sa pangkalahatang disenyo ng pahina at/o ilan sa mga kontrol na nilalaman ng pahina.
Tema
Tinutukoy ang pangalan ng tema na gagamitin sa istilo ng code para sa pahinang ito.
UI Kultura
Itinatakda ang hanay ng kultura (Kultura) na ginagamit para sa user interface mga pahina.
Ikot ng buhay ng pahinaAng siklo ng buhay ng isang pahina ng ASP.NET ay nagsisimula sa pagtanggap at pagproseso ng IIS Web server ng isang kahilingan para sa pahinang iyon at pagpasa ng kahilingang iyon sa runtime ng ASP.NET. Kapag natanggap ang isang kahilingan, nilo-load ng runtime ang klase ng page na tinatawag, nagtatakda ng mga katangian ng klase ng page, bubuo ng tree ng mga elemento, nilalagay ang mga katangian ng Request at Response, at tinawag ang IHttpHandler.ProcessRequest na paraan pagkatapos ay susuriin ng runtime kung paano tinawag ang page at kung tinawag ang page sa pamamagitan ng pagpasa ng data mula sa isa pang page, na tatalakayin sa ibang pagkakataon, itinatakda ng runtime ang property ng PreviousPage.
Nararapat ding tandaan na bilang karagdagan sa mga yugto ng pagpapatupad ng pahina na tinalakay sa ibaba, mayroon ding mga yugto sa antas ng aplikasyon na hindi partikular sa pahina. Ang mga detalye tungkol sa mga yugto ng pagpapatupad ng aplikasyon ay nakasulat sa artikulong ito.
| Pahina ng kahilingan | Ang isang kahilingan sa pahina ay ginawa sa simula ng ikot ng buhay ng pahina. Kapag humiling ang isang user, tinutukoy ng runtime ng ASP.NET kung dapat na i-compile ang page at simulan ang lifecycle nito, o kung maaari itong maghatid ng naka-cache na page bilang tugon, kaya hindi ipapatupad ang page. |
| Simula ng ikot ng buhay | Sa yugtong ito, ang mga katangian ng Tugon at Kahilingan at ang mga katangian ng UIculture ay nakatakda. Gayundin, sa yugtong ito, natutukoy kung ang pahinang ito ay hiniling bilang resulta ng isang postback (pagpapadala ng data sa server) at ang IsPostBack property ay itinakda nang naaayon. |
| Pagsisimula ng pahina | Sa oras na masimulan ang page, lahat ng child user control ay nagawa na at naitakda na ang UniqueID property. Kasabay nito, inilalapat ang mga tema sa pahina. Kung ang pahina ay tinawag bilang isang resulta ng isang postback, ang data na ipinadala sa server ay hindi pa nai-load sa mga katangian ng mga kontrol sa yugtong ito. | Kung ang pahina ay tinawag bilang isang resulta ng isang postback, pagkatapos ay sa yugtong ito ang mga katangian ng mga kontrol ay itinakda batay sa impormasyon ng estado (ViewState at ControlState). |
| Pagpapatunay | Ang Validate() method ay tinatawag para sa lahat ng validators sa page. |
| Pagproseso ng postback | Ang mga tagapangasiwa ng kaganapan ay tinatawag (sa kondisyon na ang postback ay nangyari). |
| Nagre-render | Ang impormasyon ng estado ay nai-save, pagkatapos ay tinawag ng klase ng pahina ang mga naaangkop na pamamaraan ng mga kontrol ng bata upang bumuo ng isang representasyon ng HTML at ipasa ito sa Response.OutputStream. |
| Nagbabawas ng karga | Nagaganap ang pag-unload pagkatapos malikha ang representasyon ng HTML para sa buong pahina. |
Habang umuusad ang mga yugto ng ikot ng buhay, nangyayari ang mga kaganapan na, sa pamamagitan ng pag-subscribe, pinapayagan ang developer na isagawa ang kanyang sariling code. Ito ay nagkakahalaga ng pagbanggit sa AutoEventWireup attribute ng @Page directive: kung ang attribute na ito ay nakatakda sa true (ang default na value), ang mga paraan ng page class, na pinangalanang Page_EventName, ay awtomatikong magiging mga tagapangasiwa para sa kaukulang page lifecycle na mga kaganapan.
Upang masubaybayan ang siklo ng buhay ng isang page at ang pagkakasunud-sunod ng mga pangyayari, maaari mong itakda ang Trace attribute ng @Page directive sa true at ang TraceMode attribute sa "SortByTime". Pagkatapos ay sa seksyon ng Trace Information maaari kang makahanap ng isang listahan ng mga kaganapan na naganap ( column ng Mensahe). Halimbawa:
| aspx.page | Simulan ang PreInit | ||
| aspx.page | Tapusin ang PreInit | 0.0364973314167865 | 0.036497 |
| aspx.page | Simulan ang Init | 0.0379050459346291 | 0.001408 |
| aspx.page | Tapusin ang Init | 0.047693704143491 | 0.009789 |
| aspx.page | Simulan ang InitComplete | 0.0477864508468221 | 0.000093 |
| aspx.page | Tapusin ang InitComplete | 0.0481875670270608 | 0.000401 |
| aspx.page | Simulan ang PreLoad | 0.0489879732516718 | 0.000800 |
| aspx.page | Tapusin ang PreLoad | 0.0494462283607275 | 0.000458 |
| aspx.page | Simulan ang Pag-load | 0.0494924892194238 | 0.000046 |
| aspx.page | Tapusin ang Pag-load | 0.0553441897381414 | 0.005852 |
| aspx.page | Simulan ang LoadComplete | 0.0554711043059809 | 0.000127 |
| aspx.page | Tapusin ang Pag-load | 0.055942153615399 | 0.000471 |
| aspx.page | Simulan ang PreRender | 0.0561455634022874 | 0.000203 |
| aspx.page | Tapusin ang PreRender | 0.0618604874695332 | 0.005715 |
| aspx.page | Simulan ang PreRenderComplete | 0.06269871008062 | 0.000838 |
| aspx.page | Tapusin ang PreRenderComplete | 0.0633259746265858 | 0.000627 |
| aspx.page | Simulan ang SaveState | 0.080360541216174 | 0.017035 |
| aspx.page | Tapusin ang SaveState | 0.213795377788888 | 0.133435 |
| aspx.page | Simulan ang SaveStateComplete | 0.213911298043872 | 0.000116 |
| aspx.page | Tapusin ang SaveStateComplete | 0.214385763389788 | 0.000474 |
| aspx.page | Simulan ang Pag-render | 0.214440078745078 | 0.000054 |
| aspx.page | Tapusin ang Pag-render | 0.315044337228923 | 0.100604 |
Sa lahat ng mga kaganapan sa lifecycle ng page, ang isang developer ay maaari lamang mag-subscribe sa lima, bilang karagdagan sa mga kaganapan sa pagkontrol ng bata. Ang mga kaganapang ito ay: PreInit, Init, Load, PreRender, Unload.
| Paggamit ng Kaganapan |
PreInit Ito ay nagkakahalaga ng pagpuna na sa yugtong ito, kung ang pahina ay tinawag bilang isang resulta ng isang postback, ang mga katangian ng mga kontrol ay hindi pa naitakda. Kung independiyenteng itinatakda ng developer ang mga property sa yugtong ito, sa susunod itakda ang halaga napapailalim sa pagbabago. |
| Init | Sa puntong ito, mababasa o masimulan ng developer ang mga katangian ng mga kontrol. |
| Magkarga | Sa puntong ito, maaaring basahin o baguhin ng developer ang mga katangian ng mga kontrol. |
| PreRender | Huling pagkakataon gumawa ng mga pagbabago sa hitsura ng pahina. |
| Magdiskarga | Pagpapalaya sa mga nasasakupang mapagkukunan (pagsasara ng mga bukas na koneksyon sa database, pagsasara ng mga file, atbp.) Mahalaga na sa yugtong ito ang HTML na representasyon ng pahina ay nagawa na at ang pagtatangkang gumawa ng anumang mga pagbabago (halimbawa, sa pamamagitan ng pagtawag sa Response.Write() na paraan) ay magreresulta sa isang pagbubukod. |
Upang pamahalaan ang mga kaganapang nakalista sa nakaraang seksyon at makakuha ng impormasyon tungkol sa mga resulta ng kanilang pagpapatupad, ang Page object sa ASP.NET 2.0 ay may mga sumusunod na bagong pamamaraan at katangian. Detalyadong impormasyon Ang mga bagay at pag-aari na nakalista sa ibaba at ang kanilang mga gamit ay tatalakayin pa sa susunod na seksyon ng artikulong ito.
Kultura
Isang property na nagbibigay-daan sa iyong i-disable ang suporta para sa mga tema sa isang page kung hindi ninanais ang paggamit ng isang tema.
GetValidators
Isang paraan na nagbabalik ng koleksyon ng mga validator para sa page na ito.
Header
Isang reference sa isang HtmlHead object na nagbibigay-daan sa iyong kontrolin ang nilalaman ng HTML na seksyon ng page, sa kondisyon na ang head element ay may runat="server" attribute set.
IsAsync
Isang property na nagsasaad kung paano pinoproseso ang page - synchronous o asynchronous.
IsCrossPagePostBack
Isang ari-arian na nagbibigay-daan sa iyong matukoy kung pahinang ito hiniling bilang tugon sa data na ipinadala mula sa ibang pahina.
Paganahin angTheming
Isang property na naglalaman ng page template na file name.
MaxPageStateFieldLength
Mga pag-install maximum na laki isang field na nag-iimbak ng estado, sa mga byte. Kung ang property na ito ay nakatakda sa isang numerong mas mababa sa laki ng impormasyon ng estado na kailangang i-store, maraming nakatagong field ang gagawin, bawat isa ay walang higit na data kaysa sa MaxPageStateFieldLength value .
PageAdapter
Ang property ay nagbabalik ng isang PageAdapter object na kumokontrol sa pagbuo ng HTML na representasyon ng page. Ang partikular na PageAdapter ay itinakda ng runtime depende sa mga parameter ng Requets. Kung pipiliin ang PageAdapter, ang mga kaganapan sa lifecycle ng page ay papalitan ng mga kaganapan sa PaeAdapter.
SetFocus
Isang paraan na nagbibigay-daan sa iyong itakda ang pag-highlight sa alinman sa mga kontrol na makikita sa page.
StyleSheetTheme, Tema
Tingnan sa itaas para sa isang paglalarawan ng mga bagong katangian ng direktiba ng @Page.
TestDeviceFilter
Paraan na sumusuri kung kasalukuyang browser browser ng uri na tinukoy bilang isang argumento.
Pamagat
Isang property na nagbibigay-daan sa iyong makuha at baguhin ang pamagat ng page.
Gamit ang Bagong ASP.NET 2.0 Page Objects ClientScriptManager ObjectNagbibigay ang ClientScriptManager ng mga pamamaraan para sa pagtatrabaho sa script code na gagamitin sa bahagi ng kliyente ng Web application. Ngayon ang lahat ng mga pamamaraan na ginamit sa ASP.NET 1.x upang magrehistro ng mga script ng kliyente o mga nakatagong field ay nabibilang sa klase ng ClientScriptManager. Halimbawa, minsan kinakailangan na magrehistro ng script ng kliyente nang pabago-bago, depende sa ilang mga parameter. Halimbawa, kapag nagre-reload ng isang pahina ng forum, kailangan mong ipahiwatig sa user na nakatanggap siya ng bagong personal na mensahe. Magagawa ito tulad ng ipinapakita sa sumusunod na halimbawa.
Protektadong void Page_Load(object sender, EventArgs e) ( if (CheckMail()) ( string startupScript = "" + "if(confirm("Nakatanggap ka ng bagong mensahe. Basahin?"))" + "window.navigate(" /ReadMail .aspx");" + ""; ClientScript.RegisterStartupScript(this.GetType(), "MailAlertScript", startupScript) )
object ng HtmlHeadPara sa bawat pahina ng ASP.NET na naglalaman ng tag sa HTML code nito, awtomatikong nagagawa ang isang instance ng object ng HtmlHead, na nagpapahintulot sa iyo na pamahalaan pamagat ng pahina, magdagdag ng mga META tag at link sa mga cascading style sheet.
Noong nakaraan, ang isang developer ng pahina ng ASP.NET 1.0 ay kailangang magdagdag ng isang espesyal na pag-aari o variable sa klase ng pahina o gumawa ng ilang uri ng workaround upang makontrol ang pamagat at metadata ng pahina. Halimbawa, tulad ng ipinapakita sa sumusunod na halimbawa.
Sa pagdating ng HtmlHead object, ang mga ganitong trick ay isang bagay ng nakaraan.
Page.Header.Title = "HtmlHead Test Page"; Page.Header.Metadata.Add("Author", "Gaidar Magdanurov"); Page.Header.Metadata.Add("E-Mail", "!} [email protected]");
Bilang karagdagan, tulad ng anumang elemento na maaaring maglaman ng mga nested na elemento, pinapayagan ka ng HtmlHead na magdagdag ng mga arbitrary na elemento.
((Control)Page.Header).Controls.Add(new LiteralControl (""));
Kontrol ng Pahina Pagtatakda ng highlight sa isang kontrolMinsan kinakailangan na pagkatapos i-load ang pahina, ang pagpili ay dapat itakda sa isang partikular na elemento ng kontrol (halimbawa, sa isang form ng paghahanap, lohikal na itakda ang input focus sa pangunahing field ng paghahanap), para dito maaari mong itakda ang value ng defaultfocus attribute ng form tag.
Maaaring kontrolin ang pagpili sa pamamagitan ng programmatically sa pamamagitan ng pagtawag sa SetFocus method, na ipinapasa ang natatanging identifier ng elementong ito bilang isang parameter:
Protektadong void Page_Load(object sender, EventArgs e) ( if(isPostBack) ( SetFocus("txtLastName"); ) else ( SetFocus("txtFirstText"); ) )
Ina-update ang data nang hindi nire-reload ang page
Sa ASP.NET 2.0, naging posible na i-update ang data sa isang pahina nang hindi ipinapadala ang pahina sa server at kumpletong pag-update. Naging posible ito salamat sa pagdating ng mga script ng kliyente na may mga callback (mga callback script o mga callback ng kliyente). Pagkatapos mag-trigger ng kahilingan sa server ang ilang kaganapan, direktang ipinapasa ang na-update na data sa script ng kliyente bilang mga argumento ng function.
Ang pamamaraang ito ng pag-update ng data sa isang pahina ay maginhawa at kumikitang gamitin kapag ang pag-update ng lahat ng impormasyon ay nangangailangan ng maraming mapagkukunan at sapat mahabang panahon, habang ang bahaging ito ng data ay madalas na ina-update, at ang natitirang data ay static. Pagkatapos, ang oras upang i-update ang data, halimbawa, isang elemento ng user, na isinasaalang-alang ang oras ng isang kahilingan sa server, pagproseso at pagtanggap ng tugon, ay magiging makabuluhang mas mababa kaysa sa oras upang i-update ang buong pahina.
Sabihin nating mayroong isang pahina kung saan mayroong isang drop-down na listahan. Kapag pumili ang user ng value mula sa isang listahan, nilo-load ang ilang control ng value na lohikal na nauugnay sa napiling value mula sa listahan. Sa kasong ito, ang gawain ay tulad na imposibleng iimbak ang lahat ng data sa panig ng kliyente (marahil mayroong masyadong maraming data at ang pahina ay magtatagal upang maipadala sa network, o ang data ay nabuo sa server hindi lamang depende sa drop-down list na elemento na pinili ng user). Sa ASP.NET 1.x, upang malutas ang problemang ito kailangan mong sumailalim sa kaganapan ng pagbabago ng halaga sa listahan ng dropdown paraan ng server. Sa kasong ito, ang listahan ay dapat maging sanhi ng pagpapadala ng pahina sa server sa tuwing nagbabago ang halaga (AutoPostBack="True").
Protektadong void ddStatic_SelectedIndexChanged(object sender, EventArgs e) ( // Batay sa halaga ng ddStatic.Items.Value // ang pamamaraan ay nagtatakda ng mga katangian ng iba pang mga kontrol)
Sa ASP.NET 2.0, tulad ng nabanggit sa itaas, posibleng hindi i-refresh ang buong pahina. SA sa kasong ito Mahusay na i-update lamang ang data na kailangan mo, dahil ang pag-update sa buong page para lamang magtakda ng isang halaga ay aksaya.
Upang magpatupad ng mekanismo para sa pag-update ng data nang hindi nire-reload ang page, kinakailangan na lumikha ng function ng callback ng kliyente na tumatanggap ng mga parameter na ipinasa mula sa server, function ng server, na tumatanggap ng mga parameter mula sa kliyente at nagbabalik ng mga halaga sa kliyente batay sa natanggap na mga parameter at ikonekta ang dalawang function na ito. Bukod dito, ang mekanismo ng callback sa ASP.NET 2.0 ay nagbibigay-daan sa iyo na ibalik ang resulta nang asynchronously. Upang gawin ito, dalawang pamamaraan ang tinukoy sa interface ng ICallbackEventHandler: RaiseCallbackEvent, para sa pagtanggap ng mga parameter sa server, at GetCallbackResult, para sa pagbabalik ng resulta sa kliyente. Upang ipatupad ang functionality ng nakaraang halimbawa, ang sumusunod na code ay inilalagay sa ASPX file.
function na UpdateText(resulta, konteksto) ( dSpan.innerText = resulta; )
Ang klase ng page na gumagamit ng mga function ng callback ay dapat ipatupad ang interface ng ICallbackEventHandler.
Pampublikong partial class na ScriptCallback_aspx: System.Web.UI.Page, System.Web.UI.ICallbackEventHandler ( )
Ang mga function signature na sumusuporta sa callback ay ganito ang hitsura:
Pampublikong virtual void PrepareCallbackEvent(string Argument) pampublikong virtual string RenderCallbackResult() pribadong string EventArgument = ""; public void PrepareCallbackEvent(string eventArgument) ( EventArgument = eventArgument; ) public string RenderCallbackResult() ( return EventArgument; // value uri ng string }
Ang huling hakbang patungo sa layuning ito ay i-link ang mga function ng server at client.
Protektadong void Page_Load(object sender, EventArgs e) ( // gumawa ng reference sa callback function string callbackFunction = Page.ClientScript.GetCallbackEventReference (ito, "document.all["ddDynamic"].value", "UpdateText", "null " ); // Itali ang script sa kaganapan ng pagbabago ng halaga ng drop-down // list ddDynamic.Attributes["onchange"] = String.Format("javascript:(0)", callbackFunction )
Ang GetCallbackEventReference method ng ClientScriptManager object ay tumatagal bilang mga parameter ng isang reference sa page object, isang string na nagsasaad ng value na ipapasa sa server sa callback, ang pangalan ng client-side na paraan at ang server na tumatanggap ng tugon. Ang isang detalyadong paglalarawan ay matatagpuan sa dokumentasyon ng MSDN o gamit ang tool na Visual Studio - Object Browser.
Gamit ang teknolohiyang ito, maaari kang lumikha ng mga kumplikadong pamamaraan para sa pag-update ng data ng pahina na maaaring magbunga ng makabuluhang mga benepisyo sa pagganap sa pamamagitan ng pag-unawa sa code na binubuo ng runtime ng ASP.NET upang ipatupad ang pagpapaandar na ito.
// Listahan na nagiging sanhi ng pag-reload ng pahina // Listahan na tumatawag sa pamamaraan na may callback
Ang karaniwang function ng doPostBack ay napakasimple at nagsisilbing i-save ang data ng kaganapan sa mga nakatagong field ng form.
Var theForm = document.forms["frmCallBack"]; function __doPostBack(eventTarget, eventArgument) ( if (theForm.onsubmit == null || theForm.onsubmit()) ( theForm.__EVENTTARGET.value = eventTarget; theForm.__EVENTARGUMENT.value = eventArgument; theForm.submit(); ) )
Kapag gumagamit ng mga function na may mga callback, ang mekanismo ay mas kumplikado. Ang WebForm_DoCallback function code ay mas malaki kaysa sa doPostBack dahil tinutukoy ng function na ito ang uri ng modelo ng object ng browser at pagkatapos ay nilo-load ang module na kinakailangan upang maglipat ng data mula dito.
Halimbawa, para sa isang browser na sumusuporta sa DOM ito ay magiging Microsoft.XMLHTTP. Maaari mong tingnan ang code para sa iba't ibang mga function ng kliyente na ginagamit ng ASP.NET 2.0 framework sa pamamagitan ng pag-save ng isang pahina na sumusuporta sa mga function ng callback sa iyong hard disk at pagbubukas nito sa text editor
ang WebResource.axd file, na naka-link sa HTML page.
Pag-post ng data ng form sa isa pang pahina ng ASP.NET Ang isang makabuluhang limitasyon ng mga form sa panig ng server sa ASP.NET 1.0 ay ang kawalan ng kakayahang direktang ilipat ang data na ipinasok sa form sa isa pang pahina. Upang magpadala ng mga halaga ng elemento ng form sa isa pang pahina na kailangan mong gamitin simpleng HTML
form at sa katangian ng pagkilos ay tukuyin ang landas patungo sa page na dapat tumanggap ng data.
Nawawala nito ang mga benepisyo ng paggamit ng mga form sa panig ng server.
Upang ipatupad ang tampok na ito, sinusuri ng ASP.NET 2.0 ang mga pahina ng ASPX para sa pagkakaroon ng mga kontrol na may tinukoy na katangian ng PostBackUrl at, kung mayroon man, ay lumilikha ng karagdagang nakatagong field __PREVIOUSPAGE sa pahina, na naglalaman ng impormasyon tungkol sa estado ng mga elemento ng form. Ang impormasyong ito ay magagamit sa pahina ng tatanggap sa pamamagitan ng property na PreviousPage.
Void Page_Load(object sender, EventArgs e) ( if (PreviousPage != null) ( // Kunin ang mga object ng ipinadalang form TextBox txtFirstName = (TextBox)PreviousPage.FindControl("txtFirstName"); TextBox txtLastName = (TextBox.PreviousPage. FindControl(" txtLastName"); // Use the data txtInfo.Text = "Good afternoon, " + txtFirstName.Text + "!" ) )
Sa antas ng HTML code, ganito ang hitsura ng pagpapadala ng data sa isa pang form.
Mula sa kung saan maaari naming tapusin na ang data ng form ay hindi direktang ipinadala mula sa browser patungo sa pahina ng CrossPage.aspx, ngunit unang ipinadala sa parehong pahina ng GetValues.aspx, na naglalaman ng form na frmTest. Ito ay kinakailangan upang suportahan ang server-side validation ng inilagay na data gamit ang RequiredFieldValidation, RangeValidation at iba pang mga kontrol. Maaari mong tingnan ang WebForm_DoPostBackWithOptions na paraan sa WebResource.axd file na binanggit sa nakaraang talata ng artikulong ito.
Mga Template ng Disenyo ng PahinaAno ang unang bagay na nagpapaiba sa isang Web site mula sa iba?
Para sa karaniwang gumagamit ng Internet, ang pangunahing pagkakaiba ay nakasalalay sa iba't ibang disenyo ng pahina. Bago makita ang functionality ng isang Web application, sinusuri ng isang bisita sa site kung gusto niya ang hitsura ng mga page. Samakatuwid, ang disenyo ng pahina ay halos hindi gaanong mahalaga kaysa sa pangkalahatang pag-andar. Ang gawain ng developer ay magsulat ng code, at ang gawain ng taga-disenyo ay lumikha panlabas na disenyo at layout ng HTML code para sa mga pahina. Sa karamihan ng mga kaso, ito ay kinakailangan upang matiyak ang posibilidad ng parallel na trabaho sa application code at HTML template
Kapansin-pansin na ang karamihan sa mga modernong Web site ay may katulad na hitsura para sa lahat ng mga pahina at ang bawat pahina ay may mga karaniwang elemento ng disenyo.
Sa ASP.NET 1.x, ang mga karaniwang elemento ng disenyo ng pahina ay nakabalot sa mga kontrol ng gumagamit at isinama sa bawat pahina, o, bilang kahalili, ang mga pahina ay na-convert sa mga kontrol, gamit ang isang pahina bilang batayan kung saan ang mga kontrol ay na-load batay sa isang string ng URL . Ang diskarte sa ASP.NET 2.0 ay malapit sa pangalawa sa mga diskarteng ito, ngunit naglalaman ng mga makabuluhang pakinabang. Hindi na kailangang i-convert ng developer ang mga page sa mga kontrol ng user, na ginagawang mas madali ang pag-develop at pag-debug. Ito rin ay makabuluhang pinapasimple ang gawain ng taga-disenyo, dahil ang kanyang gawain ay nabawasan sa pagsasama lamang ng ilang mga elemento ng ASP.NET sa code ng pahina ng template. Para sa higit pa detalyadong paghahambing
Paglikha ng Template ng Disenyo Ang template ng disenyo ng pahina (Master pages) ay isang regular na pahina ng ASP.NET na may ilang karagdagang katangian at katangian at naglalaman ng isa o higit pang mga espesyal na elemento Pamamahala ng nilalaman
Placeholder. Upang ma-convert ang isang regular na pahina sa isang template, sapat na upang palitan ang direktiba ng Pahina ng Master na direktiba. Pagkatapos nito, kailangan mong ipasok sa markup ng pahina mga elemento ng server
Kinokontrol ng ContentPlaceHolder, sa mga bahagi ng page kung saan ilalagay ang impormasyong hindi nauugnay sa pangkalahatang disenyo.
Ang aking home page
Oras: Katulad ng para sa regular na pahina
, sa logic file ng programa maaari kang magtrabaho kasama ang mga umiiral nang kontrol, lumikha at magdagdag ng mga bago, batay sa mga parameter ng kahilingan, baguhin ang pahina at ang pag-uugali nito. Kaya, maaari mong ilagay ang lohika para sa paglikha ng hitsura ng isang Web application halos lahat sa template ng pahina.
- Ang kontrol ng ContentPlaceHolder ay nagbibigay-daan sa iyo na tukuyin ang nilalaman na gagamitin kung ang pahina na gumagamit ng template ay hindi na-override ang nilalaman ng kontrol.
- Home page
Talaan ng nilalaman
Protektadong void Page_Load(object sender, EventArgs e) ( PageTime.InnerText = DateTime.Now.ToShortDateString(); ) public string Title ( get ( return PageTitle.InnerText; ) set ( PageTitle.InnerText = value; ) )
Paggawa ng pageAng paggamit ng mga template ng disenyo ay nagpapataw ng sarili nitong mga kinakailangan sa mga pahina. Dahil ang template ay naglalaman ng mga kontrol sa ContentPlaceHolder, ang pahina ay dapat na naglalaman ng mga kontrol sa Nilalaman na naglalaman ng markup code at iba pang mga kontrol na ire-render sa magreresultang pahina. Ang pahina ay hindi dapat magkaroon ng anumang mga kontrol sa server o markup code sa labas ng mga kontrol sa Nilalaman.
- Pahina 1
- Pahina 2
- Pahina 3
Tulad ng template, ang page logic code ay nilikha sa karaniwang paraan. Ang pagkakaiba lang ay walang sariling object ang page tulad ng HeadControl, kaya kailangan mong gumamit ng link sa page ng template sa pamamagitan ng Master property.
Protektadong void Page_Load(object sender, EventArgs e) ( if (!Page.IsPostBack) Master.Page.Header.Title = "Home page"; } protected void btnShow_Click(object sender, EventArgs e) { PlaceHolder.Controls.Add(new LiteralControl(" alert("Добрый день, " + txtName.Text + ""); ")); Master.Page.Header.Title = "Magandang hapon," + txtName.Text; }!}
Upang maiugnay ang isang pahina sa isang template, gamitin ang katangian ng MasterPageFile ng direktiba ng Pahina. Kung kailangan mong itali ang parehong template sa lahat ng pahina sa direktoryo, hindi na kailangang tukuyin ang katangian ng MasterPageFile para sa bawat pahina sapat na upang itakda ang base template sa web.config file;
Bilang karagdagan, pinapayagan ka ng ASP.NET na magtakda ng isang tema sa pamamagitan ng program. Tulad ng nabanggit sa itaas, ang paglo-load at pagli-link sa template ng disenyo ay nangyayari habang inihahanda ang pahina para sa pagsisimula. Samakatuwid, kung kailangan mong baguhin ang template ng disenyo ng pahina, dapat mong gawin ito sa handler ng kaganapan ng PreInit.
Protektadong void Page_PreInit(object sender, EventArgs e) ( Page.MasterPageFile = "AnotherMaster.master"; )
Pagproseso ng Template ng ASP.NETSa unang pagkakataon na ma-access ang isang pahina, ang ASP.NET ay naghahanap at nag-compile ng mga pagtitipon para sa lahat ng mga template sa direktoryo. Ang operasyong ito ay tumatagal ng ilang oras, depende sa bilang ng mga pahina ng template sa direktoryo, ngunit isang beses lang ginagawa. Samakatuwid, kung may mga hindi nagamit na template sa direktoryo, hindi ito hahantong sa pagkalugi sa pagganap habang tumatakbo ang application, ang tanging abala ay karagdagang oras, at ang pagsasama-sama ng mga hindi kinakailangang pagtitipon para sa mga hindi nagamit na pahina.
Kapag nag-a-access ng aspx file ng isang page na may ibinigay na template ng disenyo, ang proseso ng compilation ay halos hindi naiiba sa normal na proseso ng compilation ng page, maliban na ang isang MasterPage template class ay ginawa, isang link kung saan available sa Page.Master property.
Ang pahina ay dumaan sa lahat ng mga hakbang na inilarawan sa itaas sa artikulong ito, na nagreresulta sa pagbuo ng HTML code na ipinadala sa kliyente. Sa natanggap HTML browser Hindi na posible para sa code na matukoy kung aling bahagi ng code ang tinukoy sa template ng disenyo at kung aling bahagi ng code ang tinukoy sa mismong pahina, dahil ang ContentPlaceHolder at mga kontrol sa Content ay walang anumang HTML na sulat at hindi bumubuo karagdagang mga tag maliban sa kanilang nilalaman.
Home page
|
|
Oras: 03/20/2005
Dahil ang isang template ay isang subset ng isang page, pinahihintulutang lumikha ng mga nested na template sa pamamagitan ng pagtukoy ng path sa isa pang template para sa template sa Master na direktiba gamit ang MasterPageFile attribute. Upang gawin ito, kailangan mong tukuyin ang mga kontrol ng ContentPlaceHolder sa pangunahing template, at sa mga template na "bata", kasama ng mga elemento ng ContentPlaceHolder, tukuyin ang mga kontrol ng Content upang palitan ang mga nilalaman ng mga elemento ng ContentPlaceHolder ng base template.
Paggamit iba't ibang mga template para sa iba't ibang mga browserAlam na alam ng sinumang Web developer na ang iba't ibang mga browser (halimbawa, Microsoft Internet Explorer, Netscape Navigator, Mozilla FireFox, atbp.) na nagproseso ng HTML code sa ibang paraan at, higit sa lahat, may bahagyang magkakaibang mga modelo ng programming, na nagpapalubha sa paglikha ng mga script ng kliyente.
Upang malutas ang problemang ito, mayroong dalawang pangunahing pamamaraan na ginagamit sa parehong ASP.NET 1.x at classic na ASP. Ang una ay ang client browser ay pinadalhan ng client code na, batay sa uri at mga bersyon ng browser, nagsasagawa ng ilang pagkilos. Ang pangalawa ay ang pag-redirect ng browser ng user sa mga page na partikular na na-optimize para sa isang partikular na browser. Pinapadali ng ASP.NET ang paggawa ng mga ganitong uri ng pahina dahil ang runtime ay bumubuo ng HTML code para sa mga karaniwang kontrol ng server batay sa impormasyon tungkol sa browser ng kliyente. Kapag gumagamit ng mga template ng disenyo, maaari kang lumikha ng ilang mga template para sa bawat browser at tukuyin sa Direktiba ng Pahina ng pahina kung aling template ang gagamitin.
Ang isang listahan ng mga browser at mga katangian ng browser na ginagamit ng ASP.NET ay matatagpuan sa %WINDIT%\Microsoft.NET\Framework\version\CONFIG\Browsers na direktoryo.
Upang ma-localize ang mga application sa ASP.NET 1.x, madalas na kailangang magsulat ng code ang developer upang matukoy ang mga setting ng locale ng user. Ang code na ito ay madalas na inilagay sa global.asax at ang trabaho nito ay upang itakda ang wika ng user bilang wika ng kasalukuyang proseso sa pamamagitan ng paglikha ng isang CultureInfo object at pagtatalaga ng CurrentCulture at CurrentUICulture properties nito sa CurrentThread object:
Void Application_BeginRequest (Object sender, EventArgs e) ( if (Request.UserLanguages.Length > 0) ( CultureInfo UserCulture = CultureInfo.CreateSpecificCulture(Request.UserLanguages); Thread.CurrentThread.CurrentCulture = UserCulture; Thread.CurrentCurrent )
Sa ASP.NET 2.0, posibleng i-offload ang determinasyon ng locale ng user sa runtime environment. Sapat na upang itakda ang Culture="auto" at UICulture="auto" na mga katangian ng @Page na direktiba upang ang mga panrehiyong setting ng user para sa pahina ay awtomatikong matukoy. Kung sakali. kung kailangan mong makamit ang epektong ito sa lahat ng pahina ng site, idagdag lamang susunod na linya:
Mga expression para sa lokalisasyon
Binibigyang-daan ka ng ASP.NET 2.0 na bumuo ng mga assemblies na may mga lokal na mapagkukunan para sa bawat pahina at itali ang mga kontrol sa data na nakaimbak sa mga mapagkukunang iyon gamit ang mga expression na direktang inilagay sa view code sa ASPX file. Upang gawin ito, ginagamit ang meta:resourcekey attribute, ang value nito ay sinusuri sa panahon ng page execution.
Piliin ang Wika
O maaaring gumamit ng bagong expression:
Upang ma-localize ang static na teksto sa parehong paraan, ipinakilala ang ASP.NET 2.0 bagong elemento I-localize ang kontrol, na nagbibigay-daan sa iyong gamitin ang mga expression ng localization sa itaas.
Text
Text
Maaari kang magbasa nang higit pa tungkol sa mga expression, pagbuo ng mga mapagkukunan at pagtukoy sa mga setting ng rehiyon ng user sa artikulong ito.
KonklusyonAng artikulong ito ay nagbibigay lamang ng ilang pangunahing impormasyon tungkol sa kung ano ang bago sa ASP.NET 2.0 kumpara sa ASP.NET 1.x.
Ang mga tampok ng ASP.NET ay inilarawan nang maikli at ang artikulong ito ay maaaring magsilbi bilang isang panimulang punto para sa pag-aaral ng advanced na teknolohiya. Para sa isang mas detalyadong paglalarawan ng mga teknolohiya at mga bagong kakayahan na binanggit sa artikulo, inirerekumenda na sumangguni sa listahan ng mga karagdagang panitikan. Ang artikulo ay hindi hinawakan ang ilang mahahalagang inobasyon - asynchronous code execution, mga bagong kontrol, pag-encrypt ng mga fragment ng web.config file, mga bagong mekanismo ng pag-access ng data at marami pa. Ang lahat ng ito ay materyal kung saan higit sa isang libro ang maaaring pag-ukulan. Kung maaari, susubukan ng may-akda na i-highlight ang mga pagbabagong ito sa mga susunod na artikulo. Ang mga unang pahina sa ASP.NET ay nagbibigay ng paunang panimula sa isang matatag na teknolohiya para sa paglikha ng mga web application. Nang hindi kumplikado ang mga unang hakbang sa WebForms, MVC, WebAPI frameworks, gagawa kami ng mga simpleng web page na may naka-embed na program code para sa dalawang view handler - ASPX at Razor. Ang mga code processor, na tinatawag ding rendering engine o engine, ay idinisenyo upang dynamic na paglikha mga web page sa pamamagitan ng pagpapalit
code ng programa
kaukulang html markup. Ang ASPX engine ay isang karaniwang modelo para sa pagdaragdag ng code sa isang ASP.NET web page. Gumagamit ang ASPX ng runat="server"> mga uri, pamamaraan at mga variable na bloke ng deklarasyon at isang built-in na html markup rendering block. Ang modelo ng ASPX ng pagdaragdag ng code, na may ilang mga pagbabago, ay dinala sa ASP.NET mula sa orihinal na platform ng ASP. Ang Razor ay isang bagong mekanismo para sa pag-visualize ng program code sa isang html page. Ang Razor ay isang matalinong dynamic na makina paggawa ng html mga marka. Mayroon itong malinaw na syntax at ginagawang madali ang pag-embed ng code sa isang web page. Upang makilala ang code ng programa mula sa html code gumagamit ng simbolo na @, kasama ng
kulot na braces at walang panaklong. Upang lumikha ng mga unang web page gagamitin namin ang libre kapaligiran ng software para sa pagtatrabaho sa mga website ng WebMatrix. Sa kasalukuyan, ang ika-3 bersyon ng programming tool na ito, sapat para sa paglikha ng mga propesyonal na website, ay nilikha. Maaari mong i-download ito mula sa website Microsoft sa pamamagitan ng link ng WebMatrix. Kasama sa programa ng WebMatrix ang lahat ng kailangan mo upang lumikha at subukan ang mga website batay sa ASP.NET: isang code editor na may backlighting at IntelliSense, isang IIS Express web server, isang database management system
Kasama sa site ang tatlong pahina: ang pangunahing pahina at dalawang magkaparehong pahina para sa dynamic na paglikha ng mga talahanayan gamit ang ASPX at Razor engine. Maaaring tukuyin ang laki ng talahanayan sa linya ng query gamit ang dalawang parameter. Dapat sabihin na, sa prinsipyo, ang parehong mga humahawak ay epektibong lumikha html markup, ngunit nagbibigay ng ibang kaginhawaan sa pagpapatakbo.
Ang ASPX engine ay nangangailangan na ang lahat ng bahagi at piraso ng program code ay nakapaloob sa mga view block. Maaaring ideklara ang mga uri, pamamaraan at variable sa runat="server">... block. Ang katangian ng runat="server" ay nakikilala block na ito mula sa isang javascript block at nagsasaad ng pagproseso ng code sa block na ito nang direkta sa server.
Listahan No. 1 Web page gamit ang ASPX engine< !DOCTYPE html > < html xmlns ="http://www.w3.org/1999/xhtml"> < head runat ="server"> < meta http-equiv ="Content-Type" content ="text/html; charset=utf-8"/> < title > < link rel ="stylesheet" type ="text/css" href ="/css/style.css" /> < body > < h1 > < p >< a href ="/">Bahay< p >Bilang ng mga hanay -< br />Bilang ng mga linya -< table > < tr > < tr > < td >
Nasa ibaba ang web page code para sa Razor embedded code handler. Bigyang-pansin ang maayos na pagsasama ng html code at mga expression sa C#. Binibigyang-daan ka ng Razor engine na gumamit ng mga HTML tag nang direkta sa loob ng program code: ang matalinong bahagi ng handler ay matalinong naghihiwalay sa HTML markup mula sa C# program code.
Listahan No. 2 Web page sa Razor engine< !DOCTYPE html > < html lang ="ru"> < head > < meta http-equiv ="Content-Type" content ="text/html; charset=utf-8"/> < meta charset ="utf-8" /> < title >@namepage< link rel ="stylesheet" type ="text/css" href ="/css/style.css" /> < body > < h1 >@namepage< p >< a href ="/">Home @ Html.Raw(createLinks.GetLinks())< p >Bilang ng mga column - @numberColumns< br />Bilang ng mga row - @numberRows< table > < tr >@para sa (int i = 0; i< numberColumns; i++) { < th >Heading # @(i + 1 ) ) @ para sa (int row = 0; row< numberRows; row++) { < tr >@for(int col = 0; col< numberColumns; col++) { < td >@(row+1 ) x@(col+1 ) ) )
Maaari mong subukan ang site sa maraming paraan:
Sa konklusyon, maaari naming idagdag na para sa gumagamit ng site, ang impormasyon tungkol sa kung aling engine ay tumatakbo ang mga web page ay hindi masyadong mahalaga. Ngunit ang programmer, pagkatapos magtrabaho sa bawat naka-embed na tagapangasiwa ng code, ay tiyak na pipili ng Razor.
Huling na-update: 10/31/2015
Ang mga master page ay ginagamit upang lumikha ng pare-pareho, pinag-isang hitsura at pakiramdam sa isang site. Sa pangkalahatan, ang mga master page ay magkaparehong mga view, ngunit pinapayagan kang magsama ng iba pang mga view. Halimbawa, maaari mong tukuyin ang mga elemento sa master page na karaniwan sa lahat ng iba pang view, at kasama rin ang mga karaniwang istilo at script. Bilang isang resulta, hindi namin kailangang gawin sa bawat isa hiwalay na presentasyon tukuyin ang path sa mga style file, at pagkatapos ay baguhin ito kung kinakailangan. At ang mga placeholder o placeholder na ginamit sa mga master page ay magbibigay-daan sa iyo na magpasok ng iba pang mga view sa kanilang lugar.
Bilang default, kapag gumawa ka ng bagong proyekto ng ASP.NET MVC 5, ang isang master page na tinatawag na _Layout.chtml ay naidagdag na sa proyekto, na makikita sa Views/Shared directory. Sa apendiks mula sa ikalawang kabanata, binago namin ito bilang mga sumusunod:
@ViewBag.Title @RenderBody()
Sa unang tingin, isa itong normal na view na may isang exception: ginagamit nito ang @RenderBody() na paraan, na isang placeholder at papalitan ng iba pang view na gumagamit ng master page na ito. Bilang resulta, madali kaming makakapagtakda ng pare-parehong istilo para sa mga view ng web application.
Upang gumamit ng master page sa view, kailangan naming tukuyin ang path sa gustong master page sa Layout na seksyon. Halimbawa, sa Index.cshtml view, maaari mong tukuyin ang isang master page tulad nito:
Kung hindi kami gumagamit ng master page, tinukoy namin ang Layout = null; .
Hindi rin kailangang gumamit ng parehong master page para sa lahat ng pagsusumite. Maaari mong tukuyin ang ilang mga master page, halimbawa, isa para sa isang forum, isa para sa isang blog, atbp., at depende sa seksyon ng site, ikonekta ang kailangan mo. Idinaragdag ang mga ito sa proyekto sa parehong paraan tulad ng mga regular na view.
Ang isang master page ay maaaring magkaroon ng maraming seksyon kung saan maaaring ilagay ng mga view ang kanilang nilalaman. Halimbawa, magdagdag tayo ng seksyon ng footer sa master page:
@ViewBag.Title
@RenderBody() @RenderSection("Footer")Ngayon kapag pinatakbo namin ang nakaraang Index view makakakuha kami ng isang error dahil ang seksyon ng Footer ay hindi tinukoy. Bilang default, ang view ay dapat mag-render ng nilalaman para sa bawat seksyon ng master page. Samakatuwid, magdagdag tayo ng seksyon ng footer sa ibaba ng view ng Index. Magagawa natin ito gamit ang @section expression:
@( Layout = "~/Views/Shared/_Layout.cshtml"; ) @section Footer ( All rights reserved. Syte Corp. 2012. )
Ngunit sa diskarteng ito, kung mayroon kaming isang grupo ng mga view, at bigla naming nais na tukuyin ang isang bagong seksyon sa master page, kailangan naming baguhin ang lahat ng mga umiiral na view, na hindi masyadong maginhawa. Sa kasong ito, maaari naming gamitin ang isa sa mga opsyon para sa flexible na configuration ng seksyon.
Ang unang opsyon ay ang paggamit ng labis na karga ng paraan ng RenderSection, na nagbibigay-daan sa iyong ipahiwatig na ang seksyon ay hindi kailangang tukuyin sa view. Upang markahan ang seksyong Footer bilang opsyonal, kailangan mong ipasa ang value na false sa pamamaraan bilang pangalawang parameter:
@RenderSection("Footer", false)
Binibigyang-daan ka ng pangalawang opsyon na itakda ang default na nilalaman ng seksyon kung hindi tinukoy ang seksyong ito sa view:
@if (IsSectionDefined("Footer")) (@RenderSection("Footer") ) iba pa ( Default na nilalaman ng elemento ng footer. )
ViewStartKung mayroon kaming ilang view sa aming proyekto, madali naming mababago nang manu-mano ang paglalarawan ng master page para sa bawat isa sa seksyong Layout kung, halimbawa, nagpasya kaming gumamit ng ibang master page. Ngunit kung marami tayong pananaw, hindi ito magiging maginhawa.
Para sa mas nababaluktot na pagsasaayos ng mga view, ang _ViewStart.cshtml na pahina ay nilayon. Ang code para sa pahinang ito ay tumatakbo bago ang code para sa alinman sa mga view na matatagpuan sa parehong direktoryo. Ang file na ito ay inilapat nang sunud-sunod sa bawat view na matatagpuan sa parehong direktoryo.
Kapag lumikha ka ng proyekto ng ASP.NET MVC 5, ang file na _ViewStart.cshtml ay idinaragdag sa direktoryo ng Views bilang default. Tinutukoy ng file na ito ang default na master page:
@( Layout = "~/Views/Shared/_Layout.cshtml"; )
Gumagana ang code na ito bago ang anumang iba pang code na tinukoy sa view, upang maalis namin ang seksyong Layout mula sa iba pang mga view. Kung ang view ay dapat gumamit ng ibang master page, i-override lang namin ang Layout property, idagdag ang kahulugan nito sa simula ng view.
Hello w3ii sa HTMLAng code na ito ay nagpapakita ng isang halimbawa bilang isang HTML na pahina:
Hello w3ii!
firstpage.htm" at gumawa din ng link sa file na tulad nito: firstpage.htm
Kamusta w3ii sa ASP.NETAng pinakamadaling paraan upang i-convert ang isang HTML na pahina sa isang pahina ng ASP.NET ay upang kopyahin ang HTML file sa bagong file na may extension na .aspx.
Ipinapakita ng code na ito ang aming halimbawa tulad ng sa isang pahina ng ASP.NET:
Hello w3ii!
Kung gusto mong subukan ito mismo, i-save ang code sa isang file na tinatawag na "firstpage.aspx" at gumawa din ng link sa file na tulad nito: firstpage.aspx
Paano ito gumagana?Sa panimula, ang isang pahina ng ASP.NET ay eksaktong kapareho ng isang pahina ng HTML.
Ang isang HTML page ay may extension na .htm. Kung humiling ang browser ng HTML page mula sa server, ipapadala ng server ang page sa browser nang walang anumang pagbabago.
Ang isang pahina ng ASP.NET ay may extension na .aspx. Kung humiling ang browser ng isang pahina ng ASP.NET, ipoproseso ng server ang anuman maipapatupad na code page, bago ibalik ang resulta sa browser.
Ang pahina ng ASP.NET sa itaas ay hindi naglalaman ng anumang maipapatupad na code, kaya walang naipapatupad. Sa mga sumusunod na halimbawa, magdaragdag kami ng executable page code upang ipakita ang pagkakaiba sa pagitan ng mga static na HTML page at dynamic na ASP page.
Klasikong ASPIlang taon nang umiral ang Active Server Pages (ASP). Sa ASP, maaaring ilagay ang executable code sa loob ng mga HTML na pahina.
Ang mga nakaraang bersyon ng ASP (bago ang ASP .NET) ay madalas na tinatawag na classic na ASP.
Ang ASP.NET ay hindi ganap na tugma sa Classic ASP, ngunit karamihan sa mga Classic na ASP na pahina ay gagana nang maayos bilang mga pahina ng ASP.NET na may maliliit na pagbabago lamang.
Kung gusto mong matuto nang higit pa tungkol sa classic na ASP, pakibisita ang aming ASP Tutorial.
Mga dynamic na pahina sa classic na ASPUpang ipakita kung paano makapag-render ang ASP ng mga page na may dynamic na content, nagdagdag kami ng ilang executable code (na pula) sa nakaraang halimbawa:
Hello w3ii!
Ang code sa loob ng tag ay isinasagawa sa server.
Ang Response.Write ay ASP code para sa pagsusulat ng isang bagay sa HTML output stream.
Ang Now() ay ang server return function kasalukuyang petsa at oras.
Kung gusto mong subukan ito mismo, i-save ang code sa isang file na tinatawag na "dynpage.asp" at gumawa din ng link sa file na tulad nito: dynpage.asp
Mga Dynamic na Pahina sa ASP .NETAng code na ito ay nagbibigay ng aming halimbawa tulad ng sa isang pahina ng ASP.NET:
Hello w3ii!
Kung gusto mong subukan ito mismo, i-save ang code sa isang file na tinatawag na "dynpage.aspx" at gumawa din ng link sa file na tulad nito: dynpage.aspx
ASP.NET kumpara sa klasikong ASPAng mga nakaraang halimbawa ay hindi nagpapakita ng anumang pagkakaiba sa pagitan ng ASP.NET at classic na ASP.
Tulad ng nakikita mo mula sa huling dalawang halimbawa, walang pagkakaiba sa pagitan ng dalawang ASP at ASP.NET na pahinang ito.
Sa mga sumusunod na kabanata, makikita mo kung paano gawing mas malakas ang mga kontrol ng ASP.NET server kaysa sa klasikong ASP.
