Ontwerppatronen zijn de visuele erfenis van pagina's die voor het eerst verschenen in ASP.NET 2.0. U kunt de basis leggen voor een willekeurig aantal toepassingspagina's. Sjablonen maken het eenvoudiger om applicaties te maken en te onderhouden. Visual Studio 2005 bevat ondersteuning voor het maken en bewerken van paginasjablonen. Deze lezing onderzoekt het gebruik van paginasjablonen in een applicatie en begint met het uitleggen van de voordelen ervan.

Opmerking: de terminologie op dit gebied is nog niet vastgelegd. Sommige boeken gebruiken de uitdrukking ‘basispagina’s’. De term "masterpagina" kan worden gebruikt, hoewel deze kan worden verward met Default.aspx.

Waarom heb je paginaontwerpsjablonen nodig?

Voor de gemiddelde gebruiker is het verschil tussen de ene site en de andere het gevarieerde pagina-ontwerp. De meeste websites hebben tegenwoordig een herkenbaar ontwerp, dat wordt bereikt door dezelfde elementen op dezelfde plaatsen op verschillende pagina's van de site te gebruiken. Daarom is paginaontwerp nauwelijks minder belangrijk dan de algehele functionaliteit.

Kijk bijvoorbeeld eens naar de hoofdpagina van de krantenwebsite Komsomolskaya Pravda. Elke dag verschijnen er verschillende artikelen, maar hun ontwerp blijft hetzelfde. Dit zijn het krantenlogo, navigatiepanelen bovenaan, rechts en links, artikelbeoordelingen aan de rechterkant, formulieren voor zoeken, abonneren en inloggen op e-mail. Onderaan de pagina vindt u juridische informatie.

Sommige ontwikkelaars kopiëren en plakken dubbele elementen op alle pagina's. Dit is inefficiënt; als u één detail in deze gemeenschappelijke elementen moet wijzigen, zullen de wijzigingen op alle pagina's moeten worden aangebracht. U kunt herhaalde stukjes code in include-bestanden plaatsen met behulp van de HTML include-opdracht. Maar het is zo moeilijk om het uiteindelijke uiterlijk van de pagina in de ontwikkelomgeving te zien. In ASP.NET 1.1 werd het mogelijk om aangepaste elementen beheer. U kunt zo’n element met de gewenste inhoud aanmaken en op alle pagina’s plaatsen. De ontwikkeling van dit idee was het maken van paginasjablonen. Dit is ook een gebruikerscontrole, alleen bevindt deze zich niet op de pagina, maar daarbuiten.

Basisprincipes van basispagina's

Met paginasjablonen definieert u algemene inhoud en plaatst u deze op een pagina met de extensie .master. Uiteraard kunnen er meerdere van dergelijke pagina's in de applicatie aanwezig zijn. Deze sjabloon kan worden gebruikt door een willekeurig aantal onderliggende pagina's, die, net als gewone pagina's, een aspx-extensie hebben.

Te beginnen met deze lezing analyseren we het project dat Visual Studio 2005 maakt met behulp van de Personal Website Starter Kit-sjabloon. Het toont paginasjablonen, thema's en personalisatie en navigatie. De navigatieknoppen zijn gecentreerd op de sjabloonpagina Default.master. En dit is een natuurlijke oplossing, aangezien navigatie overal nodig is.

De sjabloonpagina bevat ook algemene kop- en voetteksten.

Dit is het enige type pagina waarop het mogelijk is om speciale ContentPlaceHolder-besturingselementen te plaatsen. Ze definiëren plaatsen waar onderliggende pagina's van een bepaalde wizard hun eigen inhoud kunnen plaatsen. Wanneer ASP.NET een verzoek ontvangt om een ​​onderliggende pagina weer te geven, voegt het de code ervan samen met de code Startpagina Hierdoor wordt HTML gegenereerd waarin geen “naden” zichtbaar zijn.

Wanneer kinderpagina bewerkt in de ontwikkelomgeving, op het tabblad Ontwerpen is de volledige pagina zichtbaar samen met elementen uit de sjabloon, maar ze worden getoond grijs. Ze kunnen niet worden bewerkt. U kunt bewerken wat er in inhoudselementen staat.

Selecteer in het dialoogvenster Nieuw item toevoegen het paginatype Hoofdpagina. Net als gewone pagina's kunnen ze worden gemaakt met code erachter of met code die is ingesloten in de pagina. Dit heeft op geen enkele manier invloed op het codedeelmodel van kind+pagina's. Bovendien kunnen de hoofd- en onderliggende pagina's in verschillende talen worden ontwikkeld.

Om een ​​duidelijke indeling van de pagina in logische delen te krijgen, wordt gebruik gemaakt van tabellen. Laten we een tabel bouwen met 3 rijen, waar in bovenste regel er is de titel van alle pagina's, de tweede bevat willekeurige inhoud, deze bestaat uit twee cellen, die elk één ContentPlaceHolder hebben. De onderste rij bevat juridische informatie. De tabel wordt heel eenvoudig gemaakt via het menu Layout-Insert Table. Maak een tabel van 2 bij 3. Voeg daarna de cellen bovenaan samen en onderste regels en plaats ContentPlaceHolder in de middelste. Creëer kop- en voettekstinhoud. Je zou op een pagina als deze moeten eindigen:

Hallo! ASP.NET 2.0 Programmeerschool Copyright © 2006 - ASP.NET 2.0 School

Het eerste verschil tussen deze pagina en een gewone pagina is dat deze begint met een hoofdrichtlijn, en niet met een pagina. De masterpaginaklasse wordt gedefinieerd in het bestand MasterPage.master.cs.

openbare gedeeltelijke klasse MasterPage: System.Web.UI.MasterPage ( beschermde ongeldige Page_Load (objectafzender, EventArgs e) ( ) )

De sjabloonklasse is een afstammeling van System.Web.UI.MasterPage, die op zijn beurt overneemt van System.Web.UI.UserControl.

Het kan alle besturingselementen en HTML-code bevatten. Ook kunnen paginagebeurtenissen erin worden verwerkt. 2 ContentPlaceHolder-elementen geven de plaatsen aan waar de inhoud van de vervolgpagina wordt ingevoegd.

Nu moet u een inhoudspagina maken. Het wordt zoals gewoonlijk gemaakt, alleen het selectievakje met de naam Selecteer stramienpagina is aangevinkt. Er verschijnt een dialoogvenster waarin u een paginasjabloon moet selecteren.

Maar zelfs in dit geval heeft de toewijzing van de hoofdpagina in de Page-richtlijn voorrang op de toewijzing op applicatieniveau. De instelling web.config wordt van kracht op pagina's waarvoor geen masterPageFile is opgegeven, maar waarvoor inhoudsbesturingselementen zijn gedefinieerd. Deze instelling heeft geen invloed op gewone aspx-pagina's.

De sjabloon kan niet aan alle pagina's worden toegewezen, maar selectief, bijvoorbeeld in een specifieke applicatiemap.

Het locatie-element wordt ingevoegd in het hoofdconfiguratieknooppunt. Dit geeft aan dat alle pagina's in de map Lectures de sjabloonpagina Lectures.master gebruiken.

De vervolgpagina van een sjabloon kan alleen elementen van het type Content bevatten, die elk overeenkomen met één ContentPlaceHolder-element van de sjabloon. U kunt geen inhoud invoegen buiten deze elementen, anders kan ASP.NET de hoofdpagina niet combineren met de inhoudspagina. De ContentPlaceHolder ID moet overeenkomen met het ContentPlaceHolderID-attribuut van het overeenkomstige Content-element.

Het programma heeft een onderliggende pagina gemaakt met twee inhoudsbesturingselementen. Als u naar het tabblad Ontwerpen overschakelt, worden deze twee inhoudselementen als lege rechthoeken naast elkaar weergegeven omdat ze zich in twee aangrenzende tabelcellen in de sjabloon bevinden. De Page-richtlijn verschilt van de gebruikelijke, naast het MasterPageFile-attribuut, door de aanwezigheid Titelkenmerk. Omdat de tags , , worden overgenomen van het sjabloonbestand, is dit de enige manier om de browserheader te overschrijven. Vervang de attribuutwaarde

Als u de resulterende pagina in de browser bekijkt, ziet u dat de browserkop de wijziging heeft weerspiegeld. De HTML-code van de pagina bevat

De pagina zelf geeft alleen de inhoud weer die is opgegeven op de sjabloonpagina.

De sjabloon kan op elk moment worden bewerkt en de wijzigingen worden weergegeven op alle afgeleide pagina's. Laten we bijvoorbeeld een afbeelding toevoegen vóór de titeltekst.

(Dit kunt u vinden in de .NET-installatie "Microsoft.NET\Framework\v2.0.xxx\ASP.NETWebAdminFiles\Images)

De onderliggende pagina in de browser ziet er nu als volgt uit:

Er is een andere manier om de browsertitel programmatisch te wijzigen. Een pagina met een sjabloon heeft een Master-eigenschap. Natuurlijk hebben alle pagina's dit, maar voor gewone pagina's is het Null. Hiermee heeft u toegang tot alle eigenschappen van de hoofdpagina. Deze eigenschap is alleen-lezen.

De hoofdpagina kan de inhoud definiëren die standaard wordt weergegeven. Het wordt in ContentPlaceHolder-elementen geplaatst en wordt overgenomen door alle onderliggende pagina's. Tenzij de onderliggende pagina de standaardinhoud overschrijft, wordt deze gebruikt wanneer deze wordt weergegeven. Laten we een SiteMapPath-besturingselement maken, dat we in ContentPlaceHolder1 plaatsen.

Het verschijnt niet op de MainSchool.aspx-pagina omdat beide Content-elementen daar zijn gedefinieerd. Echter, als binnen volgende bladzijde slechts één van de Content-elementen is gedefinieerd:

Welke programmeertaal heeft jouw voorkeur? asp:RadioButtonList ID = "rblVoting" runat = "server" DataSourceID = "SqlDataSource1" DataTextField = "variant" DataValueField = "id">

Als je het in een browser bekijkt, zien we dat aan de linkerkant “ broodkruimels" worden tentoongesteld.

Softwaredoel van de hoofdpagina

Op een inhoudspagina kunt u de hoofdpagina ervan programmatisch opnieuw toewijzen. Om dit te doen, moet u de gewenste waarde toewijzen aan de eigenschap Page.MasterPageFile. De sjabloon verandert ongeacht welke sjabloon is toegewezen in de @Page-richtlijn. Maar als u dit probeert te doen in de functies Page_Load of Page_Init, krijgt u een runtime-fout.

Deze eigenschap kan alleen worden gewijzigd tijdens de Page_PreInit-gebeurtenis. De Page_PreInit-gebeurtenis is de vroegste fase van de levenscyclus van een pagina die toegankelijk is. Tijdens de Init-gebeurtenis zijn de hoofd- en onderliggende pagina's al samengevoegd tot één pagina, dus het is te laat om de sjabloon te wijzigen. Om deze reden is de gebeurtenis Page_PreInit de enige waarvan de handler afzonderlijk van de inhoudspagina met de hoofdpagina kan werken.

Sjabloonpagina's kunnen methoden en eigenschappen bevatten. Om er toegang toe te krijgen, moet u de @MasterType-richtlijn gebruiken. In dit geval wordt de ontwerpsjabloonpaginaklasse beschikbaar via een sterk getypte link. Het TypeName-attribuut specificeert de naam van het type, en VirtualPath specificeert het pad relatief ten opzichte van de hoofdmap van de webtoepassing naar het sjabloonbestand.

Op deze manier biedt de pagina externe toegang tot de eigenschappen van de elementen.

void Page_Load() ( Master.FooterText = "Dit is een aangepaste voettekst"; AdRotator ad = (AdRotator)Master.FindControl("MyAdRotator"); if (ad != null) ( ad.BorderColor = System.Drawing.Color. Paars; ad.BorderWidth = 10; ) )

Geneste basispagina's

Ontwerpsjablonen kunnen andere sjablonen overnemen. Een site bestaat bijvoorbeeld uit verschillende secties. Alle sitepagina's hebben gemeenschappelijke elementen, en alle sectiepagina's hebben andere gemeenschappelijke elementen. De website van de bloemenwinkel bestaat uit rubrieken voor meerjarige en eenjarige bloemen. Er zijn voor hen sjablonen gemaakt die de algemene sitesjabloon overnemen.

Vaste planten

De pagina die narcissen beschrijft, bevindt zich in de sectie overblijvende bloemen en neemt de sjabloon SectionPerrenials over.

Narcissen bloeien vroeg in de lente en verwelkomen het groeiseizoen.

Volgorde van gebeurtenissen

Wanneer een samengestelde pagina op de server wordt weergegeven, vinden zowel de sjabloonpagina- als de inhoudspaginagebeurtenissen plaats. De volgorde van deze gebeurtenissen is handig om te weten of we hun handlers willen programmeren.

Initialiseren van geneste basispaginabesturingselementen.

Initialiseren van geneste.

Initialiseren van de hoofdpagina zelf.

Initialiseren van de inhoudspagina.

Page_LoadComplete-gebeurtenis van de inhoudspagina

De gebeurtenis LoadComplete werd geïntroduceerd zodat de hoofdpagina-elementen die in de Page_Load ervan waren gemaakt, toegankelijk waren vanaf de inhoudspagina. Dit kan niet worden gedaan in de Page_Load-handler van de inhoudspagina, omdat deze vóór de hoofdpagina wordt geladen.

Platformspecifieke sjabloonpagina's

In veel gevallen worden applicaties ontwikkeld om op te bekijken verschillende soorten containers. Het kan zijn verschillende browsers of webbrowsers op PDA's en mobiele telefoons.

Daarom kunt u met ASP.NET 2.0 verschillende sjabloonpagina's definiëren voor specifieke containers in het MasterPageFile-attribuut van de Page-instructie.

Conclusie

Bij het maken van apps waarbij alle pagina's gemeenschappelijke kop-, voetteksten en navigatie bevatten, kan het leven eenvoudiger worden gemaakt door ontwerppatronen. Ze zijn gemakkelijk te gebruiken en kunnen op elk moment worden gewijzigd, waardoor de hele applicatie wordt bijgewerkt.

Met ASP.NET-basispagina's kunt u een consistente lay-out voor de pagina's in uw toepassing creëren. Eén enkele stramienpagina definieert het uiterlijk en het standaardgedrag dat u wilt voor alle pagina's (of een groep pagina's) in uw toepassing. U kunt vervolgens afzonderlijke inhoudspagina's maken die de inhoud bevatten die u wilt weergeven. Wanneer gebruikers de inhoudspagina's opvragen, worden deze samengevoegd met de hoofdpagina om uitvoer te produceren die de lay-out van de hoofdpagina combineert met de inhoud van de inhoudspagina.

Hoe basispagina's werken

Basispagina's bestaan ​​eigenlijk uit twee delen: de basispagina zelf en een of meer inhoudspagina's.

Hoofdpagina's

Een stramienpagina is een ASP.NET-bestand met de extensie .master (bijvoorbeeld MySite.master) met een vooraf gedefinieerde lay-out die statische tekst, HTML-elementen en serverbesturingselementen kan bevatten. De hoofdpagina wordt geïdentificeerd door een speciale richtlijn die de richtlijn vervangt die wordt gebruikt voor gewone .aspx-pagina's. De richtlijn ziet er als volgt uit.

De @Master-richtlijn kan de meeste van dezelfde richtlijnen bevatten die een richtlijn kan bevatten. De volgende stramienpagina-instructie bevat bijvoorbeeld de naam van een code-behind-bestand en wijst een klassenaam toe aan de stramienpagina.

Naast de @ Master-richtlijn bevat de hoofdpagina ook alle HTML-elementen op het hoogste niveau voor een pagina, zoals html, head en form. Op een hoofdpagina kunt u bijvoorbeeld een HTML-tabel gebruiken voor de lay-out, een img-element voor uw bedrijfslogo, statische tekst voor de copyrightkennisgeving en serverbesturingselementen om standaardnavigatie voor uw site te creëren. Je kunt elke HTML gebruiken En elk ASP.NET-elementen als onderdeel van uw hoofdpagina.

Vervangbare tijdelijke aanduidingen voor inhoud

Naast statische tekst en besturingselementen die op alle pagina's verschijnen, bevat de stramienpagina ook een of meer besturingselementen. Deze besturingselementen voor tijdelijke aanduidingen definiëren regio's waar vervangbare inhoud zal verschijnen. De vervangbare inhoud wordt op zijn beurt gedefinieerd in inhoudspagina's. Nadat u de besturingselementen hebt gedefinieerd, kan een stramienpagina er als volgt uitzien.

Titel van de hoofdpagina

Titel van de hoofdpagina

Inhoudspagina's

U definieert de inhoud voor de tijdelijke aanduidingen van de stramienpagina door afzonderlijke inhoudspagina's te maken. Dit zijn ASP.NET-pagina's (.aspx-bestanden en eventueel code-behind-bestanden) die aan een specifieke stramienpagina zijn gebonden. De binding wordt tot stand gebracht in de @ Page-richtlijn van de inhoudspagina door een attribuut op te nemen dat verwijst naar de hoofdpagina die moet worden gebruikt. Een inhoudspagina kan bijvoorbeeld de volgende @ Page-instructie hebben, die deze aan de Master1.master-pagina koppelt.

Op de inhoudspagina maakt u de inhoud door besturingselementen toe te voegen en deze toe te wijzen aan besturingselementen op de stramienpagina. De hoofdpagina kan bijvoorbeeld tijdelijke aanduidingen voor de inhoud hebben, genaamd Hoofdpagina en Voettekst. Op de inhoudspagina, jij kan maak twee besturingselementen, één die is toegewezen aan de controle Hoofd en de andere toegewezen aan de voettekst van het besturingselement, zoals weergegeven in de volgende afbeelding.

Tijdelijke inhoud vervangen

Over het algemeen heeft deze structuur geen invloed op de manier waarop u uw pagina's opbouwt of programmeert. Als u echter een paginabrede eigenschap op de hoofdpagina instelt, kan dit in sommige gevallen het gedrag van de inhoudspagina beïnvloeden, omdat de hoofdpagina het dichtstbijzijnde bovenliggende element is voor de besturingselementen op de pagina. Als u bijvoorbeeld de eigenschap op de inhoudspagina instelt op true, maar dezelfde eigenschap op false instelt op de stramienpagina, wordt de weergavestatus feitelijk uitgeschakeld omdat de instelling op de stramienpagina voorrang krijgt.

Hoofdpagina- en inhoudspaginapaden

Wanneer een inhoudspagina wordt opgevraagd, wordt de inhoud ervan samengevoegd met de hoofdpagina en wordt de pagina uitgevoerd in de context van de inhoudspagina. Als u bijvoorbeeld de eigenschap van het object ophaalt, hetzij in inhoudspaginacode of in stramienpaginacode, vertegenwoordigt het pad de locatie van de inhoudspagina.

De stramienpagina en de inhoudspagina hoeven zich niet in dezelfde map te bevinden. Zolang het attribuut in de @ Page-instructie van de inhoudspagina wordt omgezet in een .master-pagina, kan ASP.NET de inhoud en de master-pagina's samenvoegen tot één enkele weergegeven pagina.

Verwijzen naar externe bronnen

Zowel de inhoudspagina als de hoofdpagina kunnen besturingselementen en elementen bevatten die verwijzen naar externe bronnen. Beide kunnen bijvoorbeeld afbeeldingsbesturingselementen bevatten die naar afbeeldingsbestanden verwijzen, of ze kunnen ankers bevatten die naar andere pagina's verwijzen.

De context voor de samengevoegde inhoud en stramienpagina's is die van de inhoudspagina. Dit kan invloed hebben op de manier waarop u URL's opgeeft voor bronnen, zoals afbeeldingsbestanden en doelpagina's, in ankers.

Serverbediening

In serverbesturingselementen op basispagina's wijzigt ASP.NET dynamisch de URL's van eigenschappen die verwijzen naar externe bronnen. U kunt bijvoorbeeld een besturingselement op een stramienpagina plaatsen en de eigenschap ervan zo instellen dat deze relatief is ten opzichte van de stramienpagina. Bij looptijd, zal ASP.NET de URL wijzigen zodat deze correct wordt omgezet in de context van de inhoudspagina.

ASP.NET kan URL's wijzigen in de volgende gevallen:

De URL is een eigenschap van een ASP.NET-serverbesturingselement.

De eigenschap wordt intern in het besturingselement gemarkeerd als een URL. (De eigenschap is gemarkeerd met het attribuut .) In praktische termen worden ASP.NET-serverbesturingseigenschappen die gewoonlijk worden gebruikt om naar externe bronnen te verwijzen, op deze manier gemarkeerd.

Andere elementen

ASP.NET kan geen URL's wijzigen op elementen die zijn niet servercontroles. Als u bijvoorbeeld een img-element op een hoofdpagina gebruikt en het src-attribuut ervan instelt op een URL, zal ASP.NET de URL niet wijzigen. In dat geval wordt de URL omgezet in de context van de inhoudspagina en wordt de URL dienovereenkomstig aangemaakt.

Over het algemeen wordt het aanbevolen dat u bij het werken met elementen op stramienpagina's een serverbesturingselement gebruikt, zelfs voor elementen waarvoor geen servercode nodig is. Gebruik bijvoorbeeld een serverbesturingselement in plaats van een img-element. Op die manier kan ASP.NET URL's correct omzetten en kunt u onderhoudsproblemen vermijden die kunnen optreden als u de hoofd- of inhoudspagina verplaatst.

Zie ASP.NET-websitepaden voor meer informatie over het opgeven van paden voor ASP.NET-serverbesturingselementen.

Hoofdpagina's en thema's

U kunt een ASP.NET-thema niet rechtstreeks op een stramienpagina toepassen. Als u een thema-attribuut toevoegt aan de @Master-richtlijn, zal de pagina een foutmelding geven wanneer deze wordt uitgevoerd.

Onder deze omstandigheden worden thema's echter toegepast op stramienpagina's:

Als er een thema is gedefinieerd op de inhoudspagina. Hoofdpagina's worden omgezet in de context van inhoudspagina's, zodat het thema van de inhoudspagina ook op de hoofdpagina wordt toegepast.

Als de site als geheel is geconfigureerd om een ​​thema te gebruiken door een themadefinitie in het element op te nemen.

Basispagina's verkennen

U kunt inhoudspagina's op drie niveaus aan een stramienpagina koppelen:

Op paginaniveau U kunt op elke inhoudspagina een pagina-instructie gebruiken om deze aan een stramienpagina te binden, zoals in het volgende codevoorbeeld.

Op applicatieniveau Door een instelling te maken in het pagina-element van het configuratiebestand van de applicatie (Web.config), kunt u opgeven dat alle ASP.NET-pagina's (.aspx-bestanden) in de applicatie automatisch aan een hoofdpagina worden gekoppeld. element kan er als volgt uitzien.

Als u deze strategie gebruikt, worden alle ASP.NET-pagina's in de toepassing die besturingselementen hebben, samengevoegd met de opgegeven stramienpagina. (Als een ASP.NET-pagina geen besturingselementen bevat, wordt de stramienpagina niet toegepast.)

Op mapniveau Deze strategie lijkt op binding op applicatieniveau, behalve dat u de instelling in een Web.config-bestand in slechts één map opgeeft. De masterpaginabindingen zijn vervolgens van toepassing op de ASP.NET-pagina's in die map.

Hallo w3ii in HTML

Deze code toont een voorbeeld als een HTML-pagina:

Hallo w3ii!

firstpage.htm" en maak ook een link naar het bestand, zoals deze: firstpage.htm

Hallo w3ii in ASP.NET

De gemakkelijkste manier om te converteren HTML-pagina in een ASP.NET-pagina om het HTML-bestand naar een nieuw bestand met de extensie .aspx te kopiëren.

Deze code toont ons voorbeeld zoals op een ASP.NET-pagina:

Hallo w3ii!

Als je dit zelf wilt proberen, sla de code dan op in een bestand met de naam "firstpage.aspx" en maak ook een link naar het bestand, zoals deze: firstpage.aspx

Hoe het werkt?

In principe is een ASP.NET-pagina precies hetzelfde als een HTML-pagina.

Een HTML-pagina heeft de extensie .htm. Als de browser een HTML-pagina opvraagt ​​bij de server, stuurt de server de pagina zonder enige wijziging naar de browser.

Een ASP.NET-pagina heeft de extensie .aspx. Als de browser een ASP.NET-pagina opvraagt, verwerkt de server deze uitvoerbare code pagina, voordat het resultaat wordt teruggestuurd naar de browser.

De bovenstaande ASP.NET-pagina bevat geen uitvoerbare code, dus er wordt niets uitgevoerd. In de volgende voorbeelden zullen we uitvoerbare paginacode toevoegen om het verschil aan te tonen tussen statische HTML-pagina's en dynamische pagina's ASP-pagina's.

Klassieke ASP

Active Server Pages (ASP) bestaan ​​al enkele jaren. Met ASP kan uitvoerbare code in HTML-pagina's worden geplaatst.

Eerdere versies van ASP (vóór ASP .NET) worden vaak klassieke ASP genoemd.

ASP.NET is niet volledig compatibel met Classic ASP, maar de meeste Classic ASP-pagina's werken prima als ASP.NET-pagina's met slechts kleine wijzigingen.

Als u meer wilt weten over klassieke ASP, bezoek dan onze ASP-tutorial.

Dynamische pagina's in klassieke ASP

Om te demonstreren hoe ASP pagina's met dynamische inhoud kan weergeven, hebben we in het vorige voorbeeld uitvoerbare code (in rood) toegevoegd:

Hallo w3ii!

De code in de tag wordt uitgevoerd op de server.

Response.Write is ASP-code voor het schrijven van iets naar de HTML-uitvoerstroom.

Now() is een functie om de huidige datum en tijd van de server terug te geven.

Als je dit zelf wilt proberen, sla de code dan op in een bestand met de naam "dynpage.asp" en maak ook een link naar het bestand, zoals deze: dynpage.asp

Dynamische pagina's in ASP .NET

Deze code geeft ons voorbeeld weer zoals op een ASP.NET-pagina:

Hallo w3ii!

Als je dit zelf wilt proberen, sla de code dan op in een bestand met de naam "dynpage.aspx" en maak ook een link naar het bestand, zoals deze: dynpage.aspx

ASP.NET versus klassieke ASP

De voorgaande voorbeelden laten geen verschillen zien tussen ASP.NET en klassieke ASP.

Zoals u uit de laatste twee voorbeelden kunt zien, zijn er geen verschillen tussen deze twee ASP- en ASP.NET-pagina's.

In de volgende hoofdstukken ziet u hoe u de ASP.NET-serverbesturing krachtiger kunt maken dan klassieke ASP.

Waarschijnlijk is een zeldzaam interview op ASP.NET niet compleet zonder een vraag over de levenscyclus van een pagina in ASP.NET Web Forms (hierna kortweg ASP.NET genoemd). Laten we proberen dit probleem te begrijpen. Ik heb het onderwerp in tweeën gedeeld. In dit artikel zullen we kijken naar de fasen van de paginalevenscyclus in ASP.NET.

Algemene planlevenscyclus van een ASP.NET-pagina

• het ontvangen en verwerken van een paginaverzoek door de IIS-webserver
• het verzoek verder doorgeven aan de ASP.NET-runtime

looptijd:

* laadt de klasse van de opgeroepen pagina * stelt de eigenschappen van de paginaklasse in * bouwt een boom van elementen * vult de Request- en Response-eigenschappen * roept de methode ```IHttpHandler.ProcessRequest``` aan

Fasen

Er zijn 8 hoofdfasen. Dit wordt duidelijk aangetoond door het volgende diagram

Fasebeschrijving

Aanvraagpagina	Het paginaverzoek vindt plaats voordat de levenscyclus van de pagina begint. De gebruiker doet een verzoek, de ASP.NET-runtime bepaalt of de pagina moet worden gecompileerd en begint levenscyclus, of u kunt een in de cache opgeslagen pagina als antwoord retourneren zonder de pagina uit te voeren.
Begin met de verwerking	In dit stadium worden de eigenschappen Response en Request en de eigenschap UICulture ingesteld. Deze stap bepaalt ook of de pagina is opgevraagd als resultaat van een postback en stelt de eigenschap IsPostBack dienovereenkomstig in.
Initialisatie van pagina's	Tegen de tijd dat de pagina wordt geïnitialiseerd, zijn alle besturingselementen voor onderliggende gebruikers al gemaakt en is de eigenschap UniqueID ingesteld. Op dit moment worden thema's op de pagina toegepast. Als de pagina wordt opgeroepen als resultaat van een postback, zijn de naar de server verzonden gegevens op dit moment nog niet in de eigenschappen van de besturing geladen.
Als de pagina wordt aangeroepen als gevolg van een postback, worden in dit stadium de eigenschappen van de besturingselementen ingesteld op basis van de statusinformatie (ViewState en ControlState).
Geldigmaking	De methode Validate() wordt aangeroepen voor alle validators op de pagina.
Postback-verwerking	Gebeurtenishandlers worden aangeroepen als er een postback heeft plaatsgevonden.
Weergave	Statusinformatie wordt opgeslagen, waarna de paginaklasse de juiste methoden aanroept kind elementen besturingselementen om een ​​HTML-weergave te genereren en deze door te geven aan Response.OutputStream.
Lossen	Het ontladen vindt plaats nadat de HTML-weergave voor de gehele pagina is gemaakt.

Pagina 10 van 11

Een pagina maken

Het gebruik van ontwerpsjablonen stelt zijn eigen eisen aan de pagina's. Omdat de sjabloon ContentPlaceHolder-besturingselementen bevat, moet de pagina inhoudsbesturingselementen bevatten die de opmaakcode en andere besturingselementen bevatten die op de resulterende pagina worden weergegeven. De pagina mag geen enkele bevatten serverelementen controle- of opmaakcode buiten de inhoudsbesturingselementen.

Pagina 1

• Pagina 2
• 
  Pagina 3

Net als bij de sjabloon wordt de paginalogicacode op de gebruikelijke manier gemaakt. Het enige verschil is dat de pagina geen eigen objecten heeft, zoals HeadControl, dus u moet een link naar de sjabloonpagina gebruiken via de eigenschap Master.

Beschermde ongeldige Page_Load(objectafzender, EventArgs e)(

if (!Page.IsPostBack) Master.Page.Header.Title = "Startpagina";}!}

beschermde leegte btnShow_Click(objectafzender, EventArgs e)( PlaceHolder.Controls.Add(

new LiteralControl(" alert("Goedemiddag, " + txtName.Text + ""); "));

Master.Page.Header.Title = "Goedemiddag," + txtName.Text;} !}

Om een ​​pagina aan een sjabloon te binden, gebruikt u het MasterPageFile-attribuut van de Page-instructie. Als u dezelfde sjabloon aan alle pagina's in de directory moet binden, hoeft u niet voor elke pagina het MasterPageFile-attribuut op te geven; het is voldoende om de basissjabloon in het web.config-bestand in te stellen.

Bovendien kunt u met ASP.NET programmatisch een thema instellen. Zoals hierboven vermeld, vindt het laden en koppelen van de ontwerpsjabloon plaats terwijl de pagina wordt voorbereid voor initialisatie. Als u de paginaontwerpsjabloon moet wijzigen, moet u dit daarom doen in de PreInit-gebeurtenishandler.

Beschermde ongeldige Page_PreInit (objectafzender, EventArgs e) ( Page.MasterPageFile = "AnotherMaster.master";)

ASP.NET-sjabloonverwerking

De eerste keer dat een pagina wordt geopend, zoekt en compileert ASP.NET samenstellingen voor alle sjablonen in de map. Deze bewerking duurt enige tijd, afhankelijk van het aantal sjabloonpagina's in de map, maar wordt slechts één keer uitgevoerd. Als er ongebruikte sjablonen in de directory staan, leidt dit daarom niet tot prestatieverlies terwijl de applicatie draait. Het enige ongemak is extra tijd en het compileren van onnodige assemblages voor ongebruikte pagina's.

Bij het openen van een aspx-bestand van een pagina met een bepaald ontwerpsjabloon verschilt het compilatieproces vrijwel niet van het normale paginacompilatieproces, behalve dat er een MasterPage-sjabloonklasse wordt gemaakt, waarnaar een link beschikbaar is in de eigenschap Page.Master.

De pagina doorloopt vervolgens alle stappen die hierboven in dit artikel zijn beschreven, waardoor er HTML-code wordt gegenereerd die naar de client wordt verzonden. In de door de browser ontvangen HTML is het niet meer mogelijk om te bepalen welk deel van de code in de ontwerpsjabloon is gespecificeerd en welk deel van de code op de pagina zelf is gedefinieerd, aangezien de ContentPlaceHolder- en Content-besturingselementen geen HTML hebben correspondentie en genereer geen extra tags anders dan de inhoud ervan.

Startpagina

Pagina 1 Pagina 2 Pagina 3\

\

Tijd: 20/03/2005

Omdat een sjabloon een subset van een pagina is, is het toegestaan ​​om geneste sjablonen te maken door het pad naar een andere sjabloon voor de sjabloon op te geven in de Master-instructie met behulp van het MasterPageFile-attribuut. Om dit te doen, moet u ContentPlaceHolder-besturingselementen definiëren in de hoofdsjabloon, en in “onderliggende” sjablonen, samen met ContentPlaceHolder-elementen, Content-besturingselementen definiëren om de inhoud van de ContentPlaceHolder-elementen van de basissjabloon te vervangen.

Verschillende sjablonen gebruiken voor verschillende browsers

Elke webontwikkelaar is zich daar terdege van bewust verschillende browsers(bijvoorbeeld Microsoft Internet Explorer, Netscape Navigator, Mozilla FireFox enz.) HTML-code op een andere manier verwerken en, belangrijker nog, enigszins verschillende programmeerbare modellen hebben, wat het maken van clientscripts bemoeilijkt.

Om dit probleem op te lossen, zijn er twee hoofdmethoden die zowel in ASP.NET 1.x als in klassieke ASP worden gebruikt. De eerste is dat clientcode naar de clientbrowser wordt verzonden, die, op basis van het browsertype en de versie, enkele acties uitvoert. De tweede is om de browser van de gebruiker om te leiden naar pagina's die specifiek zijn geoptimaliseerd voor een specifieke browser. ASP.NET maakt het eenvoudig om dit soort pagina's te maken, omdat de runtime HTML-code genereert voor standaard serverbesturingen op basis van informatie over de browser van de klant. Bij gebruik van ontwerpsjablonen kunt u meerdere sjablonen maken, per browser en per richtlijn Pagina pagina's specificeer welke sjabloon u wilt gebruiken.

Een lijst met browsers en de browsereigenschappen die door ASP.NET worden gebruikt, kunt u vinden in de map %WINDIT%\Microsoft.NET\Framework\version\CONFIG\Browsers.