Delen via

Overzicht van gekoppelde eigenschappen

Een gekoppelde eigenschap is een XAML-concept. Met gekoppelde eigenschappen kunnen extra eigenschaps-/waardeparen worden ingesteld voor een object, maar de eigenschappen maken geen deel uit van de oorspronkelijke objectdefinitie. Gekoppelde eigenschappen worden doorgaans gedefinieerd als een gespecialiseerde vorm van afhankelijkheidseigenschap die geen conventionele eigenschapswikkelaar heeft in het objectmodel van het type eigenaar.

Vereiste voorwaarden

We gaan ervan uit dat u het basisconcept van afhankelijkheidseigenschappen begrijpt en een overzicht van afhankelijkheidseigenschappen hebt gelezen.

Gekoppelde eigenschappen in XAML

In XAML stelt u gekoppelde eigenschappen in met behulp van de syntaxis AttachedPropertyProvider.PropertyName. Hier volgt een voorbeeld van hoe u Canvas.Left kunt instellen in XAML.

<Canvas>
  <Button Canvas.Left="50">Hello</Button>
</Canvas>

Opmerking

We gebruiken Canvas.Left als voorbeeld van een gekoppelde eigenschap zonder volledig uit te leggen waarom u deze zou gebruiken. Als u meer wilt weten over wat Canvas.Left is en hoe Canvas zijn indeling kinderen afhandelt, raadpleeg dan het Canvas naslagonderwerp of Indelingen definiëren met XAML.

Waarom gekoppelde eigenschappen gebruiken?

Gekoppelde eigenschappen zijn een manier om te ontsnappen aan de coderingsconventies die mogelijk verhinderen dat verschillende objecten in een relatie informatie tijdens runtime met elkaar communiceren. Het is zeker mogelijk om eigenschappen op een gemeenschappelijke basisklasse te plaatsen, zodat elk object die eigenschap kan ophalen en instellen. Maar uiteindelijk zal het enorme aantal scenario's waarbij u dit mogelijk wilt doen, uw basisklassen opbloat met deelbare eigenschappen. Het kan zelfs gevallen introduceren waarbij er mogelijk slechts twee honderden afstammelingen zijn die een eigenschap proberen te gebruiken. Dat is geen goed klasontwerp. Om dit te verhelpen, stelt het concept van de gekoppelde eigenschap een object in staat om een waarde toe te wijzen aan een eigenschap die niet door een eigen klassestructuur wordt gedefinieerd. De definiërende klasse kan de waarde van subobjecten tijdens uitvoeringstijd lezen nadat de verschillende objecten zijn gemaakt in een objectstructuur.

Onderliggende elementen kunnen bijvoorbeeld gekoppelde eigenschappen gebruiken om hun bovenliggende element te informeren over hoe ze moeten worden gepresenteerd in de gebruikersinterface. Dit is het geval met de gekoppelde eigenschap Canvas.Left. Canvas.Left wordt gemaakt als een gekoppelde eigenschap omdat deze is ingesteld op elementen die zich in een canvas-element bevinden, in plaats van op het canvas zelf. Elk mogelijk onderliggend element maakt vervolgens gebruik van Canvas.Left en Canvas.Top om de indelingsverschuiving op te geven binnen de bovenliggende Canvas-container. Gekoppelde eigenschappen maken het mogelijk om dit te laten werken zonder het objectmodel van het basiselement te vervuilen met veel eigenschappen die elk slechts op één van de vele mogelijke indelingscontainers van toepassing zijn. In plaats daarvan implementeren veel van de indelingscontainers hun eigen gekoppelde eigenschappenset.

Als u de gekoppelde eigenschap wilt implementeren, definieert de klasse Canvas een statisch veld DependencyProperty met de naam Canvas.LeftProperty. Vervolgens biedt Canvas de methoden SetLeft en GetLeft als openbare toegangsrechten voor de gekoppelde eigenschap, om zowel XAML-instelling als runtime-waardetoegang in te schakelen. Voor XAML en voor het afhankelijkheidseigenschapssysteem voldoet deze set API's aan een patroon dat een specifieke XAML-syntaxis voor gekoppelde eigenschappen mogelijk maakt en de waarde opslaat in het eigenschappenarchief voor afhankelijkheden.

Hoe het type eigenaar gebruikmaakt van gekoppelde eigenschappen

Hoewel gekoppelde eigenschappen kunnen worden ingesteld op elk XAML-element (of een onderliggend DependencyObject), betekent dit niet automatisch dat het instellen van de eigenschap een tastbaar resultaat oplevert of dat de waarde ooit wordt geopend. Het type dat de gekoppelde eigenschap definieert, volgt doorgaans een van deze scenario's:

  • Het type dat de gekoppelde eigenschap definieert, is het bovenliggende item in een relatie van andere objecten. De ondergeschikte objecten stellen waarden in voor de gekoppelde eigenschap. Het gekoppelde eigenschapseigenaartype heeft een ingebouwd gedrag dat iteraties uitvoert over zijn kindelementen, de waarden verkrijgt en op een bepaald moment in de levensduur van het object actie onderneemt met die waarden (een indelingsactie, Groottewijziging, enz.)
  • Het type dat de gekoppelde eigenschap definieert, wordt gebruikt als het onderliggende element voor een verscheidenheid aan mogelijke bovenliggende elementen en inhoudsmodellen, maar de informatie is niet noodzakelijkerwijs indelingsgegevens.
  • De gekoppelde eigenschap rapporteert informatie aan een service, niet aan een ander UI-element.

Zie de sectie "Meer over Canvas.Left" van aangepaste gekoppelde eigenschappen voor meer informatie over deze scenario's en eigenaarstypen.

Gekoppelde eigenschappen in code

Gekoppelde eigenschappen hebben niet de typische eigenschapshulzen voor eenvoudig ophalen en instellen, zoals dat bij andere afhankelijkheidseigenschappen wel het geval is. Dit komt doordat de gekoppelde eigenschap niet noodzakelijkerwijs deel uitmaakt van het codecentrumobjectmodel voor exemplaren waarin de eigenschap is ingesteld. (Het is toegestaan, hoewel ongebruikelijk, om een eigenschap te definiëren die beide een gekoppelde eigenschap is die andere typen op zichzelf kunnen instellen en die ook een conventioneel eigenschapsgebruik heeft voor het type eigenaar.)

Er zijn twee manieren om een gekoppelde eigenschap in code in te stellen: gebruik de API's van het eigenschappensysteem of gebruik de XAML-patroontoegangsors. Deze technieken zijn vrijwel gelijkwaardig in termen van hun eindresultaat, dus welke moet worden gebruikt, is meestal een kwestie van coderingsstijl.

Het eigenschappensysteem gebruiken

Gekoppelde eigenschappen voor Windows Runtime worden geïmplementeerd als afhankelijke eigenschappen, zodat de waarden door het eigenschappensysteem kunnen worden opgeslagen in de gedeelde afhankelijkheidseigenschappensupslag. Gekoppelde eigenschappen maken daarom een afhankelijkheidseigenschaps-id beschikbaar voor de klasse die eigenaar is.

Als u een gekoppelde eigenschap in code wilt instellen, roept u de methode SetValue aan en geeft u het veld DependencyProperty door die als id voor die gekoppelde eigenschap. (U geeft ook de waarde door die moet worden ingesteld.)

Als u de waarde van een gekoppelde eigenschap in code wilt ophalen, roept u de Methode GetValue aan en geeft u opnieuw het veld DependencyProperty door dat als id fungeert.

Het XAML-accessorpatroon gebruiken

Een XAML-processor moet gekoppelde eigenschapswaarden kunnen instellen wanneer XAML in een objectstructuur wordt geparseerd. Het type eigenaar van de gekoppelde eigenschap moet toegewezen toegangsmethoden implementeren die worden genoemd in de vorm Eigenschapsnaamophalen en Eigenschapsnaaminstellen. Deze toegewezen toegangsmethoden zijn ook een manier om de gekoppelde eigenschap in code op te halen of in te stellen. Vanuit codeperspectief is een gekoppelde eigenschap vergelijkbaar met een back-upveld met methodetoegangsors in plaats van eigenschapstoegangsors, en dat back-upveld kan bestaan op elk object in plaats van specifiek te worden gedefinieerd.

In het volgende voorbeeld ziet u hoe u een gekoppelde eigenschap in code kunt instellen via de XAML-accessor-API. In dit voorbeeld myCheckBox is dit een exemplaar van de klasse Selectievakje . De laatste regel is de code die daadwerkelijk de waarde instelt; de regels ervoor stellen de exemplaren en hun ouder-kindrelatie vast. De ongecommentarieerde laatste regel is de syntaxis als u het eigenschappensysteem gebruikt. De laatste regel met opmerkingen is de syntaxis als u het XAML-accessorpatroon gebruikt.

    Canvas myC = new Canvas();
    CheckBox myCheckBox = new CheckBox();
    myCheckBox.Content = "Hello";
    myC.Children.Add(myCheckBox);
    myCheckBox.SetValue(Canvas.TopProperty,75);
    //Canvas.SetTop(myCheckBox, 75);

    Dim myC As Canvas = New Canvas()
    Dim myCheckBox As CheckBox= New CheckBox()
    myCheckBox.Content = "Hello"
    myC.Children.Add(myCheckBox)
    myCheckBox.SetValue(Canvas.TopProperty,75)
    ' Canvas.SetTop(myCheckBox, 75)

Canvas myC;
CheckBox myCheckBox;
myCheckBox.Content(winrt::box_value(L"Hello"));
myC.Children().Append(myCheckBox);
myCheckBox.SetValue(Canvas::TopProperty(), winrt::box_value(75));
// Canvas::SetTop(myCheckBox, 75);

    Canvas^ myC = ref new Canvas();
    CheckBox^ myCheckBox = ref new CheckBox();
    myCheckBox->Content="Hello";
    myC->Children->Append(myCheckBox);
    myCheckBox->SetValue(Canvas::TopProperty,75);
    // Canvas::SetTop(myCheckBox, 75);

Aangepaste gekoppelde eigenschappen

Zie Aangepaste gekoppelde eigenschappen voor codevoorbeelden voor het definiëren van aangepaste gekoppelde eigenschappen en meer informatie over de scenario's voor het gebruik van een gekoppelde eigenschap.

Speciale syntaxis voor verwijzingen naar gekoppelde eigenschappen

De punt in de naam van een gekoppelde eigenschap is een belangrijk onderdeel van het identificatiepatroon. Soms zijn er dubbelzinnigheden wanneer een syntaxis of situatie de punt behandelt als een andere betekenis. Een punt wordt bijvoorbeeld behandeld als een doorkruising van een objectmodel voor een bindingspad. In de meeste gevallen waarbij dergelijke dubbelzinnigheid wordt gebruikt, is er een speciale syntaxis voor een gekoppelde eigenschap waarmee de binnenste stip nog steeds als eigenaar kan worden geparseerd. eigenschapsscheidingsteken van een gekoppelde eigenschap.

  • Als u een gekoppelde eigenschap wilt opgeven als onderdeel van een doelpad voor een animatie, plaatst u de naam van de gekoppelde eigenschap tussen haakjes (), (Canvas.Left)bijvoorbeeld. Zie de syntaxis van het eigenschapspad voor meer informatie.

Waarschuwing

Een bestaande beperking van de Windows Runtime XAML-implementatie is dat u geen aangepaste gekoppelde eigenschap kunt animeren.

  • Als u een gekoppelde eigenschap wilt opgeven als de doeleigenschap voor een resourceverwijzing van een resourcebestand naar x:Uid, gebruikt u een speciale syntaxis die een code-stijl, volledig gekwalificeerde using: declaratie injecteert binnen vierkante haken ("[]") om een opzettelijke scheiding van scope te creëren. Als er bijvoorbeeld een element <TextBlock x:Uid="Title" /> bestaat, is de resourcesleutel in het resourcebestand die is gericht op de waarde Canvas.Top op dat exemplaar Title.\[using:Microsoft.UI.Xaml.Controls\]Canvas.Top. Zie Tekenreeksen lokaliseren in uw gebruikersinterface voor meer informatie over resourcebestanden en XAML.
  • Last updated on