Alkalmazástartományok

  • Cikk

Az operációs rendszerek és a futtatókörnyezetek általában egyfajta elkülönítést biztosítanak az alkalmazások között. A Windows például folyamatokat használ az alkalmazások elkülönítésére. Ez az elkülönítés annak biztosításához szükséges, hogy az egyik alkalmazásban futó kód ne befolyásolja hátrányosan a többi, nem kapcsolódó alkalmazást.

Az alkalmazástartományok elkülönítési határt biztosítanak a biztonság, a megbízhatóság és a verziószámozás, valamint a szerelvények kiürítése szempontjából. Az alkalmazástartományokat általában futtatókörnyezeti gazdagépek hozzák létre, amelyek az alkalmazások futtatása előtt a közös nyelvi futtatókörnyezet rendszerindításáért felelősek.

Az alkalmazások elkülönítésének előnyei

A folyamathatárokat korábban az ugyanazon a számítógépen futó alkalmazások elkülönítésére használták. Minden alkalmazás egy külön folyamatba van betöltve, amely elkülöníti az alkalmazást az ugyanazon a számítógépen futó többi alkalmazástól.

Az alkalmazások elkülönítése azért történik, mert a memóriacímek folyamat relatívak; az egyik folyamatból a másikba továbbított memóriamutató semmilyen értelmes módon nem használható a célfolyamatban. Emellett nem indíthat közvetlen hívásokat két folyamat között. Ehelyett proxykat kell használnia, amelyek indirekt szintet biztosítanak.

A felügyelt kódot a futtatás előtt át kell adni egy ellenőrzési folyamaton (kivéve, ha a rendszergazda engedélyt adott az ellenőrzés kihagyására). Az ellenőrzési folyamat meghatározza, hogy a kód megpróbálhat-e hozzáférni az érvénytelen memóriacímekhez, vagy végrehajthat-e más olyan műveletet, amely miatt a futtatás folyamata nem működik megfelelően. Az ellenőrző teszten áthaladó kód típusbiztosnak minősül. A kód típusbiztosként való ellenőrzésének képessége lehetővé teszi, hogy a közös nyelvi futtatókörnyezet a folyamathatárhoz képest olyan nagy mértékű elkülönítést biztosítson, sokkal alacsonyabb teljesítményköltséggel.

Az alkalmazástartományok biztonságosabb és sokoldalúbb feldolgozási egységet biztosítanak, amelyet a közös nyelvi futtatókörnyezet az alkalmazások elkülönítésére használhat. Egyetlen folyamatban több alkalmazástartományt is futtathat ugyanazzal az elkülönítési szinttel, amely külön folyamatokban létezne, de a folyamatközi hívások vagy a folyamatok közötti váltás további többletterhelése nélkül. A kiszolgáló méretezhetőségét jelentősen növeli, hogy egyetlen folyamaton belül több alkalmazást is futtathat.

Az alkalmazások elkülönítése az alkalmazások biztonsága szempontjából is fontos. Egy böngészőfolyamatban például több webalkalmazás vezérlői is futtathatók úgy, hogy a vezérlők ne férhessenek hozzá egymás adataihoz és erőforrásaihoz.

Az alkalmazástartományok által biztosított elkülönítés a következő előnyökkel jár:

  • Az egyik alkalmazás hibái nem befolyásolhatják a többi alkalmazást. Mivel a típusbiztos kód nem okozhat memóriahibákat, az alkalmazástartományok használatával biztosítható, hogy az egyik tartományban futó kód ne legyen hatással a folyamat többi alkalmazására.

  • Az egyes alkalmazások a teljes folyamat leállítása nélkül leállíthatók. Az alkalmazástartományok használatával eltávolíthatja az egyetlen alkalmazásban futó kódot.

    Feljegyzés

    Nem távolíthat el egyes szerelvényeket vagy típusokat. Csak egy teljes tartomány távolítható el.

  • Az egyik alkalmazásban futó kód nem tud közvetlenül hozzáférni a kódhoz vagy az erőforrásokhoz egy másik alkalmazásból. A közös nyelvi futtatókörnyezet ezt az elkülönítést úgy kényszeríti ki, hogy megakadályozza a különböző alkalmazástartományokban lévő objektumok közötti közvetlen hívásokat. A tartományok között áthaladó objektumok másolása vagy elérése proxyval. Ha az objektum másolása történik, az objektum hívása helyi. Vagyis a hívó és a hivatkozott objektum is ugyanabban az alkalmazástartományban található. Ha az objektum proxyn keresztül érhető el, az objektum hívása távoli. Ebben az esetben a hívó és a hivatkozott objektum különböző alkalmazástartományokban található. A tartományok közötti hívások ugyanazt a távoli hívási infrastruktúrát használják, mint a két folyamat vagy két gép közötti hívások. Ezért a hivatkozott objektum metaadatainak mindkét alkalmazástartomány számára elérhetővé kell lenniük ahhoz, hogy a metódushívás megfelelően lefordítható legyen JIT-fordítással. Ha a hívó tartomány nem fér hozzá a meghívandó objektum metaadataihoz, a fordítás a típus FileNotFoundExceptionkivételével meghiúsulhat. További információ: Távoli objektumok. Az objektumok tartományok közötti elérésének módját az objektum határozza meg. További információ: System.MarshalByRefObject.

  • A kód viselkedését az alkalmazás határozza meg, amelyben fut. Más szóval az alkalmazástartomány olyan konfigurációs beállításokat biztosít, mint az alkalmazásverziós szabályzatok, az általa elért távoli szerelvények helye, valamint a tartományba betöltött szerelvények helyével kapcsolatos információk.

  • A kódhoz megadott engedélyeket az alkalmazás tartománya szabályozhatja, amelyben a kód fut.

Alkalmazástartományok és szerelvények

Ez a szakasz az alkalmazástartományok és a szerelvények közötti kapcsolatot ismerteti. A szerelvényt be kell töltenie egy alkalmazástartományba, mielőtt végrehajthatja a benne található kódot. Egy tipikus alkalmazás futtatása több szerelvényt is betölt egy alkalmazástartományba.

A szerelvény betöltési módja határozza meg, hogy az időben lefordított (JIT)-kód megosztható-e a folyamat több alkalmazástartományával, és hogy a szerelvény eltávolítható-e a folyamatból.

  • Ha egy szerelvény tartománysemleges, az azonos biztonsági támogatási készlettel rendelkező összes alkalmazástartomány ugyanazt a JIT-lefordított kódot használhatja, ami csökkenti az alkalmazás által igényelt memóriát. A szerelvény azonban soha nem távolítható el a folyamatból.

  • Ha egy szerelvény nincs betöltve tartománysemlegesen, akkor jiT-fordítást kell végezni minden olyan alkalmazástartományban, amelyben betöltődik. A szerelvény azonban eltávolítható a folyamatból az összes olyan alkalmazástartomány eltávolításával, amelyben betöltődik.

A futtatókörnyezet gazdagép határozza meg, hogy a szerelvényeket tartománysemlegesként kell-e betölteni, amikor betölti a futtatókörnyezetet egy folyamatba. Felügyelt alkalmazások esetén alkalmazza az LoaderOptimizationAttribute attribútumot a folyamat belépési pont metódusára, és adjon meg egy értéket a társított LoaderOptimization enumerálásból. A közös nyelvi futtatókörnyezetet futtató nem felügyelt alkalmazások esetén adja meg a megfelelő jelölőt a CorBindToRuntimeEx függvény metódus meghívásakor.

A tartománysemleges szerelvények betöltésének három lehetősége van:

  • LoaderOptimization.SingleDomain nem tölt be szerelvényeket tartománysemlegesként, kivéve az Mscorlib-t, amely mindig tartománysemleges. Ezt a beállítást egyetlen tartománynak nevezzük, mert gyakran használják, ha a gazdagép csak egyetlen alkalmazást futtat a folyamatban.

  • LoaderOptimization.MultiDomain az összes szerelvényt tartománysemlegesként tölti be. Ezt a beállítást akkor használja, ha a folyamat több alkalmazástartományt is használ, amelyek mindegyike ugyanazt a kódot futtatja.

  • LoaderOptimization.MultiDomainHost az erősnevű szerelvényeket tartománysemlegesként tölti be, ha azok és az összes függőség telepítve lettek a globális szerelvény-gyorsítótárban. A rendszer a többi szerelvényeket külön tölti be, és külön fordítja le a JIT-t minden olyan alkalmazástartományhoz, amelyben betöltik őket, és így eltávolíthatók a folyamatból. Ezt a beállítást akkor használja, ha több alkalmazást futtat ugyanabban a folyamatban, vagy ha olyan szerelvényeket használ, amelyeket számos alkalmazástartomány és szerelvények osztanak meg, amelyeket ki kell üríteni a folyamatból.

A JIT által lefordított kód nem osztható meg a terhelési környezetbe betöltött szerelvényekhez az LoadFrom osztály metódusával Assembly , illetve a bájttömböket megjelölő metódus túlterhelését Load használó képekről.

A natív kódba a Ngen.exe (natív képgenerátor) használatával lefordított szerelvények megoszthatók az alkalmazástartományok között, ha a rendszer tartománysemlegesen tölti be őket az első alkalommal, amikor betöltik őket egy folyamatba.

Az alkalmazás belépési pontját tartalmazó szerelvény JIT-lefordított kódja csak akkor lesz megosztva, ha az összes függősége megosztható.

A tartománysemleges szerelvények többször is lefordíthatók JIT-ből. Ha például két alkalmazástartomány biztonsági megadása eltérő, akkor nem oszthatják meg ugyanazt a JIT által lefordított kódot. A JIT által lefordított szerelvény minden példányát meg lehet osztani más olyan alkalmazástartományokkal, amelyek azonos támogatási készlettel rendelkeznek.

Amikor eldönti, hogy tartománysemlegesként szeretné-e betölteni a szerelvényeket, kompromisszumot kell hoznia a memóriahasználat csökkentése és más teljesítménytényezők között.

  • A statikus adatokhoz és metódusokhoz való hozzáférés a tartománysemleges szerelvények esetében lassabb, mivel el kell különíteni a szerelvényeket. A szerelvényhez hozzáférő összes alkalmazástartománynak külön másolatban kell rendelkeznie a statikus adatokról, hogy a statikus mezők objektumaira mutató hivatkozások ne léphessék át a tartományhatárokat. Ennek eredményeképpen a futtatókörnyezet további logikát tartalmaz a hívónak a statikus adatok vagy metódus megfelelő másolatához való irányításához. Ez az extra logika lelassítja a hívást.

  • A szerelvény minden függőségét tartománysemlegesként kell betölteni, mert a tartománysemlegesen betölthető függőség megakadályozza, hogy a szerelvény tartománysemleges legyen.

Alkalmazástartományok és -szálak

Az alkalmazástartomány elkülönítési határt képez a felügyelt kód biztonsága, verziószámozása, megbízhatósága és eltávolítása szempontjából. A szál a közös nyelvi futtatókörnyezet által a kód végrehajtásához használt operációsrendszer-szerkezet. Futásidőben az összes felügyelt kód betöltődik egy alkalmazástartományba, és egy vagy több felügyelt szál futtatja.

Nincs egy-az-egyhez korreláció az alkalmazástartományok és a szálak között. Egyszerre több szál is végrehajtható egyetlen alkalmazástartományban, és egy adott szál nem egyetlen alkalmazástartományra korlátozódik. Ez azt jelzi, hogy a szálak szabadon átlépik az alkalmazás tartományhatárait; A rendszer nem hoz létre új szálat az egyes alkalmazástartományokhoz.

Egy adott időpontban minden szál egy alkalmazástartományban fut. Előfordulhat, hogy egy vagy több szál egy adott alkalmazástartományban fut. A futtatókörnyezet nyomon követi, hogy mely szálak melyik alkalmazástartományban futnak. A metódus meghívásával Thread.GetDomain bármikor megtalálhatja azt a tartományt, amelyben egy szál fut.

Alkalmazástartományok és -kultúrák

Az objektum által CultureInfo képviselt kultúra szálakhoz van társítva. A tulajdonság használatával CultureInfo.CurrentCulture lekérheti az aktuálisan végrehajtó szálhoz társított kultúrát, és a tulajdonság használatával Thread.CurrentCulture lekérheti vagy beállíthatja az aktuálisan végrehajtó szálhoz társított kultúrát. Ha a szálhoz társított kultúra explicit módon lett beállítva a Thread.CurrentCulture tulajdonság használatával, akkor a szál továbbra is az adott szálhoz lesz társítva, amikor a szál átlépi az alkalmazástartomány határait. Ellenkező esetben a szálhoz adott időpontban társított kultúrát annak az alkalmazástartománynak a CultureInfo.DefaultThreadCurrentCulture tulajdonsága határozza meg, amelyben a szál fut:

  • Ha a tulajdonság értéke nem null, akkor a tulajdonság által visszaadott kultúra a szálhoz van társítva (és ezért a Thread.CurrentCultureCultureInfo.CurrentCulture tulajdonságok adják vissza).

  • Ha a tulajdonság értéke, nullaz aktuális rendszerkultúra a szálhoz van társítva.

Programozás alkalmazástartományokkal

Az alkalmazástartományokat általában programozott módon hozzák létre és módosítják a futtatókörnyezeti gazdagépek. Előfordulhat azonban, hogy egy alkalmazásprogram az alkalmazástartományokkal is dolgozni szeretne. Egy alkalmazásprogram például betölthet egy alkalmazás-összetevőt egy tartományba, hogy anélkül tudja eltávolítani a tartományt (és az összetevőt), hogy le kellene állítania a teljes alkalmazást.

Ez AppDomain az alkalmazástartományok programozott felülete. Ez az osztály olyan metódusokat tartalmaz, amelyekkel tartományokat hozhat létre és távolíthat el, típuspéldányokat hozhat létre a tartományokban, és regisztrálhat különböző értesítésekre, például az alkalmazástartományok kiürítésére. Az alábbi táblázat a gyakran használt AppDomain metódusokat sorolja fel.

AppDomain metódus Leírás
CreateDomain Új alkalmazástartományt hoz létre. Javasoljuk, hogy az objektumot meghatározó AppDomainSetup metódus túlterhelését használja. Ez az előnyben részesített módszer egy új tartomány( például az alkalmazásbázis vagy az alkalmazás gyökérkönyvtára) tulajdonságainak beállítására; a tartomány konfigurációs fájljának helye; és az a keresési útvonal, amelyet a közös nyelvi futtatókörnyezet használ a szerelvények tartományba való betöltéséhez.
ExecuteAssembly és ExecuteAssemblyByName Végrehajt egy szerelvényt az alkalmazástartományban. Ez egy példánymetódus, így egy másik alkalmazástartomány kódját futtathatja, amelyre hivatkozik.
CreateInstanceAndUnwrap Létrehoz egy adott típusú példányt az alkalmazástartományban, és proxyt ad vissza. Ezzel a módszerrel elkerülheti, hogy a létrehozott típust tartalmazó szerelvényt betöltse a hívó szerelvénybe.
Unload A tartomány kecses leállítását hajtja végre. Az alkalmazástartomány nem lesz eltávolítva, amíg a tartományban futó összes szál le nem állt, vagy már nem szerepel a tartományban.

Feljegyzés

A közös nyelvi futtatókörnyezet nem támogatja a globális metódusok szerializálását, ezért a meghatalmazottak nem használhatók globális metódusok más alkalmazástartományokban való végrehajtására.

A közös nyelvi futtatókörnyezet üzemeltetési felületeinek specifikációjában leírt nem felügyelt felületek szintén hozzáférést biztosítanak az alkalmazástartományokhoz. A futtatókörnyezeti gazdagépek nem felügyelt kódból származó interfészekkel hozhatnak létre és férhetnek hozzá az alkalmazástartományokhoz egy folyamaton belül.

A COMPLUS_LoaderOptimization környezeti változó

Egy környezeti változó, amely beállítja egy végrehajtható alkalmazás alapértelmezett betöltési optimalizálási szabályzatát.

Syntax

COMPLUS_LoaderOptimization = 1

Megjegyzések

Egy tipikus alkalmazás több szerelvényt tölt be egy alkalmazástartományba, mielőtt az általuk tartalmazott kód végrehajtható lenne.

A szerelvény betöltési módja határozza meg, hogy az időben lefordított (JIT-) kód megosztható-e a folyamat több alkalmazástartományával.

  • Ha egy szerelvény tartománysemleges, minden olyan alkalmazástartomány, amely ugyanazzal a biztonsági támogatási készlettel rendelkezik, ugyanazt a JIT-lefordított kódot használhatja. Ez csökkenti az alkalmazás által igényelt memóriát.

  • Ha egy szerelvény nincs betöltve tartománysemlegesen, akkor jiT-fordítással kell rendelkeznie minden olyan alkalmazástartományban, amelyben betölti, és a betöltő nem oszthat meg belső erőforrásokat az alkalmazástartományokban.

Ha az 1 értékre van állítva, a COMPLUS_LoaderOptimization környezeti jelző arra kényszeríti a futtatókörnyezet-gazdagépet, hogy az összes szerelvényt ne tartománysemleges módon, úgynevezett SingleDomain módon töltse be. A SingleDomain nem tölt be szerelvényeket tartománysemlegesként, kivéve az Mscorlibt, amely mindig tartománysemleges. Ezt a beállítást egyetlen tartománynak nevezzük, mert gyakran használják, ha a gazdagép csak egyetlen alkalmazást futtat a folyamatban.

Figyelemfelhívás

A COMPLUS_LoaderOptimization környezeti jelzőt diagnosztikai és tesztelési forgatókönyvekben való használatra tervezték. Ha a jelző be van kapcsolva, az súlyos lassulást és a memóriahasználat növekedését okozhatja.

Mintakód

Ha azt szeretné, hogy az IISADMIN szolgáltatás ne legyen tartománysemlegesként betöltve az összes szerelvényt, a környezet többsztringes értékéhez a HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\IISADMIN kulcsban hozzáfűzve COMPLUS_LoaderOptimization=1 érhető el.

Key = HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\IISADMIN  
Name = Environment  
Type = REG_MULTI_SZ  
Value (to append) = COMPLUS_LoaderOptimization=1

Lásd még