ResourceDictionary és XAML-erőforráshivatkozások

Az alkalmazás felhasználói felületét vagy erőforrásait az XAML használatával határozhatja meg. Az erőforrások általában olyan objektumok definíciói, amelyeket várhatóan többször is használni fog. Ha később egy XAML-erőforrásra szeretne hivatkozni, meg kell adnia egy olyan erőforrás kulcsát, amely a nevéhez hasonlóan működik. Egy erőforrásra az egész alkalmazásban vagy a benne található XAML-oldalról hivatkozhat. Az erőforrásokat a Windows Runtime XAML ResourceDictionary elemével határozhatja meg. Ezután a StaticResource korrektúra-bővítmény vagy a ThemeResource korrektúra-bővítmény használatával hivatkozhat az erőforrásokra.

Az XAML-erőforrásokként leggyakrabban deklarálandó XAML-elemek közé tartoznak a Stílus, a ControlTemplate, az animációs összetevők és az Ecset alosztályok. Az alábbiakban bemutatjuk, hogyan definiálhat ResourceDictionary - és kulcsalapú erőforrásokat, és hogyan viszonyulnak az XAML-erőforrások az alkalmazás vagy alkalmazáscsomag részeként definiált egyéb erőforrásokhoz. Az erőforrás-szótár fejlett funkcióit is ismertetjük, például az EgyesítettSzótárak és TémaSzótárak.

Előfeltételek

Az XAML jelölőnyelv alapos ismerete. Javasoljuk, hogy olvassa el az XAML áttekintését.

XAML-erőforrások definiálása és használata

Az XAML-erőforrások olyan objektumok, amelyekre többször hivatkoznak a jelölésből. Az erőforrások egy ResourceDictionary-ban vannak definiálva, általában egy külön fájlban vagy a korrektúralap tetején, így.

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Page.Resources>
        <x:String x:Key="greeting">Hello world</x:String>
        <x:String x:Key="goodbye">Goodbye world</x:String>
    </Page.Resources>

    <TextBlock Text="{StaticResource greeting}" Foreground="Gray" VerticalAlignment="Center"/>
</Page>

Ebben a példában:

• <Page.Resources>…</Page.Resources> – Meghatározza az erőforrás szótárát.
• <x:String> - Meghatározza az erőforrást a "greeting" kulccsal.
• {StaticResource greeting}– Megkeresi az erőforrást a TextBlockText tulajdonságához rendelt "greeting" kulccsal.

Megjegyzés:

Ne keverje össze a ResourceDictionaryval kapcsolatos fogalmakat az erőforrás-létrehozási művelettel, az erőforrásfájlokkal (.resw) vagy az alkalmazáscsomagot előállító kódprojekt strukturálásával kapcsolatban tárgyalt egyéb "erőforrásokkal".

Az erőforrásoknak nem kell sztringeknek lenniük; bármilyen megosztható objektum lehet, például stílusok, sablonok, ecsetek és színek. A vezérlők, alakzatok és egyéb FrameworkElement-elemekazonban nem oszthatók meg, így nem deklarálhatók újrafelhasználható erőforrásként. További információért a megosztásról, lásd a jelen témakör későbbi részében a XAML erőforrások megoszthatósága szakaszt.

Itt az ecset és a karakterlánc is erőforrásként van deklarálva, és az oldal vezérlőelemei használják.

<Page
    x:Class="SpiderMSDN.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Page.Resources>
        <SolidColorBrush x:Key="myFavoriteColor" Color="green"/>
        <x:String x:Key="greeting">Hello world</x:String>
    </Page.Resources>

    <TextBlock Foreground="{StaticResource myFavoriteColor}" Text="{StaticResource greeting}" VerticalAlignment="Top"/>
    <Button Foreground="{StaticResource myFavoriteColor}" Content="{StaticResource greeting}" VerticalAlignment="Center"/>
</Page>

Minden erőforrásnak rendelkeznie kell egy kulccsal. Ez a kulcs általában egy sztring, amely a x:Key="myString"-val van definiálva. A kulcs megadásának azonban van néhány más módja is:

• Stílus és ControlTemplate esetén szükséges egy TargetType, és a TargetType fog kulcsként szolgálni, ha x:Kulcs nincs megadva. Ebben az esetben a kulcs a tényleges Type objektum, nem pedig egy sztring. (Lásd az alábbi példákat)
• TargetType DataTemplate-erőforrások a TargetType használják kulcsként, ha nincs megadva x:Key. Ebben az esetben a kulcs a tényleges Type objektum, nem pedig egy sztring.
• x:A név az x:Key helyett használható. Az x:Name azonban egy kódot is létrehoz az erőforrás mezője mögött. Ennek eredményeképpen az x:Name kevésbé hatékony, mint az x:Key, mivel ezt a mezőt inicializálni kell az oldal betöltésekor.

A StaticResource korrektúrakiterjesztés csak sztringnévvel (x:Kulcs vagy x:Név) tud erőforrásokat lekérni. Az XAML-keretrendszer azonban implicit stíluserőforrásokat is keres (amelyek az x:Kulcs vagy x:Név helyett TargetType-ot használnak), amikor eldönti, hogy melyik stílus & sablont használja egy olyan vezérlőhöz, amely nem állította be a Stílus és a ContentTemplate vagy az ItemTemplate tulajdonságait.

Itt a stílus egy implicit typeof(Button) kulccsal rendelkezik, és mivel a lap alján lévő gomb nem ad meg Stílus tulajdonságot, a typeof(Button) billentyűvel rendelkező stílust keres:

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Page.Resources>
        <Style TargetType="Button">
            <Setter Property="Background" Value="Red"/>
        </Style>
    </Page.Resources>
    <Grid>
       <!-- This button will have a red background. -->
       <Button Content="Button" Height="100" VerticalAlignment="Center" Width="100"/>
    </Grid>
</Page>

Az implicit stílusokról és azok működéséről további információt a Stílusvezérlők és a Vezérlősablonok című témakörben talál.

Erőforrások keresése kódban

Az erőforrás-szótár tagjait a többi szótárhoz hasonlóan érheti el.

Figyelmeztetés

Amikor kódban végez erőforrás-keresést, a rendszer csak a Page.Resources szótárban lévő erőforrásokat vizsgálja meg. A StaticResource korrektúrakiterjesztéstől eltérően a kód nem kerül vissza a Application.Resources szótárba, ha az erőforrások nem találhatók az első szótárban.

Ez a példa bemutatja, hogyan kérhető le az erőforrás egy redButtonStyle lap erőforrás-szótárából:

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Page.Resources>
        <Style TargetType="Button" x:Key="redButtonStyle">
            <Setter Property="Background" Value="red"/>
        </Style>
    </Page.Resources>
</Page>

    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
            Style redButtonStyle = (Style)this.Resources["redButtonStyle"];
        }
    }

    MainPage::MainPage()
    {
        InitializeComponent();
        Windows::UI::Xaml::Style style = Resources().TryLookup(winrt::box_value(L"redButtonStyle")).as<Windows::UI::Xaml::Style>();
    }

Ha alkalmazásszintű erőforrásokat szeretne keresni a kódból, használja az Application.Current.Resources parancsot az alkalmazás erőforrás-szótárának lekéréséhez, ahogyan az itt látható.

<Application
    x:Class="MSDNSample.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:SpiderMSDN">
    <Application.Resources>
        <Style TargetType="Button" x:Key="appButtonStyle">
            <Setter Property="Background" Value="red"/>
        </Style>
    </Application.Resources>

</Application>

    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
            Style appButtonStyle = (Style)Application.Current.Resources["appButtonStyle"];
        }
    }

    MainPage::MainPage()
    {
        InitializeComponent();
        Windows::UI::Xaml::Style style = Application::Current().Resources()
                                                               .TryLookup(winrt::box_value(L"appButtonStyle"))
                                                               .as<Windows::UI::Xaml::Style>();
    }

Az alkalmazáserőforrást kódban is hozzáadhatja.

Ebben az esetben két dolgot kell szem előtt tartani.

• Először fel kell vennie az erőforrásokat, mielőtt bármelyik oldal megpróbálná használni az erőforrást.
• Másodszor, nem adhat hozzá erőforrásokat az alkalmazás konstruktorához.

Mindkét problémát elkerülheti, ha hozzáadja az erőforrást az Application.OnLaunched metódushoz.

// App.xaml.cs
    
sealed partial class App : Application
{
    protected override void OnLaunched(LaunchActivatedEventArgs e)
    {
        Frame rootFrame = Window.Current.Content as Frame;
        if (rootFrame == null)
        {
            SolidColorBrush brush = new SolidColorBrush(Windows.UI.Color.FromArgb(255, 0, 255, 0)); // green
            this.Resources["brush"] = brush;
            // … Other code that VS generates for you …
        }
    }
}

// App.cpp

void App::OnLaunched(LaunchActivatedEventArgs const& e)
{
    Frame rootFrame{ nullptr };
    auto content = Window::Current().Content();
    if (content)
    {
        rootFrame = content.try_as<Frame>();
    }

    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == nullptr)
    {
        Windows::UI::Xaml::Media::SolidColorBrush brush{ Windows::UI::ColorHelper::FromArgb(255, 0, 255, 0) };
        Resources().Insert(winrt::box_value(L"brush"), winrt::box_value(brush));
        // … Other code that VS generates for you …

Minden FrameworkElement rendelkezhet egy erőforrás-szótárral.

A FrameworkElement egy olyan alaposztály, amelytől a vezérlők öröklődnek, és rendelkezik erőforrás-tulajdonságokkal . Tehát hozzáadhat egy helyi erőforrás-szótárat bármely FrameworkElementelemhez.

Itt mind a lap, mind a szegély rendelkeznek erőforrás-szótárakkal, és mindkettő rendelkezik egy "üdvözlés" elnevezett erőforrással. A "textBlock2" nevű TextBlock a Szegély-en belül található, így az erőforrás-keresés először a Szegélyerőforrásaira, majd a Oldalerőforrásaira, végül az Alkalmazás erőforrásaira hivatkozik. A TextBlock felolvassa a "Hola mundo" szöveget.

Ha az elem erőforrásait kódból szeretné elérni, használja az elem Resources tulajdonságát. Ha az XAML helyett kódban fér hozzá a FrameworkElement erőforrásaihoz, az csak ebben a szótárban jelenik meg, a szülőelem szótáraiban nem.

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Page.Resources>
        <x:String x:Key="greeting">Hello world</x:String>
    </Page.Resources>
    
    <StackPanel>
        <!-- Displays "Hello world" -->
        <TextBlock x:Name="textBlock1" Text="{StaticResource greeting}"/>

        <Border x:Name="border">
            <Border.Resources>
                <x:String x:Key="greeting">Hola mundo</x:String>
            </Border.Resources>
            <!-- Displays "Hola mundo" -->
            <TextBlock x:Name="textBlock2" Text="{StaticResource greeting}"/>
        </Border>

        <!-- Displays "Hola mundo", set in code. -->
        <TextBlock x:Name="textBlock3"/>
    </StackPanel>
</Page>

    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
            textBlock3.Text = (string)border.Resources["greeting"];
        }
    }

    MainPage::MainPage()
    {
        InitializeComponent();
        textBlock3().Text(unbox_value<hstring>(border().Resources().TryLookup(winrt::box_value(L"greeting"))));
    }

Egyesített erőforrás-szótárak

Az egyesített erőforrás-szótárak egy erőforrásszótárat egyesítenek egymással, általában egy másik fájlban.

Tipp Erőforrásszótárat hozhat létre a Microsoft Visual Studióban az Új elem hozzáadása… > Erőforrásszótár > lehetőség használatával a Projekt menüből.

Itt definiálhat egy erőforrás-szótárat egy külön XAML-fájlban, a Dictionary1.xaml fájlban.

<!-- Dictionary1.xaml -->
<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:MSDNSample">

    <SolidColorBrush x:Key="brush" Color="Red"/>

</ResourceDictionary>

A szótár használatához egyesítse azt az oldala szótárával.

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Page.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="Dictionary1.xaml"/>
            </ResourceDictionary.MergedDictionaries>

            <x:String x:Key="greeting">Hello world</x:String>

        </ResourceDictionary>
    </Page.Resources>

    <TextBlock Foreground="{StaticResource brush}" Text="{StaticResource greeting}" VerticalAlignment="Center"/>
</Page>

Ez történik ebben a példában. Az <Page.Resources>keretében kijelented <ResourceDictionary>. Az XAML-keretrendszer implicit módon létrehoz egy erőforrásszótárat az Ön számára, amikor erőforrásokat ad hozzá <Page.Resources>. Ebben az esetben azonban nem csak egy erőforrásszótárat szeretne, hanem olyat, amely egyesített szótárakat tartalmaz.

Így deklarálhatja <ResourceDictionary>, majd hozzáadhat dolgokat a <ResourceDictionary.MergedDictionaries> gyűjteményéhez. Mindegyik bejegyzés a <ResourceDictionary Source="Dictionary1.xaml"/>formát önti. Ha egynél több szótárt szeretne hozzáadni, csak adjon hozzá egy bejegyzést <ResourceDictionary Source="Dictionary2.xaml"/> az első bejegyzés után.

Ezután <ResourceDictionary.MergedDictionaries>…</ResourceDictionary.MergedDictionaries>opcionálisan további erőforrásokat is elhelyezhet a fő szótárban. Az egyesített szótárak erőforrásait ugyanúgy használhatja, mint a hagyományos szótárat. A fenti {StaticResource brush} példában megkeresi az erőforrást a gyermek-/egyesített szótárban (Dictionary1.xaml), míg {StaticResource greeting} az erőforrást a főoldal szótárában találja meg.

Az erőforrás-keresési sorrendben az EgyesítettSzótárak csak az adott ResourceDictionaryösszes többi kulcsos erőforrásának ellenőrzése után kerül ellenőrzésre. A szint keresése után a keresés eléri az egyesített szótárakat, és a rendszer ellenőrzi az egyesített szótárak minden elemét. Ha több egyesített szótár is létezik, ezek a szótárak annak a sorrendnek az inverzében vannak bejelölve, amelyben deklarálva vannak az Egyesített szótárak tulajdonságban. A következő példában, ha a Dictionary2.xaml és a Dictionary1.xaml is ugyanazt a kulcsot deklarálta, akkor a Dictionary2.xaml kulcs lesz az első, mert az utolsó az Egyesítettdictionaries halmazban.

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Page.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="Dictionary1.xaml"/>
                <ResourceDictionary Source="Dictionary2.xaml"/>
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Page.Resources>

    <TextBlock Foreground="{StaticResource brush}" Text="greetings!" VerticalAlignment="Center"/>
</Page>

A ResourceDictionaryhatókörén belül a szótár ellenőrzi a kulcs egyediségét. Ez a hatókör azonban nem terjed ki a egyesített szótárak fájlok különböző elemeire.

A keresési sorrend és az egyesített szótárak hatókörei közötti egyedi kulcs kényszerítésének hiányának kombinációjával létrehozhatja a ResourceDictionary erőforrások tartalék értéksorrendjét. Előfordulhat például, hogy egy adott ecsetszín felhasználói beállításait a sorozat utolsó egyesített erőforrás-szótárában tárolja egy olyan erőforrás-szótár használatával, amely szinkronizálja az alkalmazás állapotát és a felhasználói beállítások adatait. Ha ám még nincsenek felhasználói beállítások, a kezdeti EgyesítettSzótárak fájlban definiálható a ResourceDictionary erőforrás kulcsszövege, és tartalék értékként is szolgálhat. Ne feledje, hogy az elsődleges erőforrás-szótárakban megadott értékek mindig be vannak jelölve az egyesített szótárak ellenőrzése előtt, ezért ha a tartalék technikát szeretné használni, ne definiálja ezt az erőforrást egy elsődleges erőforrás-szótárban.

Témaerőforrások és témaszótárak

A ThemeResource hasonló a StaticResource, de az erőforrás-keresés újraértékelődik, amikor a téma megváltozik.

Ebben a példában egy TextBlock előterét állítja be az aktuális téma értékére.

<TextBlock Text="hello world" Foreground="{ThemeResource FocusVisualWhiteStrokeThemeBrush}" VerticalAlignment="Center"/>

A témaszótár egy speciális egyesített szótártípus, amely a felhasználó által az eszközén használt témától eltérő erőforrásokat tartalmazza. A "világos" téma például fehér színű ecsetet, míg a "sötét" téma sötét színű ecsetet használhat. Az ecset megváltoztatja az általa feloldott erőforrást, de egyébként az azonos ecsetet erőforrásként használó vezérlő összetétele azonos maradhat. Ha a témaváltási viselkedést szeretné reprodukálni saját sablonjaiban és stílusaiban, az MergedDictionaries tulajdonság használata helyett, az elemeket a fő szótárakba való egyesítéshez használja a ThemeDictionaries tulajdonságot.

A ThemeDictionaries összes ResourceDictionary elemének x:Key értékkel kell rendelkeznie. Az érték egy sztring, amely a releváns témát adja meg – például "Alapértelmezett", "Sötét", "Világos" vagy "HighContrast". Általában azonos nevű, Dictionary1Dictionary2 de eltérő értékekkel rendelkező erőforrásokat határoz meg.

Itt piros szöveget használ a világos témához, és kék szöveget a sötét témához.

<!-- Dictionary1.xaml -->
<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:MSDNSample">

    <SolidColorBrush x:Key="brush" Color="Red"/>

</ResourceDictionary>

<!-- Dictionary2.xaml -->
<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:MSDNSample">

    <SolidColorBrush x:Key="brush" Color="blue"/>

</ResourceDictionary>

Ebben a példában egy TextBlock előterét állítja be az aktuális téma értékére.

<Page
    x:Class="MSDNSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Page.Resources>
        <ResourceDictionary>
            <ResourceDictionary.ThemeDictionaries>
                <ResourceDictionary Source="Dictionary1.xaml" x:Key="Light"/>
                <ResourceDictionary Source="Dictionary2.xaml" x:Key="Dark"/>
            </ResourceDictionary.ThemeDictionaries>
        </ResourceDictionary>
    </Page.Resources>
    <TextBlock Foreground="{StaticResource brush}" Text="hello world" VerticalAlignment="Center"/>
</Page>

A témaszótárak esetében az erőforrás-kereséshez használandó aktív szótár dinamikusan változik, amikor ThemeResource jelölőbővítményt használnak a hivatkozás létrehozásához, és a rendszer észleli a téma módosítását. A rendszer által végzett keresési viselkedés azon alapul, hogy az aktív témát megfelelteti egy adott témaszótár x:Kulcs kulcsának.

Hasznos lehet megvizsgálni, hogy a témaszótárak hogyan vannak strukturálva az alapértelmezett XAML tervezési erőforrásokban, amelyek a Windows Futtatókörnyezet által alapértelmezés szerint a vezérlőkhöz használt sablonokkal párhuzamosak. Nyissa meg az XAML-fájlokat a \(Program Files)\Windows Kits\10\DesignTime\CommonConfiguration\Neutral\UAP\<SDK-verzió,>\Generic használatával egy szövegszerkesztő vagy a fejlesztői környezet segítségével. Figyelje meg, hogy a témaszótárak hogyan vannak először definiálva a generic.xaml fájlban, és hogy az egyes témaszótárak hogyan definiálják ugyanazokat a kulcsokat. Ezután ezekre a kulcsokra hivatkoznak a kompozíció elemjei, amelyek a különböző kulcselemek között találhatók, és a témaszótárakon kívül, valamint később az XAML-ben definiálva vannak. A tervezéshez külön themeresources.xaml fájl is tartozik, amely csak a témaerőforrásokat és a további sablonokat tartalmazza, nem az alapértelmezett vezérlősablonokat. A tématerületek a generic.xaml-ben látható elemek másolatai.

Ha XAML tervezőeszközökkel szerkessze a stílusok és sablonok másolatát, a tervezőeszközök kinyerik a szakaszokat az XAML tervezési erőforrás-szótáraiból, és azokat az alkalmazás és projekt részét képező XAML-szótárelemek helyi példányaként helyezik el.

További információkért és az alkalmazás számára elérhető témaspecifikus és rendszererőforrások listájáért tekintse meg az XAML témaerőforrásait.

Keresési viselkedés XAML-erőforráshivatkozásokhoz

A keresési viselkedés az a kifejezés, amely leírja, hogy az XAML-erőforrások rendszere hogyan próbál XAML-erőforrást keresni. A keresés akkor fordul elő, ha egy kulcsra XAML-erőforráshivatkozásként hivatkozik az alkalmazás XAML-jében. Először is az erőforrásrendszer kiszámítható viselkedéssel rendelkezik arra vonatkozóan, hogy hol fogja ellenőrizni az erőforrás meglétét a hatókör alapján. Ha egy erőforrás nem található a kezdeti hatókörben, a hatókör kibővül. A keresési viselkedés továbbra is folytatódik azon helyeken és hatókörökben, amelyeket egy XAML-erőforrás meghatározhat egy alkalmazás vagy a rendszer által. Ha az összes lehetséges erőforrás-keresési kísérlet meghiúsul, gyakran hiba történik. Ezeket a hibákat általában meg lehet szüntetni a fejlesztési folyamat során.

Az XAML-erőforráshivatkozások keresési működése azzal az objektummal kezdődik, amelyben a tényleges használat történik, és a saját Erőforrások tulajdonsággal. Ha létezik ResourceDictionary, akkor azt ellenőrzik, hogy a ResourceDictionary tartalmazza-e a kért kulccsal rendelkező elemet. Ez az első keresési szint ritkán releváns, mivel általában nem definiálunk és hivatkozunk erőforrásra ugyanazon az objektumon. Valójában az Erőforrások tulajdonság gyakran nem létezik itt. Az XAML-erőforráshivatkozásokat szinte bárhonnan létrehozhatja az XAML-ben; Nem korlátozódik a FrameworkElement alosztályok tulajdonságaira.

A keresési sorozat ezután ellenőrzi a következő szülőobjektumot az alkalmazás futtatókörnyezeti objektumfája alatt. Ha létezik FrameworkElement.Resources, és ResourceDictionarytárol, a rendszer a megadott kulccsal rendelkező szótári elemet kéri. Ha az erőforrás megtalálható, a keresési sorozat leáll, és az objektum azon a helyen lesz megadva, ahol a hivatkozás történt. Ellenkező esetben a keresési viselkedés a következő szülőszintre lép az objektumfa gyökérszintje felé. A keresés rekurzívan felfelé folytatódik, amíg el nem éri az XAML gyökérelemét, kimerítve az összes lehetséges azonnali erőforráshely keresését.

Megjegyzés:

Gyakori gyakorlat az összes közvetlen erőforrás meghatározása a lap gyökérszintjén, mind az erőforrás-keresési viselkedés előnyeinek kihasználása, mind az XAML-korrektúrastílus konvenciójaként.

Ha a kért erőforrás nem található az azonnali erőforrásokban, a következő keresési lépés az Application.Resources tulajdonság ellenőrzése. Az Application.Resources a legjobb hely minden olyan alkalmazásspecifikus erőforrás elhelyezésére, amelyekre az alkalmazás navigációs struktúrájában több oldal hivatkozik.

Fontos

A ResourceDictionary-hoz hozzáadott erőforrások sorrendje befolyásolja az alkalmazásuk sorrendjét. A XamlControlsResources szótár sok alapértelmezett erőforráskulcsot ír felül, ezért először hozzá kell adni a Application.Resources-hez, hogy ne írja felül az alkalmazásban lévő többi egyéni stílust vagy erőforrást.

A vezérlősablonok egy másik lehetséges helyet is találhatnak a referenciakeresésben: a témaszótárakat. A témaszótár egyetlen XAML-fájl, amelynek gyökéreleme ResourceDictionary elem. Lehetséges, hogy a témaszótár az Application.Resourcesegyesített szótára. A témaszótár lehet egy sablonalapú egyéni vezérlőhöz tartozó specifikus témaszótár is.

Végül létezik egy erőforrás-keresés a platformerőforrásokkal szemben. A platformerőforrások tartalmazzák az egyes rendszer felhasználói felületi témákhoz definiált vezérlősablonokat, amelyek meghatározzák a Felhasználói felülethez használt összes vezérlő alapértelmezett megjelenését a Windows Futtatókörnyezeti alkalmazásokban. A platformerőforrások nevesített erőforrásokat is tartalmaznak, amelyek a rendszerszintű megjelenéshez és témákhoz kapcsolódnak. Ezek az erőforrások technikailag egy egyesített szótárakat tartalmazó elemek, és így elérhetőek az alkalmazás betöltése után XAML-ból vagy kódból történő kereséshez. A rendszer téma erőforrásai közé tartozik például egy "SystemColorWindowTextColor" nevű erőforrás, amely Szín definíciót biztosít az alkalmazás szövegszínének a rendszerablak szövegszínéhez való igazításához, amely az operációs rendszerből és a felhasználói beállításokból származik. Az alkalmazás más XAML-stílusai is hivatkozhatnak erre a stílusra, vagy a kód lekérhet egy erőforrás-keresési értéket (és a példaesetben Szín).

További információ és az XAML-t használó Windows-alkalmazások számára elérhető témaspecifikus és rendszererőforrások listája: XAML témaerőforrások.

Ha a kért kulcs továbbra sem található ezen helyek egyikében sem, XAML-elemzési hiba/kivétel lép fel. Bizonyos körülmények között az XAML-elemzési kivétel futásidejű kivétel lehet, amelyet nem észlel egy XAML-korrektúrafordítási művelet, vagy egy XAML tervezési környezet.

Az erőforrás-szótárak rétegzett keresési viselkedése miatt szándékosan definiálhat több olyan erőforráselemet, amelyek mindegyike ugyanazzal a sztring értékkel rendelkezik, mint a kulcs, feltéve, hogy az egyes erőforrások más szinten vannak definiálva. Más szóval, bár a kulcsnak egyedinek kell lennie egy adott ResourceDictionary-ban, az egyediségi követelmény nem terjed ki a keresési viselkedés egészére. A keresés során csak az első, sikeresen lekért objektumot használja a rendszer az XAML-erőforráshivatkozáshoz, majd a keresés leáll. Ezzel a viselkedéssel kérheti le ugyanazt az XAML-erőforrást az alkalmazás XAML-jén belüli különböző pozíciókban kulcs alapján, de különböző erőforrásokat kaphat vissza attól függően, hogy milyen hatókörből származik az XAML-erőforráshivatkozás, és hogy az adott keresés hogyan viselkedik.

Hivatkozások továbbítása egy ResourceDictionary-on belül

Egy adott erőforrásszótár XAML-erőforráshivatkozásainak egy kulccsal már definiált erőforrásra kell hivatkoznia, és az erőforrásnak lexikálisan meg kell jelennie az erőforrás-hivatkozás előtt. A továbbítási hivatkozásokat nem lehet XAML-erőforráshivatkozással feloldani. Ezért, ha XAML-erőforráshivatkozásokat használ egy másik erőforrásból, úgy kell megterveznie az erőforrás-szótár struktúráját, hogy a más erőforrások által használt erőforrások először egy erőforrásszótárban legyenek definiálva.

Az alkalmazás szintjén definiált erőforrások nem hivatkozhatók azonnali erőforrásokra. Ez egyenértékű a továbbítási hivatkozás megkísérlésével, mivel az alkalmazás erőforrásait a rendszer először dolgozza fel (az alkalmazás első indításakor és a navigációs oldal tartalmának betöltése előtt). Bármely közvetlen erőforrás hivatkozhat egy alkalmazáserőforrásra, és ez hasznos módszer lehet az előre utalási helyzetek elkerüléséhez.

Az XAML-erőforrásoknak megoszthatónak kell lenniük

Ahhoz, hogy egy objektum egy ResourceDictionary-ban létezni lehessen, az objektumnak megoszthatónak kell lennie.

A megosztásra azért van szükség, mert ha egy alkalmazás objektumfáját futásidőben készítik és használják, az objektumok nem létezhetnek a fa több helyén. Az erőforrásrendszer belsőleg létrehozza az alkalmazás objektumgráfjában használandó erőforrásértékek másolatait minden XAML-erőforrás kérésekor.

A ResourceDictionary és a Windows Runtime XAML általában támogatja ezeket az objektumokat a megosztható használathoz:

• Stílusok és sablonok (Stílus és az FrameworkTemplateosztályaiból származó)
• Ecsetek és színek ( ecsetből és színértékekből származtatott osztályok)
• Animációs típusok, beleértve a Storyboardot
• Átalakítások (a GeneralTransformosztályokból származó osztályok)
• Mátrix és Mátrix3D
• Pont értékei
• Bizonyos egyéb, felhasználói felülettel kapcsolatos struktúrák, például a Vastagság és a CornerRadius
• XAML belső adattípusok

Az egyéni típusokat megosztható erőforrásként is használhatja, ha követi a szükséges megvalósítási mintákat. Ezeket az osztályokat a háttérkódban (vagy az Ön által használt futtatókörnyezeti összetevőkben) definiálja, majd az XAML-ben erőforrásként példányosíthatja ezeket az osztályokat. Ilyenek például az objektum-adatforrások és az adatkötés IValueConverter-implementációi .

Az egyéni típusoknak alapértelmezett konstruktorsal kell rendelkezniük, mivel az XAML-elemzők ezt használják az osztály példányosításához. Az erőforrásokként használt egyéni típusok nem tartalmazhatják a UIElement osztályt az öröklésükben, mert a felhasználói felület soha nem osztható meg (mindig pontosan egy olyan felhasználói felületi elemet kell képviselnie, amely a futtatókörnyezeti alkalmazás objektumgráfjában egy helyen található).

A UserControl használati hatóköre

A UserControl-elemek különleges helyzetben vannak az erőforrás-keresési viselkedéshez, mivel a definíciós hatókör és a használati hatókör eredendő fogalmaival rendelkezik. Az XAML-erőforrást a definíció hatóköréből referenciaként használó UserControlnak képesnek kell lennie támogatnia az adott erőforrás keresését a saját definíció-hatókör keresési sorozatán belül, vagyis nem fér hozzá az alkalmazás erőforrásaihoz. Egy UserControl használati hatóköréből az erőforrás-hivatkozás a keresési sorrenden belül van a használati lap gyökeréhez (ugyanúgy, mint a betöltött objektumfában lévő objektumból készített egyéb erőforráshivatkozások), és hozzáférhet az alkalmazás erőforrásaihoz.

ResourceDictionary és XamlReader.Load

A XamlReader.Load metódushoz a ResourceDictionary használható az XAML-bemenet gyökereként vagy annak részeként is. Az XAML-erőforráshivatkozásokat is belefoglalhatja ebbe az XAML-be, ha az összes ilyen hivatkozás teljesen önálló a betöltéshez beküldött XAML-ben. A XamlReader.Load olyan környezetben elemzi az XAML-t, amely nem ismer más ResourceDictionary objektumokat, még az Application.Resourcest sem. Ne használja a {ThemeResource}-t se a XAML-ben, ami a XamlReader.Load-t illeti.

ResourceDictionary használata kódból

A ResourceDictionary legtöbb forgatókönyve kizárólag az XAML-ben van kezelve. A ResourceDictionary tárolót és a benne lévő erőforrásokat XAML-fájlként vagy XAML-csomópontok készleteként deklarálja egy felhasználói felület definíciós fájljában. Ezután XAML-erőforráshivatkozásokkal kérheti le ezeket az erőforrásokat az XAML más részeitől. Vannak azonban olyan esetek, amikor az alkalmazás módosítani szeretné egy ResourceDictionary tartalmát az alkalmazás futása közben végrehajtott kód használatával, vagy legalábbis egy ResourceDictionary tartalmának lekérdezéséhez, hogy lássa, van-e már definiálva erőforrás. Ezeket a kódhívásokat egy ResourceDictionary példányon hajtják végre, ezért először le kell kérnie egyet – vagy egy közvetlen ResourceDictionary valahol az objektumfában a FrameworkElement.Resourceslekérésével, vagy Application.Current.Resources.

A C#-ban hivatkozhat egy adott ResourceDictionary-erőforrásra az indexelő (Item) használatával. A ResourceDictionary egy sztringkulcsú szótár, ezért az indexelő a sztringkulcsot használja egész szám index helyett. A Visual C++ összetevőbővítményekben (C++/CX) használja a Keresés.

A ResourceDictionary vizsgálatára vagy módosítására szolgáló kód használatakor az API-k, például a Keresés vagy az Elem viselkedése nem halad át az azonnali erőforrásokról az alkalmazáserőforrásokra; ez egy XAML-elemző viselkedés, amely csak az XAML-lapok betöltésekor történik. Futásidőben a kulcsok hatóköre az adott időpontban használt ResourceDictionary példányhoz tartozik. Ez a hatókör azonban kiterjed a egyesített szótárakterületére is.

Ha olyan kulcsot kér, amely nem létezik a ResourceDictionary-ben, lehet, hogy nem jelentkezik hiba; a visszaadott érték egyszerűen nulllehet. A visszaadott null érték értékként való használata esetén azonban továbbra is hibaüzenet jelenhet meg. A hiba a tulajdonság beállítójától származik, nem a ResourceDictionary-hívástól . Csak akkor kerülheti el a hibát, ha a tulajdonság érvényes értékként elfogadná a null értéket. Figyelje meg, hogy ez a viselkedés hogyan szemben áll az XAML keresési viselkedésével XAML-elemzési időpontban; Ha nem sikerül feloldani a megadott kulcsot az XAML-ből az elemzési időpontban, XAML-elemzési hibát eredményez, még akkor is, ha a tulajdonság null értéket fogadhatott volna el.

Az összevont erőforrás-szótárak bekerülnek az őket hivatkozó elsődleges erőforrás-szótár index tartományába futási időben. Más szóval, az elsődleges szótárból a Elem vagy a Keresés használatával megkeresheti azokat az objektumokat, amelyeket ténylegesen az egyesített szótárban definiáltak. Ebben az esetben a keresési viselkedés hasonlít az XAML elemzési viselkedésére: ha az egyesített szótárakban több objektum is található, amelyek mindegyike ugyanazzal a kulccsal rendelkezik, a rendszer visszaadja az utoljára hozzáadott szótár objektumát.

A Hozzáadás vagy beszúrás (C++/CX) meghívásával hozzáadhat elemeket egy meglévő ResourceDictionary-hez. Az elemeket hozzáadhatja azonnali erőforrásokhoz vagy alkalmazáserőforrásokhoz. Ezen API-hívások egyikének kulcsra van szüksége, amely megfelel annak a követelménynek, hogy a ResourceDictionary minden egyes elemének rendelkeznie kell egy kulccsal. A ResourceDictionary-hez futtatáskor hozzáadott elemek azonban nem relevánsak az XAML-erőforráshivatkozások szempontjából. Az XAML-erőforráshivatkozások szükséges keresése akkor történik, ha az XAML először az alkalmazás betöltésekor lesz elemezve (vagy témamódosítást észlel). A gyűjteményekhez futásidőben hozzáadott erőforrások akkor nem voltak elérhetők, és a ResourceDictionary módosítása még akkor sem érvénytelenít egy már lekért erőforrást, ha módosítja az erőforrás értékét.

Eltávolíthatja az elemeket a ResourceDictionary-ból futásidőben, másolatot készíthet néhány vagy az összes elemről, vagy végezhet más műveleteket is. A ResourceDictionary taglistái jelzik, hogy mely API-k érhetők el. Vegye figyelembe, hogy mivel a ResourceDictionary egy előrejelzett API-val támogatja a mögöttes gyűjteményfelületeket, az API-beállítások attól függően különböznek, hogy C# vagy Visual Basic vagy C++/CX elemet használ- e.

Erőforrás-szótár és lokalizáció

Az XAML ResourceDictionary kezdetben honosítandó karakterláncokat tartalmazhat. Ha igen, ezeket a sztringeket projekterőforrásként tárolja, ne pedig egy ResourceDictionary-ben. Távolítsa el a karakterláncokat az XAML-ből, és ahelyett adjon meg egy x:Uid direktíva értéket. Ezután definiáljon egy erőforrást egy erőforrásfájlban. Adjon meg egy erőforrásnevet a következő alakban: XUIDValue.PropertyName, valamint az lokalizálandó sztring erőforrásértékét.

Egyéni erőforrás-keresés

Speciális forgatókönyvek esetén olyan osztályokat implementálhat, amelyek viselkedése eltér a jelen témakörben ismertetett XAML-erőforrás-referencia keresési viselkedésétől. Ehhez implementálja a CustomXamlResourceLoader osztályt, majd ezt a viselkedést a CustomResource jelölőbővítmény használatával érheti el erőforrás-hivatkozásokhoz a StaticResource vagy a ThemeResource helyett. A legtöbb alkalmazás nem rendelkezik ehhez szükséges forgatókönyvekkel. További információ: CustomXamlResourceLoader.

Kapcsolódó témakörök

• ErőforrásSzótár
• XAML-áttekintés
• StaticResource jelölő bővítmény
• ThemeResource jelölő kiterjesztés
• XAML-témaerőforrások
• stílusvezérlők
• x:Key attribútum