ക്ലാസ് പേജ്. വെബ് ആപ്ലിക്കേഷനുകളുടെ ലളിതമായ പ്രാദേശികവൽക്കരണം. മാസ്റ്റർ പേജ് പ്രോപ്പർട്ടികൾ ആക്സസ് ചെയ്യുക

ASP.NET-ലെ ഒരു അപൂർവ അഭിമുഖം ASP.NET വെബ് ഫോമുകളിലെ ഒരു പേജിന്റെ ജീവിത ചക്രത്തെക്കുറിച്ച് ഒരു ചോദ്യമില്ലാതെ പൂർത്തിയാകില്ല (ഇനിമുതൽ ചുരുക്കത്തിൽ ASP.NET എന്ന് വിളിക്കുന്നു). ഈ പ്രശ്നം മനസിലാക്കാൻ ശ്രമിക്കാം. ഞാൻ വിഷയം രണ്ടായി വിഭജിച്ചു. ഈ ലേഖനത്തിൽ ഞങ്ങൾ ഘട്ടങ്ങൾ വിശകലനം ചെയ്യും ജീവിത ചക്രം ASP.NET-ലെ പേജുകൾ.

ASP.NET പേജിന്റെ പൊതുവായ പ്ലാൻ ലൈഫ് സൈക്കിൾ

IIS വെബ് സെർവർ മുഖേന ഒരു പേജ് അഭ്യർത്ഥന സ്വീകരിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു
ASP.NET റൺടൈമിലേക്ക് അഭ്യർത്ഥന കൈമാറുന്നു

റൺടൈം:

* വിളിക്കുന്ന പേജിന്റെ ക്ലാസ് ലോഡ് ചെയ്യുന്നു * പേജ് ക്ലാസിന്റെ പ്രോപ്പർട്ടികൾ സജ്ജീകരിക്കുന്നു * ഘടകങ്ങളുടെ ഒരു വൃക്ഷം നിർമ്മിക്കുന്നു * അഭ്യർത്ഥന, പ്രതികരണ പ്രോപ്പർട്ടികൾ പൂരിപ്പിക്കുന്നു * ``IHttpHandler.ProcessRequest``` രീതിയെ വിളിക്കുന്നു

ഘട്ടങ്ങൾ

8 പ്രധാന ഘട്ടങ്ങളുണ്ട്. ഇനിപ്പറയുന്ന ഡയഗ്രം ഇത് വ്യക്തമായി പ്രകടമാക്കുന്നു

സ്റ്റേജ് വിവരണം

അഭ്യർത്ഥന പേജ്	പേജിന്റെ ജീവിത ചക്രം ആരംഭിക്കുന്നതിന് മുമ്പ് പേജ് അഭ്യർത്ഥന സംഭവിക്കുന്നു. ഉപയോക്താവ് ഒരു അഭ്യർത്ഥന നടത്തുന്നു, കൂടാതെ ASP.NET റൺടൈം പേജ് കംപൈൽ ചെയ്ത് അതിന്റെ ജീവിതചക്രം ആരംഭിക്കേണ്ടതുണ്ടോ, അല്ലെങ്കിൽ പേജ് എക്സിക്യൂട്ട് ചെയ്യാതെ തന്നെ ഒരു കാഷെ ചെയ്ത പേജ് ഒരു പ്രതികരണമായി നൽകാനാകുമോ എന്ന് നിർണ്ണയിക്കുന്നു.
പ്രോസസ്സിംഗ് ആരംഭിക്കുക	ഈ ഘട്ടത്തിൽ, Response and Request പ്രോപ്പർട്ടികൾ, UICulture പ്രോപ്പർട്ടി എന്നിവ സജ്ജീകരിച്ചിരിക്കുന്നു. ഈ ഘട്ടം ഒരു പോസ്റ്റ്ബാക്കിന്റെ ഫലമായി പേജ് അഭ്യർത്ഥിച്ചതാണോ എന്ന് നിർണ്ണയിക്കുകയും അതിനനുസരിച്ച് IsPostBack പ്രോപ്പർട്ടി സജ്ജമാക്കുകയും ചെയ്യുന്നു.
പേജ് സമാരംഭം	പേജ് ആരംഭിക്കുമ്പോഴേക്കും, എല്ലാ ചൈൽഡ് ഉപയോക്താക്കളും നിയന്ത്രണങ്ങൾഇതിനകം സൃഷ്‌ടിക്കപ്പെട്ടിട്ടുണ്ട് കൂടാതെ UniqueID പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്നു. ഈ സമയത്ത്, തീമുകൾ പേജിൽ പ്രയോഗിക്കുന്നു. ഒരു പോസ്റ്റ്ബാക്കിന്റെ ഫലമായാണ് പേജ് വിളിക്കുന്നതെങ്കിൽ, സെർവറിലേക്ക് അയച്ച ഡാറ്റ ഈ ഘട്ടത്തിൽ ഇതുവരെ നിയന്ത്രണങ്ങളുടെ പ്രോപ്പർട്ടികളിലേക്ക് ലോഡ് ചെയ്തിട്ടില്ല.
ഒരു പോസ്റ്റ്ബാക്കിന്റെ ഫലമായാണ് പേജ് വിളിക്കുന്നതെങ്കിൽ, ഈ ഘട്ടത്തിൽ നിയന്ത്രണങ്ങളുടെ പ്രോപ്പർട്ടികൾ സംസ്ഥാന വിവരങ്ങളുടെ (വ്യൂസ്റ്റേറ്റ്, കൺട്രോൾസ്റ്റേറ്റ്) അടിസ്ഥാനമാക്കി സജ്ജീകരിച്ചിരിക്കുന്നു.
മൂല്യനിർണ്ണയം	പേജിലെ എല്ലാ വാലിഡേറ്റർമാർക്കും Validate() രീതി വിളിക്കുന്നു.
പോസ്റ്റ്ബാക്ക് പ്രോസസ്സിംഗ്	ഒരു പോസ്റ്റ്ബാക്ക് സംഭവിച്ചിട്ടുണ്ടെങ്കിൽ ഇവന്റ് ഹാൻഡ്ലർമാരെ വിളിക്കുന്നു.
റെൻഡറിംഗ്	സംസ്ഥാന വിവരങ്ങൾ സംരക്ഷിച്ചു, തുടർന്ന് പേജ് ക്ലാസ് ഉചിതമായ രീതികൾ വിളിക്കുന്നു കുട്ടികളുടെ ഘടകങ്ങൾഒരു HTML പ്രാതിനിധ്യം സൃഷ്ടിക്കുന്നതിനും അത് Response.OutputStream-ലേക്ക് കൈമാറുന്നതിനും നിയന്ത്രിക്കുന്നു.
അൺലോഡ് ചെയ്യുന്നു	മുഴുവൻ പേജിനുമുള്ള HTML പ്രാതിനിധ്യം സൃഷ്ടിച്ചതിന് ശേഷം അൺലോഡിംഗ് സംഭവിക്കുന്നു.

ഗൈദർ മഗ്ദാനുറോവ്
ASP.NET 2.0 അവതരിപ്പിക്കുന്നു ആമുഖം

ഓരോ തവണയും നിങ്ങൾ ഒരു പ്രോജക്റ്റ് വികസിപ്പിക്കുകയും ഒരു വെബ് ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു വിവിധ മാർഗങ്ങളിലൂടെഒരു ആപ്ലിക്കേഷൻ ആർക്കിടെക്ചർ സൃഷ്ടിക്കാൻ, കോഡ് എഡിറ്റ് ചെയ്ത് ഒരു വെബ് സെർവറിൽ നിങ്ങളുടെ ജോലിയുടെ ഫലങ്ങൾ പ്രസിദ്ധീകരിക്കുക. അതേ സമയം, അന്തിമ ഉപയോക്താവിനെ സംബന്ധിച്ചിടത്തോളം, ഏതെങ്കിലും സങ്കീർണ്ണതയുടെ ഒരു വെബ് ആപ്ലിക്കേഷൻ HTML പേജുകളുടെ ഒരു കൂട്ടമായി തുടരുന്നു, അവയിൽ ഓരോന്നിനും അതിന്റേതായ തനതായ URL ഉണ്ട്. വലിയതോതിൽ, ആപ്ലിക്കേഷൻ ഏത് പ്ലാറ്റ്‌ഫോമിലോ സാങ്കേതികവിദ്യയിലോ സൃഷ്‌ടിച്ചതാണെന്ന് ഉപയോക്താവ് ശ്രദ്ധിക്കുന്നില്ല. ഉപയോക്താവിന് അവൻ നേടാൻ ആഗ്രഹിക്കുന്ന ഒരു ലക്ഷ്യമുണ്ട് സാർവത്രിക പ്രതിവിധി, അവൻ ഉപയോഗിക്കുന്ന മിക്കവാറും എല്ലാ വെബ് ബ്രൗസറും. ആപ്ലിക്കേഷനുകളെ അപേക്ഷിച്ച് ഇന്റർനെറ്റിനായുള്ള ആപ്ലിക്കേഷനുകളുടെ ഒരു വലിയ നേട്ടമാണിത് ഡെസ്ക്ടോപ്പ് സിസ്റ്റങ്ങൾ- പൊതുവായി അംഗീകരിക്കപ്പെട്ട "ആശയവിനിമയ ഭാഷ", HTML കോഡിന്റെ അസ്തിത്വം. ഒരു വെബ് ആപ്ലിക്കേഷൻ വിന്യസിക്കുന്നതിന്, അത് സെർവറിൽ ഇൻസ്റ്റാൾ ചെയ്താൽ മതിയാകും, അതിനുശേഷം ഒരു വെബ് ബ്രൗസർ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഏതൊരു ക്ലയന്റിനും ആപ്ലിക്കേഷൻ ആക്സസ് ചെയ്യാൻ കഴിയും. നിർഭാഗ്യവശാൽ, ഇവിടെയും ഒരു വ്യക്തമായ പ്രശ്നമുണ്ട് HTML പ്രോസസ്സിംഗ്വ്യത്യസ്ത നിർമ്മാതാക്കളിൽ നിന്നുള്ള ബ്രൗസറുകളിൽ നിന്നുള്ള കോഡ്.
അന്തിമ ഉപയോക്താവ് ഉപയോഗിക്കുന്ന മിക്ക ബ്രൗസറുകൾക്കും അനുയോജ്യമായ HTML കോഡ് സൃഷ്ടിക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുക എന്നതാണ് ഡവലപ്പറുടെ ചുമതല. ഒരു വെബ് ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന ഓരോ സാങ്കേതികവിദ്യയും HTML കോഡ് സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അതിനാൽ, ആത്യന്തികമായി, ഒരു വെബ് ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുന്നതിനുള്ള സാങ്കേതികവിദ്യയുടെ തിരഞ്ഞെടുപ്പ് വികസനത്തിന്റെ സൗകര്യത്തെയും വേഗതയെയും അന്തിമ ഉൽപ്പന്നത്തിന്റെ വിന്യാസത്തിന്റെയും പിന്തുണയുടെയും എളുപ്പത്തെ ആശ്രയിച്ചിരിക്കുന്നു.
മറ്റുള്ളവയെ അപേക്ഷിച്ച് ASP.NET സാങ്കേതികവിദ്യയുടെ പ്രയോജനം മുകളിൽ നിർമ്മിച്ച ഉയർന്ന അളവിലുള്ള അമൂർത്തീകരണമാണ് സാധാരണ HTMLകോഡ്: ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് മാതൃകയുടെ ഉപയോഗം, നിരവധി പ്രോഗ്രാമിംഗ് ഭാഷകൾക്കുള്ള പിന്തുണ, പ്രോജക്റ്റുകളിൽ ഉപയോഗത്തിന് ഇതിനകം തയ്യാറായ ആയിരക്കണക്കിന് പരിഹാരങ്ങൾ അടങ്ങിയ ഒരു സാർവത്രിക അടിത്തറയുടെ സാന്നിധ്യം - Microsoft .NET ഫ്രെയിംവർക്ക്.
കൂടാതെ, ഒരു ആപ്ലിക്കേഷൻ വികസിപ്പിക്കുന്നതിന്, ഏതെങ്കിലും വികസന പരിതസ്ഥിതി അല്ലെങ്കിൽ ഒരു ടെക്സ്റ്റ് എഡിറ്റർ പോലും ഉപയോഗിക്കാം, ഇത് സൃഷ്ടിക്കാനും എഡിറ്റുചെയ്യാനും സംരക്ഷിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു ടെക്സ്റ്റ് ഫയലുകൾ. മൈക്രോസോഫ്റ്റിന്റെ മുഴുവൻ ശക്തിയും പ്രയോജനപ്പെടുത്താൻ ഡവലപ്പർ ആഗ്രഹിക്കുന്നുവെങ്കിൽ. നെറ്റ് ഫ്രെയിംവർക്ക്കൂടാതെ ASP.NET കൂടാതെ, അതേ സമയം, കഴിയുന്നത്ര കുറച്ച് പരിശ്രമം ചെലവഴിക്കുകയും, തുടർന്ന് അവന്റെ ചുമതലകൾക്ക് അനുയോജ്യമായ ഒരു വികസന അന്തരീക്ഷം ഉപയോഗിക്കേണ്ടതുണ്ട്. ഏറ്റവും കൂടുതൽ ഒന്ന് ഫലപ്രദമായ മാർഗങ്ങൾ ASP.NET വെബ് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നത് Microsoft ആണ് വിഷ്വൽ സ്റ്റുഡിയോ. ASP.NET 2.0 പിന്തുണ വിഷ്വൽ സ്റ്റുഡിയോ 2005 ൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.
ASP.NET ചട്ടക്കൂടിന്റെ പുതിയ പതിപ്പായ ASP.NET 2.0-ലെ മിക്ക പുതിയ സവിശേഷതകളും ഈ ലേഖനം ഹ്രസ്വമായി അവതരിപ്പിക്കുന്നു. വാചകത്തിൽ വായനക്കാരന് ASP.NET 1.0 അല്ലെങ്കിൽ ASP.NET 1.1 സാങ്കേതികവിദ്യ പരിചിതമാണെന്ന് അനുമാനിക്കപ്പെടുന്നു. പരിഗണനയിലുള്ള വിഷയം ലേഖനത്തിന്റെ പരിധിക്കപ്പുറമാണെങ്കിൽ, വിശദമായ വിവരങ്ങൾ അടങ്ങിയ ലേഖനത്തിലേക്കുള്ള ഒരു ഹൈപ്പർലിങ്ക് നേരിട്ട് ടെക്സ്റ്റിൽ സ്ഥിതിചെയ്യുന്നു. കൂടാതെ, ലേഖനത്തിന്റെ അവസാനം ഈ ലേഖനത്തിലെ വിവരങ്ങൾ അവതരിപ്പിക്കുന്ന ക്രമത്തിൽ റഫറൻസുകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ട്.

ഒന്നിലധികം പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉപയോഗിക്കുന്നു

Microsoft .NET Framework, Visual Studio 2005 വിഷ്വൽ ബേസിക്, വിഷ്വൽ സി#, വിഷ്വൽ സി++, വിഷ്വൽ ജെ# എന്നിങ്ങനെ നിരവധി പ്രോഗ്രാമിംഗ് ഭാഷകളെ പിന്തുണയ്ക്കുന്നു. കാരണം ഈ ഭാഷകൾ ഒരു പൊതു CLR (പൊതുഭാഷാ റൺടൈം) ഉപയോഗിക്കുകയും അനുസരിക്കുകയും ചെയ്യുന്നു പൊതു മാനദണ്ഡങ്ങൾ CLS (കോമൺ ലാംഗ്വേജ് സ്പെസിഫിക്കേഷൻ), തുടർന്ന് .NET ഭാഷകളിലൊന്ന് ഉപയോഗിച്ച് സൃഷ്ടിച്ച ഒരു അസംബ്ലി മറ്റൊരു പ്രോഗ്രാമിംഗ് ഭാഷയിൽ വികസിപ്പിച്ച ഒരു പ്രോജക്റ്റിൽ ഉപയോഗിക്കാം, ഈ അസംബ്ലിയും ആപ്ലിക്കേഷനും ഒരേ ഭാഷയിൽ എഴുതിയത് പോലെ.
Microsoft .NET Framework 2.0 പുറത്തിറങ്ങിയതോടെ ഇതേ പദ്ധതിയിൽ ഉപയോഗിക്കാൻ സാധിച്ചു വ്യത്യസ്ത ഭാഷകൾപ്രോഗ്രാമിംഗ്. ഒരു ASP.NET വെബ് ആപ്ലിക്കേഷൻ നിരവധി പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ എഴുതാം എന്നത് ഒരു ഭാഷയിൽ ഇതിനകം തെളിയിക്കപ്പെട്ട പരിഹാരങ്ങളുണ്ടെങ്കിൽ, പ്രോജക്റ്റ് മറ്റൊരു ഭാഷ ഉപയോഗിച്ചാണ് എഴുതിയതെങ്കിൽ അല്ലെങ്കിൽ ടീമിന് വ്യത്യസ്തമായ ഡെവലപ്പർമാർ ഉണ്ടെങ്കിൽ അത് വളരെ സൗകര്യപ്രദമാണ്. പ്രോഗ്രാമിംഗ് ഭാഷകൾ. ഒരു പ്രോജക്റ്റിൽ വ്യത്യസ്ത ഭാഷകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ച് ഈ ലേഖനത്തിൽ നിങ്ങൾക്ക് വായിക്കാം.

കോഡ് പങ്കിടൽ സാങ്കേതികവിദ്യ

ഒരു വെബ് ആപ്ലിക്കേഷനിലെ എല്ലാറ്റിന്റെയും കാതൽ പേജാണ്. ഉപയോക്താവ്, ഒരു ബ്രൗസർ ഉപയോഗിച്ച്, പേജുകൾക്കിടയിൽ നീങ്ങുന്നു, മുമ്പ് കണ്ട പേജുകളിലേക്ക് ഇടയ്‌ക്കിടെ മടങ്ങുന്നു, കുറച്ച് ഡാറ്റ HTML ഫോമുകളിലേക്ക് നൽകുകയും ചില ഫലങ്ങൾ നേടുകയും ചെയ്യുന്നു. ASP.NET-ൽ, ഉപയോക്താവ് സൃഷ്ടിക്കുന്ന ഇവന്റുകളോട് പ്രതികരിക്കുന്ന വിവിധ നിയന്ത്രണങ്ങൾ അടങ്ങുന്ന ഒരു വെബ് ഫോമാണ് പേജ്.
അവതരണ കോഡിൽ നിന്ന് ലോജിക് കോഡ് വേർതിരിക്കാൻ ASP.NET 1.x നിങ്ങളെ അനുവദിക്കുന്നു, അതായത്, പേജ് പ്രോഗ്രാം ലോജിക് കോഡ് ഒരു .cs അല്ലെങ്കിൽ .vb ഫയലിൽ സ്ഥാപിക്കുക, പേജ് കോഡിൽ നിന്ന് തന്നെ വേറിട്ട്, ഒരു .aspx ഫയലിൽ സ്ഥാപിക്കുക. ഈ സാങ്കേതികവിദ്യയെ കോഡ്-ബിഹൈൻഡ് എന്ന് വിളിക്കുന്നു. അതിനാൽ, പേജ് കോഡിനെ ബാധിക്കാതെ പേജ് ഡിസൈൻ മാറ്റാൻ കഴിയും, ഇത് ഉത്തരവാദിത്തം പങ്കിടാൻ നിങ്ങളെ അനുവദിക്കുന്നു രൂപംഡിസൈനറും പ്രോഗ്രാമറും തമ്മിലുള്ള പേജിന്റെ പ്രവർത്തനവും. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് .aspx ഫയലിൽ പേജ് നിർദ്ദേശത്തിന്റെ പാരാമീറ്ററുകൾ സജ്ജമാക്കാൻ കഴിയും.

എന്നാൽ എഡിറ്റിംഗിനെ പിന്തുണയ്ക്കാൻ Microsoft ഉപയോഗിച്ച് ASP.NET പേജിലെ വിഷ്വൽ സ്റ്റുഡിയോ .NET, ഈ പേജിന് അനുയോജ്യമായ ക്ലാസും ഈ ക്ലാസിനുള്ള കോഡ് ഏത് ഫയലിലാണോ ഉള്ളതെന്ന് വ്യക്തമാക്കണം. ഇത് ചെയ്യുന്നതിന്, Codebenind, Inherits എന്നീ കീവേഡുകൾ ഉപയോഗിച്ച് പേജ് നിർദ്ദേശം പരിവർത്തനം ചെയ്യുന്നു.

ASP.NET 2.0 മറ്റൊരു കോഡ് വേർതിരിക്കൽ സംവിധാനം ഉപയോഗിക്കുന്നു. പേജ് നിർദ്ദേശത്തിൽ, നിങ്ങൾ മറ്റ് കീവേഡുകൾ ഉപയോഗിക്കണം: CodeFile, Inherits.

ഈ സാഹചര്യത്തിൽ, പേജ് പ്രോഗ്രാം ലോജിക് ക്ലാസിന്റെ കോഡ് CodeFile ആട്രിബ്യൂട്ടിൽ വ്യക്തമാക്കിയ ഫയലിൽ സ്ഥാപിക്കും. വിഷ്വൽ സ്റ്റുഡിയോ 2005 ഭാഗിക ക്ലാസുകൾ ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

പൊതു ഭാഗിക ക്ലാസ് ഡിഫോൾട്ട്: System.Web.UI.Page (സംരക്ഷിത ശൂന്യമായ Page_Load(object sender, EventArgs e) ( ) )

അതിനാൽ, ഒരു ഡവലപ്പർക്ക് ഒരു ക്ലാസിന്റെ കോഡ് നിരവധി ഫയലുകളിൽ സ്ഥാപിക്കാൻ കഴിയും, എന്നാൽ അത്തരം കോഡ് വിതരണം ആപ്ലിക്കേഷനെ വളരെ വലുതും പരിപാലിക്കാനും വികസിപ്പിക്കാനും പ്രയാസകരമാക്കുന്നു.
വിഷ്വൽ സ്റ്റുഡിയോ 2003-ൽ ഉപയോഗിച്ചിരിക്കുന്ന കോഡ്-ബിഹൈൻഡ് മോഡലിന് വളരെ പ്രധാനപ്പെട്ട നിരവധി പോരായ്മകളുണ്ട്. ഒന്നാമതായി, വിഷ്വൽ സ്റ്റുഡിയോ ഉപയോഗിച്ച്, ഒരു ഡെവലപ്പർ പ്രസിദ്ധീകരിക്കുന്നതിന് മുമ്പ് പ്രോജക്റ്റ് കംപൈൽ ചെയ്യണം, കാരണം വിഷ്വൽ സ്റ്റുഡിയോ ഉപയോഗിക്കാത്ത Src ആട്രിബ്യൂട്ട് വ്യക്തമാക്കിയാൽ മാത്രമേ ASP.NET പേജുകൾ കംപൈൽ ചെയ്യുന്നുള്ളൂ. അതേ സമയം, ASP.NET എൻവയോൺമെന്റ് അസംബ്ലി സൃഷ്ടിക്കുന്ന തീയതിയിലെ മാറ്റം കണ്ടെത്തുന്നതിനാൽ, ബിൻ ഡയറക്‌ടറിയിലെ പഴയ അസംബ്ലി മാറ്റിസ്ഥാപിക്കുന്നതിന് ശേഷവും, ആപ്ലിക്കേഷൻ ഡൊമെയ്‌ൻ പുനരാരംഭിക്കുന്നു, ഇത് ആപ്ലിക്കേഷനിൽ താൽക്കാലിക "മന്ദഗതി" ഉണ്ടാക്കുന്നു.
വിഷ്വൽ സ്റ്റുഡിയോ 2005 പുതിയത് ഉപയോഗിക്കുന്നു കീവേഡുകൾ, ASP.NET 2.0 റൺടൈം പിന്തുണയ്ക്കുന്നു, കൂടാതെ റൺടൈം ഉപയോഗിക്കുന്നു പുതിയ സാങ്കേതികവിദ്യപേജുകളുടെ സമാഹാരം. അസംബ്ലിയെ പുതിയൊരെണ്ണം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നതിനുള്ള പ്രശ്നം പരിഹരിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
ഇതൊക്കെയാണെങ്കിലും, വിഷ്വൽ സ്റ്റുഡിയോ 2005 ഇപ്പോഴും നിങ്ങളെ കോഡ് വിഭജനത്തിൽ നിന്ന് മാറി, പേജ് ഫയലിൽ തന്നെ പ്രോഗ്രാം ലോജിക് കോഡ് സ്ഥാപിക്കാനും ഉപയോഗിക്കാനും അനുവദിക്കുന്നു. കൂടാതെ, സ്വതവേ, വിഷ്വൽ സ്റ്റുഡിയോ കോഡ് വിഭജനം കൂടാതെ പേജുകൾ സൃഷ്ടിക്കുന്നു.

ആവശ്യാനുസരണം പേജുകൾ സമാഹരിക്കുന്നു

ഒരു ഉപയോക്താവ് .aspx എക്സ്റ്റൻഷനുമായി ഒരു ഫയൽ അഭ്യർത്ഥിക്കുമ്പോൾ ASP.NET 2.0, ASP.NET 1.0 എന്നിവ ചെയ്യുന്ന പ്രവർത്തനങ്ങൾ താരതമ്യം ചെയ്യാം. ASP.NET 1.x-ൽ, റൺടൈം നിർദ്ദേശം പാഴ്‌സ് ചെയ്യുന്നു പേജ് പേജുകൾ, ആപ്ലിക്കേഷൻ അസംബ്ലിയിലെ അനുബന്ധ ക്ലാസിനായി തിരയുന്നു, തുടർന്ന് പേജ് കോഡിനെ അടിസ്ഥാനമാക്കി, പേജ് പ്രോഗ്രാം ലോജിക് ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ഒരു ക്ലാസ് സൃഷ്ടിക്കപ്പെടുന്നു. അസംബ്ലി നഷ്ടപ്പെട്ടാൽ, പേജ് നിർദ്ദേശത്തിന്റെ Src ആട്രിബ്യൂട്ടിൽ വ്യക്തമാക്കിയ പ്രോഗ്രാം ലോജിക് ഫയൽ തിരയുന്നു. ഫയൽ കണ്ടെത്തിയാൽ, അസംബ്ലി കംപൈൽ ചെയ്യുന്നു; ഇല്ലെങ്കിൽ, ASP.NET ഒരു ഒഴിവാക്കൽ നൽകുന്നു.
ASP.NET 2.0-ൽ, റൺടൈം പേജ് നിർദ്ദേശങ്ങൾ പാഴ്‌സ് ചെയ്യുന്നു, പേജ് ലോജിക് ക്ലാസുമായി പൊരുത്തപ്പെടുന്ന ഒരു അസംബ്ലിക്കായി തിരയുന്നു, തുടർന്ന് പേജ് ക്ലാസ് സൃഷ്ടിക്കുന്നു. ASP.NET 1.x-ൽ നിന്ന് വ്യത്യസ്തമായി, പേജ് ക്ലാസിനായുള്ള പാരന്റ് ക്ലാസ് System.Web.UI.Page ആണ്, കാരണം സൃഷ്ടിക്കപ്പെടുന്ന ഡൈനാമിക് ക്ലാസ് പേജ് ക്ലാസ് തന്നെയാണ് (പേജ് ക്ലാസിനും ആപ്ലിക്കേഷൻ ലോജിക് ക്ലാസിനും ഭാഗിക ക്ലാസുകൾ ഉപയോഗിക്കുന്നത്) , കൂടാതെ ആപ്ലിക്കേഷൻ ക്ലാസ് ലോജിക്കിന്റെ പിൻഗാമിയല്ല. അതിനാൽ, ASP.NET 1.x-ൽ വെബ് ഫോം ക്ലാസിനെ വെബ് ഫോമിന് തന്നെ വിളിക്കാം.

... പൊതു ക്ലാസ് frmDefault: System.Web.UI.Page (സംരക്ഷിത ശൂന്യമായ Page_Load(object sender, EventArgs e) ( ) )

ASP.NET 2.0-ൽ, System.Web.UI.Form നിയന്ത്രണം ഒരു ക്ലാസിലെ അംഗമായതിനാൽ ഇത് അനുവദനീയമല്ല.
പേജ് പ്രവർത്തിപ്പിക്കുന്നതിന് അസംബ്ലി ആവശ്യമില്ലെങ്കിൽ, മുഴുവൻ അസംബ്ലിയും വീണ്ടും കംപൈൽ ചെയ്യാതെ, പേജിന്റെ ലോജിക് ഫയൽ മാത്രമേ കംപൈൽ ചെയ്യുകയുള്ളൂ എന്നതാണ് ASP.NET-ന്റെ പ്രധാന നേട്ടം. ഡൈനാമിക് കംപൈലേഷൻ ഉള്ളതിനാൽ, ആപ്ലിക്കേഷന്റെ എല്ലാ പേജുകൾക്കും പൊതുവായുള്ള കോഡ് സൃഷ്ടിക്കാനുള്ള കഴിവ് നൽകേണ്ടത് ആവശ്യമാണ്. ഈ ആവശ്യത്തിനായി, ASP.NET 2.0-ൽ ആപ്ലിക്കേഷൻ റൂട്ട് ഡയറക്‌ടറിയുടെ ചൈൽഡ് ഡയറക്‌ടറികളായ പ്രത്യേക ഡയറക്‌ടറികളുണ്ട്, അതിലൊന്നാണ് App_Code, അടങ്ങുന്ന ഫയലുകൾ സംഭരിക്കാൻ ഉപയോഗിക്കുന്നു. പൊതു കോഡ്എല്ലാ പേജുകൾക്കും. ഡൈനാമിക് കംപൈലേഷൻ നടത്തുമ്പോൾ, App_Code ഡയറക്ടറിയിൽ നിന്നുള്ള കോഡ് കംപൈൽ ചെയ്യുകയും വെബ് ആപ്ലിക്കേഷന്റെ എല്ലാ പേജുകളിലും ലഭ്യമാക്കുകയും ചെയ്യുന്നു. അതേ സമയം, വിഷ്വൽ സ്റ്റുഡിയോ 2005 App_Code ഡയറക്ടറിയിൽ സ്ഥിതി ചെയ്യുന്ന കോഡിനെ പിന്തുണയ്ക്കുന്നു, അതിനാൽ വാക്യഘടന ഹൈലൈറ്റിംഗും ഇന്റലിസെൻസും പ്രവർത്തിക്കുന്നു.
ASP.NET 2.0 റൺടൈം സൃഷ്‌ടിച്ച ഫയലുകൾ നിങ്ങൾക്ക് പരിശോധിക്കാനും ഡയറക്‌ടറിയിലെ ഉള്ളടക്കങ്ങൾ പരിശോധിച്ചുകൊണ്ട് കംപൈലേഷൻ പ്രക്രിയ വിശദമായി മനസ്സിലാക്കാനും കഴിയും: %WINDIT%\Microsoft.NET\Framework\version\Temporary ASP.NET Files\application_name, ഇവിടെ ASP .NET 2.0 സ്ഥലങ്ങൾ ചലനാത്മകമായി സൃഷ്ടിച്ച അസംബ്ലികൾ . അല്ലെങ്കിൽ, ഡീബഗ്ഗിംഗ് മോഡിൽ ഒരു ASP.NET പേജിൽ ഒരു പിശക് സംഭവിച്ചതിനാൽ, സമ്പൂർണ്ണ സമാഹരണ ഉറവിടം കാണിക്കുക എന്ന ലിങ്ക് തിരഞ്ഞെടുക്കുക.

നിങ്ങൾക്ക് പ്രോജക്റ്റ് മുൻകൂട്ടി കംപൈൽ ചെയ്യണമെങ്കിൽ, ASP.NET 2.0-ൽ സെർവറിൽ വിന്യസിക്കുന്നതിന് മുമ്പ്, വെബ് ആപ്ലിക്കേഷൻ പൂർണ്ണമായോ ഭാഗികമായോ മുൻകൂട്ടി കംപൈൽ ചെയ്യാൻ സാധിക്കും. ഈ ലേഖനത്തിൽ പ്രീകോമ്പൈലേഷനെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതൽ വായിക്കാം.

വിഷ്വൽ സ്റ്റുഡിയോ പ്രോജക്റ്റ് ഘടനയിലെ മാറ്റങ്ങൾ

വിഷ്വൽ സ്റ്റുഡിയോ 2005-ൽ ഓരോ ASP.NET പ്രോജക്റ്റ് തരത്തിനും മുമ്പ് സൃഷ്‌ടിച്ച .csproj അല്ലെങ്കിൽ .vbproj ഫയലുകൾ ഇനിയുണ്ടാകില്ല. പ്രോജക്റ്റ് ഫയലുകൾക്ക് പകരം, വിഷ്വൽ സ്റ്റുഡിയോ ഒരു ഡയറക്‌ടറി ഘടനയാണ് ഉപയോഗിക്കുന്നത്, അതിനാൽ ഒരു പ്രോജക്റ്റിൽ നിലവിലുള്ള ഒരു ഫയൽ ഉൾപ്പെടുത്തുന്നതിന്, അത് പ്രോജക്റ്റ് ഡയറക്‌ടറിയിലേക്ക് പകർത്തുക. സൊല്യൂഷൻ എക്സ്പ്ലോറർ വിൻഡോയിലെ പ്രോജക്റ്റ് ഫയൽ ട്രീയിൽ നിന്ന് ഒരു ഫയലോ ഡയറക്ടറിയോ ഇല്ലാതാക്കിയാൽ, ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് ഫയലോ ഡയറക്ടറിയോ ഫിസിക്കൽ ആയി നീക്കം ചെയ്യപ്പെടുമെന്ന കാര്യം ശ്രദ്ധിക്കേണ്ടതാണ്.

ASP.NET 2.0 പേജ് @പേജ് നിർദ്ദേശം

ASP.NET 2.0-ലേക്ക് പുതിയ സവിശേഷതകൾ കൊണ്ടുവരുന്നതിന്, പേജ് ക്ലാസിൽ മാറ്റങ്ങളും കൂട്ടിച്ചേർക്കലുകളും നടത്തേണ്ടത് ആവശ്യമാണ്. പേജ് ഡയറക്‌ടീവിന്റെ ആട്രിബ്യൂട്ടുകൾ ഡിസൈൻ-ടൈമിൽ പേജ് പ്രോപ്പർട്ടികൾ സജ്ജീകരിക്കാൻ ഉപയോഗിക്കുന്നതിനാൽ, വ്യക്തിഗതമാക്കൽ മെക്കാനിസങ്ങൾ, ഡിസൈൻ ടെംപ്ലേറ്റുകൾ, ലേഔട്ട്, പേജുകളുടെ അസിൻക്രണസ് ഓപ്പറേഷൻ എന്നിവ നടപ്പിലാക്കുന്നതിനായി പ്രത്യക്ഷപ്പെട്ട പുതിയ ആട്രിബ്യൂട്ടുകൾ ഇവിടെ ചർച്ചചെയ്യും. പുതിയ ആട്രിബ്യൂട്ടുകളുടെ അസൈൻമെന്റിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ പേജ് ക്ലാസിന്റെ പുതിയ പ്രോപ്പർട്ടികൾ, രീതികൾ എന്നിവയ്ക്കായി നീക്കിവച്ചിരിക്കുന്ന ലേഖനത്തിന്റെ ഭാഗത്ത് കാണാം.

അസിൻക്

പേജ് ക്ലാസ് നടപ്പിലാക്കുന്ന IHttpHandler അല്ലെങ്കിൽ IHttpAsyncHandler എന്നിവയിൽ ഏതാണ് ഇന്റർഫേസ് എന്ന് സൂചിപ്പിക്കുന്നു. ഈ ആട്രിബ്യൂട്ട് true ആയി സജ്ജീകരിച്ച ശേഷം, ചലനാത്മകമായി ജനറേറ്റ് ചെയ്ത പേജ് ക്ലാസ് IHttpAsyncHandler നടപ്പിലാക്കും, അല്ലാത്തപക്ഷം ക്ലാസ് IHttpHandler നടപ്പിലാക്കും. പേജ് ക്ലാസ് IHttpAsyncHandler നടപ്പിലാക്കുകയാണെങ്കിൽ, പ്രീറെൻഡർ പേജ് ലൈഫ് സൈക്കിളിൽ ഒരു പുതിയ ഇവന്റ് സംഭവിക്കുന്നത് വരെ പേജ് കോഡ് അസമന്വിതമായി നടപ്പിലാക്കാൻ കഴിയും, ആ സമയത്ത് HTML കോഡ് സമന്വയിപ്പിച്ച് ക്ലയന്റ് ബ്രൗസറിലേക്ക് അയയ്‌ക്കാൻ തയ്യാറാണ്.

AsyncTimeOut

അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള സമയ പരിധി സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ഈ ക്രമീകരണം 45 സെക്കൻഡാണ്.

സംസ്കാരം

പേജിനായി ഉപയോഗിക്കുന്ന സംസ്കാര സെറ്റ് സജ്ജമാക്കുന്നു.

EnableTheming

തീം പിന്തുണ പ്രവർത്തനക്ഷമമാക്കാനോ പ്രവർത്തനരഹിതമാക്കാനോ നിങ്ങളെ അനുവദിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനക്ഷമമാക്കി.

മാസ്റ്റർപേജ് ഫയൽ

ഈ പേജിനായി കോഡ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന ടെംപ്ലേറ്റിലേക്കുള്ള പാത വ്യക്തമാക്കുന്നു.

സ്റ്റൈൽ ഷീറ്റ് തീം

മാറ്റാൻ ഉപയോഗിക്കുന്ന ചർമ്മത്തിന്റെ ഐഡി സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു ഇൻസ്റ്റാൾ ചെയ്ത തീംഡിസൈൻ (തീം ആട്രിബ്യൂട്ടിൽ അല്ലെങ്കിൽ web.confg ഫയലിൽ). ഈ രീതിയിൽ, നിങ്ങൾക്ക് മുഴുവൻ സൈറ്റിനും പൊതുവായ ഒരു തീം സജ്ജീകരിക്കാനും പേജിന്റെ മൊത്തത്തിലുള്ള രൂപകൽപ്പനയിലും കൂടാതെ/അല്ലെങ്കിൽ പേജിൽ അടങ്ങിയിരിക്കുന്ന ചില നിയന്ത്രണങ്ങളിലും ചില മാറ്റങ്ങൾ വരുത്താൻ StyleSheetTheme ആട്രിബ്യൂട്ട് ഉപയോഗിക്കാനും കഴിയും.

തീം

ഈ പേജിന്റെ കോഡ് സ്റ്റൈൽ ചെയ്യാൻ ഉപയോഗിക്കുന്ന തീമിന്റെ പേര് വ്യക്തമാക്കുന്നു.

UI സംസ്കാരം

ഉപയോഗിക്കുന്ന സംസ്ക്കാരം (സംസ്കാരം) സജ്ജമാക്കുന്നു ഉപയോക്തൃ ഇന്റർഫേസ്പേജുകൾ.

പേജ് ജീവിത ചക്രം

ഒരു ASP.NET പേജിന്റെ ജീവിത ചക്രം ആരംഭിക്കുന്നത് IIS വെബ് സെർവർ ആ പേജിനായി ഒരു അഭ്യർത്ഥന സ്വീകരിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ASP.NET റൺടൈമിലേക്ക് ആ അഭ്യർത്ഥന കൈമാറുകയും ചെയ്യുന്നു. ഒരു അഭ്യർത്ഥന ലഭിക്കുമ്പോൾ, റൺടൈം വിളിക്കപ്പെടുന്ന പേജിന്റെ ക്ലാസ് ലോഡ് ചെയ്യുന്നു, പേജ് ക്ലാസിന്റെ പ്രോപ്പർട്ടികൾ സജ്ജീകരിക്കുന്നു, ഘടകങ്ങളുടെ ഒരു ട്രീ നിർമ്മിക്കുന്നു, അഭ്യർത്ഥന, പ്രതികരണ പ്രോപ്പർട്ടികൾ പോപ്പുലേറ്റ് ചെയ്യുന്നു, കൂടാതെ IHttpHandler.ProcessRequest രീതി വിളിക്കുന്നു. റൺടൈം പിന്നീട് പരിശോധിക്കുന്നു. പേജിനെ എങ്ങനെയാണ് വിളിച്ചത്, മറ്റൊരു പേജിൽ നിന്ന് ഡാറ്റ കൈമാറുന്നതിലൂടെയാണ് പേജ് വിളിച്ചതെങ്കിൽ, അത് പിന്നീട് ചർച്ചചെയ്യും, റൺടൈം PreviousPage പ്രോപ്പർട്ടി സജ്ജമാക്കുന്നു.
ചുവടെ ചർച്ച ചെയ്‌തിരിക്കുന്ന പേജ് എക്‌സിക്യൂഷൻ ഘട്ടങ്ങൾക്ക് പുറമേ, പേജിന് പ്രത്യേകമല്ലാത്ത ആപ്ലിക്കേഷൻ-ലെവൽ ഘട്ടങ്ങളും ഉണ്ടെന്നതും ശ്രദ്ധിക്കേണ്ടതാണ്. ആപ്ലിക്കേഷൻ എക്സിക്യൂഷൻ ഘട്ടങ്ങളെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ ഈ ലേഖനത്തിൽ എഴുതിയിരിക്കുന്നു.

സ്റ്റേജ് വിവരണം

അഭ്യർത്ഥന പേജ്	പേജിന്റെ ജീവിത ചക്രത്തിന്റെ തുടക്കത്തിൽ ഒരു പേജ് അഭ്യർത്ഥന നടത്തുന്നു. ഒരു ഉപയോക്താവ് ഒരു അഭ്യർത്ഥന നടത്തുമ്പോൾ, ASP.NET റൺടൈം പേജ് കംപൈൽ ചെയ്ത് അതിന്റെ ലൈഫ് സൈക്കിൾ ആരംഭിക്കണമോ അതോ കാഷെ ചെയ്‌ത പേജ് ഒരു പ്രതികരണമായി നൽകണമോ എന്ന് നിർണ്ണയിക്കുന്നു, അങ്ങനെ പേജ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നില്ല.
ജീവിത ചക്രത്തിന്റെ തുടക്കം	ഈ ഘട്ടത്തിൽ, Response and Request പ്രോപ്പർട്ടികൾ, UICulture പ്രോപ്പർട്ടികൾ എന്നിവ സജ്ജീകരിച്ചിരിക്കുന്നു. കൂടാതെ, ഈ ഘട്ടത്തിൽ ഈ പേജ് ഒരു പോസ്റ്റ്ബാക്ക് (സെർവറിലേക്ക് ഡാറ്റ അയയ്ക്കൽ) ഫലമായി അഭ്യർത്ഥിച്ചതാണോ എന്ന് നിർണ്ണയിക്കപ്പെടുന്നു, അതനുസരിച്ച് IsPostBack പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്നു.
പേജ് സമാരംഭം	പേജ് ആരംഭിക്കുമ്പോഴേക്കും, എല്ലാ ചൈൽഡ് ഉപയോക്തൃ നിയന്ത്രണങ്ങളും ഇതിനകം തന്നെ സൃഷ്‌ടിക്കപ്പെട്ടിട്ടുണ്ട്, കൂടാതെ UniqueID പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്നു. അതേ സമയം, തീമുകൾ പേജിൽ പ്രയോഗിക്കുന്നു. ഒരു പോസ്റ്റ്‌ബാക്കിന്റെ ഫലമായാണ് പേജ് വിളിക്കുന്നതെങ്കിൽ, സെർവറിലേക്ക് അയച്ച ഡാറ്റ ഈ ഘട്ടത്തിൽ ഇതുവരെ നിയന്ത്രണങ്ങളുടെ പ്രോപ്പർട്ടികളിലേക്ക് ലോഡ് ചെയ്തിട്ടില്ല.
ഒരു പോസ്റ്റ്ബാക്കിന്റെ ഫലമായാണ് പേജ് വിളിക്കുന്നതെങ്കിൽ, ഈ ഘട്ടത്തിൽ നിയന്ത്രണങ്ങളുടെ പ്രോപ്പർട്ടികൾ സംസ്ഥാന വിവരങ്ങളുടെ (വ്യൂസ്റ്റേറ്റ്, കൺട്രോൾസ്റ്റേറ്റ്) അടിസ്ഥാനമാക്കി സജ്ജീകരിച്ചിരിക്കുന്നു.
മൂല്യനിർണ്ണയം	പേജിലെ എല്ലാ വാലിഡേറ്റർമാർക്കും Validate() രീതി വിളിക്കുന്നു.
പോസ്റ്റ്ബാക്ക് പ്രോസസ്സിംഗ്	ഇവന്റ് ഹാൻഡ്ലർമാരെ വിളിക്കുന്നു (പോസ്റ്റ്ബാക്ക് സംഭവിച്ചിട്ടുണ്ടെങ്കിൽ).
റെൻഡറിംഗ്	സംസ്ഥാന വിവരങ്ങൾ സംരക്ഷിച്ചു, തുടർന്ന് ഒരു HTML പ്രാതിനിധ്യം സൃഷ്ടിക്കുന്നതിനും Response.OutputStream-ലേക്ക് കൈമാറുന്നതിനുമുള്ള കുട്ടിയുടെ നിയന്ത്രണങ്ങളുടെ ഉചിതമായ രീതികൾ പേജ് ക്ലാസ് വിളിക്കുന്നു.
അൺലോഡ് ചെയ്യുന്നു	മുഴുവൻ പേജിനുമുള്ള HTML പ്രാതിനിധ്യം സൃഷ്ടിച്ചതിന് ശേഷം അൺലോഡിംഗ് സംഭവിക്കുന്നു.

ജീവിത ചക്രം പുരോഗമിക്കുമ്പോൾ, സബ്‌സ്‌ക്രൈബ് ചെയ്യുന്നതിലൂടെ, ഡവലപ്പറെ സ്വന്തം കോഡ് എക്‌സിക്യൂട്ട് ചെയ്യാൻ അനുവദിക്കുന്ന സംഭവങ്ങൾ സംഭവിക്കുന്നു. @Page നിർദ്ദേശത്തിന്റെ AutoEventWireup ആട്രിബ്യൂട്ട് പരാമർശിക്കേണ്ടതാണ്: ഈ ആട്രിബ്യൂട്ട് true ആയി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ (സ്ഥിര മൂല്യം), Page_EventName എന്ന് പേരുള്ള പേജ് ക്ലാസിന്റെ രീതികൾ, അനുബന്ധ പേജ് ലൈഫ് സൈക്കിൾ ഇവന്റുകളുടെ ഹാൻഡ്‌ലറുകളായി മാറുന്നു.
ഒരു പേജിന്റെ ജീവിത ചക്രവും സംഭവങ്ങളുടെ ക്രമവും കണ്ടെത്തുന്നതിന്, നിങ്ങൾക്ക് @പേജ് നിർദ്ദേശത്തിന്റെ ട്രേസ് ആട്രിബ്യൂട്ട് true ആയും TraceMode ആട്രിബ്യൂട്ട് "SortByTime" ആയും സജ്ജമാക്കാൻ കഴിയും. തുടർന്ന് ട്രെയ്‌സ് ഇൻഫർമേഷൻ വിഭാഗത്തിൽ നിങ്ങൾക്ക് സംഭവിച്ച ഇവന്റുകളുടെ ഒരു ലിസ്റ്റ് കണ്ടെത്താനാകും (സന്ദേശ കോളം). ഉദാഹരണത്തിന്:

വിവരങ്ങൾ കണ്ടെത്തുകആദ്യ(കളിൽ) നിന്നുള്ള വിഭാഗം സന്ദേശം അവസാന(കളിൽ) നിന്ന്

aspx.page	PreInit ആരംഭിക്കുക
aspx.page	പ്രീഇനിറ്റ് അവസാനിപ്പിക്കുക	0.0364973314167865	0.036497
aspx.page	Init ആരംഭിക്കുക	0.0379050459346291	0.001408
aspx.page	ഇനിറ്റ് അവസാനിപ്പിക്കുക	0.047693704143491	0.009789
aspx.page	InitComplete ആരംഭിക്കുക	0.0477864508468221	0.000093
aspx.page	InitComplete അവസാനിപ്പിക്കുക	0.0481875670270608	0.000401
aspx.page	പ്രീലോഡ് ആരംഭിക്കുക	0.0489879732516718	0.000800
aspx.page	പ്രീലോഡ് അവസാനിപ്പിക്കുക	0.0494462283607275	0.000458
aspx.page	ലോഡ് ആരംഭിക്കുക	0.0494924892194238	0.000046
aspx.page	എൻഡ് ലോഡ്	0.0553441897381414	0.005852
aspx.page	ലോഡ് കംപ്ലീറ്റ് ആരംഭിക്കുക	0.0554711043059809	0.000127
aspx.page	ലോഡ് കംപ്ലീറ്റ് അവസാനിപ്പിക്കുക	0.055942153615399	0.000471
aspx.page	പ്രീറെൻഡർ ആരംഭിക്കുക	0.0561455634022874	0.000203
aspx.page	പ്രീറെൻഡർ അവസാനിപ്പിക്കുക	0.0618604874695332	0.005715
aspx.page	PreRenderComplete ആരംഭിക്കുക	0.06269871008062	0.000838
aspx.page	PreRenderComplete അവസാനിപ്പിക്കുക	0.0633259746265858	0.000627
aspx.page	SaveState ആരംഭിക്കുക	0.080360541216174	0.017035
aspx.page	SaveState അവസാനിപ്പിക്കുക	0.213795377788888	0.133435
aspx.page	SaveStateComplete ആരംഭിക്കുക	0.213911298043872	0.000116
aspx.page	SaveStateComplete അവസാനിപ്പിക്കുക	0.214385763389788	0.000474
aspx.page	റെൻഡർ ആരംഭിക്കുക	0.214440078745078	0.000054
aspx.page	റെൻഡർ അവസാനിപ്പിക്കുക	0.315044337228923	0.100604

എല്ലാ പേജ് ലൈഫ് സൈക്കിൾ ഇവന്റുകളിലും, ഒരു ഡെവലപ്പർക്ക് ചൈൽഡ് കൺട്രോൾ ഇവന്റുകൾക്ക് പുറമേ അഞ്ചെണ്ണം മാത്രമേ സബ്‌സ്‌ക്രൈബ് ചെയ്യാൻ കഴിയൂ. ഈ ഇവന്റുകൾ ഇവയാണ്: PreInit, Init, ലോഡ്, പ്രീറെൻഡർ, അൺലോഡ്. ഈ ഇവന്റുകൾ ഉപയോഗിക്കുന്നതിനുള്ള ഓപ്ഷനുകൾ നോക്കാം.

ഇവന്റ് ഉപയോഗം

പ്രീഇനിറ്റ്	ഈ ഇവന്റ് സമയത്ത്, ഈ പേജ് ആദ്യമായി വിളിച്ചതാണോ അതോ ഒരു പോസ്റ്റ്ബാക്കിന്റെ ഫലമാണോ എന്ന് നിർണ്ണയിക്കാൻ നിങ്ങൾക്ക് IsPostBack പ്രോപ്പർട്ടി ഉപയോഗിക്കാം. പേജ് മാനേജുമെന്റിന്റെ കാര്യത്തിൽ, ഒരു ഡെവലപ്പർക്ക് കഴിയും: ചലനാത്മകമായി നിയന്ത്രണങ്ങൾ സൃഷ്ടിക്കുക, ഒരു ഡിസൈൻ ടെംപ്ലേറ്റ് അല്ലെങ്കിൽ തീം ചലനാത്മകമായി സജ്ജമാക്കുക, ഒരു പ്രൊഫൈൽ ഒബ്‌ജക്റ്റിന്റെ പ്രോപ്പർട്ടികൾ വായിക്കുക അല്ലെങ്കിൽ സജ്ജമാക്കുക. ഈ ഘട്ടത്തിൽ, ഒരു പോസ്റ്റ്ബാക്കിന്റെ ഫലമായാണ് പേജ് വിളിച്ചതെങ്കിൽ, നിയന്ത്രണങ്ങളുടെ സവിശേഷതകൾ ഇതുവരെ സജ്ജീകരിച്ചിട്ടില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഡവലപ്പർ ഈ ഘട്ടത്തിൽ, അടുത്ത ഘട്ടത്തിൽ പ്രോപ്പർട്ടികൾ സ്വതന്ത്രമായി സജ്ജമാക്കുകയാണെങ്കിൽ സെറ്റ് മൂല്യംമാറ്റാൻ കഴിയും.
Init	ഈ ഘട്ടത്തിൽ, ഡെവലപ്പർക്ക് നിയന്ത്രണങ്ങളുടെ സവിശേഷതകൾ വായിക്കാനോ ആരംഭിക്കാനോ കഴിയും.
ലോഡ് ചെയ്യുക	ഈ സമയത്ത്, ഡെവലപ്പർക്ക് നിയന്ത്രണങ്ങളുടെ സവിശേഷതകൾ വായിക്കാനോ മാറ്റാനോ കഴിയും.
പ്രീറെൻഡർ	അവസാനത്തെ അവസരംപേജിന്റെ രൂപത്തിൽ മാറ്റങ്ങൾ വരുത്തുക.
അൺലോഡ് ചെയ്യുക	അധിനിവേശ ഉറവിടങ്ങൾ സ്വതന്ത്രമാക്കുക (ഡാറ്റാബേസിലേക്കുള്ള തുറന്ന കണക്ഷനുകൾ അടയ്ക്കുക, ഫയലുകൾ ഷട്ട്ഡൗൺ ചെയ്യുക മുതലായവ) ഈ ഘട്ടത്തിൽ പേജിന്റെ HTML പ്രാതിനിധ്യം ഇതിനകം തന്നെ സൃഷ്‌ടിച്ചിട്ടുണ്ട് എന്നത് പ്രധാനമാണ്, കൂടാതെ എന്തെങ്കിലും മാറ്റങ്ങൾ വരുത്താനുള്ള ശ്രമം (ഉദാഹരണത്തിന്, Response.Write() രീതി എന്ന് വിളിക്കുന്നതിലൂടെ) ഒരു ഒഴിവാക്കലിന് കാരണമാകും.

പേജ് ഒബ്ജക്റ്റിന്റെ പുതിയ ഗുണങ്ങളും രീതികളും

മുമ്പത്തെ വിഭാഗത്തിൽ ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന ഇവന്റുകൾ നിയന്ത്രിക്കുന്നതിനും അവയുടെ നിർവ്വഹണ ഫലങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുന്നതിനും, ASP.NET 2.0-ലെ പേജ് ഒബ്‌ജക്റ്റിന് ഇനിപ്പറയുന്ന പുതിയ രീതികളും സവിശേഷതകളും ഉണ്ട്. പൂർണമായ വിവരംചുവടെ ലിസ്റ്റുചെയ്തിരിക്കുന്ന വസ്തുക്കളും ഗുണങ്ങളും അവയുടെ ഉപയോഗങ്ങളും ഈ ലേഖനത്തിന്റെ അടുത്ത വിഭാഗത്തിൽ കൂടുതൽ ചർച്ചചെയ്യും.

EnableTheming

ഒരു തീമിന്റെ ഉപയോഗം ആവശ്യമില്ലെങ്കിൽ, ഒരു പേജിലെ തീമുകൾക്കുള്ള പിന്തുണ പ്രവർത്തനരഹിതമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രോപ്പർട്ടി.

GetValidators

ഈ പേജിനായി മൂല്യനിർണ്ണയക്കാരുടെ ഒരു ശേഖരം തിരികെ നൽകുന്ന ഒരു രീതി.

തലക്കെട്ട്

ഹെഡ് എലമെന്റിൽ runat="server" ആട്രിബ്യൂട്ട് സെറ്റ് ഉണ്ടെങ്കിൽ, പേജിന്റെ HTML വിഭാഗത്തിലെ ഉള്ളടക്കം നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു HtmlHead ഒബ്‌ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസ്.

IsAsync

പേജ് പ്രോസസ്സ് ചെയ്യുന്നതെങ്ങനെയെന്ന് സൂചിപ്പിക്കുന്ന ഒരു പ്രോപ്പർട്ടി - സിൻക്രണസ് അല്ലെങ്കിൽ അസിൻക്രണസ്.

IsCrossPagePostBack

എന്ന് നിർണ്ണയിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രോപ്പർട്ടി ഈ പേജ്മറ്റൊരു പേജിൽ നിന്ന് അയച്ച ഡാറ്റയുടെ പ്രതികരണമായി അഭ്യർത്ഥിച്ചു.

മാസ്റ്റർപേജ് ഫയൽ

പേജ് ടെംപ്ലേറ്റ് ഫയലിന്റെ പേര് അടങ്ങുന്ന ഒരു പ്രോപ്പർട്ടി.

MaxPageStateFieldLength

ഇൻസ്റ്റാൾ ചെയ്യുന്നു പരമാവധി വലിപ്പംസംസ്ഥാനത്തെ സംഭരിക്കുന്ന ഒരു ഫീൽഡ്, ബൈറ്റുകളിൽ. ഈ പ്രോപ്പർട്ടി സംഭരിക്കേണ്ട സംസ്ഥാന വിവരങ്ങളുടെ വലുപ്പത്തേക്കാൾ കുറവായി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഒന്നിലധികം മറഞ്ഞിരിക്കുന്ന ഫീൽഡുകൾ സൃഷ്ടിക്കപ്പെടും, ഓരോന്നിനും MaxPageStateFieldLength മൂല്യത്തേക്കാൾ കൂടുതൽ ഡാറ്റയില്ല .

പേജ് അഡാപ്റ്റർ

പേജിന്റെ HTML പ്രാതിനിധ്യത്തിന്റെ ജനറേഷൻ നിയന്ത്രിക്കുന്ന ഒരു PageAdapter ഒബ്‌ജക്റ്റ് പ്രോപ്പർട്ടി നൽകുന്നു. റിക്വറ്റ് പാരാമീറ്ററുകൾ അനുസരിച്ച് റൺടൈം അനുസരിച്ച് നിർദ്ദിഷ്ട പേജ് അഡാപ്റ്റർ സജ്ജീകരിച്ചിരിക്കുന്നു. PageAdapter തിരഞ്ഞെടുത്തിട്ടുണ്ടെങ്കിൽ, പേജ് ലൈഫ് സൈക്കിൾ ഇവന്റുകൾ PaeAdapter ഇവന്റുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും.

സെറ്റ്ഫോക്കസ്

പേജിൽ ദൃശ്യമാകുന്ന ഏത് നിയന്ത്രണങ്ങളിലേക്കും ഹൈലൈറ്റിംഗ് സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു രീതി.

സ്റ്റൈൽ ഷീറ്റ് തീം, തീം

പുതിയ @പേജ് ഡയറക്റ്റീവ് ആട്രിബ്യൂട്ടുകളുടെ വിവരണത്തിനായി മുകളിൽ കാണുക.

TestDeviceFilter

എന്ന് പരിശോധിക്കുന്ന രീതി നിലവിലെ ബ്രൗസർഒരു ആർഗ്യുമെന്റായി വ്യക്തമാക്കിയ തരത്തിലുള്ള ബ്രൗസർ.

തലക്കെട്ട്

പേജിന്റെ ശീർഷകം നേടാനും മാറ്റാനും നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രോപ്പർട്ടി.

പുതിയ ASP.NET 2.0 പേജ് ഒബ്ജക്റ്റ്സ് ClientScriptManager ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നു

ClientScriptManager, വെബ് ആപ്ലിക്കേഷന്റെ ക്ലയന്റ് ഭാഗത്ത് ഉപയോഗിക്കുന്ന സ്ക്രിപ്റ്റ് കോഡുമായി പ്രവർത്തിക്കുന്നതിനുള്ള രീതികൾ നൽകുന്നു. ഇപ്പോൾ ASP.NET 1.x-ൽ ക്ലയന്റ് സ്‌ക്രിപ്‌റ്റുകളോ മറഞ്ഞിരിക്കുന്ന ഫീൽഡുകളോ രജിസ്റ്റർ ചെയ്യുന്നതിന് ഉപയോഗിച്ച എല്ലാ രീതികളും ClientScriptManager ക്ലാസിൽ പെടുന്നു. ഉദാഹരണത്തിന്, ചില പരാമീറ്ററുകളെ ആശ്രയിച്ച്, ചിലപ്പോൾ ഒരു ക്ലയന്റ് സ്ക്രിപ്റ്റ് ഡൈനാമിക് ആയി രജിസ്റ്റർ ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഉദാഹരണത്തിന്, ഒരു ഫോറം പേജ് വീണ്ടും ലോഡുചെയ്യുമ്പോൾ, ഉപയോക്താവിന് ഒരു പുതിയ വ്യക്തിഗത സന്ദേശം ലഭിച്ചുവെന്ന് നിങ്ങൾ സൂചിപ്പിക്കേണ്ടതുണ്ട്. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഇത് ചെയ്യാൻ കഴിയും.

സംരക്ഷിത ശൂന്യമായ Page_Load(object sender, EventArgs e) ((CheckMail()) (string startupScript = "" + "if(confirm("നിങ്ങൾക്ക് ഒരു പുതിയ സന്ദേശം ലഭിച്ചു. വായിക്കുക?"))" + "window.navigate(" /ReadMail .aspx");" + ""; ClientScript.RegisterStartupScript(this.GetType(), "MailAlertScript", startupScript); ) )

HtmlHead ഒബ്‌ജക്റ്റ്

ഓരോ ASP.NET പേജിനും അതിന്റെ HTML കോഡിൽ ഒരു ടാഗ് അടങ്ങിയിരിക്കുന്നു, HtmlHead ഒബ്‌ജക്റ്റിന്റെ ഒരു ഉദാഹരണം സ്വയമേവ സൃഷ്‌ടിക്കപ്പെടും, ഇത് നിങ്ങളെ മാനേജ് ചെയ്യാൻ അനുവദിക്കുന്നു പേജ് തലക്കെട്ട്, കാസ്‌കേഡിംഗ് സ്റ്റൈൽ ഷീറ്റുകളിലേക്ക് META ടാഗുകളും ലിങ്കുകളും ചേർക്കുക.
മുമ്പ്, ഒരു ASP.NET 1.0 പേജ് ഡെവലപ്പർ പേജിന്റെ ശീർഷകവും മെറ്റാഡാറ്റയും നിയന്ത്രിക്കുന്നതിന് പേജ് ക്ലാസിലേക്ക് ഒരു പ്രത്യേക പ്രോപ്പർട്ടി അല്ലെങ്കിൽ വേരിയബിൾ ചേർക്കണം അല്ലെങ്കിൽ ഏതെങ്കിലും തരത്തിലുള്ള പരിഹാരങ്ങൾ കൊണ്ടുവരേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ.

HtmlHead ഒബ്‌ജക്‌റ്റിന്റെ വരവോടെ, അത്തരം തന്ത്രങ്ങൾ പഴയ കാര്യമാണ്.

Page.Header.Title = "HtmlHead ടെസ്റ്റ് പേജ്"; Page.Header.Metadata.Add("Author", "Gaidar Magdanurov"); Page.Header.Metadata.Add("E-Mail", "!} [ഇമെയിൽ പരിരക്ഷിതം]");

കൂടാതെ, നെസ്റ്റഡ് ഘടകങ്ങൾ ഉൾക്കൊള്ളാൻ കഴിയുന്ന ഏതൊരു ഘടകത്തെയും പോലെ, അനിയന്ത്രിതമായ ഘടകങ്ങൾ ചേർക്കാൻ HtmlHead നിങ്ങളെ അനുവദിക്കുന്നു.

((നിയന്ത്രണം)Page.Header).Controls.Add(പുതിയ ലിറ്ററൽ കൺട്രോൾ (""));

പേജ് നിയന്ത്രണം ഒരു നിയന്ത്രണത്തിലേക്ക് ഒരു ഹൈലൈറ്റ് സജ്ജീകരിക്കുന്നു

ചിലപ്പോൾ പേജ് ലോഡുചെയ്‌തതിനുശേഷം, തിരഞ്ഞെടുപ്പ് ഒരു പ്രത്യേക നിയന്ത്രണ ഘടകത്തിലേക്ക് സജ്ജീകരിക്കേണ്ടത് ആവശ്യമാണ് (ഉദാഹരണത്തിന്, ഒരു തിരയൽ ഫോമിൽ, പ്രധാന തിരയൽ ഫീൽഡിലേക്ക് ഇൻപുട്ട് ഫോക്കസ് സജ്ജീകരിക്കുന്നത് യുക്തിസഹമാണ്), ഇതിനായി നിങ്ങൾക്ക് സജ്ജമാക്കാൻ കഴിയും ഫോം ടാഗിന്റെ ഡിഫോൾട്ട് ഫോക്കസ് ആട്രിബ്യൂട്ടിന്റെ മൂല്യം.

സെറ്റ്ഫോക്കസ് രീതി വിളിച്ച് ഈ ഘടകത്തിന്റെ അദ്വിതീയ ഐഡന്റിഫയർ ഒരു പാരാമീറ്ററായി നൽകിക്കൊണ്ട് സെലക്ഷൻ പ്രോഗ്രമാറ്റിക്കായി നിയന്ത്രിക്കാനാകും:

സംരക്ഷിത ശൂന്യമായ Page_Load(object sender, EventArgs e) ( if(isPostBack) ( SetFocus("txtLastName"); ) മറ്റുള്ളവ ( SetFocus("txtFirstText"); ) )

പേജ് റീലോഡ് ചെയ്യാതെ തന്നെ ഡാറ്റ അപ്ഡേറ്റ് ചെയ്യുന്നു

ASP.NET 2.0-ൽ, സെർവറിലേക്ക് പേജ് അയയ്‌ക്കാതെ തന്നെ ഒരു പേജിലെ ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യാൻ സാധിച്ചു. പൂർണ്ണമായ അപ്ഡേറ്റ്. കോൾബാക്കുകൾ (കോൾബാക്ക് സ്ക്രിപ്റ്റുകൾ അല്ലെങ്കിൽ ക്ലയന്റ് കോൾബാക്കുകൾ) ഉള്ള ക്ലയന്റ് സ്ക്രിപ്റ്റുകളുടെ വരവോടെ ഇത് സാധ്യമായി. ചില ഇവന്റ് സെർവറിലേക്ക് ഒരു അഭ്യർത്ഥന ട്രിഗർ ചെയ്‌തതിന് ശേഷം, അപ്‌ഡേറ്റ് ചെയ്‌ത ഡാറ്റ നേരിട്ട് ക്ലയന്റ് സ്‌ക്രിപ്റ്റിലേക്ക് ഫംഗ്‌ഷൻ ആർഗ്യുമെന്റുകളായി കൈമാറും.
ഒരു പേജിലെ ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യുന്ന ഈ രീതി എല്ലാ വിവരങ്ങളും അപ്‌ഡേറ്റ് ചെയ്യുമ്പോൾ ഉപയോഗിക്കാൻ സൗകര്യപ്രദവും ലാഭകരവുമാണ്. നീണ്ട കാലം, ഡാറ്റയുടെ ഈ ഭാഗം ഇടയ്ക്കിടെ അപ്ഡേറ്റ് ചെയ്യുമ്പോൾ, ശേഷിക്കുന്ന ഡാറ്റ സ്ഥിരമാണ്. തുടർന്ന് ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യാനുള്ള സമയം, ഉദാഹരണത്തിന്, ഒരു ഉപയോക്തൃ ഘടകം, സെർവറിലേക്കുള്ള ഒരു അഭ്യർത്ഥനയുടെ സമയം, പ്രോസസ്സ് ചെയ്യൽ, പ്രതികരണം സ്വീകരിക്കൽ എന്നിവ കണക്കിലെടുക്കുമ്പോൾ, മുഴുവൻ പേജും അപ്‌ഡേറ്റ് ചെയ്യുന്ന സമയത്തേക്കാൾ വളരെ കുറവായിരിക്കും.
ഒരു ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റ് ഉള്ള ഒരു പേജ് ഉണ്ടെന്ന് പറയാം. ഉപയോക്താവ് ഒരു ലിസ്റ്റിൽ നിന്ന് ഒരു മൂല്യം തിരഞ്ഞെടുക്കുമ്പോൾ, ചില നിയന്ത്രണങ്ങൾ ലിസ്റ്റിൽ നിന്ന് തിരഞ്ഞെടുത്ത മൂല്യവുമായി യുക്തിസഹമായി ബന്ധപ്പെട്ടിരിക്കുന്ന ഒരു മൂല്യത്തിൽ ലോഡ് ചെയ്യപ്പെടും. ഈ സാഹചര്യത്തിൽ, എല്ലാ ഡാറ്റയും ക്ലയന്റ് വശത്ത് സംഭരിക്കുന്നത് അസാധ്യമാണ് (ഒരുപക്ഷേ വളരെയധികം ഡാറ്റ ഉണ്ടായിരിക്കാം കൂടാതെ പേജ് നെറ്റ്‌വർക്കിലൂടെ കൈമാറാൻ വളരെയധികം സമയമെടുക്കും, അല്ലെങ്കിൽ ഡാറ്റ ജനറേറ്റുചെയ്യുന്നത് സെർവർ ഉപയോക്താവ് തിരഞ്ഞെടുത്ത ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റ് ഘടകത്തെ മാത്രം ആശ്രയിച്ചിരിക്കുന്നില്ല). ASP.NET 1.x-ൽ, ഈ പ്രശ്നം പരിഹരിക്കാൻ നിങ്ങൾ ഡ്രോപ്പ്ഡൗൺ ലിസ്റ്റിലെ മൂല്യ മാറ്റ പരിപാടിയുമായി ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. സെർവർ രീതി. ഈ സാഹചര്യത്തിൽ, മൂല്യം മാറുമ്പോഴെല്ലാം (AutoPostBack="True") പേജ് സെർവറിലേക്ക് അയയ്ക്കുന്നതിന് ലിസ്റ്റ് കാരണമാകണം.

സംരക്ഷിത ശൂന്യമായ ddStatic_SelectedIndexChanged(object sender, EventArgs e) ( // ddStatic.Items.Value മൂല്യത്തെ അടിസ്ഥാനമാക്കി // രീതി മറ്റ് നിയന്ത്രണങ്ങളുടെ ഗുണങ്ങളെ സജ്ജമാക്കുന്നു)

ASP.NET 2.0-ൽ, മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, മുഴുവൻ പേജും പുതുക്കാതിരിക്കാൻ സാധിക്കും. IN ഈ സാഹചര്യത്തിൽനിങ്ങൾക്ക് ആവശ്യമുള്ള ഡാറ്റ മാത്രം അപ്‌ഡേറ്റ് ചെയ്യുന്നത് നല്ലതാണ്, കാരണം ഒരു മൂല്യം സജ്ജീകരിക്കാൻ പേജ് മുഴുവൻ അപ്‌ഡേറ്റ് ചെയ്യുന്നത് പാഴായിപ്പോകും.
പേജ് വീണ്ടും ലോഡുചെയ്യാതെ ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനം നടപ്പിലാക്കുന്നതിന്, സെർവറിൽ നിന്ന് പാസാക്കിയ പാരാമീറ്ററുകൾ സ്വീകരിക്കുന്ന ഒരു ക്ലയന്റ് കോൾബാക്ക് ഫംഗ്‌ഷൻ സൃഷ്ടിക്കേണ്ടത് ആവശ്യമാണ്, സെർവർ പ്രവർത്തനം, ഇത് ക്ലയന്റിൽ നിന്ന് പാരാമീറ്ററുകൾ സ്വീകരിക്കുകയും സ്വീകരിച്ച പാരാമീറ്ററുകളെ അടിസ്ഥാനമാക്കി ക്ലയന്റിലേക്ക് മൂല്യങ്ങൾ തിരികെ നൽകുകയും ഈ രണ്ട് ഫംഗ്ഷനുകളും ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു. മാത്രമല്ല, ASP.NET 2.0-ലെ കോൾബാക്ക് മെക്കാനിസം ഫലം അസമന്വിതമായി നൽകുന്നതിന് നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, ICallbackEventHandler ഇന്റർഫേസിൽ രണ്ട് രീതികൾ നിർവചിച്ചിരിക്കുന്നു: സെർവറിൽ പാരാമീറ്ററുകൾ സ്വീകരിക്കുന്നതിന് RaiseCallbackEvent, കൂടാതെ ഫലം ക്ലയന്റിലേക്ക് തിരികെ നൽകുന്നതിന് GetCallbackResult. മുമ്പത്തെ ഉദാഹരണത്തിന്റെ പ്രവർത്തനം നടപ്പിലാക്കുന്നതിന്, ഇനിപ്പറയുന്ന കോഡ് ASPX ഫയലിൽ സ്ഥാപിച്ചിരിക്കുന്നു.

ഫംഗ്ഷൻ അപ്ഡേറ്റ് ടെക്സ്റ്റ് (ഫലം, സന്ദർഭം) ( dSpan.innerText = ഫലം; )

കോൾബാക്ക് ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്ന പേജ് ക്ലാസ് ICallbackEventHandler ഇന്റർഫേസ് നടപ്പിലാക്കണം.

പൊതു ഭാഗിക ക്ലാസ് ScriptCallback_aspx: System.Web.UI.Page, System.Web.UI.ICallbackEventHandler ( )

കോൾബാക്ക് പിന്തുണയ്ക്കുന്ന ഫംഗ്ഷൻ സിഗ്നേച്ചറുകൾ ഇതുപോലെ കാണപ്പെടുന്നു:

പൊതു വെർച്വൽ ശൂന്യത PrepareCallbackEvent(സ്ട്രിംഗ് ആർഗ്യുമെന്റുകൾ) പൊതു വെർച്വൽ സ്ട്രിംഗ് RenderCallbackResult() private string EventArgument = ""; പൊതു ശൂന്യമായ PrepareCallbackEvent (string eventArgument) ( EventArgument = eventArgument; ) പൊതു സ്ട്രിംഗ് RenderCallbackResult() ( EventArgument തിരികെ നൽകുക; // മൂല്യം ടൈപ്പ് സ്ട്രിംഗ് }

സെർവറും ക്ലയന്റ് ഫംഗ്‌ഷനുകളും ലിങ്ക് ചെയ്യുക എന്നതാണ് ഈ ലക്ഷ്യത്തിലേക്കുള്ള അവസാന ഘട്ടം.

സംരക്ഷിത ശൂന്യമായ Page_Load(object sender, EventArgs e) ( // കോൾബാക്ക് ഫംഗ്‌ഷൻ സ്‌ട്രിംഗിലേക്ക് ഒരു റഫറൻസ് സൃഷ്‌ടിക്കുക callbackFunction = Page.ClientScript.GetCallbackEventReference (ഇത്, "document.all["ddDynamic"].value", "UpdateText", "nuText" ");

ClientScriptManager ഒബ്‌ജക്‌റ്റിന്റെ GetCallbackEventReference രീതി, പേജ് ഒബ്‌ജക്‌റ്റിലേക്കുള്ള ഒരു റഫറൻസ്, കോൾബാക്കിലെ സെർവറിലേക്ക് കൈമാറേണ്ട മൂല്യം, ക്ലയന്റ് സൈഡ് രീതിയുടെ പേര്, പ്രതികരണം സ്വീകരിക്കുന്ന സെർവർ എന്നിവയെ സൂചിപ്പിക്കുന്ന ഒരു സ്ട്രിംഗ് പാരാമീറ്ററുകളായി എടുക്കുന്നു. MSDN ഡോക്യുമെന്റേഷനിലോ വിഷ്വൽ സ്റ്റുഡിയോ ടൂൾ - ഒബ്‌ജക്റ്റ് ബ്രൗസർ ഉപയോഗിച്ചോ വിശദമായ വിവരണം കണ്ടെത്താനാകും.
ഈ സാങ്കേതികവിദ്യ ഉപയോഗിച്ച്, ഈ പ്രവർത്തനം നടപ്പിലാക്കുന്നതിനായി ASP.NET റൺടൈം സൃഷ്ടിക്കുന്ന കോഡ് മനസ്സിലാക്കുന്നതിലൂടെ, പേജ് ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുള്ള സങ്കീർണ്ണമായ രീതികൾ നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും.

// പേജ് റീലോഡ് ചെയ്യാൻ കാരണമാകുന്ന ലിസ്റ്റ് // ഒരു കോൾബാക്ക് ഉപയോഗിച്ച് രീതിയെ വിളിക്കുന്ന ലിസ്റ്റ്

സ്റ്റാൻഡേർഡ് doPostBack ഫംഗ്ഷൻ വളരെ ലളിതവും മറഞ്ഞിരിക്കുന്ന ഫോം ഫീൽഡുകളിലേക്ക് ഇവന്റ് ഡാറ്റ സംരക്ഷിക്കാൻ സഹായിക്കുന്നു.

Var theForm = document.forms["frmCallBack"]; ഫംഗ്‌ഷൻ __doPostBack(eventTarget, eventArgument) ((theForm.onsubmit == null || theForm.onsubmit()) ( theForm.__EVENTTARGET.value = eventTarget; theForm.__EVENTARGUMENT.value = eventArgument);mubmit;

കോൾബാക്കുകൾ ഉപയോഗിച്ച് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, മെക്കാനിസം കൂടുതൽ സങ്കീർണ്ണമാണ്. WebForm_DoCallback ഫംഗ്‌ഷൻ കോഡ് doPostBack നേക്കാൾ വളരെ വലുതാണ്, കാരണം ഈ ഫംഗ്‌ഷൻ ബ്രൗസർ ഒബ്‌ജക്റ്റ് മോഡലിന്റെ തരം നിർണ്ണയിക്കുകയും അതിൽ നിന്ന് ഡാറ്റ കൈമാറാൻ ആവശ്യമായ മൊഡ്യൂൾ ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, DOM-നെ പിന്തുണയ്ക്കുന്ന ഒരു ബ്രൗസറിന് ഇത് Microsoft.XMLHTTP ആയിരിക്കും.
ASP.NET 2.0 ഫ്രെയിംവർക്ക് ഉപയോഗിക്കുന്ന വിവിധ ക്ലയന്റ് ഫംഗ്‌ഷനുകൾക്കായുള്ള കോഡ് നിങ്ങളുടെ ഹാർഡ് ഡിസ്‌കിലേക്ക് കോൾബാക്ക് ഫംഗ്‌ഷനുകളെ പിന്തുണയ്‌ക്കുന്ന ഒരു പേജ് സംരക്ഷിച്ച് അത് തുറക്കുന്നതിലൂടെ നിങ്ങൾക്ക് കാണാനാകും. ടെക്സ്റ്റ് എഡിറ്റർ HTML പേജിൽ ലിങ്ക് ചെയ്‌തിരിക്കുന്ന WebResource.axd ഫയൽ.
ക്ലയന്റ് കോൾബാക്ക് ഫംഗ്‌ഷനുകളുടെ കഴിവുകളുടെയും വ്യാപ്തിയുടെയും കൂടുതൽ വിശദമായ വിവരണം ഡിനോ എസ്പോസിറ്റോയുടെ ലേഖനത്തിൽ വിവരിച്ചിരിക്കുന്നു.

മറ്റൊരു ASP.NET പേജിലേക്ക് ഫോം ഡാറ്റ പോസ്റ്റ് ചെയ്യുന്നു

ASP.NET 1.0-ലെ സെർവർ-സൈഡ് ഫോമുകളുടെ ഒരു പ്രധാന പരിമിതി, ഫോമിൽ നൽകിയ ഡാറ്റ മറ്റൊരു പേജിലേക്ക് നേരിട്ട് കൈമാറാനുള്ള കഴിവില്ലായ്മയാണ്. ഫോം ഘടകങ്ങളുടെ മൂല്യങ്ങൾ മറ്റൊരു പേജിലേക്ക് അയയ്ക്കാൻ നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട് ലളിതമായ HTMLഫോമിലും പ്രവർത്തന ആട്രിബ്യൂട്ടിലും ഡാറ്റ സ്വീകരിക്കേണ്ട പേജിലേക്കുള്ള പാത വ്യക്തമാക്കുക. ഇത് സെർവർ സൈഡ് ഫോമുകൾ ഉപയോഗിക്കുന്നതിന്റെ പ്രയോജനങ്ങൾ നഷ്‌ടപ്പെടുത്തുന്നു.
ASP.NET 2.0-ൽ, ഒരു നിയന്ത്രണ ടാഗിന് ഒരു അധിക PostBackUrl ആട്രിബ്യൂട്ട് ഉണ്ടായിരിക്കും, അത് സെർവറിലേക്ക് ഡാറ്റ അയയ്‌ക്കാൻ നിയന്ത്രണം ആരംഭിക്കുകയാണെങ്കിൽ, ഏത് പേജിലേക്കാണ് സിസ്റ്റം വെബ് ഫോം സമർപ്പിക്കേണ്ടതെന്ന് വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ബട്ടണിൽ ക്ലിക്കുചെയ്തതിനുശേഷം, ഉപയോക്താവിന്റെ ബ്രൗസർ crosspost.aspx പേജിലേക്ക് റീഡയറക്‌ടുചെയ്യും, കൂടാതെ ഡാറ്റ അയച്ച ഫോമിന്റെ നിയന്ത്രണങ്ങളെക്കുറിച്ചുള്ള എല്ലാ വിവരങ്ങളും കൈമാറും.
ഈ ഫീച്ചർ നടപ്പിലാക്കുന്നതിനായി, ASP.NET 2.0, ASPX പേജുകൾ, നിർദ്ദിഷ്ട PostBackUrl ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് നിയന്ത്രണങ്ങളുടെ സാന്നിധ്യത്തിനായി പരിശോധിക്കുന്നു, കൂടാതെ എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, ഫോം ഘടകങ്ങളുടെ അവസ്ഥയെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങുന്ന പേജിൽ __PREVIOUSPAGE ഒരു അധിക മറച്ച ഫീൽഡ് സൃഷ്ടിക്കുന്നു. ഈ വിവരങ്ങൾ PreviousPage പ്രോപ്പർട്ടി വഴി സ്വീകർത്താവിന്റെ പേജിൽ ലഭ്യമാണ്.

അസാധുവായ Page_Load(object sender, EventArgs e) ((PreviousPage != null) എങ്കിൽ ( // അയച്ച ഫോമിലെ ഒബ്ജക്റ്റുകൾ നേടുക TextBox txtFirstName = (TextBox)PreviousPage.FindControl("txtFirstName)TextName പേജ്. FindControl("txtLastName"); // ഡാറ്റ ഉപയോഗിക്കുക txtInfo.Text = "ഗുഡ് ആഫ്റ്റർനൂൺ, " + txtFirstName.Text + "!"; ) )

HTML കോഡ് തലത്തിൽ, മറ്റൊരു ഫോമിലേക്ക് ഡാറ്റ അയയ്ക്കുന്നത് ഇതുപോലെയാണ്.

അതിൽ നിന്ന് ഫോം ഡാറ്റ ബ്രൗസറിൽ നിന്ന് നേരിട്ട് CrossPage.aspx പേജിലേക്ക് അയയ്‌ക്കുന്നില്ല, എന്നാൽ ആദ്യം ഫ്രംടെസ്റ്റ് ഫോം അടങ്ങുന്ന അതേ GetValues.aspx പേജിലേക്കാണ് അയയ്‌ക്കുന്നത് എന്ന് നമുക്ക് നിഗമനം ചെയ്യാം. RequiredFieldValidation, RangeValidation, മറ്റ് നിയന്ത്രണങ്ങൾ എന്നിവ ഉപയോഗിച്ച് നൽകിയ ഡാറ്റയുടെ സെർവർ-സൈഡ് മൂല്യനിർണ്ണയത്തെ പിന്തുണയ്ക്കുന്നതിന് ഇത് ആവശ്യമാണ്. ഈ ലേഖനത്തിന്റെ മുൻ ഖണ്ഡികയിൽ പരാമർശിച്ചിരിക്കുന്ന WebResource.axd ഫയലിൽ നിങ്ങൾക്ക് WebForm_DoPostBackWithOptions രീതി കാണാൻ കഴിയും.

പേജ് ഡിസൈൻ ടെംപ്ലേറ്റുകൾ

ഒരു വെബ്‌സൈറ്റിനെ മറ്റൊന്നിൽ നിന്ന് വ്യത്യസ്തമാക്കുന്ന ആദ്യത്തെ കാര്യം എന്താണ്? ശരാശരി ഇന്റർനെറ്റ് ഉപയോക്താവിന്, പ്രധാന വ്യത്യാസം വൈവിധ്യമാർന്ന പേജ് ഡിസൈനാണ്. ഒരു വെബ് ആപ്ലിക്കേഷന്റെ പ്രവർത്തനക്ഷമതയെ അഭിമുഖീകരിക്കുന്നതിന് മുമ്പ്, ഒരു സൈറ്റ് സന്ദർശകൻ പേജുകളുടെ രൂപം ഇഷ്ടപ്പെടുന്നുണ്ടോ എന്ന് വിലയിരുത്തുന്നു. അതിനാൽ, പേജ് രൂപകൽപ്പന മൊത്തത്തിലുള്ള പ്രവർത്തനത്തേക്കാൾ വളരെ കുറവാണ്.
ഡവലപ്പറുടെ ചുമതല കോഡ് എഴുതുക എന്നതാണ്, ഡിസൈനറുടെ ചുമതല സൃഷ്ടിക്കുക എന്നതാണ് ബാഹ്യ ഡിസൈൻപേജുകൾക്കായുള്ള HTML കോഡിന്റെ ലേഔട്ടും. മിക്ക കേസുകളിലും, ആപ്ലിക്കേഷൻ കോഡിലും സമാന്തര പ്രവർത്തനത്തിനുള്ള സാധ്യതയും ഉറപ്പാക്കേണ്ടത് ആവശ്യമാണ് HTML ടെംപ്ലേറ്റ്. പ്രോഗ്രാം ലോജിക് കോഡും കോഡ്-ബിഹൈൻഡ് പേജിന്റെ HTML കോഡും വേർതിരിക്കുന്ന സാങ്കേതികവിദ്യ ഇത് വളരെ വിജയകരമായി നേരിട്ടു. എന്നാൽ, അതേ സമയം, ഓരോ പേജിലും പ്രവർത്തിക്കുമ്പോൾ, പേജ് ലേഔട്ട് കൈകാര്യം ചെയ്യാൻ ഡവലപ്പർക്ക് ഒരു വഴി അല്ലെങ്കിൽ മറ്റൊന്ന് ഉണ്ട്.
മിക്ക ആധുനിക വെബ്‌സൈറ്റുകൾക്കും എല്ലാ പേജുകൾക്കും സമാനമായ രൂപമാണുള്ളത്, ഓരോ പേജിനും പൊതുവായ ഡിസൈൻ ഘടകങ്ങൾ ഉണ്ട് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ASP.NET 1.x-ൽ, പൊതുവായ പേജ് ഡിസൈൻ ഘടകങ്ങൾ ഉപയോക്തൃ നിയന്ത്രണങ്ങളിൽ പൊതിഞ്ഞ് ഓരോ പേജിലും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, അല്ലെങ്കിൽ, ഒരു URL സ്‌ട്രിംഗിനെ അടിസ്ഥാനമാക്കി നിയന്ത്രണങ്ങൾ ലോഡുചെയ്‌ത ഒരു അടിത്തറയായി ഒരൊറ്റ പേജ് ഉപയോഗിച്ച് പേജുകളെ നിയന്ത്രണങ്ങളാക്കി പരിവർത്തനം ചെയ്‌തു. .
ASP.NET 2.0-ലെ സമീപനം ഈ സമീപനങ്ങളിൽ രണ്ടാമത്തേതിന് അടുത്താണ്, എന്നാൽ കാര്യമായ ഗുണങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഡവലപ്പർക്ക് ഇനി പേജുകളെ ഉപയോക്തൃ നിയന്ത്രണങ്ങളാക്കി മാറ്റേണ്ടതില്ല, ഇത് വികസനവും ഡീബഗ്ഗിംഗും വളരെ എളുപ്പമാക്കുന്നു. ടെംപ്ലേറ്റ് പേജ് കോഡിൽ നിരവധി ASP.NET ഘടകങ്ങൾ ഉൾപ്പെടുത്തുന്നതിന് മാത്രമായി അദ്ദേഹത്തിന്റെ ചുമതല ചുരുക്കിയതിനാൽ ഇത് ഡിസൈനറുടെ ജോലിയെ ഗണ്യമായി ലളിതമാക്കുന്നു. കൂടുതൽ വിശദമായ താരതമ്യം ASP.NET 2.0 ടെംപ്ലേറ്റിംഗ് സാങ്കേതികവിദ്യകൾ മുമ്പേ നിലവിലുള്ള ടെംപ്ലേറ്റിംഗ് ടെക്നിക്കുകൾ ഉപയോഗിച്ച് Fritz Onyen ന്റെ ലേഖനം റഫർ ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നു.

ഒരു ഡിസൈൻ ടെംപ്ലേറ്റ് സൃഷ്ടിക്കുന്നു

ഒരു പേജ് ഡിസൈൻ ടെംപ്ലേറ്റ് (മാസ്റ്റർ പേജുകൾ) ഒരു സാധാരണ ASP.NET പേജാണ്, അതിന് കുറച്ച് അധിക ആട്രിബ്യൂട്ടുകളും പ്രോപ്പർട്ടികളും ഉണ്ട് കൂടാതെ ഒന്നോ അതിലധികമോ പ്രത്യേക ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഉള്ളടക്ക മാനേജ്മെന്റ്പ്ലേസ് ഹോൾഡർ. ഒരു സാധാരണ പേജ് ഒരു ടെംപ്ലേറ്റാക്കി മാറ്റുന്നതിന്, പേജ് ഡയറക്റ്റീവ് മാറ്റി മാസ്റ്റർ ഡയറക്റ്റീവ് നൽകിയാൽ മതിയാകും.
ഇതിനുശേഷം, നിങ്ങൾ അത് പേജ് മാർക്ക്അപ്പിലേക്ക് തിരുകേണ്ടതുണ്ട് സെർവർ ഘടകങ്ങൾ ContentPlaceHolder നിയന്ത്രണങ്ങൾ, പേജിന്റെ മൊത്തത്തിലുള്ള ഡിസൈനുമായി ബന്ധമില്ലാത്ത വിവരങ്ങൾ സ്ഥാപിക്കുന്ന ഭാഗങ്ങളിൽ.

എന്റെ ഹോം പേജ്

സമയം:

എന്നതിന് സമാനമാണ് സാധാരണ പേജ്, പ്രോഗ്രാം ലോജിക് ഫയലിൽ നിങ്ങൾക്ക് നിലവിലുള്ള നിയന്ത്രണങ്ങൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനും പുതിയവ സൃഷ്ടിക്കാനും ചേർക്കാനും കഴിയും, അഭ്യർത്ഥന പാരാമീറ്ററുകൾ അടിസ്ഥാനമാക്കി, പേജും അതിന്റെ സ്വഭാവവും മാറ്റുക. അതിനാൽ, നിങ്ങൾക്ക് ഒരു വെബ് ആപ്ലിക്കേഷന്റെ ബാഹ്യ രൂപം സൃഷ്ടിക്കുന്നതിനുള്ള യുക്തി ഏതാണ്ട് പൂർണ്ണമായും പേജ് ടെംപ്ലേറ്റിൽ ഉൾപ്പെടുത്താം.
ടെംപ്ലേറ്റ് ഉപയോഗിക്കുന്ന പേജ് നിയന്ത്രണത്തിന്റെ ഉള്ളടക്കത്തെ അസാധുവാക്കുന്നില്ലെങ്കിൽ ഉപയോഗിക്കേണ്ട ഉള്ളടക്കം നിർവ്വചിക്കാൻ ContentPlaceHolder കൺട്രോൾ നിങ്ങളെ അനുവദിക്കുന്നു.

ഹോം പേജ്
ഉള്ളടക്ക പട്ടിക

ടെംപ്ലേറ്റ് പേജ് നിയന്ത്രണങ്ങൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ഒരു സാധാരണ പേജിനുള്ള നിയന്ത്രണങ്ങളുമായി പ്രവർത്തിക്കുന്നതിൽ നിന്ന് വ്യത്യസ്തമല്ല. അതുപോലെ, ഈ ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് എല്ലാ പേജുകൾക്കും ലഭ്യമാകുന്ന രീതികളും ഗുണങ്ങളും നിങ്ങൾക്ക് നിർവചിക്കാം.

സംരക്ഷിത ശൂന്യമായ Page_Load (object sender, EventArgs e) ( PageTime.InnerText = DateTime.Now.ToShortDateString(); ) പൊതു സ്ട്രിംഗ് ശീർഷകം ( നേടുക (പേജ് ടൈറ്റിൽ.ഇന്നർടെക്സ്റ്റ്; ) മൂല്യം സജ്ജമാക്കുക (പേജ് ടൈറ്റിൽ) =.ഇന്നർ ടെക്സ്റ്റിൽ;

ഒരു പേജ് സൃഷ്ടിക്കുന്നു

ഡിസൈൻ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നത് പേജുകളിൽ സ്വന്തം ആവശ്യകതകൾ ചുമത്തുന്നു. ടെംപ്ലേറ്റിൽ ContentPlaceHolder നിയന്ത്രണങ്ങൾ അടങ്ങിയിരിക്കുന്നതിനാൽ, പേജിൽ മാർക്ക്അപ്പ് കോഡും ഫലമായുണ്ടാകുന്ന പേജിൽ റെൻഡർ ചെയ്യുന്ന മറ്റ് നിയന്ത്രണങ്ങളും അടങ്ങിയിരിക്കുന്ന ഉള്ളടക്ക നിയന്ത്രണങ്ങൾ ഉണ്ടായിരിക്കണം. പേജിന് ഉള്ളടക്ക നിയന്ത്രണങ്ങൾക്ക് പുറത്ത് സെർവർ നിയന്ത്രണങ്ങളോ മാർക്ക്അപ്പ് കോഡോ ഉണ്ടാകരുത്.

പുറം 1
പേജ് 2
പേജ് 3

ടെംപ്ലേറ്റ് പോലെ, പേജ് ലോജിക് കോഡ് സാധാരണ രീതിയിൽ സൃഷ്ടിച്ചിരിക്കുന്നു. ഒരേയൊരു വ്യത്യാസം പേജിന് ഹെഡ്കൺട്രോൾ പോലുള്ള സ്വന്തം ഒബ്‌ജക്റ്റുകൾ ഇല്ല എന്നതാണ്, അതിനാൽ നിങ്ങൾ മാസ്റ്റർ പ്രോപ്പർട്ടി വഴി ടെംപ്ലേറ്റ് പേജിലേക്കുള്ള ഒരു ലിങ്ക് ഉപയോഗിക്കേണ്ടതുണ്ട്.

സംരക്ഷിത ശൂന്യമായ Page_Load(object sender, EventArgs e) ((!Page.IsPostBack) Master.Page.Header.Title = "ഹോം പേജ്)"; } protected void btnShow_Click(object sender, EventArgs e) { PlaceHolder.Controls.Add(new LiteralControl(" alert("Добрый день, " + txtName.Text + ""); ")); Master.Page.Header.Title = "ഗുഡ് ആഫ്റ്റർനൂൺ," + txtName.Text; }!}

ഒരു ടെംപ്ലേറ്റിലേക്ക് ഒരു പേജ് ബന്ധിപ്പിക്കുന്നതിന്, പേജ് നിർദ്ദേശത്തിന്റെ MasterPageFile ആട്രിബ്യൂട്ട് ഉപയോഗിക്കുക. നിങ്ങൾക്ക് ഡയറക്‌ടറിയിലെ എല്ലാ പേജുകളിലേക്കും ഒരേ ടെംപ്ലേറ്റ് ബൈൻഡ് ചെയ്യണമെങ്കിൽ, ഓരോ പേജിനും MasterPageFile ആട്രിബ്യൂട്ട് വ്യക്തമാക്കേണ്ട ആവശ്യമില്ല; web.config ഫയലിൽ അടിസ്ഥാന ടെംപ്ലേറ്റ് സജ്ജമാക്കിയാൽ മതി.

കൂടാതെ, ASP.NET ഒരു തീം പ്രോഗ്രാമാറ്റിക് ആയി സജ്ജീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ഡിസൈൻ ടെംപ്ലേറ്റുമായി ലോഡുചെയ്യുന്നതും ലിങ്കുചെയ്യുന്നതും പേജ് ആരംഭിക്കുന്നതിന് തയ്യാറെടുക്കുമ്പോൾ സംഭവിക്കുന്നു. അതിനാൽ, നിങ്ങൾക്ക് പേജ് ഡിസൈൻ ടെംപ്ലേറ്റ് മാറ്റണമെങ്കിൽ, നിങ്ങൾ ഇത് PreInit ഇവന്റ് ഹാൻഡ്‌ലറിൽ ചെയ്യണം.

പരിരക്ഷിത ശൂന്യമായ Page_PreInit(ഒബ്ജക്റ്റ് അയച്ചയാൾ, EventArgs e) ( Page.MasterPageFile = "AnotherMaster.master"; )

ASP.NET ടെംപ്ലേറ്റ് പ്രോസസ്സിംഗ്

ആദ്യമായി ഒരു പേജ് ആക്സസ് ചെയ്യുമ്പോൾ, ASP.NET ഡയറക്ടറിയിലെ എല്ലാ ടെംപ്ലേറ്റുകൾക്കുമായി അസംബ്ലികൾ തിരയുകയും സമാഹരിക്കുകയും ചെയ്യുന്നു. ഡയറക്‌ടറിയിലെ ടെംപ്ലേറ്റ് പേജുകളുടെ എണ്ണത്തെ ആശ്രയിച്ച് ഈ പ്രവർത്തനത്തിന് കുറച്ച് സമയമെടുക്കും, പക്ഷേ ഒരിക്കൽ മാത്രമേ ഇത് നടപ്പിലാക്കുകയുള്ളൂ. അതിനാൽ, ഡയറക്‌ടറിയിൽ ഉപയോഗിക്കാത്ത ടെംപ്ലേറ്റുകൾ ഉണ്ടെങ്കിൽ, ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുമ്പോൾ ഇത് പ്രകടന നഷ്ടത്തിലേക്ക് നയിക്കില്ല, അസൗകര്യം അധിക സമയം മാത്രമാണ്, കൂടാതെ ഉപയോഗിക്കാത്ത പേജുകൾക്കായി അനാവശ്യ അസംബ്ലികളുടെ സമാഹാരം.
തന്നിരിക്കുന്ന ഡിസൈൻ ടെംപ്ലേറ്റുള്ള ഒരു പേജിന്റെ aspx ഫയൽ ആക്സസ് ചെയ്യുമ്പോൾ, കംപൈലേഷൻ പ്രക്രിയ സാധാരണ പേജ് കംപൈലേഷൻ പ്രക്രിയയിൽ നിന്ന് വ്യത്യസ്തമല്ല, ഒരു MasterPage ടെംപ്ലേറ്റ് ക്ലാസ് സൃഷ്ടിക്കപ്പെടുന്നു എന്നതൊഴിച്ചാൽ, അതിലേക്കുള്ള ഒരു ലിങ്ക് Page.Master പ്രോപ്പർട്ടിയിൽ ലഭ്യമാണ്.
ഈ ലേഖനത്തിൽ മുകളിൽ വിവരിച്ച എല്ലാ ഘട്ടങ്ങളിലൂടെയും പേജ് കടന്നുപോകുന്നു, അതിന്റെ ഫലമായി ക്ലയന്റിലേക്ക് അയയ്ക്കുന്ന HTML കോഡ് ജനറേറ്റുചെയ്യുന്നു. ലഭിച്ചതിൽ HTML ബ്രൗസർ ContentPlaceHolder, Content controls എന്നിവയ്‌ക്ക് HTML കത്തിടപാടുകൾ ഇല്ലാത്തതിനാലും മറ്റ് അധിക ടാഗുകൾ സൃഷ്ടിക്കാത്തതിനാലും, ഡിസൈൻ ടെംപ്ലേറ്റിൽ കോഡിന്റെ ഏത് ഭാഗമാണ് നിർവചിച്ചിരിക്കുന്നതെന്നും പേജിൽ തന്നെ കോഡിന്റെ ഏത് ഭാഗമാണ് നിർവചിച്ചിരിക്കുന്നതെന്നും കോഡിന് ഇനി പറയാനാകില്ല. അവരുടെ ഉള്ളടക്കം.

ഹോംപേജ്

പുറം 1
പേജ് 2
പേജ് 3

സമയം: 03/20/2005

ഒരു ടെംപ്ലേറ്റ് ഒരു പേജിന്റെ ഉപവിഭാഗമായതിനാൽ, MasterPageFile ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് മാസ്റ്റർ ഡയറക്‌ടീവിലെ ടെംപ്ലേറ്റിനായി മറ്റൊരു ടെംപ്ലേറ്റിലേക്കുള്ള പാത വ്യക്തമാക്കി നെസ്റ്റഡ് ടെംപ്ലേറ്റുകൾ സൃഷ്ടിക്കുന്നത് അനുവദനീയമാണ്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ പ്രധാന ടെംപ്ലേറ്റിൽ ContentPlaceHolder നിയന്ത്രണങ്ങൾ നിർവചിക്കേണ്ടതുണ്ട്, കൂടാതെ "ചൈൽഡ്" ടെംപ്ലേറ്റുകളിൽ, ContentPlaceHolder ഘടകങ്ങൾക്കൊപ്പം, അടിസ്ഥാന ടെംപ്ലേറ്റിലെ ContentPlaceHolder ഘടകങ്ങളുടെ ഉള്ളടക്കങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നതിന് ഉള്ളടക്ക നിയന്ത്രണങ്ങൾ നിർവചിക്കേണ്ടതുണ്ട്.

ഉപയോഗം വ്യത്യസ്ത ടെംപ്ലേറ്റുകൾവ്യത്യസ്ത ബ്രൗസറുകൾക്കായി

വ്യത്യസ്ത ബ്രൗസറുകൾ (ഉദാഹരണത്തിന്, മൈക്രോസോഫ്റ്റ്) എന്ന് ഏതൊരു വെബ് ഡെവലപ്പർക്കും നന്നായി അറിയാം ഇന്റർനെറ്റ് എക്സ്പ്ലോറർ, നെറ്റ്‌സ്‌കേപ്പ് നാവിഗേറ്റർ, മോസില്ല ഫയർഫോക്സ് മുതലായവ) HTML കോഡ് വ്യത്യസ്തമായി പ്രോസസ്സ് ചെയ്യുന്നു, ഏറ്റവും പ്രധാനമായി, കുറച്ച് വ്യത്യസ്തമായ പ്രോഗ്രാമിംഗ് മോഡലുകൾ ഉണ്ട്, ഇത് ക്ലയന്റ് സ്‌ക്രിപ്റ്റുകളുടെ നിർമ്മാണത്തെ സങ്കീർണ്ണമാക്കുന്നു.
ഈ പ്രശ്നം പരിഹരിക്കുന്നതിന്, ASP.NET 1.x, ക്ലാസിക് ASP എന്നിവയിൽ രണ്ട് പ്രധാന രീതികൾ ഉപയോഗിക്കുന്നു. ആദ്യത്തേത്, ക്ലയന്റ് ബ്രൗസറിന് ക്ലയന്റ് കോഡ് അയയ്‌ക്കുന്നു, അത് തരത്തെയും അടിസ്ഥാനമാക്കിയും ബ്രൗസർ പതിപ്പുകൾ, ചില പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു. ഒരു നിർദ്ദിഷ്‌ട ബ്രൗസറിനായി പ്രത്യേകമായി ഒപ്റ്റിമൈസ് ചെയ്‌ത പേജുകളിലേക്ക് ഉപയോക്താവിന്റെ ബ്രൗസർ റീഡയറക്‌ട് ചെയ്യുക എന്നതാണ് രണ്ടാമത്തേത്. ASP.NET ഇത്തരത്തിലുള്ള പേജുകൾ സൃഷ്‌ടിക്കുന്നത് എളുപ്പമാക്കുന്നു, കാരണം ക്ലയന്റ് ബ്രൗസറിനെക്കുറിച്ചുള്ള വിവരങ്ങളെ അടിസ്ഥാനമാക്കി സാധാരണ സെർവർ നിയന്ത്രണങ്ങൾക്കായി റൺടൈം HTML കോഡ് സൃഷ്‌ടിക്കുന്നു. ഡിസൈൻ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഓരോ ബ്രൗസറിനും നിരവധി ടെംപ്ലേറ്റുകൾ സൃഷ്ടിക്കാനും ഏത് ടെംപ്ലേറ്റ് ഉപയോഗിക്കണമെന്ന് പേജിന്റെ പേജ് നിർദ്ദേശത്തിൽ വ്യക്തമാക്കാനും കഴിയും.

ASP.NET ഉപയോഗിക്കുന്ന ബ്രൗസറുകളുടെയും ബ്രൗസർ പ്രോപ്പർട്ടികളുടെയും ഒരു ലിസ്റ്റ് %WINDIT%\Microsoft.NET\Framework\version\CONFIG\Browsers ഡയറക്ടറിയിൽ കാണാം.

വെബ് ആപ്ലിക്കേഷനുകളുടെ ലളിതമായ പ്രാദേശികവൽക്കരണം ഉപയോക്താവിന്റെ പ്രാദേശിക ക്രമീകരണങ്ങൾ നിർവചിക്കുന്നു

ASP.NET 1.x-ൽ ആപ്ലിക്കേഷനുകൾ പ്രാദേശികവൽക്കരിക്കുന്നതിന്, ഉപയോക്താവിന്റെ പ്രാദേശിക ക്രമീകരണങ്ങൾ നിർണ്ണയിക്കാൻ ഡവലപ്പർക്ക് പലപ്പോഴും കോഡ് എഴുതേണ്ടി വരും. ഈ കോഡ് പലപ്പോഴും ഗ്ലോബൽ.അസാക്സിൽ സ്ഥാപിച്ചിട്ടുണ്ട്, ഒരു CultureInfo ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ച് അതിന്റെ CurrentCulture, CurrentUICulture പ്രോപ്പർട്ടികൾ CurrentThread ഒബ്‌ജക്റ്റിന് നൽകിക്കൊണ്ട് ഉപയോക്താവിന്റെ ഭാഷയെ നിലവിലെ പ്രക്രിയയുടെ ഭാഷയായി സജ്ജീകരിക്കുക എന്നതായിരുന്നു അതിന്റെ ജോലി:

അസാധുവായ Application_BeginRequest (Object sender, EventArgs e) ((Request.UserLanguages.Length > 0) (CultureInfo UserCulture = CultureInfo.CreateSpecificCulture(Request.UserLanguages; Thread.UserLanguages); Thread.Crent.Crent. hread.CurrentUICulture = UserCulture; ) )

ASP.NET 2.0-ൽ, റൺടൈം എൻവയോൺമെന്റിലേക്ക് ഉപയോക്താവിന്റെ ഭാഷയുടെ നിർണ്ണയം ഓഫ്‌ലോഡ് ചെയ്യാൻ സാധിക്കും. @പേജ് നിർദ്ദേശത്തിന്റെ Culture="auto", UICulture="auto" ആട്രിബ്യൂട്ടുകൾ സജ്ജമാക്കിയാൽ മതിയാകും, അതുവഴി പേജിനായുള്ള ഉപയോക്താവിന്റെ പ്രാദേശിക ക്രമീകരണങ്ങൾ സ്വയമേവ നിർണ്ണയിക്കപ്പെടും. എപ്പോൾ. സൈറ്റിന്റെ എല്ലാ പേജുകളിലും നിങ്ങൾക്ക് ഈ പ്രഭാവം നേടണമെങ്കിൽ, ചേർക്കുക അടുത്ത വരി:

പ്രാദേശികവൽക്കരണത്തിനുള്ള എക്സ്പ്രഷനുകൾ

ASP.NET 2.0 നിങ്ങളെ ഓരോ പേജിനും പ്രാദേശിക ഉറവിടങ്ങൾ ഉപയോഗിച്ച് അസംബ്ലികൾ സൃഷ്ടിക്കാനും ASPX ഫയലിലെ വ്യൂ കോഡിൽ നേരിട്ട് സ്ഥാപിച്ചിട്ടുള്ള എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് ആ ഉറവിടങ്ങളിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റയിലേക്ക് നിയന്ത്രണങ്ങൾ ബന്ധിപ്പിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, meta:resourcekey ആട്രിബ്യൂട്ട് ഉപയോഗിക്കുന്നു, പേജ് എക്സിക്യൂഷൻ സമയത്ത് അതിന്റെ മൂല്യം വിശകലനം ചെയ്യുന്നു.

ഭാഷ തിരഞ്ഞെടുക്കുക

അല്ലെങ്കിൽ ഒരു പുതിയ പദപ്രയോഗം ഉപയോഗിക്കാം:

സ്റ്റാറ്റിക് ടെക്‌സ്‌റ്റ് അതേ രീതിയിൽ പ്രാദേശികവൽക്കരിക്കുന്നതിന്, ASP.NET 2.0 അവതരിപ്പിച്ചു പുതിയ ഘടകംനിയന്ത്രണം ലോക്കലൈസ് ചെയ്യുക, ഇത് മുകളിലുള്ള പ്രാദേശികവൽക്കരണ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

വാചകം

ഈ ലേഖനത്തിൽ എക്സ്പ്രഷനുകൾ, ഉറവിടങ്ങൾ സൃഷ്ടിക്കൽ, ഉപയോക്താവിന്റെ പ്രാദേശിക ക്രമീകരണങ്ങൾ എന്നിവയെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതൽ വായിക്കാം.

ഉപസംഹാരം

ASP.NET 1.x-നെ അപേക്ഷിച്ച് ASP.NET 2.0-ൽ പുതിയതെന്താണെന്നതിനെക്കുറിച്ചുള്ള ചില അടിസ്ഥാന വിവരങ്ങൾ ഈ ലേഖനം നൽകുന്നു. ASP.NET-ന്റെ സവിശേഷതകൾ വളരെ ചുരുക്കമായി വിവരിച്ചിരിക്കുന്നു, ഈ നൂതന സാങ്കേതികവിദ്യ പഠിക്കുന്നതിനുള്ള ഒരു തുടക്കമായി ഈ ലേഖനം വർത്തിക്കും. ലേഖനത്തിൽ പരാമർശിച്ചിരിക്കുന്ന സാങ്കേതികവിദ്യകളുടെയും പുതിയ കഴിവുകളുടെയും കൂടുതൽ വിശദമായ വിവരണത്തിന്, അധിക സാഹിത്യങ്ങളുടെ പട്ടിക റഫർ ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നു. ലേഖനം നിരവധി പ്രധാന കണ്ടുപിടിത്തങ്ങളെ സ്പർശിച്ചിട്ടില്ല - അസമന്വിത കോഡ് എക്സിക്യൂഷൻ, പുതിയ നിയന്ത്രണങ്ങൾ, web.config ഫയലിന്റെ ശകലങ്ങളുടെ എൻക്രിപ്ഷൻ, പുതിയ ഡാറ്റ ആക്സസ് മെക്കാനിസങ്ങൾ എന്നിവയും അതിലേറെയും. ഇതെല്ലാം ഒന്നിലധികം പുസ്തകങ്ങൾ സമർപ്പിക്കാൻ കഴിയുന്ന മെറ്റീരിയലാണ്. സാധ്യമെങ്കിൽ, രചയിതാവ് ഈ പുതുമകൾ ഭാവിയിലെ ലേഖനങ്ങളിൽ ഹൈലൈറ്റ് ചെയ്യാൻ ശ്രമിക്കും.

ASP.NET-ലെ ആദ്യ പേജുകൾ വെബ് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു സോളിഡ് ടെക്നോളജിയുടെ പ്രാരംഭ ആമുഖം നൽകുന്നു. WebForms, MVC, WebAPI ചട്ടക്കൂടുകൾ എന്നിവ ഉപയോഗിച്ച് ആദ്യ ഘട്ടങ്ങൾ സങ്കീർണ്ണമാക്കാതെ, ASPX, Razor എന്നീ രണ്ട് വ്യൂ ഹാൻഡ്‌ലറുകൾക്കായി ഞങ്ങൾ എംബഡഡ് പ്രോഗ്രാം കോഡ് ഉപയോഗിച്ച് ലളിതമായ വെബ് പേജുകൾ സൃഷ്ടിക്കും. റെൻഡറിംഗ് എഞ്ചിനുകൾ അല്ലെങ്കിൽ എഞ്ചിനുകൾ എന്നും വിളിക്കപ്പെടുന്ന കോഡ് പ്രോസസ്സറുകൾ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ് ചലനാത്മക സൃഷ്ടിവെബ് പേജുകൾ മാറ്റിസ്ഥാപിക്കുന്നതിലൂടെ പ്രോഗ്രാം കോഡ്അനുബന്ധ html മാർക്ക്അപ്പ്.

ASP.NET വെബ് പേജിലേക്ക് കോഡ് ചേർക്കുന്നതിനുള്ള ഒരു സ്റ്റാൻഡേർഡ് മോഡലാണ് ASPX എഞ്ചിൻ. ASPX runat="server"> തരങ്ങളും നടപടിക്രമങ്ങളും വേരിയബിളുകളും ഡിക്ലറേഷൻ ബ്ലോക്കുകളും ഒരു ബിൽറ്റ്-ഇൻ html മാർക്ക്അപ്പ് റെൻഡറിംഗ് ബ്ലോക്കും ഉപയോഗിക്കുന്നു. കോഡ് ചേർക്കുന്നതിനുള്ള ASPX മോഡൽ, ചില മാറ്റങ്ങളോടെ, യഥാർത്ഥ ASP പ്ലാറ്റ്‌ഫോമിൽ നിന്ന് ASP.NET-ലേക്ക് കൊണ്ടുപോയി.

ഒരു html പേജിൽ പ്രോഗ്രാം കോഡ് ദൃശ്യവൽക്കരിക്കുന്നതിനുള്ള ഒരു പുതിയ സംവിധാനമാണ് റേസർ. റേസർ ഒരു ഇന്റലിജന്റ് ഡൈനാമിക് എഞ്ചിനാണ് html സൃഷ്ടിക്കുന്നുഅടയാളപ്പെടുത്തലുകൾ. ഇതിന് വ്യക്തമായ വാക്യഘടനയുണ്ട് കൂടാതെ ഒരു വെബ് പേജിലേക്ക് കോഡ് ഉൾപ്പെടുത്തുന്നത് എളുപ്പമാക്കുന്നു. പ്രോഗ്രാം കോഡ് വേർതിരിച്ചറിയാൻ html കോഡ്കൂടെ സംയോജിപ്പിച്ച് @ ചിഹ്നം ഉപയോഗിക്കുന്നു ചുരുണ്ട ബ്രേസുകൾകൂടാതെ പരാൻതീസിസ് ഇല്ലാതെ.

ആദ്യ വെബ് പേജുകൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ സൗജന്യമായി ഉപയോഗിക്കും സോഫ്റ്റ്വെയർ പരിസ്ഥിതി WebMatrix വെബ്സൈറ്റുകളിൽ പ്രവർത്തിക്കുന്നതിന്. നിലവിൽ, പ്രൊഫഷണൽ വെബ്‌സൈറ്റുകൾ സൃഷ്‌ടിക്കുന്നതിന് മതിയായ ഈ പ്രോഗ്രാമിംഗ് ടൂളിന്റെ മൂന്നാം പതിപ്പ് സൃഷ്‌ടിച്ചു. വെബ്സൈറ്റിൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യാം മൈക്രോസോഫ്റ്റ് WebMatrix ലിങ്ക് വഴി. ASP.NET അടിസ്ഥാനമാക്കിയുള്ള വെബ്‌സൈറ്റുകൾ സൃഷ്‌ടിക്കാനും പരിശോധിക്കാനും ആവശ്യമായ എല്ലാം വെബ്‌മാട്രിക്‌സ് പ്രോഗ്രാമിൽ ഉൾപ്പെടുന്നു: ബാക്ക്‌ലൈറ്റിംഗും ഇന്റലിസെൻസും ഉള്ള ഒരു കോഡ് എഡിറ്റർ, ഒരു IIS എക്സ്പ്രസ് വെബ് സെർവർ, ഒരു ഡാറ്റാബേസ് മാനേജ്‌മെന്റ് സിസ്റ്റം SQL ഡാറ്റലോക്കൽ ഡി.ബി.

സൈറ്റിൽ മൂന്ന് പേജുകൾ ഉൾപ്പെടുന്നു: ASPX, Razor എഞ്ചിനുകൾ ഉപയോഗിച്ച് ചലനാത്മകമായി പട്ടികകൾ സൃഷ്ടിക്കുന്നതിനുള്ള പ്രധാന പേജും രണ്ട് സമാന പേജുകളും. രണ്ട് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് അന്വേഷണ വരിയിൽ പട്ടികയുടെ വലുപ്പം വ്യക്തമാക്കാം. തത്വത്തിൽ, രണ്ട് ഹാൻഡ്‌ലറുകളും ഫലപ്രദമായി സൃഷ്ടിക്കുന്നുവെന്ന് പറയണം html മാർക്ക്അപ്പ്, എന്നാൽ വ്യത്യസ്തമായ പ്രവർത്തന സുഖം നൽകുന്നു.

പ്രോഗ്രാം കോഡിന്റെ എല്ലാ ഭാഗങ്ങളും ഭാഗങ്ങളും വ്യൂ ബ്ലോക്കുകളിൽ ഉൾപ്പെടുത്തണമെന്ന് ASPX എഞ്ചിൻ ആവശ്യപ്പെടുന്നു. തരങ്ങളും നടപടിക്രമങ്ങളും വേരിയബിളുകളും runat="server">... ബ്ലോക്കിൽ പ്രഖ്യാപിക്കാം. runat="server" ആട്രിബ്യൂട്ട് വേർതിരിക്കുന്നു ഈ ബ്ലോക്ക്ഒരു ജാവാസ്ക്രിപ്റ്റ് ബ്ലോക്കിൽ നിന്ന്, സെർവറിൽ നേരിട്ട് ഈ ബ്ലോക്കിലെ കോഡ് പ്രോസസ്സ് ചെയ്യുന്നതിനെ സൂചിപ്പിക്കുന്നു.

ASPX എഞ്ചിൻ ഉപയോഗിക്കുന്ന ലിസ്റ്റിംഗ് നമ്പർ 1 വെബ് പേജ്

< !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 ="/">പ്രധാനത്തിലേക്ക്< p >നിരകളുടെ എണ്ണം -< br />വരികളുടെ എണ്ണം -< table > < tr > < tr > < td >

റേസർ എംബഡഡ് കോഡ് ഹാൻഡ്‌ലറിനായുള്ള വെബ് പേജ് കോഡ് ചുവടെയുണ്ട്. C#-ലെ html കോഡിന്റെയും എക്സ്പ്രഷനുകളുടെയും യോജിപ്പുള്ള ലയനം ശ്രദ്ധിക്കുക. പ്രോഗ്രാം കോഡിനുള്ളിൽ നേരിട്ട് HTML ടാഗുകൾ ഉപയോഗിക്കാൻ റേസർ എഞ്ചിൻ നിങ്ങളെ അനുവദിക്കുന്നു: ഹാൻഡ്‌ലറിന്റെ ഇന്റലിജന്റ് ഘടകം C# പ്രോഗ്രാം കോഡിൽ നിന്ന് HTML മാർക്ക്അപ്പിനെ സമർത്ഥമായി വേർതിരിക്കുന്നു.

റേസർ എഞ്ചിനിലെ ലിസ്റ്റിംഗ് നമ്പർ 2 വെബ് പേജ്

< !DOCTYPE html > < html lang ="ru"> < head > < meta http-equiv ="Content-Type" content ="text/html; charset=utf-8"/> < meta charset ="utf-8" /> < title >@പേര് പേജ്< link rel ="stylesheet" type ="text/css" href ="/css/style.css" /> < body > < h1 >@പേര് പേജ്< p >< a href ="/">ഹോം @ Html.Raw(createLinks.GetLinks())< p >നിരകളുടെ എണ്ണം - @numberColumns< br />വരികളുടെ എണ്ണം - @numberRows< table > < tr >@ for (int i = 0; i< numberColumns; i++) { < th >തലക്കെട്ട് # @(i + 1 ) ) @ എന്നതിന് (ഇന്റ് വരി = 0; വരി< numberRows; row++) { < tr >@ for(int col = 0; col< numberColumns; col++) { < td >@(വരി+1) x@(കോൾ+1) )

നിങ്ങൾക്ക് പല തരത്തിൽ സൈറ്റ് പരിശോധിക്കാൻ കഴിയും:

MS വിഷ്വൽ സ്റ്റുഡിയോ - ഫയൽ-> വെബ്സൈറ്റ് തുറക്കുക ->ആർക്കൈവ് അൺപാക്ക് ചെയ്ത ഫോൾഡർ തിരഞ്ഞെടുക്കുക ബ്രൗസറിൽ സമാരംഭിക്കുക (അല്ലെങ്കിൽ F5 കീ)

WebMatrix - തുറക്കുക->ഫോൾഡർ->സൈറ്റ് ആർക്കൈവ് അൺപാക്ക് ചെയ്തിരിക്കുന്ന ഫോൾഡർ തിരഞ്ഞെടുക്കുക->ഫോൾഡർ തിരഞ്ഞെടുക്കുക ആരംഭിക്കുക

ഇതിലേക്ക് ആർക്കൈവ് അൺപാക്ക് ചെയ്യുക ഫിസിക്കൽ ഫോൾഡർപ്രാദേശിക അല്ലെങ്കിൽ ഇന്റർനെറ്റ് സൈറ്റ്. അതിന്റെ URL ഉപയോഗിച്ച് ഒരു ബ്രൗസറിൽ സൈറ്റ് സമാരംഭിക്കുക.

ഉപസംഹാരമായി, സൈറ്റ് ഉപയോക്താവിന്, വെബ് പേജുകൾ ഏത് എഞ്ചിനിലാണ് പ്രവർത്തിക്കുന്നത് എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ വളരെ പ്രധാനമല്ലെന്ന് നമുക്ക് ചേർക്കാം. എന്നാൽ പ്രോഗ്രാമർ, ഓരോ എംബഡഡ് കോഡ് ഹാൻഡ്‌ലറിലും പ്രവർത്തിച്ച ശേഷം, തീർച്ചയായും റേസർ തിരഞ്ഞെടുക്കും.

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 10/31/2015

ഒരു സൈറ്റിന് സ്ഥിരവും ഏകീകൃതവുമായ രൂപവും ഭാവവും സൃഷ്ടിക്കാൻ മാസ്റ്റർ പേജുകൾ ഉപയോഗിക്കുന്നു. അടിസ്ഥാനപരമായി, മാസ്റ്റർ പേജുകൾ ഒരേ കാഴ്ചകളാണ്, എന്നാൽ മറ്റ് കാഴ്ചകൾ ഉൾപ്പെടുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, മറ്റെല്ലാ കാഴ്ചകൾക്കും പൊതുവായുള്ള മാസ്റ്റർ പേജിലെ ഘടകങ്ങൾ നിങ്ങൾക്ക് നിർവചിക്കാം, കൂടാതെ പൊതുവായ ശൈലികളും സ്ക്രിപ്റ്റുകളും ഉൾപ്പെടുത്താം. തൽഫലമായി, ഞങ്ങൾക്ക് എല്ലാം ചെയ്യേണ്ടതില്ല പ്രത്യേക അവതരണംസ്റ്റൈൽ ഫയലുകളിലേക്കുള്ള പാത വ്യക്തമാക്കുക, തുടർന്ന് ആവശ്യമെങ്കിൽ അത് മാറ്റുക. മാസ്റ്റർ പേജുകളിൽ ഉപയോഗിക്കുന്ന പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ അല്ലെങ്കിൽ പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ അവയുടെ സ്ഥാനത്ത് മറ്റ് കാഴ്ചകൾ ചേർക്കാൻ നിങ്ങളെ അനുവദിക്കും.

സ്ഥിരസ്ഥിതിയായി, നിങ്ങൾ ഒരു പുതിയ ASP.NET MVC 5 പ്രോജക്‌റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ, _Layout.chtml എന്ന മാസ്റ്റർ പേജ് ഇതിനകം പ്രോജക്‌റ്റിലേക്ക് ചേർത്തിട്ടുണ്ട്, അത് കാഴ്ചകൾ/പങ്കിട്ട ഡയറക്‌ടറിയിൽ കാണാം. രണ്ടാം അധ്യായത്തിൽ നിന്നുള്ള അനുബന്ധത്തിൽ ഞങ്ങൾ അത് ഇനിപ്പറയുന്ന രീതിയിൽ മാറ്റി:

@ViewBag.Title @RenderBody()

ഒറ്റനോട്ടത്തിൽ, ഇത് ഒരു ഒഴിവാക്കലുള്ള ഒരു സാധാരണ കാഴ്‌ചയാണ്: ഇത് @RenderBody() രീതി ഉപയോഗിക്കുന്നു, ഇത് ഒരു പ്ലെയ്‌സ്‌ഹോൾഡറും ഈ മാസ്റ്റർ പേജ് ഉപയോഗിക്കുന്ന മറ്റ് കാഴ്ചകളാൽ മാറ്റിസ്ഥാപിക്കപ്പെടും. തൽഫലമായി, വെബ് ആപ്ലിക്കേഷന്റെ കാഴ്‌ചകൾക്കായി ഞങ്ങൾക്ക് സ്ഥിരമായ ഒരു ശൈലി എളുപ്പത്തിൽ സജ്ജമാക്കാൻ കഴിയും.

കാഴ്ചയിൽ ഒരു മാസ്റ്റർ പേജ് ഉപയോഗിക്കുന്നതിന്, ലേഔട്ട് വിഭാഗത്തിൽ ആവശ്യമുള്ള മാസ്റ്റർ പേജിലേക്കുള്ള പാത ഞങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, Index.cshtml കാഴ്ചയിൽ, നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു മാസ്റ്റർ പേജ് നിർവചിക്കാം:

ഞങ്ങൾ ഒരു മാസ്റ്റർ പേജ് ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, ഞങ്ങൾ ലേഔട്ട് = null; .

എല്ലാ സമർപ്പിക്കലുകൾക്കും ഒരേ മാസ്റ്റർ പേജ് ഉപയോഗിക്കേണ്ടതില്ല. നിങ്ങൾക്ക് നിരവധി മാസ്റ്റർ പേജുകൾ നിർവചിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ഫോറത്തിന് ഒന്ന്, ബ്ലോഗിന് ഒന്ന് മുതലായവ, സൈറ്റിന്റെ വിഭാഗത്തെ ആശ്രയിച്ച്, നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ബന്ധിപ്പിക്കുക. പതിവ് കാഴ്ചകൾ പോലെ തന്നെ അവ പ്രോജക്റ്റിലേക്ക് ചേർക്കുന്നു.

ഒരു മാസ്റ്റർ പേജിന് കാഴ്ചകൾക്ക് അവയുടെ ഉള്ളടക്കം സ്ഥാപിക്കാൻ കഴിയുന്ന ഒന്നിലധികം വിഭാഗങ്ങൾ ഉണ്ടായിരിക്കാം. ഉദാഹരണത്തിന്, മാസ്റ്റർ പേജിലേക്ക് ഒരു അടിക്കുറിപ്പ് വിഭാഗം ചേർക്കാം:

@ViewBag.Title

@RenderBody() @RenderSection("Footer")

ഇപ്പോൾ നമ്മൾ മുമ്പത്തെ സൂചിക കാഴ്ച പ്രവർത്തിപ്പിക്കുമ്പോൾ അടിക്കുറിപ്പ് വിഭാഗം നിർവചിക്കാത്തതിനാൽ നമുക്ക് ഒരു പിശക് ലഭിക്കും. ഡിഫോൾട്ടായി, മാസ്റ്റർ പേജിന്റെ ഓരോ വിഭാഗത്തിനും കാഴ്‌ച ഉള്ളടക്കം റെൻഡർ ചെയ്യണം. അതിനാൽ, സൂചിക കാഴ്ചയുടെ അടിയിൽ ഒരു ഫൂട്ടർ വിഭാഗം ചേർക്കാം. @section എക്സ്പ്രഷൻ ഉപയോഗിച്ച് നമുക്ക് ഇത് ചെയ്യാൻ കഴിയും:

@( ലേഔട്ട് = "~/കാഴ്ചകൾ/പങ്കിട്ടത്/_Layout.cshtml"; ) @വിഭാഗം അടിക്കുറിപ്പ് (എല്ലാ അവകാശങ്ങളും നിക്ഷിപ്തം. സൈറ്റ് കോർപ്പറേഷൻ. 2012. )

എന്നാൽ ഈ സമീപനത്തിലൂടെ, ഞങ്ങൾക്ക് ഒരു കൂട്ടം കാഴ്ചകൾ ഉണ്ടെങ്കിൽ, ഞങ്ങൾ പെട്ടെന്ന് മാസ്റ്റർ പേജിൽ ഒരു പുതിയ വിഭാഗം നിർവചിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിലവിലുള്ള എല്ലാ കാഴ്ചകളും ഞങ്ങൾ മാറ്റേണ്ടിവരും, അത് വളരെ സൗകര്യപ്രദമല്ല. ഈ സാഹചര്യത്തിൽ, ഫ്ലെക്സിബിൾ സെക്ഷൻ കോൺഫിഗറേഷനായി നമുക്ക് ഓപ്ഷനുകളിലൊന്ന് ഉപയോഗിക്കാം.

റെൻഡർസെക്ഷൻ രീതിയുടെ ഒരു ഓവർലോഡ് ഉപയോഗിക്കുന്നതാണ് ആദ്യ ഓപ്ഷൻ, ഇത് കാഴ്ചയിൽ വിഭാഗം നിർവചിക്കേണ്ട ആവശ്യമില്ലെന്ന് സൂചിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അടിക്കുറിപ്പ് വിഭാഗം ഓപ്ഷണലായി അടയാളപ്പെടുത്തുന്നതിന്, നിങ്ങൾ രണ്ടാമത്തെ പാരാമീറ്ററായി രീതിയിലേക്ക് തെറ്റായ മൂല്യം നൽകേണ്ടതുണ്ട്:

@RenderSection("അടിക്കുറിപ്പ്", തെറ്റ്)

കാഴ്ചയിൽ ഈ വിഭാഗം നിർവചിച്ചിട്ടില്ലെങ്കിൽ, സ്ഥിരസ്ഥിതി വിഭാഗത്തിന്റെ ഉള്ളടക്കങ്ങൾ സജ്ജമാക്കാൻ രണ്ടാമത്തെ ഓപ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു:

@if (IsSectionDefined("Footer")) ( @RenderSection("Footer") ) else ( അടിക്കുറിപ്പ് മൂലകത്തിന്റെ സ്ഥിരസ്ഥിതി ഉള്ളടക്കം. )

കാണുക ആരംഭിക്കുക

ഞങ്ങളുടെ പ്രോജക്‌റ്റിൽ രണ്ട് കാഴ്ചകൾ ഉണ്ടെങ്കിൽ, ഉദാഹരണത്തിന്, മറ്റൊരു മാസ്റ്റർ പേജ് ഉപയോഗിക്കാൻ ഞങ്ങൾ തീരുമാനിക്കുകയാണെങ്കിൽ, ലേഔട്ട് വിഭാഗത്തിലെ ഓരോന്നിന്റെയും മാസ്റ്റർ പേജ് വിവരണം നമുക്ക് സ്വമേധയാ മാറ്റാനാകും. എന്നാൽ ഞങ്ങൾക്ക് ധാരാളം കാഴ്ചകൾ ഉണ്ടെങ്കിൽ, ഇത് വളരെ സൗകര്യപ്രദമായിരിക്കില്ല.

കാഴ്ചകളുടെ കൂടുതൽ വഴക്കമുള്ള കോൺഫിഗറേഷനായി, _ViewStart.cshtml പേജ് ഉദ്ദേശിച്ചുള്ളതാണ്. ഈ പേജിന്റെ കോഡ് ഒരേ ഡയറക്‌ടറിയിൽ സ്ഥിതിചെയ്യുന്ന ഏതെങ്കിലും കാഴ്‌ചകളുടെ കോഡിന് മുമ്പായി പ്രവർത്തിക്കുന്നു. ഈ ഫയൽഒരേ ഡയറക്‌ടറിയിൽ സ്ഥിതിചെയ്യുന്ന ഓരോ കാഴ്‌ചയിലും തുടർച്ചയായി പ്രയോഗിക്കുന്നു.

നിങ്ങൾ ഒരു ASP.NET MVC 5 പ്രോജക്‌റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ, _ViewStart.cshtml എന്ന ഫയൽ സ്ഥിരസ്ഥിതിയായി വ്യൂസ് ഡയറക്‌ടറിയിലേക്ക് ചേർക്കും. ഈ ഫയൽ ഡിഫോൾട്ട് മാസ്റ്റർ പേജ് നിർവചിക്കുന്നു:

@( ലേഔട്ട് = "~/കാഴ്ചകൾ/പങ്കിട്ടത്/_Layout.cshtml"; )

കാഴ്‌ചയിൽ നിർവചിച്ചിരിക്കുന്ന മറ്റേതെങ്കിലും കോഡിന് മുമ്പായി ഈ കോഡ് പ്രവർത്തിക്കുന്നു, അതിനാൽ ഞങ്ങൾക്ക് മറ്റ് കാഴ്ചകളിൽ നിന്ന് ലേഔട്ട് വിഭാഗം നീക്കംചെയ്യാം. കാഴ്ച മറ്റൊരു മാസ്റ്റർ പേജ് ഉപയോഗിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ ലേഔട്ട് പ്രോപ്പർട്ടി അസാധുവാക്കുന്നു, കാഴ്ചയുടെ തുടക്കത്തിലേക്ക് അതിന്റെ നിർവചനം ചേർക്കുക.

HTML-ൽ ഹലോ w3ii

ഈ കോഡ് ഒരു HTML പേജായി ഒരു ഉദാഹരണം കാണിക്കുന്നു:

ഹലോ w3ii!

firstpage.htm" കൂടാതെ ഫയലിലേക്ക് ഇതുപോലുള്ള ഒരു ലിങ്ക് സൃഷ്ടിക്കുക: firstpage.htm

ASP.NET-ൽ ഹലോ w3ii

ഒരു HTML പേജ് ASP.NET പേജിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ഏറ്റവും എളുപ്പ മാർഗം HTML ഫയൽ പകർത്തുക എന്നതാണ് പുതിയ ഫയൽ.aspx വിപുലീകരണത്തോടൊപ്പം.

ഒരു ASP.NET പേജിലെന്നപോലെ ഈ കോഡ് ഞങ്ങളുടെ ഉദാഹരണം കാണിക്കുന്നു:

ഹലോ w3ii!

നിങ്ങൾക്ക് ഇത് സ്വയം പരീക്ഷിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, "firstpage.aspx" എന്ന ഫയലിൽ കോഡ് സംരക്ഷിക്കുക, കൂടാതെ ഫയലിലേക്ക് ഇതുപോലെ ഒരു ലിങ്ക് സൃഷ്ടിക്കുക: firstpage.aspx

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു?

അടിസ്ഥാനപരമായി, ഒരു ASP.NET പേജ് ഒരു HTML പേജിന് തുല്യമാണ്.

ഒരു HTML പേജിന് .htm എന്ന വിപുലീകരണമുണ്ട്. സെർവറിൽ നിന്ന് ബ്രൗസർ ഒരു HTML പേജ് അഭ്യർത്ഥിച്ചാൽ, സെർവർ യാതൊരു മാറ്റവുമില്ലാതെ ആ പേജ് ബ്രൗസറിലേക്ക് അയയ്ക്കുന്നു.

ഒരു ASP.NET പേജിന് .aspx വിപുലീകരണമുണ്ട്. ബ്രൗസർ ഒരു ASP.NET പേജ് അഭ്യർത്ഥിച്ചാൽ, സെർവർ എന്തെങ്കിലും പ്രോസസ്സ് ചെയ്യുന്നു എക്സിക്യൂട്ടബിൾ കോഡ്പേജ്, ഫലം ബ്രൗസറിലേക്ക് തിരികെ അയയ്ക്കുന്നതിന് മുമ്പ്.

മുകളിലുള്ള ASP.NET പേജിൽ എക്സിക്യൂട്ടബിൾ കോഡുകളൊന്നും അടങ്ങിയിട്ടില്ല, അതിനാൽ ഒന്നും എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നില്ല. ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങളിൽ, സ്റ്റാറ്റിക് HTML പേജുകളും ഡൈനാമിക് എഎസ്പി പേജുകളും തമ്മിലുള്ള വ്യത്യാസം കാണിക്കാൻ ഞങ്ങൾ എക്സിക്യൂട്ടബിൾ പേജ് കോഡ് ചേർക്കും.

ക്ലാസിക് ASP

സജീവ സെർവർ പേജുകൾ (ASP) നിരവധി വർഷങ്ങളായി നിലവിലുണ്ട്. ASP ഉപയോഗിച്ച്, HTML പേജുകൾക്കുള്ളിൽ എക്സിക്യൂട്ടബിൾ കോഡ് സ്ഥാപിക്കാൻ കഴിയും.

ASP-യുടെ മുൻ പതിപ്പുകൾ (ASP .NET-ന് മുമ്പ്) പലപ്പോഴും ക്ലാസിക് ASP എന്ന് വിളിക്കപ്പെടുന്നു.

ASP.NET ക്ലാസിക് ASP-യുമായി പൂർണ്ണമായും പൊരുത്തപ്പെടുന്നില്ല, എന്നാൽ മിക്ക ക്ലാസിക് ASP പേജുകളും ചെറിയ മാറ്റങ്ങളോടെ ASP.NET പേജുകളായി നന്നായി പ്രവർത്തിക്കും.

നിങ്ങൾക്ക് ക്ലാസിക് എഎസ്പിയെക്കുറിച്ച് കൂടുതലറിയണമെങ്കിൽ, ഞങ്ങളുടെ എഎസ്പി ട്യൂട്ടോറിയൽ സന്ദർശിക്കുക.

ക്ലാസിക് ASP-യിലെ ഡൈനാമിക് പേജുകൾ

ഡൈനാമിക് ഉള്ളടക്കമുള്ള പേജുകൾ എഎസ്പിക്ക് എങ്ങനെ റെൻഡർ ചെയ്യാം എന്ന് കാണിക്കാൻ, മുമ്പത്തെ ഉദാഹരണത്തിൽ ഞങ്ങൾ ചില എക്സിക്യൂട്ടബിൾ കോഡ് (ചുവപ്പ് നിറത്തിൽ) ചേർത്തു:

ഹലോ w3ii!

ടാഗിനുള്ളിലെ കോഡ് സെർവറിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു.

പ്രതികരണം.എഴുതുക എന്നത് HTML ഔട്ട്‌പുട്ട് സ്ട്രീമിലേക്ക് എന്തെങ്കിലും എഴുതുന്നതിനുള്ള ASP കോഡാണ്.

ഇപ്പോൾ() എന്നത് സെർവറുകൾ റിട്ടേൺ ഫംഗ്‌ഷൻ ആണ് നിലവിലെ തീയതിസമയവും.

നിങ്ങൾക്ക് ഇത് സ്വയം പരീക്ഷിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, "dynpage.asp" എന്ന ഫയലിൽ കോഡ് സംരക്ഷിക്കുക, കൂടാതെ ഫയലിലേക്ക് ഇതുപോലെ ഒരു ലിങ്ക് സൃഷ്ടിക്കുക: dynpage.asp

ASP .NET-ലെ ഡൈനാമിക് പേജുകൾ

ഒരു ASP.NET പേജിലെന്നപോലെ ഈ കോഡ് ഞങ്ങളുടെ ഉദാഹരണം നൽകുന്നു:

ഹലോ w3ii!

നിങ്ങൾക്ക് ഇത് സ്വയം പരീക്ഷിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, "dynpage.aspx" എന്ന ഫയലിൽ കോഡ് സംരക്ഷിക്കുക, കൂടാതെ ഫയലിലേക്ക് ഇതുപോലെ ഒരു ലിങ്ക് സൃഷ്ടിക്കുക: dynpage.aspx

ASP.NET vs ക്ലാസിക് ASP

മുമ്പത്തെ ഉദാഹരണങ്ങൾ ASP.NET ഉം ക്ലാസിക് ASP ഉം തമ്മിലുള്ള വ്യത്യാസങ്ങളൊന്നും കാണിക്കുന്നില്ല.

കഴിഞ്ഞ രണ്ട് ഉദാഹരണങ്ങളിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ രണ്ട് ASP, ASP.NET പേജുകൾ തമ്മിൽ വ്യത്യാസങ്ങളൊന്നുമില്ല.

ഇനിപ്പറയുന്ന അധ്യായങ്ങളിൽ, ASP.NET സെർവർ നിയന്ത്രണങ്ങൾ ക്ലാസിക് ASP-യെക്കാൾ ശക്തമാക്കുന്നത് എങ്ങനെയെന്ന് നിങ്ങൾ കാണും.