Megosztás:

Függőségi tulajdonságok áttekintése

Ez a témakör azt a függőségi tulajdonságrendszert ismerteti, amely akkor érhető el, ha windowsos futtatókörnyezeti alkalmazást ír XAML-definíciókkal a felhasználói felülethez.

Mi az a függőségi tulajdonság?

A függőségi tulajdonság egy speciális tulajdonságtípus. Ez egy olyan tulajdonság, amelyben a tulajdonság értékét egy dedikált tulajdonságrendszer követi nyomon és befolyásolja, amely a Windows futtatókörnyezet része.

A függőségi tulajdonság támogatásához a tulajdonságot meghatározó objektumnak DependencyObjectnek kell lennie (más szóval egy olyan osztálynak, amely a DependencyObject alaposztályával rendelkezik valahol az öröklésében). Az XAML-vel rendelkező UWP-alkalmazások felhasználói felületi definícióihoz használt számos típus Függőségiobject alosztály lesz, és támogatja a függőségi tulajdonságokat. A Windows futtatókörnyezet névteréből származó olyan típusok azonban, amelyek nevében nem szerepel "XAML", nem támogatják a függőségi tulajdonságokat; Az ilyen típusú tulajdonságok olyan szokásos tulajdonságok, amelyek nem rendelkeznek a tulajdonságrendszer függőségi viselkedésével.

A függőségi tulajdonságok célja, hogy rendszerszintű módot biztosítson egy tulajdonság értékének kiszámítására más bemenetek (egyéb tulajdonságok, események és állapotok) alapján, amelyek az alkalmazásban futnak. Ezek a további bemenetek a következők lehetnek:

  • Külső bemenet, például felhasználói beállítások
  • Igény szerinti tulajdonságmeghatározási mechanizmusok, például adatkötés, animációk és forgatókönyvek
  • Többszörös használatú templatálási minták, például erőforrások és stílusok
  • Az objektumfa más elemeivel való szülő-gyermek kapcsolatok által ismert értékek

A függőségi tulajdonság a programozási modell egy adott funkcióját jelöli vagy támogatja a Windows-futtatókörnyezeti alkalmazások XAML for UI-vel való meghatározásához. Ezek a funkciók a következők:

  • Adatkötés
  • Stílusok
  • Storyboarded animációk
  • "PropertyChanged" viselkedés; a függőségi tulajdonság implementálható olyan visszahívások biztosítására, amelyek más függőségi tulajdonságokra is propagálhatják a módosításokat
  • Tulajdonság metaadataiból származó alapértelmezett érték használata
  • Általános tulajdonságrendszer-segédprogram, például ClearValue és metaadatok keresése

Függőségi tulajdonságok és Windows-futtatókörnyezet tulajdonságai

A függőségi tulajdonságok kibővítik a Windows futtatókörnyezet alapvető tulajdonságfunkcióit egy globális, belső tulajdonságtároló biztosításával, amely egy alkalmazás összes függőségi tulajdonságát futtatáskor háttérbe helyezi. Ez egy alternatíva a tulajdonságdefiníciós osztályban található privát mezővel való tulajdonság támogatásának szokásos mintájához. Ezt a belső tulajdonságtárolót úgy tekintheti, mint egy adott objektumhoz tartozó tulajdonságazonosítók és értékek készletét (mindaddig, amíg az egy DependencyObject). Ahelyett, hogy név alapján azonosítanák őket, az áruház minden tulajdonságát egy DependencyProperty-példány azonosítja. A tulajdonságrendszer azonban többnyire elrejti ezt a megvalósítási részletet: a függőségi tulajdonságokat általában egyszerű névvel érheti el (a programozott tulajdonság neve a használt kódnyelven, vagy egy attribútumnév xAML írásakor).

A függőségi tulajdonságrendszer alapjául szolgáló alaptípus a DependencyObject. A DependencyObject olyan metódusokat határoz meg, amelyek hozzáférhetnek a függőségi tulajdonsághoz, és a DependencyObject származtatott osztály példányai belsőleg támogatják a korábban említett tulajdonságtároló-koncepciót.

Az alábbiakban összefoglaljuk a dokumentációban használt terminológiát a függőségi tulajdonságok megvitatásakor:

Időszak Description
Függőségi tulajdonság Egy DependencyProperty azonosítón található tulajdonság (lásd alább). Ez az azonosító általában a definiált DependencyObject származtatott osztály statikus tagjaként érhető el.
Függőségi tulajdonság azonosítója A tulajdonság azonosítására szolgáló állandó érték, amely általában nyilvános és csak olvasható.
Tulajdonságburkoló A hívható get és set implementációk egy Windows Runtime tulajdonság esetén. Vagy az eredeti definíció nyelvspecifikus vetülete. A get property wrapper implementáció meghívja a GetValue-t, és átadja a kapcsolódó függőségi tulajdonság azonosítót.

A tulajdonságburkoló nem csak a hívók kényelmét szolgálja, hanem a függőségi tulajdonságot minden olyan folyamatnak, eszköznek vagy kivetítésnek is elérhetővé teszi, amely a Windows futtatókörnyezet definícióit használja a tulajdonságokhoz.

Az alábbi példa egy egyéni függőségi tulajdonságot határoz meg a C#-nak megfelelően, és megjeleníti a függőségi tulajdonság azonosítójának és a tulajdonságburkolónak a kapcsolatát.

public static readonly DependencyProperty LabelProperty = DependencyProperty.Register(
  "Label",
  typeof(string),
  typeof(ImageWithLabelControl),
  new PropertyMetadata(null)
);


public string Label
{
    get { return (string)GetValue(LabelProperty); }
    set { SetValue(LabelProperty, value); }
}

Megjegyzés:

Az előző példa nem az egyéni függőségi tulajdonság létrehozásának teljes példája. Célja a függőségi tulajdonság fogalmainak megjelenítése mindenki számára, aki inkább a kódon keresztüli tanulást részesíti előnyben. A példa részletesebb magyarázatát az Egyéni függőség tulajdonságai című témakörben talál.

Függőségi tulajdonság értékének elsőbbsége

Amikor lekéri egy függőségi tulajdonság értékét, az adott tulajdonsághoz meghatározott értéket a Windows Futtatókörnyezet tulajdonságrendszerében részt vevő bármely bemeneten keresztül kapja meg. A függőségi tulajdonságértékek elsőbbséget élveznek, így a Windows futtatókörnyezet tulajdonságrendszere kiszámítható módon tudja kiszámítani az értékeket, és fontos, hogy ön is tisztában legyen az alapszintű sorrenddel. Ellenkező esetben előfordulhat, hogy olyan helyzetben találja magát, amikor egy tulajdonságot egy elsőbbséget élvező szinten próbál beállítani, de valami más (a rendszer, a külső hívók, a saját kód egy része) egy másik szinten állítja be, és csalódott lesz, amikor megpróbálja kitalálni, hogy melyik tulajdonságértéket használja, és honnan származik ez az érték.

A stílusok és sablonok például közös kiindulópontként szolgálnak a tulajdonságértékek és így a vezérlőelemek megjelenésének meghatározásához. Egy adott vezérlőpéldányon azonban érdemes lehet módosítani az értékét a sablonban gyakran használt értékkel szemben, például más háttérszínt vagy más szöveges sztringet adhat meg tartalomként. A Windows Futtatókörnyezet tulajdonságrendszer a stílusok és sablonok által biztosított értékeknél nagyobb elsőbbséget élvez a helyi értékekkel szemben. Ez lehetővé teszi, hogy az alkalmazásspecifikus értékek felülírják a sablonokat, hogy a vezérlők hasznosak legyenek a saját használatukhoz az alkalmazás felhasználói felületén.

Függőségi tulajdonság elsőbbségi listája

Az alábbi végleges sorrendet használja a tulajdonságrendszer egy függőségi tulajdonság futásidejű értékének hozzárendeléséhez. A legmagasabb prioritású elemek kerülnek előre a listában. A lista mellett részletesebb magyarázatokat talál.

  1. Animált értékek: Aktív animációk, vizualizációállapot-animációk vagy HoldEnd-viselkedésű animációk. A gyakorlati hatás eléréséhez egy tulajdonságra alkalmazott animációnak elsőbbséget kell élveznie az alapérték (nem pontosított) értékével szemben, még akkor is, ha az érték helyileg lett beállítva.
  2. Helyi érték: A helyi értékeket a tulajdonságburkoló kényelmével lehet beállítani, amely az XAML attribútumaként vagy tulajdonságelemként való beállítását is jelenti, vagy egy adott példány tulajdonságát használó SetValue metódus hívásával. Ha egy helyi értéket egy kötéssel vagy statikus erőforrással állít be, ezek az értékek elsőbbséget élveznek, mintha egy helyi érték lett volna beállítva, és a kötések vagy erőforráshivatkozások törlődnek, ha új helyi érték van beállítva.
  3. Sablonalapú tulajdonságok: Egy elem akkor rendelkezik ezekkel, ha sablon részeként jött létre ( ControlTemplate-ból vagy DataTemplate-ból).
  4. Stílus beállítók: Értékek egy Setterből a lap- vagy alkalmazáserőforrások stílusainak keretében.
  5. Alapértelmezett érték: A függőségi tulajdonság a metaadatok részeként alapértelmezett értékkel rendelkezhet.

Sablonos tulajdonságok

A sablonos tulajdonságok elsőbbséget élvező elemként nem vonatkoznak olyan elemek egyik tulajdonságára sem, amelyet közvetlenül az XAML-lap korrektúrája során deklarál. A sablonalapú tulajdonságfogalom csak olyan objektumok esetében létezik, amelyek akkor jönnek létre, amikor a Windows futtatókörnyezet XAML-sablont alkalmaz egy felhasználói felületi elemre, és így meghatározza a vizualizációkat.

A vezérlősablonból beállított összes tulajdonság valamilyen értékkel rendelkezik. Ezek az értékek majdnem olyanok, mint a vezérlőelem alapértelmezett értékeinek kiterjesztett készlete, és gyakran olyan értékekkel vannak társítva, amelyeket később közvetlenül a tulajdonságértékek beállításával alaphelyzetbe állíthat. Így a sablonkészlet értékeinek megkülönböztethetőnek kell lenniük egy valódi helyi értéktől, hogy minden új helyi érték felülírhassa azt.

Megjegyzés:

Bizonyos esetekben a sablon még a helyi értékeket is felülbírálhatja, ha a sablon nem tudta elérhetővé tenni a {TemplateBinding} korrektúra-bővítmény hivatkozásait olyan tulajdonságokhoz, amelyeket a példányokon be kellett volna állítani. Ez általában csak akkor történik meg, ha a tulajdonságot valójában nem a példányokra kívánják beállítani, például ha csak a vizualizációk és a sablon viselkedése szempontjából releváns, és nem a sablont használó vezérlő tervezett függvényére vagy futtatókörnyezeti logikájára.

Kötések és elsőbbség

A kötési műveletek megfelelő precedenciával rendelkeznek azokhoz a hatókörökhöz, amelyekhez használják. Egy helyi értékre alkalmazott {Binding} például helyi értékként működik, a tulajdonságválasztó { TemplateBinding} korrektúrakiterjesztése pedig a stíluskészlet-beállítóhoz hasonlóan működik. Mivel a kötéseknek futásidőben kell várniuk, hogy adatforrásokból értékeket kapjanak, a tulajdonság értékének sorrendben történő meghatározása szintén futásidőre tolódik ki.

A kötések nem csak a helyi értékekkel azonos elsőbbséget élveznek, hanem valóban helyi értéknek minősülnek, ahol a kötés egy elhalasztott érték helyőrzője. Ha rendelkezik kötéssel egy tulajdonságértékhez, és futásidő közben beállít egy helyi értéket, az teljes egészében helyettesíti a kötést. Hasonlóképpen, ha meghívja a SetBindinget egy olyan kötés definiálásához, amely csak futásidőben jön létre, lecseréli az XAML-ben esetleg alkalmazott helyi értékeket vagy a korábban végrehajtott kódot.

Storyboarded animációk és alapérték

A storyboarded animációk az alapérték fogalmán alapulnak. Az alapérték az az érték, amelyet a tulajdonságrendszer a saját elsőbbsége alapján határoz meg, de kihagyja az animációk keresése utolsó lépését. Előfordulhat például, hogy egy alapérték egy vezérlő sablonjából származik, vagy egy helyi érték beállításából származhat egy vezérlőelem egy példányán. Akárhogy is, az animáció alkalmazása felülírja ezt az alapértéket, és mindaddig alkalmazza az animált értéket, amíg az animáció továbbra is fut.

Animált tulajdonság esetén az alapérték továbbra is hatással lehet az animáció viselkedésére, ha az animáció nem adja meg explicit módon a From és a To tulajdonságot, vagy ha az animáció befejezett állapotban visszaállítja a tulajdonságot az alapértékre. Ezekben az esetekben, ha egy animáció már nem fut, a rendszer ismét a többi elsőbbséget használja.

Azonban, egy, HoldEnd viselkedéssel rendelkező animáció, amely megadja a To értéket, felülírhatja a helyi értékeket egészen addig, amíg az animáció el nem lesz távolítva, még akkor is, ha vizuálisan úgy tűnik, hogy leállt. Elméletileg ez olyan, mint egy örökké futó animáció, még akkor is, ha nincs vizuális animáció a felhasználói felületen.

Egyetlen tulajdonságra több animáció is alkalmazható. Előfordulhat, hogy ezek az animációk az értékelőzmény különböző pontjairól származó alapértékek helyére lettek definiálva. Ezek az animációk azonban futtatáskor egyszerre fognak futni, és ez gyakran azt jelenti, hogy össze kell kapcsolniuk az értékeiket, mert minden animációnak azonos hatása van az értékre. Ez pontosan az animációk definiálásának módjától és az animált érték típusától függ.

További információ: Storyboarded animációk.

Alapértelmezett értékek

A függőségi tulajdonság alapértelmezett értékének PropertyMetadata értékkel való létrehozását az Egyéni függőség tulajdonságai témakör ismerteti részletesebben.

A függőségi tulajdonságok továbbra is alapértelmezett értékekkel rendelkeznek, még akkor is, ha ezek az alapértelmezett értékek nincsenek explicit módon definiálva a tulajdonság metaadataiban. Kivéve, ha metaadatok módosították őket, a Windows futtatókörnyezet függőségi tulajdonságainak alapértelmezett értékei általában a következők egyike:

  • Egy futásidejű objektumot vagy alapszintű objektumtípust ( referenciatípust) használó tulajdonság alapértelmezett értéke null. A DataContext például null értékű, amíg szándékosan be nem állítja vagy örökli.
  • Egy olyan tulajdonság, amely alapértéket, például számokat vagy logikai értéket ( értéktípust) használ, a várt alapértelmezett értéket használja az adott értékhez. Például 0 egész számok és lebegőpontos számok esetén, false logikai érték esetén.
  • A Windows futtatókörnyezeti struktúrát használó tulajdonság alapértelmezett értékkel rendelkezik, amelyet az adott struktúra implicit alapértelmezett konstruktorának meghívásával kapunk. Ez a konstruktor a struktúra minden alapértékmezőjének alapértelmezett értékeit használja. Egy pontérték alapértelmezett értéke például 0-val inicializálódik az X és az Y értékekkel.
  • Az enumerálást használó tulajdonság alapértelmezett értéke az enumerálás első definiált tagja. Az alapértelmezett érték megtekintéséhez tekintse meg az adott enumerálások hivatkozását.
  • Egy sztringet használó tulajdonság (System.String for .NET, Platform::String for C++/CX) alapértelmezett értéke egy üres sztring (").
  • A gyűjteménytulajdonságok általában nem függőségi tulajdonságokként vannak implementálva, a jelen témakörben részletesebben tárgyalt okok miatt. Ha azonban egyéni gyűjteménytulajdonságot implementál, és azt függőségi tulajdonságként szeretné használni, ügyeljen arra, hogy elkerülje a véletlen szingletont, ahogyan az a Egyéni függőségi tulajdonságok végénél kerül leírásra.

Függőségi tulajdonság által biztosított tulajdonságfunkciók

Adatkötés

A függőségi tulajdonság értéke adatkötés alkalmazásával állítható be. Az adatkötés a {Binding} korrektúrakiterjesztés szintaxisát használja az XAML, {x:Bind} korrektúrakiterjesztésben vagy a kód Kötés osztályában. Adatkapcsolatú tulajdonság esetén a rendszer a végleges tulajdonságérték-meghatározást a futtatás időpontjáig elhalasztja. Ekkor az érték egy adatforrásból származik. A függőségi tulajdonságrendszer szerepe itt az, hogy helyőrző viselkedést biztosít az olyan műveletekhez, mint például az XAML betöltése, ha az érték még nem ismert, majd az érték futásidőben történő megadása a Windows futtatókörnyezet adatkötési motorjával való interakcióval.

Az alábbi példa egy TextBlock-elemSzöveg értékét állítja be egy kötés használatával az XAML-ben. A kötés öröklött adatkörnyezetet és objektum-adatforrást használ. (Ezek közül egyik sem jelenik meg a rövidített példában; a kontextust és a forrást megjelenítő teljesebb mintához tekintse meg az adatkötés részletes ismertetését.)

<Canvas>
  <TextBlock Text="{Binding Team.TeamName}"/>
</Canvas>

Az XAML helyett kóddal is létrehozhat kötéseket. Lásd: SetBinding.

Megjegyzés:

Az ilyen kötések helyi értékként vannak kezelve a függőségi tulajdonság értékének elsőbbsége érdekében. Ha egy olyan tulajdonsághoz állít be egy másik helyi értéket, amely eredetileg kötési értéket tartott, a kötést teljes egészében felülírja, nem csak a kötés futásidejét. {x:Bind} A kötések olyan generált kóddal implementálhatók, amely beállít egy helyi értéket a tulajdonsághoz. Ha a(z) {x:Bind} tulajdonságot használó tulajdonsághoz állít be helyi értéket, akkor a rendszer a kötés következő kiértékelésekor lecseréli azt, például amikor a forrásobjektum tulajdonságváltozását észleli.

Kötési források, kötési célok, a FrameworkElement szerepe

Ahhoz, hogy egy kötés forrása legyen, a tulajdonságnak nem kell függőségi tulajdonságnak lennie; Általában bármilyen tulajdonságot használhat kötési forrásként, bár ez a programozási nyelvtől függ, és mindegyik rendelkezik bizonyos peremes esetekkel. Ahhoz azonban, hogy egy {Binding} jelölőbővítmény vagy kötés legyen a cél, ennek a tulajdonságnak függőségi tulajdonságnak kell lennie. A(z) {x:Bind} nem rendelkezik ezzel a követelménnyel, mivel generált kódot használ a kötési értékek alkalmazásához.

Ha kódban hoz létre kötést, vegye figyelembe, hogy a SetBinding API csak a FrameworkElementhez van definiálva. Azonban létrehozhat kötésdefiníciót a BindingOperations használatával, és így hivatkozhat bármely DependencyObject tulajdonságra.

Kód vagy XAML esetén ne feledje, hogy a DataContext egy FrameworkElement tulajdonság. A szülő-gyermek tulajdonságöröklés (általában XAML jelölés) használatával a kötési rendszer feloldhatja a szülői elemhez tartozó DataContextet. Ez az öröklés akkor is kiértékelhető, ha a gyermekobjektum (amely rendelkezik a céltulajdonságsal) nem FrameworkElement , ezért nem rendelkezik saját DataContext-értékkel . Az öröklődő szülőelemnek azonban FrameworkElement elemnek kell lennie a DataContext beállításához és tárolásához. Másik lehetőségként meg kell határoznia a kötést, hogy null értékkel működjön a DataContext esetében.

A kötés bekötése nem az egyetlen dolog, amire a legtöbb adatkötési forgatókönyv esetében szükség van. Ahhoz, hogy egy egyirányú vagy kétirányú kötés hatékony legyen, a forrástulajdonságnak támogatnia kell a kötési rendszerbe propagált változásértesítéseket, így a célt. Egyéni kötési források esetén ez azt jelenti, hogy a tulajdonságnak függőségi tulajdonságnak kell lennie, vagy az objektumnak támogatnia kell az INotifyPropertyChanged tulajdonságot. A gyűjteményeknek támogatniuk kell az INotifyCollectionChanged parancsot. Egyes osztályok támogatják ezeket az interfészeket implementációikban, hogy az adatkötési forgatókönyvek alaposztályaiként hasznosak legyenek; ilyen osztály például az ObservableCollection<T>. Az adatkötésről és arról, hogy az adatkötés hogyan kapcsolódik a tulajdonságrendszerhez, tekintse meg az adatkötés részletes ismertetését.

Megjegyzés:

Az itt felsorolt típusok támogatják a Microsoft .NET-adatforrásokat. A C++/CX adatforrások különböző interfészeket használnak a változásértesítéshez vagy a megfigyelhető viselkedéshez. Lásd az adatkötés részletes ismertetését.

Stílusok és sablonok

A stílusok és sablonok a függőségi tulajdonságokként definiált tulajdonságok két forgatókönyve. A stílusok az alkalmazás felhasználói felületét meghatározó tulajdonságok beállításához hasznosak. A stílusok erőforrásként vannak definiálva az XAML-ben, vagy egy erőforráscsoport bejegyzéseként, vagy különálló XAML-fájlokban, például témaerőforrás-szótárakban. A stílusok azért használják a tulajdonságrendszert, mert a tulajdonságkészleteket tartalmazzák. Itt a legfontosabb tulajdonság egy vezérlőelemControl.Template tulajdonsága: a vezérlők vizualizációs megjelenésének és vizualizációs állapotának nagy részét meghatározza. A stílusokról és a stílusokat definiáló és beállítókat használó XAML-ről további információt a Stílusvezérlők című témakörben talál.

A stílusokból vagy sablonokból származó értékek halasztott értékek, hasonlóan a kötésekhez. Ezáltal a felhasználók újrasablonozhatják a vezérlőket, vagy újradefiniálhatják a stílusokat. Ezért a stílusok tulajdonság beállítói csak a függőségi tulajdonságokra képesek hatni, a szokásos tulajdonságokra nem.

Storyboarded animációk

A függőségi tulajdonság értékét forgatókönyv-alapú animációval animálhatja. A Windows Runtime környezetben a storyboard vezérelt animációk nem csupán vizuális dekorációk. Érdemesebb úgy tekinteni az animációkra, mint állapotgép-technikára, amely beállíthatja az egyes tulajdonságok vagy a vezérlőelemek összes tulajdonságának és vizualizációjának értékeit, és idővel módosíthatja ezeket az értékeket.

Az animációhoz az animáció céltulajdonságának függőségi tulajdonságnak kell lennie. Az animáláshoz a céltulajdonság értéktípusát a meglévő ütemtervalapú animációs típusok egyikének kell támogatnia. A Szín, a Dupla és a Pont értékeket interpolációs vagy kulcskeretes technikákkal lehet animálni. A legtöbb más érték különálló objektumkulcskeretekkel animálható.

Animáció alkalmazásakor és futtatásakor az animált érték nagyobb prioritással működik, mint bármely olyan érték (például helyi érték), amelyet a tulajdonság egyébként használ. Az animációk opcionális HoldEnd-viselkedéssel is rendelkeznek, amely miatt az animációk akkor is alkalmazhatók a tulajdonságértékekre, ha úgy tűnik, hogy az animáció le van állítva.

A storyboardos animációk használata testesíti meg az állapotgép-alapelvet, amely a VisualStateManager állapotmodelljének része a vezérlők esetében. A storyboard animációkkal kapcsolatos további információkért lásd a Storyboard animációkat. A VisualStateManagerről és a vezérlők vizualizációs állapotainak meghatározásáról további információt a Storyboarded animációk vizuális állapotokhoz vagy a Vezérlősablonok című témakörben talál.

Tulajdonság által módosított viselkedés

A tulajdonság által módosított viselkedés a függőségi tulajdonság terminológiájának "függőség" részének eredete. Egy tulajdonság érvényes értékeinek fenntartása, ha egy másik tulajdonság befolyásolhatja az első tulajdonság értékét, sok keretrendszerben nehéz fejlesztési problémát jelent. A Windows futtatókörnyezet tulajdonságrendszerében minden függőségi tulajdonság megadhat egy visszahívást, amelyet a rendszer meghív, amikor a tulajdonság értéke megváltozik. Ez a visszahívás a kapcsolódó tulajdonságértékek értesítésére vagy módosítására használható, általában szinkron módon. Számos meglévő függőségi tulajdonság megváltozott tulajdonsággal bír. Az egyéni függőségi tulajdonságokhoz hasonló visszahívási viselkedést is hozzáadhat, és saját, tulajdonságában módosított visszahívásokat valósíthat meg. Példát lásd az Egyéni függőségi tulajdonságok alatt.

A Windows 10 bevezeti a RegisterPropertyChangedCallback metódust . Ez lehetővé teszi, hogy az alkalmazáskód regisztráljon a változásértesítésekre, ha a megadott függőségi tulajdonság módosul a DependencyObject egy példányán.

Alapértelmezett érték és ClearValue

A függőségi tulajdonság rendelkezhet a tulajdonság metaadatainak részeként definiált alapértelmezett értékkel. Függőségi tulajdonság esetén az alapértelmezett érték nem válik irrelevánssá a tulajdonság első beállítása után. Az alapértelmezett érték futásidőben újra alkalmazható, amikor az érték elsőbbsége valamilyen más meghatározója eltűnik. (A függőségi tulajdonság értékének elsőbbséget a következő szakaszban tárgyaljuk.) Előfordulhat például, hogy szándékosan eltávolít egy stílusértéket vagy egy tulajdonságra vonatkozó animációt, de azt szeretné, hogy ezt követően az érték ésszerű alapértelmezett legyen. A függőségi tulajdonság alapértelmezett értéke ezt az értéket adja meg anélkül, hogy külön meg kellene adnia az egyes tulajdonságok értékét további lépésként.

A tulajdonságot szándékosan az alapértelmezett értékre állíthatja, még akkor is, ha már beállította egy helyi értékkel. Ha ismét alapértelmezett értékre szeretne állítani egy értéket, és engedélyezni szeretné, hogy más résztvevők elsőbbséget élvezhessenek, amelyek felülírhatják az alapértelmezett, de nem helyi értéket, hívja meg a ClearValue metódust (a tulajdonságra hivatkozva törölje metódusparaméterként). Nem mindig szeretné, hogy a tulajdonság szó szerint használja az alapértelmezett értéket, de ha törli a helyi értéket, és visszaáll az alapértelmezett értékre, akkor egy másik elem is elsőbbséget élvezhet, például egy vezérlősablon stílusbeállításaiból származó érték használatával.

DependencyObject és szálkezelés

Minden DependencyObject-példányt azon a felhasználói felületen kell létrehozni, amely a Windows Futtatókörnyezet alkalmazás által megjelenített aktuális ablakhoz van társítva. Bár minden DependencyObject-et a fő felhasználói felületen kell létrehozni, az objektumok más szálakból származó diszpécserhivatkozással érhetők el a DispatcherQueue tulajdonság eléréséhez. Ezután meghívhat olyan metódusokat, mint a TryEnqueue , és végrehajthatja a kódot a felhasználói felület szálkorlátozásainak szabályain belül.

Megjegyzés:

UWP-alkalmazások esetén keresse meg a Dispatcher tulajdonságot. Ezután meghívhat olyan metódusokat, mint a RunAsync a CoreDispatcher objektumon, és végrehajthatja a kódot a felhasználói felület szálkorlátozásainak szabályai között. A Windows App SDK UWP és WinUI közötti különbségekről további információt a Szálkezelés funkció áttelepítése című témakörben talál.

A DependencyObject szálkezeléssel kapcsolatos szempontjai azért relevánsak, mert általában azt jelenti, hogy csak a felhasználói felületen futó kód módosíthatja vagy akár beolvashatja a függőségi tulajdonság értékét. A szálkezeléssel kapcsolatos problémák általában elkerülhetők a tipikus felhasználói felületi kódban, amely helyesen használja az aszinkron mintákat és a háttérmunkaszálakat. Általában csak a DependencyObject-hez kapcsolódó szálkezeléssel kapcsolatos problémákba ütközik, ha saját DependencyObject-típusokat definiál, és azokat adatforrásokhoz vagy más olyan forgatókönyvekhez próbálja használni, ahol a DependencyObject nem feltétlenül megfelelő.

Fogalmi anyag

  • Last updated on