Irgalmatlan benyújtani asp. Automatikus adatvisszaküldés

A keresztneved:

Mi a kedvenc jégkrém ízed:

vanília

Eper

Csokoládé

köves út

Erről az űrlapról a következő kéréstörzs adható át:

keresztnév=James&flavor=Rocky+Road

Ezután az alábbi szkript használható:

Üdvözöljük,<%= Request.Form("firstname") %>.

A kedvenc ízed az<%= Request.Form("flavor") %>.

Az eredmény így fog kinézni:

Isten hozott, James. Kedvenc ízed a Rocky Road.

Ha az alábbi szkriptet használja:

A nem elemzett űrlapadatok a következők:<%= Request.Form %>

így fog kinézni az eredmény:

A nem elemzett űrlapadatok: keresztnév=James&flavor=Rocky+Road

Jegyzet. Ha az űrlap több azonos nevű objektumot (például HTML SELECT címkéket) tartalmaz, az űrlapcsalád eleme az összes kiválasztott érték vesszővel elválasztott listája lesz.

Alkalmazási terület

Lásd még

Ügyféltanúsítvány _ClientCertificate, Cookie-k _Cookies_Request, QueryString _QueryString, Szerverváltozók _ServerVariables

ASP.NET modell

HTML űrlapok

Aki ismeri a HTML nyelvet, az tudja ezt leginkább egyszerű módon kliens adatok küldése a szervernek a kezelő használata . A fogantyú belsejében leírók helyezhetők el mások képviseletében alapelemek felhasználói felület, például gombok, szövegmezők, listamezők és rádiógombok.

Például lent látható egy HTML oldal, amelynek űrlapja két szövegmezőt, két jelölőnégyzetet és egy küldés gombot tartalmaz, pl. csak öt leíró :

FirstName=Vasily&LastName=Pupkin&CS=on&VB=on

A karakterlánc létrehozásakor a böngésző bizonyos szabályokat követ. Az információ mindig név/érték párok sorozataként kerül elküldésre, és jellel (&) elválasztva. Páron belül a nevet egyenlőségjel (=) választja el az értéktől. A jelölőnégyzeteket a rendszer figyelmen kívül hagyja, amíg ki nem jelöli őket, ilyenkor a böngésző a szöveget adja át értékként. Teljes információ A minden jelenlegi böngészőben támogatott HTML űrlapszabványról a W3C - Forms oldalon olvashat.

Gyakorlatilag minden szerveroldali programozási keretrendszer hozzáad egy absztrakciós réteget a nyers űrlapadatokhoz. Felbontják ezt a sort, és hasznosabban mutatják be. Például a JSP, ASP és ASP.NET lehetővé teszi egy űrlapvezérlő értékének lekérését a vékony objektumréteg használatával. Az ASP-ben és az ASP.NET-ben az értékek név szerint kereshetők Request.Form gyűjtemények. Ha az előző oldalt ASP.NET webes űrlapra konvertáljuk, akkor ez a megközelítés a következő kóddal alkalmazható:

String firstName = Request.Form["FirstName"];

Ez a vékony "réteg" a POST üzenet tetején hasznos, de még mindig messze van a valódi objektum-orientált struktúrától. Ezért az ASP.NET egy lépéssel tovább viszi. Amikor az oldal visszakerül az ASP.NET környezetbe, lekéri az értékeket, feltölti az Űrlap gyűjteményt (az ASP-kóddal való visszafelé kompatibilitás érdekében), majd konfigurálja a megfelelő vezérlőobjektumokat. Ez azt jelenti, hogy a következő sokkal értelmesebb szintaxis használható információk lekérésére egy ASP.NET webes űrlapról:

Karakterlánc keresztnév = txtFirstName.Text;

Ennek a kódnak megvan a típusbiztonsági előnye is. Más szóval, amikor lekéri a jelölőnégyzet állapotát, a be szó helyett egy igaz vagy hamis logikai értéket kap. Ennek eredményeként a fejlesztők el vannak szigetelve a HTML szintaxis egyedi jellemzőitől.

Az ASP.NET-ben minden vezérlő egy külön fogantyúban van elhelyezve. . Ez a leíró a runat="server" attribútummal van megjelölve, amely lehetővé teszi a szerveren való futtatását. Az ASP.NET nem engedélyezi egynél több szerverleírót tartalmazó webes űrlapok létrehozását , bár lehetőség van olyan oldalak létrehozására, amelyek információkat küldenek más oldalakra az oldalközi benyújtási technológia segítségével.

Dinamikus felhasználói felület

Kétségtelen, hogy a vezérlőmodell megkönnyíti az űrlapról információ kinyerését. Még figyelemre méltóbb, hogy megkönnyíti az életet, ha információkat kell hozzáadnia egy oldalhoz. Szinte az összes webvezérlő tulajdonság olvasható és beállítható. Ez azt jelenti, hogy például egy szövegmező Szöveg tulajdonsága ugyanolyan egyszerűen beállítható, mint az olvasás.

Fontolja meg például, mi történik, ha egy weboldalon lévő szövegrész frissítésére készül, hogy tükrözze a felhasználó által korábban megadott információkat. A klasszikus ASP-ben meg kell találnia egy kényelmes helyet egy HTML-kódot író szkriptblokk beszúrásához. A következő egy ASP.NET kódrészlet, amely ezzel a technikával élénk színű üdvözlő üzenetet jelenít meg:

Karakterlánc üzenet = " Üdvözöljük " + txtFirstName.Text + " " + txtLastName.Text + ""; Response.Write(üzenet);

Másrészt a helyzet leegyszerűsödik az ASP.NET címkevezérlőjének (címke) meghatározásakor:

Most már csak beállíthatja a tulajdonságait:

Label1.Text = "Üdvözöljük" + txtFirstName.Text + " " + txtLastName.Text; Label1.ForeColor = Color.Red;

Ennek a kódnak számos előnye van. Először is, sokkal könnyebb írni (és hiba nélkül). Ebben a példában a megtakarítás elhanyagolható, de ha figyelembe vesszük, igen jelentőssé válik teljes oldal ASP.NET, amelynek dinamikusan módosítania kell a linkeket, képeket és stílusokat tartalmazó összetett HTML-blokkokat.

Másodszor, a vezérlés alapú kódot is sokkal könnyebb elhelyezni az oldalon. ASP.NET kódot írhat, függetlenül attól, hogy hol történik a megfelelő művelet. Másrészt a klasszikus ASP esetén gondoskodni kell az oldalon lévő tartalom elrendezéséről és a script blokk kód megfelelő elhelyezéséről. Ha egy oldal dinamikus régiókat tartalmaz, akkor az egymáshoz nem kapcsolódó és rendellenes szkriptblokkok zűrzavarává válhat.

A vezérlési modell másik (kevésbé látható, de jelentősebb) előnye az alacsony szintű HTML-részletek elrejtésének módja. Ez nemcsak a HTML sajátosságainak megismerése nélkül teszi lehetővé a kód írását, hanem azt is lehetővé teszi, hogy az oldalak a böngészők szélesebb körét támogassák. Mivel a vezérlő önmagát jeleníti meg, képes a kimenetét a különböző böngészők, fejlett kliensoldali szolgáltatások vagy akár más HTML-hez kapcsolódó szabványok, például XHTML vagy WML támogatására szabni. Mint ilyen, a kód már nincs közvetlenül a HTML-szabványhoz kötve.

ASP.NET eseménymodell

A klasszikus ASP technológiát használja lineáris modell feldolgozás. Ez azt jelenti, hogy az oldal kódja az elejétől a végéig feldolgozásra kerül, és sorrendben végrehajtódik. E modell miatt a klasszikus ASP technológiát használó fejlesztőknek még egyszerű oldalakhoz is megfelelő mennyiségű kódot kell írniuk.

Tipikus példa erre egy weboldal, amely három különböző beküldőgombot tartalmaz három különböző művelethez. Ilyen esetben a script kódnak egyértelműen meg kell különböztetnie, hogy az oldal beküldésekor melyik gombra kattintott, majd feltételes logika alapján meg kell határoznia és végre kell hajtania a megfelelő műveletet.

Az ASP.NET felajánlásával megkönnyíti a dolgokat eseményvezérelt feldolgozási modell. Ebben a modellben a fejlesztő először vezérlőket ad a webes űrlaphoz, majd eldönti, hogy mely eseményekre kíván válaszolni. Minden eseménykezelő külön módszer, így az oldal kódja rendezettnek és rendezettnek tűnik.

Ez a modell nem új, de az ASP.NET megjelenése előtt kizárólag az ablakos felhasználói felületek programozása terén használták gazdag kliens alkalmazásokhoz. Hogyan működnek az események az ASP.NET-ben? Meglepően nagyon egyszerű. Röviden így néz ki:

Az oldal első futtatásakor az ASP.NET objektumokat hoz létre az oldalhoz és vezérlőihez. Ezt követően az inicializálási kód végrehajtása megtörténik, majd az oldalt HTML-be konvertálva visszaküldik a kliensnek, a létrehozott objektumokat pedig eltávolítják a szerver memóriájából.

Egy bizonyos ponton a felhasználó olyan műveletet hajt végre, amely visszaküldést indít el, például rákattint egy gombra. Az oldal ezután az összes űrlapadattal együtt elküldésre kerül a szervernek.

Az ASP.NET elkapja ezt a visszaadott oldalt, és újra létrehozza az objektumokat, visszaállítva azokat abba az állapotba, amelyben az oldalt az ügyfélnek utoljára elküldték.

Ezután az ASP.NET ellenőrzi, hogy melyik művelet okozta az adatok visszaküldését, és létrehozza a megfelelő eseményeket (például Button.Click), amelyekre a fejlesztő egy bizonyos reakciót adhat a kódjában.

Általános szabály, hogy a fejlesztők ebben a szakaszban előszeretettel hajtanak végre valamilyen szerveroldali műveletet (például adatbázis frissítése vagy adatok kiolvasása fájlból), majd módosítják a vezérlőobjektumokat úgy, hogy azok megjelenítsék az új információkat.

A módosított oldalt a rendszer HTML formátumba konvertálja és visszaküldi a kliensnek. Az oldalobjektumok törlődnek a memóriából. Abban az esetben, ha újabb visszaküldés történik, az ASP.NET megismétli a 2-4. bekezdésekben felsorolt ​​lépéseket.

Más szavakkal, az ASP.NET az űrlapadatokat nem csak az oldalon lévő vezérlőobjektumok konfigurálására használja, hanem annak eldöntésére is, hogy mely eseményeket aktiválja.

Például, ha észreveszi, hogy a szövegmezőben megjelenő szöveg megváltozott a legutóbbi visszaküldés óta, az ASP.NET elindítja az oldal értesítéséhez szükséges eseményt. A fejlesztő döntése, hogy reagál-e erre az eseményre vagy sem.

Ne feledje, hogy mivel a HTTP nem támogatja az állapotok fogalmát, és az ASP.NET által elérhetővé tett összes állapot visszaáll, az eseményvezérelt modell lényegében egy emuláció. A modell támogatásához az ASP.NET-nek számos feladatot kell végrehajtania háttér. Ennek a koncepciónak az a szépsége, hogy egy kezdő programozónak nem kell ismernie a rendszer minden részletét ahhoz, hogy sikeresen kihasználhassa a szerveresemények előnyeit.

Automatikus adatvisszaküldés

Természetesen van egy hiányosság az eddig leírt rendezvényrendszerben. A Windows-alkalmazások fejlesztői régóta hozzászoktak ahhoz, hogy olyan gazdag eseménymodellel foglalkozzanak, amely lehetővé teszi a kód számára, hogy reagáljon az egérmozgásokra, a billentyűzet billentyűleütéseire és az azonnali vezérlési interakciókra. Az ASP.NET-ben azonban az ügyfélművelet a kliens oldalon, a szerveroldali feldolgozás pedig a webszerveren történik. Ez azt jelenti, hogy egy eseményre való reagálás mindig többletköltséggel jár. Ezért a gyorsan elindított események (mint például az egérmozgatás események) teljesen kivitelezhetetlenek az ASP.NET világában.

Hogy elérd felhasználói felület specifikus hatást, kliensoldali JavaScriptet hozhat létre a gyors események, például az egérmozgások kezelésére. Vagy ami még jobb, használhatod speciális elem Az ilyen típusú beépített képességekkel rendelkező ASP.NET vezérlők, például az egyik ASP.NET AJAX vezérlő. Az üzleti logikai kódot azonban csak biztonságos, gazdag szerverkörnyezetben szabad futtatni.

Ha ismeri HTML űrlapok, akkor tudja, hogy az oldal elküldésének egyik meglehetősen gyakori módja a Küldés gombra kattintás. A szabványos HTML-kiszolgálóvezérlők használata esetén az .aspx webes űrlapokon általában ez a módszer az egyetlen lehetséges lehetőség. Miután azonban az oldalt már visszaküldték, az ASP.NET azonnal aktiválhat más eseményeket (például olyan eseményeket, amelyek jelzik, hogy egy bemeneti vezérlőben megváltozott az érték).

Nyilvánvalóan ez nem elég egy teljesen működőképes webes űrlap létrehozásához. Szerencsére az ASP.NET webes vezérlői ezt a modellt az automatikus visszaküldéssel bővítik. Ezzel a lehetőséggel a bemeneti vezérlők különféle eseményeket generálhatnak, amelyekre a kiszolgáló kódja azonnal reagálni tud.

Például elindíthat egy visszaküldést, amikor a felhasználó rákattint egy jelölőnégyzetre, megváltoztat egy kijelölést a listában, vagy módosítja a szöveget egy szövegmezőben, majd egy másik mezőbe lép. Ezek az események nem olyan modulárisak, mint egy Windows-alkalmazásban, de jelentős előrelépést jelentenek a Küldés gombhoz képest.

Mi az az automatikus visszaküldés

Az automatikus visszaküldés használatához telepítenie kell AutoPostBack tulajdonság webvezérlő igaz értékre (alapértelmezés szerint ez a tulajdonság hamisra van állítva, ami optimális teljesítményt biztosít olyan esetekben, amikor nem kell reagálni semmilyen változási eseményre). Az ASP.NET ezután a JavaScript-ügyféloldalt használja a kliens és a kiszolgáló kódja közötti szakadék áthidalására.

Különösen a következők fordulnak elő: amikor egy weboldalt egy vagy több olyan webvezérlővel hoznak létre, amelyeknél be van állítva az AutoPostBack, az ASP.NET egy JavaScript-függvényt ad hozzá a néven megjelenített HTML-oldalhoz. ____doPostBack(). A funkció meghívásakor visszaküldést kezdeményez, és visszaküldi az oldalt a webszervernek az összes űrlapadattal együtt.

Ezenkívül az ASP.NET két rejtett beviteli mezőt is hozzáad, amelyeket a ____doPostBack() függvény arra használ, hogy bizonyos információkat visszaküldjön a kiszolgálónak. Ez az információ az eseményt elindító vezérlő azonosítója és egyéb releváns információk. Kezdetben a mező adatok üresek, amint az alább látható:

A ____doPostBack() függvény felelős azért, hogy ezeket az értékeket beállítsa a megfelelő eseményinformációkhoz, majd elküldje az űrlapot. Az alábbiakban egy példa a ____doPostBack() függvényre:

__doPostBack(eventTarget, eventArgument) függvény ( if (!theForm.onsubmit || (theForm.onsubmit() != false)) ( theForm.__EVENTTARGET.value = eventCél; theForm.__EVENTARGUMENT.value = eventArgument; theForm); ) )

Ne felejtse el, hogy az ASP.NET automatikusan generálja a __doPostBack() függvényt. Ez a kód kibővül, amint további AutoPostBack-vezérlőket adnak az oldalhoz, mivel minden egyes vezérlőhöz be kell állítani az eseményadatokat.

Végül minden olyan vezérlő, amelynek az AutoPostBack tulajdonsága igaz, a __doPostBack() függvényhez kapcsolódik az onclick vagy onchange attribútum használatával. Ezek az attribútumok jelzik, hogy a böngészőnek milyen műveletet kell végrehajtania az onclick és onchange JavaScript-kliens eseményekre.

Más szóval, az ASP.NET a __doPostBack() függvényt proxyként használva automatikusan ASP.NET-kiszolgálóeseménymé alakítja át a JavaScript-ügyfél eseményeit. Egy tapasztalt ASP-alkalmazásfejlesztő természetesen manuálisan is létrehozhat hasonló megoldás hagyományos ASP stílusú weboldalakhoz. De az ASP.NET minden bizonnyal nagyban megkönnyíti a fejlesztő életét azáltal, hogy automatikusan kezeli ezeket a részleteket.

Állapot megtekintése

Az ASP.NET modell utolsó összetevője a állapotmechanizmus megtekintése. Ez a mechanizmus megold egy másik problémát, amely abból a tényből ered, hogy a HTTP nem támogatja az állapotot – a változásokkal kapcsolatos információvesztést.

Minden alkalommal, amikor egy oldalt visszaküldenek a szervernek, az ASP.NET megkapja az összes adatot, amelyet a felhasználó a kezelőben található adatok bármelyikébe beírt. vezérlők . Az ASP.NET ezután betölti a weboldalt az eredeti állapotában (az elrendezési séma és az .aspx fájlban megadott alapértelmezett beállítások alapján), és az új adatok szerint testreszabja.

A probléma az, hogy egy dinamikus webes űrlapon a kód sokkal több részletet képes megváltoztatni. Például képes programozottan megváltoztatni a cím színét, szerkeszteni egy statikus szövegrészt, elrejteni vagy megjeleníteni egy panelt vezérlőkkel, vagy akár egy teljes adattáblázatot rácsra illeszteni. Mindezek a műveletek magukban foglalják az oldal kezdeti állapotának megváltoztatását. Ezek közül azonban egyik sem jelenik meg a benyújtott űrlapadatokban. Ez pedig azt jelenti, hogy az adatok minden egyes visszaküldése után ezek az információk elvesznek.

Az állami támogatás hiányát általában egyszerű cookie-k, munkamenet-cookie-k és egyéb megkerülő megoldások segítségével oldják meg. Azonban minden ilyen mechanizmus megköveteli a saját fejlesztési intézkedések alkalmazását (amelyek néha sok erőfeszítést igényelnek).

Ennek a korlátozásnak a megoldására az ASP.NET saját integrált állapotsorosítási mechanizmussal rendelkezik. Lényegében ez a mechanizmus a következőképpen működik: az oldalkód végrehajtása után (és közvetlenül a végső HTML-dokumentum generálása és az ügyfélnek való elküldése előtt) az ASP.NET megvizsgálja az ezen az oldalon bemutatott összes vezérlőelem tulajdonságait. Ha ezen tulajdonságok bármelyike ​​megváltozott az eredeti állapothoz képest, az ASP.NET megfelelő megjegyzést tesz a név-érték gyűjteménybe. Az ASP.NET ezután az összes összegyűjtött információt beszúrja egy Base64 formátumú karakterláncba (ami garantálja, hogy a HTML-ben nincsenek illegális speciális karakterek), majd beszúrja ezt a karakterláncot a szakaszba. oldalakat új rejtett mezőként.

Az oldal következő közzétételekor az ASP.NET a következőket teszi:

Újra létrehozza az oldalobjektumot és vezérlőelemeit az alapértelmezett értékek (az .aspx fájlban megadott) alapján, és az oldalt ugyanabban az állapotban hagyja, amelyben az első kéréskor volt.

Deszerializálja az állapotinformációkat, és frissíti az összes vezérlőt. Ennek eredményeként az oldal visszatér az ügyfélnek való utolsó elküldés előtti állapotba.

Végül az oldal konfigurálása a beküldött űrlapadatok szerint történik. Például, ha a felhasználó új szöveget ír be egy szövegmezőbe, vagy új kiválasztást végez egy listamezőben, akkor ezek az információk az Űrlapgyűjteménybe kerülnek, és az ASP.NET felhasználja a megfelelő vezérlők létrehozásához. Az oldal ezután megjeleníti az aktuális állapotot, amikor a felhasználó megtekinti.

Most az eseménykezelő kódja lép működésbe. Az ASP.NET előállítja a megfelelő eseményeket, és a kód az oldal megváltoztatásával, oda navigálással reagálhat új oldal vagy más művelet végrehajtásával.

A nézet állapot használata nagyszerű megoldás, mert a szerver erőforrásai minden kérés után felszabadíthatók, így több száz vagy több ezer kérésre méretezhető anélkül, hogy lelassítaná a szervert. Azonban mindenért fizetni kell. A nézet állapotának az oldalon belüli tárolása növeli az oldal méretét. Ennek kettős hatása van a kliensre, hiszen nem csak nagyobb oldalt kell kapnia, hanem a következő visszaküldéskor a rejtett nézet állapotadatait is vissza kell küldenie a szervernek. Ezért az oldal fogadása és elküldése sokáig tart.

Az egyszerű oldalak esetében ez a többletköltség kicsi, de összetett, adatigényes vezérlők, például GridView beállításakor a nézetállapot-információk mennyisége jelentősen megnőhet. Ilyen esetekben letilthatja a vezérlő nézet állapotát a beállítással EnableViewState tulajdonság hogy hamis. De ebben az esetben minden visszaküldéskor újra kell inicializálnia a vezérlést.

Még akkor is, ha az EnableViewState értéke false, a vezérlő továbbra is megőrizhet egy kis mennyiségű nézetállapot-információt, amely kritikus fontosságú a megfelelő működéséhez. Ez a privilegizált nézet állapotinformációja az úgynevezett vezérlő állapot, és nem tudod kikapcsolni. Egy jól megtervezett vezérlőben azonban a vezérlőállapot-adatok mennyisége sokkal kisebb, mint a teljes nézetállapot mérete.

Az ASP.NET csak az oldal- és vezérlőtulajdonságokra alkalmazza a nézet állapotát. Az ASP.NET nem teszi ugyanezt a példányváltozókkal és más, esetleg felhasznált adatokkal. Más típusú adatokat azonban nézet állapotba helyezhet, és később manuálisan lekérheti ezeket az információkat.

Az alábbi ábra az átjelentkezési oldalkérés mechanizmusát mutatja, amely egyesíti ezeket a fogalmakat:

Állapotelemzés megtekintése

Ha megnézi az ASP.NET oldal generált HTML-kódját, egy rejtett beviteli mezőt fog találni a nézet állapotinformációival:

A nézet állapotsora nem ember által olvasható: csak úgy néz ki, mint egy véletlenszerű karaktersorozat. Fontos azonban megjegyezni, hogy ha kívánja, a felhasználó egy kis erőfeszítést tehet, és meglehetősen könnyen visszafejtheti. A következő egy .NET kódrészlet, amely ezt teszi, és megjeleníti a dekódolt információkat egy weboldalon:

// A viewStateString nézet állapotinformációkat tartalmaz. string viewStateString = Kérelem["__VIEWSTATE"]; // A Base64 karakterlánc átalakítása egy szabályos bájttömbbé //, amely ASCII karaktereket képvisel. byte bytes = Convert.FromBase64String(viewStateString); // A karakterlánc deszerializálása és megjelenítése Label1.Text = System.Text.Encoding.ASCII.GetString(bytes);

A dekódolás után az állapotsor valahogy így fog kinézni:

915261182d__ControlsRequirePostBackKey__CSVB[?S???&?7 ???

A nézet állapota nem alkalmas olyan érzékeny információk tárolására, amelyeket a kliens nem akar látni, ezért az ilyen típusú adatokat a szerveren kell hagyni. Ezenkívül kerülnie kell a nézet állapotán alapuló döntések meghozatalát, amelyek veszélyeztethetik az alkalmazást, ha az ügyfél szándékosan vagy véletlenül módosítja a nézetállapot adatait.

Szerencsére lehetőség van a nézetállapot-adatok biztonságának növelésére. Engedélyezheti az automatikus kivonatolást, hogy megakadályozza a nézet állapotának megváltoztatására irányuló kísérleteket, vagy akár titkosíthatja is a nézet állapotát, hogy megakadályozza annak visszafejtését. Ezek a trükkök a rejtett mezőket durva megkerülő megoldásból sokkal megbízhatóbb és tiszteletreméltóbb infrastruktúrává alakítják.

Nézet állapot felosztása

A rejtett nézet állapota mező mérete nincs korlátozva. Egyes proxy-k, tűzfalak és mobilböngészők azonban nem engedik át az oldalakat, ha a rejtett mezők nagyobbak egy bizonyos értéknél. A probléma megoldásához használhatja a nézet állapotfelosztását, amely automatikusan több mezőre osztja fel a nézet állapotát, hogy a rejtett mezők mérete ne haladja meg a megadott korlátot.

Ehhez telepíteni kell maxPageStateFieldLength attribútum elem A web.config fájlban. Ez határozza meg maximális méretállapot megtekintése bájtban. A következő példa egy 1 KB-os nézet állapotának meghatározására szolgál:

Ne feledje, hogy a nézetállapot felosztása csak egy mechanizmus bizonyos proxykkal kapcsolatos problémák minimalizálására (ami viszonylag ritka előfordulás). A nézet állapotának felosztása nem javítja a teljesítményt (ellenkezőleg, egy kis pluszt jelent a további szerializáláshoz). A teljesítmény javítása érdekében törekedjen arra, hogy a lehető legkevesebb információt tartalmazzon a nézet állapotában.

A UseSubmitBehavior attribútum határozza meg, hogy a Button vezérlő az ügyfélböngésző beépített véglegesítési funkcióját használja-e, vagy az ASP.NET tranzakcióértesítési mechanizmust használja.

Ha a vezérlő böngészőt használ a funkcióinak elküldésére, akkor a tulajdonság TRUE értékre van állítva. Ellenkező esetben HAMIS. Az alapértelmezett érték TRUE.

Ha a UseSubmitBehavior értéke FALSE, az ASP.NET egy ügyféloldali parancsfájlt ad hozzá az űrlap elküldéséhez. Jelenleg a vezérlőfejlesztők a gomb GetPostBackEventReference metódusát használhatják az ügyfél visszaküldési eseményének visszaküldésére. A GetPostBackEventReference metódus olyan karakterláncot ad vissza, amely az ügyfélfüggvény-hívás szövegét tartalmazza, amely beilleszthető egy ügyféloldali eseménykezelőbe.

nyelvtan

/>

példák

példák

A következő példa az ASP.NET visszaküldési mechanizmust használja:

Kattintson a gombra:
Text="Küldés" onclick="SubmitBtn"
UseSubmitBehavior="FALSE" />