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 XAML-definíciókat tartalmazó WinUI-alkalmazást ír 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, a WinUI részét képező dedikált tulajdonságrendszer követi és befolyásolja.

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ő WinUI-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. Azonban minden olyan típus, amely olyan Windows Runtime névtérből származik, amelynek nevében nem szerepel "XAML", nem támogatja 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ágok a programozási modell egy adott funkcióját jelölik vagy támogatják a WinUI-alkalmazások XAML for UI-vel való meghatározásához. Ezek a funkciók a következők:

  • Adatkötés
  • Stílusok
  • Történetvázlatos 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 Runtime tulajdonságok

A függőségi tulajdonságok kiterjesztik az alapvető Windows Runtime tulajdonságfunkciókat úgy, hogy egy globális, belső tulajdonságtárolót biztosítanak, 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: általában egyszerű névvel érhet el függőségi tulajdonságokat (a programozási nyelven használt tulajdonság nevét, vagy amikor XAML-t ír, attribútumnevet).

A függőségi tulajdonságrendszer alapjául szolgáló alaptípus a DependencyObject. DependencyObject olyan metódusokat határoz meg, amelyek access a függőségi tulajdonságot, valamint 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ó Egy Windows Runtime tulajdonság hívható get és set implementációi. 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 tulajdonságok Windows Runtime definícióit használja.

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

Egy függőségi tulajdonság értékének lekérésekor az adott tulajdonsághoz meghatározott értéket a Windows Runtime tulajdonságrendszerben részt vevő bemenetek bármelyikén keresztül kapja meg. A függőségi tulajdonságértékek elsőbbséget élveznek, így a Windows Runtime tulajdonságrendszer kiszámítható módon számíthatja ki az értékeket, és fontos, hogy az alapszintű sorrendet is ismernie kell. 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 Runtime 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 WinUI XAML-sablont alkalmaz egy felhasználói felületi elemre, és így meghatározza annak vizualizációit.

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. Ha a metaadatok nem módosítják őket, a Windows Runtime függőségi tulajdonságok 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 Runtime 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.
  • Azok a tulajdonságok, amelyek sztringet (System.String a .NET-hez, Platform::String a C++/CX-hez) használnak, alapértelmezés szerint üres sztring értéket ("") kapnak.
  • 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 futásidőben adja meg az értéket a Windows Runtime adatkötési motor használatá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.

Történetvázlatos animációk

A függőségi tulajdonság értékét forgatókönyv-alapú animációval animálhatja. A storyboard animációk a Windows Runtime rendszerben 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 Runtime tulajdonságrendszerben 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.

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 létre kell hozni a felhasználói felületen, amely a WinUI-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:

Az UWP és a WinUI 3 közötti különbségekről a Windows App SDK a Treading funkció áttelepítése című témakörben talál további információt.

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