{x:Bind} jelölő kiterjesztés

Jegyzet Az adatkötés alkalmazásbeli {x:Bind} használatával kapcsolatos általános információkért (és a {x:Bind} és a {Binding} közötti teljes összehasonlításért tekintse meg az adatkötés részletes ismertetését.

A (Windows 10-hez új) {x:Bind} jelölőbővítmény a {Binding} alternatíva. A(z) {x:Bind} kevesebb idő alatt és kevesebb memóriával fut, mint a {Binding} , és támogatja a jobb hibakeresést.

XAML fordítási időben a(z) {x:Bind} kóddá alakul, amely értéket kér le egy adatforrás tulajdonságából, és beállítja a jelölőben megadott tulajdonságra. A kötésobjektum igény szerint konfigurálható úgy, hogy megfigyelje az adatforrástulajdonság értékének változásait, és a módosítások (Mode="OneWay") alapján frissítse magát. Konfigurálható úgy is, hogy a saját értékében lévő módosításokat visszaküldje a forrástulajdonságba (Mode="TwoWay").

A(z) {x:Bind} és {Binding} által létrehozott kötésobjektumok funkcionálisan egyenértékűek. A(z) {x:Bind} azonban speciális célú kódot hajt végre, amelyet fordítási időben hoz létre, a {Binding} pedig általános célú futtatókörnyezeti objektumvizsgálatot használ. Ennek következtében az {x:Bind} kötések (más néven lefordított kötések) nagy teljesítménnyel rendelkeznek, fordítási idő alapján ellenőrzik a kötési kifejezéseket, és támogatják a hibakeresést azáltal, hogy lehetővé teszik töréspontok beállítását a lap részleges osztályaként létrehozott kódfájlokban. Ezek a fájlok a mappában obj találhatók, például (C#) <view name>.g.csnéven.

Jótanács

A(z) {x:Bind} a OneTime alapértelmezett módjával rendelkezik, ellentétben a {Binding} móddal, amely a OneWay alapértelmezett módjával rendelkezik. Ez teljesítménybeli okokból lett kiválasztva, mivel a OneWay használatával több kód jön létre a változásészlelés összekapcsolásához és kezeléséhez. Explicit módon megadhat egy módot a OneWay- vagy a TwoWay-kötés használatára. Az x:DefaultBindMode használatával is módosíthatja a {x:Bind} alapértelmezett módját a korrektúrafa egy adott szegmenséhez. A meghatározott mód az adott elemen és annak gyermekein lévő {x:Bind} kifejezésekre vonatkozik, amelyek a kötés részeként nem határoznak meg egyértelműen módot.

XAML-attribútumok használata

<object property="{x:Bind}" .../>
-or-
<object property="{x:Bind propertyPath}" .../>
-or-
<object property="{x:Bind bindingProperties}" .../>
-or-
<object property="{x:Bind propertyPath, bindingProperties}" .../>
-or-
<object property="{x:Bind pathToFunction.functionName(functionParameter1, functionParameter2, ...), bindingProperties}" .../>

Időszak	Description
propertyPath	A kötés tulajdonságútvonalát meghatározó sztring. További információ az alábbi Tulajdonságútvonal szakaszban található.
bindingProperties
propName=érték[, propName=érték]*	Egy vagy több, név/érték pár szintaxisával megadott kötési tulajdonság.
propName	A kötésobjektumon beállítani kívánt tulajdonság sztringneve. Például: "Konverter".
value	A tulajdonság beállításának értéke. Az argumentum szintaxisa a beállított tulajdonságtól függ. Íme egy példa a propName=érték használatára, ahol az érték maga egy korrektúrakiterjesztés: Converter={StaticResource myConverterClass}. További információ: Tulajdonságok, amelyeket az alábbi {x:Bind} szakaszsal állíthat be .

Példák

<Page x:Class="QuizGame.View.HostView" ... >
    <Button Content="{x:Bind Path=ViewModel.NextButtonText, Mode=OneWay}" ... />
</Page>

Ez a példa az XAML egy ListView.ItemTemplate tulajdonsággal rendelkező {x:Bind} tulajdonságot használ. Jegyezze fel az x:DataType érték deklarációját.

  <DataTemplate x:Key="SimpleItemTemplate" x:DataType="data:SampleDataGroup">
    <StackPanel Orientation="Vertical" Height="50">
      <TextBlock Text="{x:Bind Title}"/>
      <TextBlock Text="{x:Bind Description}"/>
    </StackPanel>
  </DataTemplate>

Tulajdonság elérési útja

A PropertyPath egy {x:Bind} kifejezés elérési útját állítja be. Az elérési út egy tulajdonság elérési útja, amely annak a tulajdonságnak, altulajdonságnak, mezőnek vagy metódusnak az értékét adja meg, amelyhez (a forráshoz) kötődik. Az Elérési út tulajdonság neve kifejezetten megemlíthető: {x:Bind Path=...}. Vagy kihagyhatja: {x:Bind ...}.

Tulajdonság elérési útjának feloldás

A(z) {x:Bind} nem a DataContextet használja alapértelmezett forrásként, hanem magát a lapot vagy a felhasználói vezérlőt használja. A tulajdonságok, mezők és metódusok tehát a lap vagy a felhasználó vezérlőelem mögötti kódban jelennek meg. Ha a nézetmodellt a(z) {x:Bind} számára szeretné elérhetővé tenni, általában új mezőket vagy tulajdonságokat szeretne hozzáadni az oldal vagy a felhasználói vezérlő mögötti kódhoz. A tulajdonságútvonalak lépéseit pontokkal (.) tagolják, és több elválasztójelet is megadhat az egymást követő altulajdonságok közötti mozgáshoz. Használja a ponthatárolást, függetlenül attól, hogy milyen programozási nyelvre van szükség ahhoz az objektumhoz, amelyhez hozzá van kötve.

Például: egy lapon a Text="{x:Bind Employee.FirstName}" kifejezés egy alkalmazottat keres a lapon, majd egy FirstName tagot az alkalmazott által visszaadott objektumon. Ha egy elemvezérlőt egy olyan tulajdonsághoz köt, amely egy alkalmazott függőit tartalmazza, a tulajdonság elérési útja lehet "Employee.Depends", és az elemvezérlő elemsablonja gondoskodik az elemek "Függők" elemének megjelenítéséről.

C++/CX esetén a(z) {x:Bind} nem tud kapcsolódni a lap vagy adatmodell magánmezőihez és tulajdonságaihoz – a kötéshez nyilvános tulajdonsággal kell rendelkeznie. A kötés felületét CX-osztályokként/interfészekként kell elérhetővé tenni, hogy megkaphassuk a megfelelő metaadatokat. A [Bindable] attribútumra nincs szükség.

Az x:Kötés esetén nem kell az ElementName=xxx elemet használnia a kötési kifejezés részeként. Ehelyett használhatja az elem nevét a kötés elérési útjának első részeként, mivel az elnevezett elemek a gyökérkötés forrását képviselő lapon vagy felhasználói vezérlőben lévő mezőkké válnak.

Collections

Ha az adatforrás gyűjtemény, akkor a tulajdonság elérési útja a gyűjtemény elemeit a helyük vagy az indexük alapján határozhatja meg. Például: "Teams[0]. Players", ahol a "[]" szó a "0" szót tartalmazza, amely egy nulla indexelt gyűjtemény első elemét kéri le.

Az indexelő használatához a modellnek IList<T-t> vagy IVector<T-t> kell implementálnia az indexelni kívánt tulajdonság típusán. (Vegye figyelembe, hogy az IReadOnlyList<A T> és az IVectorView<T> nem támogatja az indexelő szintaxisát.) Ha az indexelt tulajdonság típusa támogatja az INotifyCollectionChanged vagy az IObservableVector protokollt, és a kötés OneWay vagy TwoWay, akkor regisztrálja és figyeli a változásértesítéseket ezeken a felületeken. A változásészlelési logika az összes gyűjteménymódosítás alapján frissül, még akkor is, ha ez nem befolyásolja az adott indexelt értéket. Ennek az az oka, hogy a figyelési logika közös a gyűjtemény minden példányában.

Ha az adatforrás szótár vagy térkép, akkor a tulajdonság elérési útja a sztringnév alapján adhat meg elemeket a gyűjteményben. Például <TextBlock Text="{x:Bind Players['John Smith"}" /> a "John Smith" nevű szótárban keres egy elemet.\n'] A nevet idézőjelek közé kell tenni, és egy vagy két idézőjel is használható. A hat (^) sztringekben lévő idézőjelek feloldására használható. Általában a legegyszerűbb alternatív idézőjeleket használni az XAML attribútumhoz használt idézőjelekből. (Vegye figyelembe, hogy az IReadOnlyDictionary<A T> és az IMapView<T> nem támogatja az indexelő szintaxisát.)

A láncindexelő használatához a modellnek meg kell valósítania az IDictionary<String, T> vagy az IMap<String, T> interfészt az indexelni kívánt tulajdonság típusán. Ha az indexelt tulajdonság típusa támogatja az IObservableMap-ot , és a kötés OneWay vagy TwoWay, akkor regisztrálja és figyeli a változásértesítéseket ezeken a felületeken. A változásészlelési logika az összes gyűjteménymódosítás alapján frissül, még akkor is, ha ez nem befolyásolja az adott indexelt értéket. Ennek az az oka, hogy a figyelési algoritmus a gyűjtemény összes példányában közös.

Csatolt tulajdonságok

A csatolt tulajdonságokhoz való kötéshez zárójelbe kell helyeznie az osztály és a tulajdonság nevét a pont után. Például Text="{x:Bind Button22.(Grid.Row)}". Ha a tulajdonság nem Xaml-névtérben van deklarálva, akkor előtaggal kell ellátnia egy XML-névteret, amelyet le kell képeznie egy kódnévtérre a dokumentum elején.

Szereplőválogatás

A fordított lekötések erősen típusosak, és meghatározzák az útvonal minden lépésének a típusát. Ha a visszaadott típus nem rendelkezik tagként, fordításkor sikertelen lesz. Megadhatja az objektum valódi típusának kötésére vonatkozó öntött értéket.

A következő esetben az obj egy objektum típusú tulajdonság, de tartalmaz egy szövegdobozt, így használhatjuk a Text="{x:Bind ((TextBox)obj).Text}" vagy Text="{x:Bind obj.(TextBox.Text)}" parancsokat.

A groups3 mező a Text="{x:Bind ((data:SampleDataGroup)groups3[0]).Title}" szótáraként van definiálva, ezért azt a data:SampleDataGroup típusra kell áttípusosítania. Figyelje meg az xml-adatok használatát: a névtér előtagja az objektumtípus olyan kódnévtérre való leképezéséhez, amely nem része az alapértelmezett XAML-névtérnek.

Megjegyzés: A C#-stílusú öntött szintaxis rugalmasabb, mint a csatolt tulajdonságszintaxis, és ez az ajánlott szintaxis.

Útvonalmentes öntés

A natív kötéselemző nem biztosít függvényparaméterként ábrázolható this kulcsszót, de támogatja az elérési út nélküli öntést (például {x:Bind (x:String)}), amely függvényparaméterként használható. {x:Bind MethodName((namespace:TypeOfThis))} Ezért érvényes módszer a fogalmilag egyenértékű műveletek végrehajtására{x:Bind MethodName(this)}.

Példa:

Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}"

<Page
    x:Class="AppSample.MainPage"
    ...
    xmlns:local="using:AppSample">

    <Grid>
        <ListView ItemsSource="{x:Bind Songs}">
            <ListView.ItemTemplate>
                <DataTemplate x:DataType="local:SongItem">
                    <TextBlock
                        Margin="12"
                        FontSize="40"
                        Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}" />
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </Grid>
</Page>

namespace AppSample
{
    public class SongItem
    {
        public string TrackName { get; private set; }
        public string ArtistName { get; private set; }

        public SongItem(string trackName, string artistName)
        {
            ArtistName = artistName;
            TrackName = trackName;
        }
    }

    public sealed partial class MainPage : Page
    {
        public List<SongItem> Songs { get; }
        public MainPage()
        {
            Songs = new List<SongItem>()
            {
                new SongItem("Track 1", "Artist 1"),
                new SongItem("Track 2", "Artist 2"),
                new SongItem("Track 3", "Artist 3")
            };

            this.InitializeComponent();
        }

        public static string GenerateSongTitle(SongItem song)
        {
            return $"{song.TrackName} - {song.ArtistName}";
        }
    }
}

Függvények a kötési útvonalakban

A Windows 10 1607-es verziójától kezdve az {x:Bind} támogatja a függvény használatát a kötési útvonal levéllépéseként. Ez egy hatékony adatkötési funkció, amely több forgatókönyvet is lehetővé tesz a korrektúrában. Részletekért tekintse meg a függvénykötéseket .

Eseménykötés

Az eseménykötés a lefordított kötés egyedi funkciója. Lehetővé teszi egy esemény kezelőjének megadását kötéssel, nem pedig a mögöttes kód egyik metódusának kell lennie. Például: Click="{x:Bind rootFrame.GoForward}".

Események esetén a célmetódus nem lehet túlterhelve, és a következőket is meg kell tennie:

• Egyezzen meg az esemény aláírásával.
• VAGY nincsenek paraméterek.
• VAGY az eseményparaméterek típusaiból hozzárendelhető típusok azonos számú paraméterével rendelkezik.

A létrehozott kód mögötti, lefordított kötés kezeli az eseményt, és a modell metódusához irányítja, kiértékelve a kötési kifejezés elérési útját az esemény bekövetkezésekor. Ez azt jelenti, hogy a tulajdonságkötésekkel ellentétben nem követi nyomon a modell módosításait.

A tulajdonság elérési útjának sztringszintaxisával kapcsolatos további információkért tekintse meg a Tulajdonság-elérési út szintaxist, és tartsa szem előtt a(z) {x:Bind} esetében itt ismertetett különbségeket.

A(z) {x:Bind} használatával beállítható tulajdonságok

A(z) {x:Bind} a bindingProperties helyőrző szintaxissal van illusztrálva, mivel a korrektúrakiterjesztésben több olvasási/írási tulajdonság állítható be. A tulajdonságok bármilyen sorrendben beállíthatók vesszővel tagolt propName=értékpárokkal . Vegye figyelembe, hogy a kötési kifejezésben nem szerepelhet sortörés. Egyes tulajdonságokhoz olyan típusok szükségesek, amelyek nem rendelkeznek típuskonverzióval, ezért ezekhez saját, a(z) {x:Bind} fájlba ágyazott korrektúrakiterjesztésekre van szükség.

Ezek a tulajdonságok ugyanúgy működnek, mint a Kötés osztály tulajdonságai.

Ingatlan	Description
Path	Lásd a fenti Tulajdonságút szakaszt .
Konverter	A kötési motor által meghívott konverterobjektumot adja meg. A konverter XAML-ben állítható be, de csak akkor, ha egy {StaticResource} jelölőkiterjesztésben hozzárendelt objektumpéldányra hivatkozik az erőforrásszótárban.
ConverterLanguage	A konverter által használandó kultúrát adja meg. (Ha a ConverterLanguage beállítást használja, akkor a Convertert is be kell állítania.) A kultúra szabványalapú azonosítóként van beállítva. További információ: ConverterLanguage.
ConverterParameter	Megadja a konverterlogikában használható konverterparamétert. (Ha a ConverterParametert állítja be, akkor a Convertert is be kell állítania.) A legtöbb konverter egyszerű logikát használ, amely lekér minden szükséges információt az átadott értékről az átalakításhoz, és nincs szükség ConverterParameter-értékre . A ConverterParameter paraméter olyan közepesen fejlett konverter-implementációkhoz készült, amelyek több logikával rendelkeznek, amelyek a ConverterParameterben átadott elemeket leküldik. Írhat olyan konvertert, amely nem sztringeket használ, de ez nem gyakori. További információt a ConverterParameter megjegyzései című témakörben talál.
FallbackValue	Olyan értéket ad meg, amely akkor jelenik meg, ha a forrás vagy az elérési út nem oldható fel.
Mode	A kötési módot a következő karakterláncok egyikeként adja meg: "OneTime", "OneWay" vagy "TwoWay". Az alapértelmezett érték a "OneTime". Vegye figyelembe, hogy ez eltér a {Binding} alapértelmezett értékétől, amely a legtöbb esetben "OneWay".
TargetNullValue	A forrásérték feloldásakor megjelenítendő értéket ad meg, de explicit módon null értékű.
BindBack	Megadja a függvényt, amelyet a kétirányú kötés fordított irányához kell használni.
UpdateSourceTrigger	Megadja, hogy mikor kell a módosításokat visszaküldni a vezérlőből a modellbe a TwoWay-kötésekben. A TextBox.Text kivételével az összes tulajdonság alapértelmezett értéke PropertyChanged; a TextBox.Text alapértelmezett értéke LostFocus.

Megjegyzés:

Ha {Binding} értékről {x:Bind} értékre konvertálja a korrektúrát, vegye figyelembe a Mód tulajdonság alapértelmezett értékeinek különbségeit. x:DefaultBindMode használatával módosíthatja az x:Kötés alapértelmezett módját a korrektúrafa egy adott szegmenséhez. A kiválasztott mód az x:Bind kifejezéseket alkalmazza az adott elemre és annak gyermekeire, amelyek nem határoznak meg explicit módot a kötés részeként. A OneTime nagyobb teljesítményű, mint a OneWay, mivel a OneWay használatával több kód jön létre a változásészlelés összekapcsolásához és kezeléséhez.

Megjegyzések

Mivel a(z) {x:Bind} generált kódot használ az előnyei eléréséhez, fordításkor típusinformációra van szükség. Ez azt jelenti, hogy nem köthet olyan tulajdonságokhoz, amelyeknél nem ismeri előre a típust. Emiatt a(z) {x:Bind} nem használható az Objektum típusú DataContext tulajdonsággal, és futásidőben is változhat.

Amikor {x:Bind}-et használ adatsablonokkal, az adott típus megjelöléséhez a x:DataType értéket kell beállítania, ahogy az a Példák szakaszban látható. A típust egy interfész- vagy alaposztálytípusra is beállíthatja, majd szükség esetén típuskonverziókat használhat, hogy a teljes kifejezést megadja.

A lefordított kötések a kódgenerálástól függenek. Ha tehát {x:Bind} értéket használ egy erőforrás-szótárban, akkor az erőforrás-szótárnak kód mögötti osztályt kell használnia. Példakódért tekintse meg az erőforrás szótárakat {x:Bind} használatával.

A lefordított kötéseket tartalmazó lapok és felhasználói vezérlők "Kötések" tulajdonságot tartalmaznak a létrehozott kódban. Ez a következő módszereket foglalja magában:

• Update() – Ez frissíti az összes lefordított kötés értékét. Az egyirányú és kétirányú kötéseknél a figyelők csatlakoztatva lesznek a változások észleléséhez.
• Initialize() – Ha a kötések inicializálása még nem történt meg, az Update() meghívásával inicializálja a kötéseket
• StopTracking() – Ez feloldja az egyirányú és kétirányú kötésekhez létrehozott összes figyelőt. Az Update() metódussal újra inicializálhatók.

Megjegyzés:

A Windows 10 1607-es verziójától kezdve az XAML-keretrendszer beépített logikai és láthatósági konvertert biztosít. A konverter a true értéket a Visible enumerálási értékhez, és a false értéket a Collapsed-hez rendeli, így a Visibility tulajdonságot konverter létrehozása nélkül is kötheti egy logikai értékhez. Vegye figyelembe, hogy ez nem a függvénykötés egyik funkciója, csak a tulajdonságkötés. A beépített konverter használatához az alkalmazás minimális cél SDK-verziójának 14393-as vagy újabb verziónak kell lennie. Nem használható, ha az alkalmazás a Windows 10 korábbi verzióit célozza meg. További információ a célverziókról: Adaptív verziókód.

Jótanács

Ha egyetlen kapcsos zárójelet kell megadnia egy értékhez, például az Elérési út vagy a ConverterParameter esetén, akkor azt egy fordított perjel előzi meg: \{. Másik lehetőségként zárja be a teljes karakterláncot, amely tartalmazza a menekítendő kapcsos zárójeleket egy másodlagos idézőjelkészletbe, például ConverterParameter='{Mix}'.

A konverter, a ConverterLanguage és a ConverterLanguage mind a kötési forrásból származó érték vagy típus kötési céltulajdonságokkal kompatibilis típussá vagy értékké alakításának forgatókönyvéhez kapcsolódnak. További információkért és példákért tekintse meg az Adatkötés részletes adatkonvertálás című szakaszát.

A(z) {x:Bind} csak korrektúrakiterjesztés, és nem lehet programozott módon létrehozni vagy módosítani az ilyen kötéseket. A korrektúrakiterjesztésekkel kapcsolatos további információkért lásd az XAML áttekintését.