Delen via

Overzicht van afhankelijkheidseigenschappen

In dit onderwerp wordt het systeem van afhankelijkheden uitgelegd dat beschikbaar is wanneer u een Windows Runtime-app schrijft met XAML-definities voor de gebruikersinterface.

Wat is een afhankelijkheidseigenschap?

Een afhankelijkheidseigenschap is een speciaal type eigenschap. Dit is een eigenschap waarin de waarde van de eigenschap wordt bijgehouden en beïnvloed door een toegewezen eigenschapssysteem dat deel uitmaakt van De Windows Runtime.

Om een afhankelijkheidseigenschap te ondersteunen, moet het object dat de eigenschap definieert een DependencyObject zijn (met andere woorden een klasse met de basisklasse DependencyObject ergens in de overname). Veel van de typen die u gebruikt voor uw UI-definities voor een UWP-app met XAML, zijn een subklasse DependencyObject en ondersteunen afhankelijkheidseigenschappen. Elk type dat afkomstig is van een Windows Runtime-naamruimte zonder 'XAML' in de naam, biedt echter geen ondersteuning voor afhankelijkheidseigenschappen; eigenschappen van dergelijke typen zijn gewone eigenschappen die geen afhankelijkheidsgedrag van het eigenschappensysteem hebben.

Het doel van afhankelijkheidseigenschappen is om een systemische manier te bieden om de waarde van een eigenschap te berekenen op basis van andere invoer (andere eigenschappen, gebeurtenissen en statussen die plaatsvinden binnen uw app terwijl deze wordt uitgevoerd). Deze andere invoer kan het volgende omvatten:

  • Externe invoer, zoals gebruikersvoorkeur
  • Just-In-Time-mechanismen voor eigenschapsbepaling, zoals gegevensbinding, animaties en storyboards
  • Sjablonenpatronen voor meervoudig gebruik, zoals bronnen en stijlen
  • Waarden die bekend zijn via ouder-kindrelaties met andere elementen in de objectstructuur

Een afhankelijkheidseigenschap vertegenwoordigt of ondersteunt een specifieke functie van het programmeermodel voor het definiëren van een Windows Runtime-app met XAML voor de gebruikersinterface. Deze functies zijn onder andere:

  • Gegevensbinding
  • Stijlen
  • Animaties met verhaalbord
  • "PropertyChanged"-gedrag; een afhankelijkheidseigenschap kan worden geïmplementeerd om callbacks te bieden waarmee wijzigingen in andere afhankelijkheidseigenschappen kunnen worden doorgegeven
  • Een standaardwaarde gebruiken die afkomstig is van metagegevens van eigenschappen
  • Algemene eigenschappenbeheer zoals ClearValue en metagegevens opzoeken.

Eigenschappen van afhankelijkheden en Eigenschappen van Windows Runtime

Afhankelijkheidseigenschappen breiden de basisfunctionaliteit van Windows Runtime-eigenschappen uit door een globale, interne eigenschappenopslag te bieden die alle afhankelijkheidseigenschappen in een app ondersteunt tijdens de uitvoering. Dit is een alternatief voor het standaardpatroon van het ondersteunen van een eigenschap met een privéveld dat zich in de klasse voor eigenschapsdefinitie bevindt. U kunt dit interne eigenschappenarchief beschouwen als een set eigenschaps-id's en waarden die bestaan voor een bepaald object (zolang het een DependencyObject is). In plaats van op naam te worden geïdentificeerd, wordt elke eigenschap in de opslag geïdentificeerd door een DependencyProperty-exemplaar. Het eigenschappensysteem verbergt echter meestal deze implementatiedetails: u hebt meestal toegang tot afhankelijkheidseigenschappen met behulp van een eenvoudige naam (de naam van de programmatische eigenschap in de codetaal die u gebruikt, of een kenmerknaam wanneer u XAML schrijft).

Het basistype dat de onderliggende kenmerken van het afhankelijkheidseigenschapssysteem biedt, is DependencyObject. DependencyObject definieert methoden die toegang hebben tot de afhankelijkheidseigenschap en exemplaren van een afgeleide klasse DependencyObject ondersteunen intern het concept van het eigenschappenarchief dat we eerder hebben genoemd.

Hier volgt een samenvatting van de terminologie die we in de documentatie gebruiken bij het bespreken van afhankelijkheidseigenschappen:

Termijn Description
Afhankelijkheidseigenschap Een eigenschap die bestaat op een DependencyProperty-id (zie hieronder). Deze identifier is meestal beschikbaar als statisch lid van de klasse die de afgeleide klasse DependencyObject definieert.
Id van afhankelijkheidseigenschap Een constante waarde om de eigenschap te identificeren, deze is doorgaans openbaar en alleen-lezen.
Eigenschapswikkelaar De aanroepbare get - en set-implementaties voor een Windows Runtime-eigenschap. Of de taalspecifieke projectie van de oorspronkelijke definitie. Een get property wrapper-implementatie roept GetValue aan, waarbij de relevante id van de afhankelijkheidseigenschap wordt doorgegeven.

De eigenschap wrapper is niet alleen handig voor bellers, maar maakt ook de afhankelijkheidseigenschap beschikbaar voor elk proces, hulpprogramma of projectie dat gebruikmaakt van Windows Runtime-definities voor eigenschappen.

In het volgende voorbeeld wordt een aangepaste afhankelijkheidseigenschap voor C# gedefinieerd, en wordt de relatie tussen de id van de afhankelijkheidseigenschap en de eigenschapsomslag getoond.

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); }
}

Opmerking

Het voorgaande voorbeeld is niet bedoeld als het volledige voorbeeld voor het maken van een aangepaste afhankelijkheidseigenschap. Het is bedoeld om afhankelijkheidseigenschapsconcepten weer te geven voor iedereen die de voorkeur geeft aan leerconcepten via code. Zie Aangepaste afhankelijkheidseigenschappen voor een volledigere uitleg van dit voorbeeld.

Prioriteitsvolgorde van afhankelijke eigenschapswaarden

Wanneer u de waarde van een afhankelijkheidseigenschap krijgt, krijgt u een waarde die voor die eigenschap is bepaald via een van de invoer die deelneemt aan het Eigenschappensysteem van Windows Runtime. De prioriteit van de eigenschapswaarde van afhankelijkheden bestaat, zodat het Eigenschapssysteem van Windows Runtime waarden op een voorspelbare manier kan berekenen en het is belangrijk dat u ook bekend bent met de basisvolgorde van prioriteit. Anders kan het zijn dat u zich in een situatie bevindt waarin u een eigenschap probeert in te stellen op één niveau van prioriteit, maar iets anders (het systeem, bellers van derden, sommige van uw eigen code) het op een ander niveau instelt en u gefrustreerd bent om te achterhalen welke eigenschapswaarde wordt gebruikt en waar die waarde vandaan komt.

Stijlen en sjablonen zijn bijvoorbeeld bedoeld als een gedeeld uitgangspunt voor het tot stand brengen van eigenschapswaarden en het uiterlijk van een besturingselement. Maar bij een bepaald besturingselement wilt u de waarde ervan aanpassen in vergelijking met de standaard sjabloonwaarde, door dat besturingselement een andere achtergrondkleur of een andere tekst als inhoud te geven. Het eigenschappensysteem van Windows Runtime beschouwt lokale waarden met een hogere prioriteit dan waarden die worden geleverd door stijlen en sjablonen. Dit maakt het scenario mogelijk dat app-specifieke waarden de sjablonen overschrijven, zodat de besturingselementen nuttig zijn voor uw eigen gebruik ervan in de gebruikersinterface van de app.

Eigenschapsvolgorde voor afhankelijkheden

Hier volgt de definitieve volgorde die het eigenschapssysteem gebruikt bij het toewijzen van de runtimewaarde voor een afhankelijkheidseigenschap. De hoogste prioriteit wordt als eerste weergegeven. U vindt meer gedetailleerde uitleg net voorbij deze lijst.

  1. Geanimeerde waarden: Actieve animaties, visuele statusanimaties of animaties met een HoldEnd-gedrag . Als u een praktisch effect wilt hebben, moet een animatie die is toegepast op een eigenschap voorrang hebben op de basiswaarde (niet-animatie) zelfs als die waarde lokaal is ingesteld.
  2. Lokale waarde: Een lokale waarde kan worden ingesteld via de property wrapper, wat ook neerkomt op het instellen als een kenmerk of eigenschapselement in XAML, of door een aanroep van de SetValue-method met behulp van een eigenschap van een specifieke instantie. Als u een lokale waarde instelt met behulp van een binding of een statische resource, handelen deze beide in de prioriteit alsof een lokale waarde is ingesteld en worden bindingen of resourceverwijzingen gewist als er een nieuwe lokale waarde is ingesteld.
  3. Sjablooneigenschappen: Een element heeft dit als het is gemaakt als onderdeel van een sjabloon (van een ControlTemplate of DataTemplate).
  4. Stijlsetters: Waarden uit een Setter binnen stijlen van pagina- of toepassingsbronnen.
  5. Standaardwaarde: Een afhankelijkheidseigenschap kan een standaardwaarde hebben als onderdeel van de metagegevens.

Sjablooneigenschappen

Sjablooneigenschappen als prioriteitsitem zijn niet van toepassing op een eigenschap van een element dat u rechtstreeks declareert in XAML-paginamarkeringen. Het concept van de sjablooneigenschap bestaat alleen voor objecten die worden gemaakt wanneer windows Runtime een XAML-sjabloon toepast op een UI-element en de bijbehorende visuals definieert.

Alle eigenschappen die zijn ingesteld op basis van een besturingssjabloon, hebben waarden van een bepaald type. Deze waarden lijken bijna op een uitgebreide set standaardwaarden voor het besturingselement en zijn vaak gekoppeld aan waarden die u later opnieuw kunt instellen door de eigenschapswaarden rechtstreeks in te stellen. De waarden van de sjabloonset moeten dus worden onderscheiden van een echte lokale waarde, zodat elke nieuwe lokale waarde deze kan overschrijven.

Opmerking

In sommige gevallen kan de sjabloon zelfs lokale waarden overschrijven, als de sjabloon { TemplateBinding}-markeringsextensieverwijzingen niet beschikbaar kon stellen voor eigenschappen die op exemplaren moeten zijn ingesteld. Dit wordt meestal alleen gedaan als de eigenschap echt niet is bedoeld om te worden ingesteld op exemplaren, bijvoorbeeld als deze alleen relevant is voor visuals en sjabloongedrag en niet voor de beoogde functie of runtimelogica van het besturingselement dat gebruikmaakt van de sjabloon.

Bindingen en voorrang

Bindingsbewerkingen hebben de juiste prioriteit voor elk bereik waarvoor ze worden gebruikt. Een {Binding} die is toegepast op een lokale waarde fungeert bijvoorbeeld als lokale waarde en een {TemplateBinding} markup-extensie voor een eigenschapssetter wordt toegepast op een manier zoals een stijlsetter dat doet. Omdat bindingen moeten wachten totdat de runtime waarden ophaalt uit gegevensbronnen, wordt het proces voor het bepalen van de prioriteit van de eigenschapswaarde voor een eigenschap ook in runtime uitgebreid.

Bindingen werken niet alleen op dezelfde prioriteit als een lokale waarde, ze zijn echt een lokale waarde, waarbij de binding de tijdelijke aanduiding is voor een waarde die wordt uitgesteld. Als u een binding hebt ingesteld voor een eigenschapswaarde en u er tijdens runtime een lokale waarde op instelt, vervangt deze de binding volledig. Als u SetBinding aanroept om een binding te definiëren die alleen tijdens runtime wordt gebruikt, vervangt u elke lokale waarde die u mogelijk hebt toegepast in XAML of met eerder uitgevoerde code.

Animaties met storyboard, basiswaarde

Storyboard-animaties werken op basis van een concept van een basiswaarde. De basiswaarde is de waarde die wordt bepaald door het eigenschapssysteem met behulp van de prioriteit, maar die laatste stap van het zoeken naar animaties weglaat. Een basiswaarde kan bijvoorbeeld afkomstig zijn van de sjabloon van een besturingselement of van het instellen van een lokale waarde op een exemplaar van een besturingselement. Als u een animatie toepast, wordt deze basiswaarde overschreven en wordt de waarde van de animatie toegepast zolang de animatie blijft worden uitgevoerd.

Voor een eigenschap met animatie kan de basiswaarde nog steeds een effect hebben op het gedrag van de animatie, als die animatie niet expliciet van en naar opgeeft, of als de animatie de eigenschap terugdraait naar de basiswaarde wanneer deze is voltooid. In dergelijke gevallen wordt de rest van de prioriteit opnieuw gebruikt zodra een animatie niet meer wordt uitgevoerd.

Een animatie die een Doel met een HoldEnd-gedrag specificeert, kan echter een lokale waarde overschrijven totdat de animatie wordt verwijderd, zelfs wanneer deze visueel lijkt te worden gestopt. Conceptueel gezien is dit een animatie die voor altijd wordt uitgevoerd, zelfs als er geen visuele animatie in de gebruikersinterface is.

Meerdere animaties kunnen worden toegepast op één eigenschap. Elk van deze animaties is mogelijk gedefinieerd om basiswaarden te vervangen die afkomstig zijn van verschillende punten in de prioriteit van de waarde. Deze animaties worden echter allemaal tegelijk uitgevoerd tijdens runtime en dat betekent vaak dat ze hun waarden moeten combineren omdat elke animatie gelijke invloed heeft op de waarde. Dit is afhankelijk van precies hoe de animaties worden gedefinieerd en het type van de waarde die wordt geanimeerd.

Zie Storyboarded animaties voor meer informatie.

Standaardwaarden

Het instellen van de standaardwaarde voor een afhankelijkheidseigenschap met een PropertyMetadata-waarde wordt uitgebreid beschreven in het onderwerp Aangepaste afhankelijkheidseigenschappen .

Afhankelijkheidseigenschappen hebben nog steeds standaardwaarden, zelfs als deze standaardwaarden niet expliciet zijn gedefinieerd in de metagegevens van die eigenschap. Tenzij ze zijn gewijzigd door metagegevens, zijn standaardwaarden voor de eigenschappen van de Windows Runtime-afhankelijkheid in het algemeen een van de volgende:

  • Een eigenschap die gebruikmaakt van een runtime-object of het basisobjecttype (een verwijzingstype) heeft een standaardwaarde van null. DataContext is bijvoorbeeld null totdat deze opzettelijk is ingesteld of overgenomen.
  • Een eigenschap die gebruikmaakt van een basiswaarde, zoals getallen of een Booleaanse waarde (een waardetype), gebruikt een verwachte standaardwaarde voor die waarde. Bijvoorbeeld 0 voor gehele getallen en drijvendekommagetallen, onwaar voor een Booleaanse waarde.
  • Een eigenschap die gebruikmaakt van een Windows Runtime-structuur heeft een standaardwaarde die wordt verkregen door de impliciete standaardconstructor van die structuur aan te roepen. Deze constructor gebruikt de standaardwaarden voor elk van de basiswaardevelden van de structuur. Een standaardwaarde voor een puntwaarde wordt bijvoorbeeld geïnitialiseerd met de X - en Y-waarden als 0.
  • Een eigenschap die gebruikmaakt van een opsomming heeft een standaardwaarde van het eerste gedefinieerde lid in die opsomming. Controleer de verwijzing naar specifieke opsommingen om te zien wat de standaardwaarde is.
  • Een eigenschap die gebruikmaakt van een tekenreeks (System.String voor .NET, Platform::String voor C++/CX) heeft een standaardwaarde van een lege tekenreeks ("").
  • Verzamelingseigenschappen worden doorgaans niet geïmplementeerd als afhankelijkheidseigenschappen, om redenen die verder worden besproken in dit onderwerp. Maar als u een aangepaste verzamelingseigenschap implementeert en u wilt dat deze een afhankelijkheidseigenschap is, moet u een onbedoelde singleton voorkomen zoals wordt beschreven aan het einde van aangepaste afhankelijkheidseigenschappen.

Eigenschapsfunctionaliteit van een afhankelijkheidseigenschap

Gegevensbinding

De waarde van een afhankelijkheidseigenschap kan worden ingesteld door een gegevensbinding toe te passen. Gegevensbinding maakt gebruik van de syntaxis van de markeringsextensie {Binding} in XAML, de markeringsextensie {x:Bind} of de bindingsklasse in code. Voor een eigenschap gebonden aan gegevens wordt de uiteindelijke bepaling van de eigenschapswaarde uitgesteld tot uitvoeringstijd. Op dat moment wordt de waarde verkregen uit een gegevensbron. De rol van het afhankelijkheidseigenschapssysteem hier is om tijdelijk gedrag mogelijk te maken voor bewerkingen zoals het laden van XAML wanneer de waarde nog niet bekend is, en vervolgens de waarde tijdens runtime te leveren door te communiceren met de gegevensbindingsengine van Windows Runtime.

In het volgende voorbeeld wordt de tekstwaarde voor een TextBlock-element ingesteld met behulp van een binding in XAML. De binding maakt gebruik van een overgenomen gegevenscontext en een objectgegevensbron. (Geen van beide wordt weergegeven in het ingekorte voorbeeld; zie gegevensbinding uitgebreid voor een uitgebreider voorbeeld waarin context en bron worden weergegeven.)

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

U kunt ook bindingen maken met behulp van code in plaats van XAML. Zie SetBinding.

Opmerking

Bindingen zoals deze worden behandeld als een lokale waarde voor de waardevoorrang van afhankelijkheidseigenschappen. Als u een andere lokale waarde instelt voor een eigenschap die oorspronkelijk een bindingswaarde heeft, overschrijft u de binding volledig, niet alleen de runtimewaarde van de binding. {x:Bind} Bindingen worden geïmplementeerd met behulp van gegenereerde code waarmee een lokale waarde voor de eigenschap wordt ingesteld. Als u een lokale waarde instelt voor een eigenschap die gebruikmaakt van {x:Bind}, wordt die waarde vervangen wanneer de binding de volgende keer wordt geëvalueerd, bijvoorbeeld wanneer een eigenschapswijziging in het bronobject wordt waargenomen.

Bindingsbronnen, bindingsdoelen, de rol van FrameworkElement

Als bron van een binding hoeft een eigenschap geen afhankelijkheidseigenschap te zijn; u kunt over het algemeen elke eigenschap als bindingsbron gebruiken, hoewel dit afhankelijk is van uw programmeertaal en elk ervan bepaalde edge-gevallen heeft. Deze eigenschap moet echter een afhankelijkheidseigenschap zijn om het doel te zijn van een markeringsextensie voor {Binding} of Binding. {x:Bind} heeft deze vereiste niet omdat er gegenereerde code wordt gebruikt om de bindingswaarden toe te passen.

Als u een binding in code maakt, moet u er rekening mee houden dat de SetBinding-API alleen is gedefinieerd voor FrameworkElement. U kunt echter een bindingsdefinitie maken met BindingOperations en daarmee wijzen naar elke eigenschap van een DependencyObject.

Voor code of XAML moet u er rekening mee houden dat DataContext een FrameworkElement-eigenschap is. Door gebruik te maken van een vorm van overname van bovenliggende en onderliggende eigenschappen (meestal ingesteld in XAML-markeringen), kan het bindingssysteem een DataContext oplossen die op een bovenliggend element bestaat. Deze overname kan zelfs evalueren als het onderliggende object (met de doeleigenschap) geen FrameworkElement is en dus geen eigen DataContext-waarde bevat. Het bovenliggende element dat wordt overgenomen, moet echter een FrameworkElement zijn om de DataContext in te stellen en vast te houden. U moet ook de binding definiëren, zodat deze kan functioneren met een null-waarde voor DataContext.

Het verbinden van de binding is niet het enige wat nodig is voor de meeste gegevensbindingsscenario's. Voor een eenrichtings- of tweerichtingsbinding moet de bron-eigenschap wijzigingsmeldingen ondersteunen die worden doorgegeven aan het bindingssysteem en daardoor ook aan het bindingsdoel. Voor aangepaste bindingsbronnen betekent dit dat de eigenschap een afhankelijkheidseigenschap moet zijn of dat het object INotifyPropertyChanged moet ondersteunen. Verzamelingen moeten INotifyCollectionChanged ondersteunen. Bepaalde klassen ondersteunen deze interfaces in hun implementaties, zodat ze nuttig zijn als basisklassen voor scenario's voor gegevensbinding; een voorbeeld van een dergelijke klasse is ObservableCollection<T>. Zie Gegevensbinding uitgebreid voor meer informatie over gegevensbinding en hoe gegevensbinding zich verhoudt tot het eigenschappensysteem.

Opmerking

De typen die hier worden vermeld, ondersteunen Microsoft .NET-gegevensbronnen. C++/CX-gegevensbronnen gebruiken verschillende interfaces voor wijzigingsmeldingen of waarneembaar gedrag. Zie gegevensbinding uitgebreid.

Stijlen en sjablonen

Stijlen en sjablonen zijn twee van de scenario's voor eigenschappen die worden gedefinieerd als afhankelijkheidseigenschappen. Stijlen zijn handig voor het instellen van eigenschappen waarmee de gebruikersinterface van de app wordt gedefinieerd. Stijlen worden gedefinieerd als resources in XAML, ofwel als vermelding in een resourcesverzameling of in afzonderlijke XAML-bestanden, zoals themaresourcewoordenlijsten. Stijlen communiceren met het eigenschappensysteem omdat ze setters voor eigenschappen bevatten. De belangrijkste eigenschap hier is de eigenschap Control.Template van een besturingselement: hiermee definieert u het grootste deel van het uiterlijk en de visuele status van een besturingselement. Zie Stijlbesturingselementen voor meer informatie over stijlen en een voorbeeld van XAML die een stijl definieert en setters gebruikt.

Waarden die afkomstig zijn van stijlen of sjablonen zijn uitgestelde waarden, vergelijkbaar met bindingen. Dit is zodat controlegebruikers sjablonen van controles kunnen herbouwen of stijlen opnieuw kunnen definiëren. Daarom kunnen eigenschapssetters in stijlen alleen reageren op afhankelijkheidseigenschappen, niet op gewone eigenschappen.

Animaties met verhaalbord

U kunt de waarde van een afhankelijkheidseigenschap animeren met behulp van een verhaalbordanimatie. Storyboard-animaties in Windows Runtime zijn niet alleen visuele decoraties. Het is handiger om animaties te beschouwen als een techniek voor een toestandsmachine waarmee de waarden van afzonderlijke eigenschappen of van alle eigenschappen en visuele elementen van een besturingselement kunnen worden ingesteld en deze waarden over tijd kunnen veranderen.

Als u een animatie wilt maken, moet de doeleigenschap van de animatie een afhankelijkheidseigenschap zijn. Bovendien moet het waardetype van de doeleigenschap worden ondersteund door een van de animatietypen die zijn afgeleid van een Tijdlijn. Waarden van kleur, dubbel en punt kunnen worden geanimeerd met behulp van interpolatie- of sleutelframetechnieken. De meeste andere waarden kunnen worden geanimeerd met discrete objectsleutelframes .

Wanneer een animatie wordt toegepast en wordt uitgevoerd, heeft de waarde met animatie een hogere prioriteit dan een willekeurige waarde (zoals een lokale waarde) die de eigenschap anders heeft. Animaties hebben ook een optioneel HoldEnd-gedrag waardoor animaties kunnen worden toegepast op eigenschapswaarden, zelfs als de animatie visueel lijkt te worden gestopt.

Het statusmachineprincipe wordt opgenomen door het gebruik van storyboard-animaties als onderdeel van het VisualStateManager-statusmodel voor besturingselementen. Zie Storyboarded animaties voor meer informatie over storyboarded animaties. Voor meer informatie over VisualStateManager en het definiëren van visuele toestanden voor besturingselementen, zie Storyboarded animaties voor visuele toestanden of Besturingssjablonen.

Gedrag bij eigenschapswijziging

Gedrag dat door eigenschappen is gewijzigd, is de oorsprong van het onderdeel 'afhankelijkheid' van de terminologie van de afhankelijkheidseigenschap. Het onderhouden van geldige waarden voor een eigenschap wanneer een andere eigenschap invloed kan hebben op de waarde van de eerste eigenschap, is een moeilijk ontwikkelingsprobleem in veel frameworks. In het Eigenschappensysteem van Windows Runtime kan elke afhankelijkheidseigenschap een callback opgeven die wordt aangeroepen wanneer de eigenschapswaarde wordt gewijzigd. Deze callback kan worden gebruikt om gerelateerde eigenschapswaarden op een algemene synchrone manier op de hoogte te stellen of te wijzigen. Veel bestaande afhankelijkheidseigenschappen hebben een gedrag dat optreedt bij eigenschapswijzigingen. U kunt ook vergelijkbaar callbackgedrag toevoegen aan aangepaste afhankelijkheidseigenschappen en uw eigen door eigenschappen gewijzigde callbacks implementeren. Zie aangepaste afhankelijkheidseigenschappen voor een voorbeeld.

Windows 10 introduceert de methode RegisterPropertyChangedCallback . Hierdoor kan toepassingscode zich registreren voor wijzigingsmeldingen wanneer de opgegeven afhankelijkheidseigenschap wordt gewijzigd op een exemplaar van DependencyObject.

Standaardwaarde en ClearValue

Een afhankelijkheidseigenschap kan een standaardwaarde hebben die is gedefinieerd als onderdeel van de metagegevens van de eigenschap. Voor een afhankelijkheidseigenschap wordt de standaardwaarde niet relevant nadat de eigenschap voor het eerst is ingesteld. De standaardwaarde kan opnieuw worden toegepast tijdens runtime wanneer een andere determinant in waardeprioriteit verdwijnt. (Prioriteit van eigenschapswaarde voor afhankelijkheden wordt besproken in de volgende sectie.) U kunt bijvoorbeeld opzettelijk een stijlwaarde of animatie verwijderen die van toepassing is op een eigenschap, maar u wilt dat de waarde een redelijke standaardwaarde is nadat u dit hebt uitgevoerd. De standaardwaarde van de afhankelijkheidseigenschap kan deze waarde bieden, zonder dat u de waarde van elke eigenschap specifiek hoeft in te stellen als een extra stap.

U kunt bewust een eigenschap instellen op de standaardwaarde, zelfs nadat u deze al hebt ingesteld met een lokale waarde. Als u een waarde opnieuw wilt instellen als de standaardwaarde en ook andere deelnemers prioriteit wilt geven die de standaardwaarde kan overschrijven, maar niet een lokale waarde, roept u de ClearValue-methode aan (verwijs naar de eigenschap die moet worden gewist als een methodeparameter). U wilt niet altijd dat de eigenschap letterlijk de standaardwaarde gebruikt. Door de lokale waarde te wissen en terug te keren naar de standaardwaarde, kan een ander item met hogere prioriteit worden geactiveerd dat u nu wilt gebruiken, zoals de waarde afkomstig van een stijlsetter in een besturingselementsjabloon.

DependencyObject en threads

Alle DependencyObject-exemplaren moeten worden gemaakt op de UI-thread die is gekoppeld aan het huidige venster dat wordt weergegeven door een Windows Runtime-app. Hoewel elk DependencyObject moet worden gemaakt op de hoofd-UI-thread, kunnen de objecten worden geopend met behulp van een dispatcherverwijzing van andere threads, door toegang te krijgen tot de eigenschap DispatcherQueue . Vervolgens kunt u methoden zoals TryEnqueue aanroepen en uw code uitvoeren binnen de regels van threadbeperkingen voor de ui-thread.

Opmerking

Voor UWP-apps opent u de eigenschap Dispatcher . Vervolgens kunt u methoden zoals RunAsync aanroepen op het CoreDispatcher-object en uw code uitvoeren binnen de regels van threadbeperkingen voor de UI-thread. Zie Threading-functionaliteitsmigratie voor meer informatie over verschillen tussen UWP en WinUI voor de Windows App SDK.

De threadingaspecten van DependencyObject zijn relevant omdat dit in het algemeen betekent dat alleen code die wordt uitgevoerd op de UI-thread de waarde van een afhankelijkheidseigenschap kan wijzigen of zelfs lezen. Threadingproblemen kunnen meestal worden vermeden in typische UI-code die het juiste gebruik maakt van asynchrone patronen en achtergrondwerkthreads. Normaal gesproken loopt u alleen problemen met DependencyObject-gerelateerde threading tegen als u uw eigen DependencyObject-typen definieert en probeert ze te gebruiken voor gegevensbronnen of andere scenario's waar een DependencyObject niet per se geschikt is.

Conceptueel materiaal

  • Last updated on