ResourceDictionary ve XAML kaynak başvuruları

XAML kullanarak uygulamanızın kullanıcı arabirimini veya kaynaklarını tanımlayabilirsiniz. Kaynaklar genellikle birden çok kez kullanmayı beklediğiniz bazı nesne tanımlarıdır. Daha sonra bir XAML kaynağına başvurmak için, kaynağın adı gibi davranan bir anahtar belirtirsiniz. Bir kaynağı uygulama genelinde veya içindeki herhangi bir XAML sayfasından referans alabilirsiniz. Kaynaklarınızı Windows Çalışma Zamanı XAML'sinden bir ResourceDictionary öğesi kullanarak tanımlayabilirsiniz. Ardından, StaticResource işaretleme uzantısını veya ThemeResource işaretleme uzantısını kullanarak kaynaklarınıza başvurabilirsiniz.

XAML kaynakları olarak en sık bildirmek isteyebileceğiniz XAML öğeleri Style, ControlTemplate, animasyon bileşenleri ve Brush alt sınıflarıdır. Burada ResourceDictionary ve anahtarlı kaynakların nasıl tanımlanacağı ve XAML kaynaklarının uygulama veya uygulama paketinizin bir parçası olarak tanımladığınız diğer kaynaklarla nasıl ilişkilendirildiğini açıklayacağız. Ayrıca MergedDictionaries ve ThemeDictionaries gibi kaynak sözlüğü gelişmiş özelliklerini de açıklıyoruz.

Önkoşullar

XAML işaretlemesinin sağlam bir şekilde anlaşılması. XAML'e genel bakışokumanızı öneririz.

XAML kaynaklarını tanımlama ve kullanma

XAML kaynakları, işaretlemeden birden çok kez referans alınan nesnelerdir. Kaynaklar bir ResourceDictionary içinde, genellikle ayrı bir dosyada veya işaretleme sayfasının üst kısmında tanımlanır.

<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>

Bu örnekte:

• <Page.Resources>…</Page.Resources> - Kaynak sözlüğü tanımlar.
• <x:String> - Kaynağı "greeting" anahtarıyla tanımlar.
• {StaticResource greeting} - "greeting" anahtarıyla kaynağı arar ve bu, TextBlock'ün Metin özelliğine atanmıştır.

Uyarı

ResourceDictionary ile ilgili kavramları Kaynak derleme eylemi, kaynak (.resw) dosyaları veya uygulama paketinizi oluşturan kod projesini yapılandırma bağlamında ele alınan diğer "kaynaklar" ile karıştırmayın.

Kaynakların dize olması gerekmez; stiller, şablonlar, fırçalar ve renkler gibi paylaşılabilir herhangi bir nesne olabilir. Ancak denetimler, şekiller ve diğer FrameworkElement'lerpaylaşılabilir olmadığından yeniden kullanılabilir kaynaklar olarak bildirilemez. Paylaşım hakkında daha fazla bilgi için bu konunun devamında yer alan XAML kaynaklarının paylaşılabilir olması gerekir bölümüne bakın.

Burada hem bir fırça hem de bir dizi kaynak olarak tanımlanır ve bir sayfadaki denetimler tarafından kullanılır.

<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>

Tüm kaynakların bir anahtarı olması gerekir. Genellikle bu anahtar ile x:Key="myString"tanımlanan bir dizedir. Ancak, anahtar belirtmenin birkaç yolu daha vardır:

• Style ve ControlTemplate bir TargetType gerektirir ve x:Key belirtilmezse anahtar olarak TargetType'ı kullanır. Bu durumda anahtar, dize değil gerçek Type nesnesidir. (Aşağıdaki örneklere bakın)
• TargetType sahip DataTemplate kaynakları , x:Key belirtilmezse anahtar olarak TargetType kullanır. Bu durumda anahtar, dize değil gerçek Type nesnesidir.
• x:Key yerine x:Name kullanılabilir. Ancak x:Name, kaynak için ek olarak arka plan kod alanı da oluşturur. Sonuç olarak, sayfa yüklendiğinde bu alanın başlatılması gerektiğinden x:Name, x:Key değerinden daha az verimlidir.

StaticResource işaretleme uzantısı yalnızca dize adıyla (x:Key veya x:Name) kaynakları alabilir. Ancak XAML çerçevesi, Style ve ContentTemplate veya ItemTemplate özelliklerini ayarlamamış bir denetim için hangi stilin ve şablonun kullanılacağına karar verince örtük stil kaynaklarını da (x:Key veya x:Name yerine TargetType kullananlar) arar.

Burada, Style typeof(Button)örtük bir anahtara sahiptir ve, sayfanın altındaki Button Style özelliğini belirtmediğinden,typeof(Button) anahtarına sahip bir stil bulmaya çalışır.

<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>

Örtük stiller ve bunların nasıl çalıştığı hakkında daha fazla bilgi için bkz. Stil denetimleri ve Denetim şablonları.

Kodda kaynakları arama

Kaynak sözlüğü üyelerine diğer sözlükler gibi erişebilirsiniz.

Uyarı

Kodda kaynak araması gerçekleştirdiğinizde yalnızca sözlükteki Page.Resources kaynaklara bakılır. StaticResource işaretleme uzantısından farklı olarak, kaynaklar ilk sözlükte Application.Resources bulunmazsa kod sözlüğe geri dönmez.

Bu örnek, bir sayfanın kaynak sözlüğünden redButtonStyle kaynağın nasıl alınacağını göstermektedir.

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

Koddan uygulama genelindeki kaynakları aramak için Application.Current.Resources'ı kullanarak burada gösterildiği gibi uygulamanın kaynak sözlüğüne ulaşın.

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

Koda bir uygulama kaynağı da ekleyebilirsiniz.

Bunu yaparken aklınızda bulundurması gereken iki şey vardır.

• İlk olarak, herhangi bir sayfa kaynağı kullanmayı denemeden önce kaynakları eklemeniz gerekir.
• İkincisi, Uygulamanın oluşturucusunda kaynak ekleyemezsiniz.

Kaynağı Application.OnLaunched yöntemine eklerseniz her iki sorundan da kaçınabilirsiniz.

// 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 …

Her FrameworkElement bir ResourceDictionary'ye sahip olabilir

FrameworkElement öğesinden türetilen bir temel sınıftır ve Resources özelliğine sahiptir. Bu nedenle, herhangi bir FrameworkElementüzerinden yerel bir kaynak sözlüğü ekleyebilirsiniz.

Burada hem Sayfa hem de Kenarlık kaynak sözlükleri vardır ve her ikisinin de "selamlama" adlı bir kaynağı vardır. 'textBlock2' adlı TextBlockKenarlıkiçindedir, bu nedenle kaynak araması önce Kenarlıkkaynaklarına, sonra Sayfakaynaklarına ve sonra Uygulama kaynaklarına bakar. TextBlock "Hola mundo" ifadesini okur.

Bu öğenin kaynaklarına koddan erişmek için bu öğenin Resources özelliğini kullanın. FrameworkElementkaynaklarına XAML yerine kodda erişildiğinde, bu durumda yalnızca ilgili sözlükte arama yapılacaktır, üst öğenin sözlüklerinde arama yapılmayacaktır.

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

Birleştirilmiş kaynak sözlükleri

birleştirilmiş kaynak sözlüğü, genellikle başka bir dosyada bulunan bir kaynak sözlüğünü diğerine birleştirir.

İpucu Microsoft Visual Studio'da > menüsündeki Yeni Öğe > Ekle… Kaynak Sözlüğü seçeneğini kullanarak bir kaynak sözlüğü dosyası oluşturabilirsiniz.

Burada, Dictionary1.xaml adlı ayrı bir XAML dosyasında kaynak sözlüğü tanımlarsınız.

<!-- 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>

Bu sözlüğü kullanmak için sayfanızın sözlüğüyle birleştirin:

<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>

Bu örnekte neler olduğu aşağıda verilmiştır. <Page.Resources>içinde <ResourceDictionary>'i ilan edersiniz. XAML çerçevesi, 'a <Page.Resources>kaynak eklediğinizde sizin için örtük olarak bir kaynak sözlüğü oluşturur; ancak bu durumda, yalnızca herhangi bir kaynak sözlüğü istemezsiniz, birleştirilmiş sözlükler içeren bir sözlük istersiniz.

Önce <ResourceDictionary>bildirirsiniz, sonra öğeleri <ResourceDictionary.MergedDictionaries> koleksiyonuna eklersiniz. Bu girdilerin her biri biçimindedir <ResourceDictionary Source="Dictionary1.xaml"/>. Birden fazla sözlük eklemek için, ilk girdiden sonra bir <ResourceDictionary Source="Dictionary2.xaml"/> girdi eklemeniz gerekir.

'den sonra <ResourceDictionary.MergedDictionaries>…</ResourceDictionary.MergedDictionaries>, isteğe bağlı olarak ana sözlüğünüze ek kaynaklar ekleyebilirsiniz. Birleştirilmiş bir sözlükten kaynakları normal bir sözlük gibi kullanırsınız. Yukarıdaki örnekte, {StaticResource brush} alt/birleştirilmiş sözlükteki (Dictionary1.xaml) kaynağı bulurken {StaticResource greeting} , kaynağını ana sayfa sözlüğünde bulur.

Kaynak arama dizisinde, bir MergedDictionaries sözlüğü, yalnızca o ResourceDictionaryiçerisindeki diğer tüm anahtarlı kaynaklar denetlendikten sonra kontrol edilir. Bu düzey arandıktan sonra arama birleştirilmiş sözlüklere ulaşır ve MergedDictionaries içindeki her öğe denetlenir. Birden çok birleştirilmiş sözlük varsa, bu sözlükler MergedDictionaries özelliğinde bildirildikleri sıranın tersinde denetlenilir. Aşağıdaki örnekte, hem Dictionary2.xaml hem de Dictionary1.xaml aynı anahtarı bildirdiyse, Dictionary2.xaml anahtarı ilk olarak kullanılır çünkü MergedDictionaries kümesinde en son bulunan odur.

<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>

Herhangi birResourceDictionary kapsamında, sözlük anahtar benzersizliği için denetlenir. Ancak, bu kapsam, farklı MergedDictionaries dosyalarındaki öğeler arasında uzanmaz.

ResourceDictionary kaynaklarından oluşan bir geri dönüş değer dizisi oluşturmak için arama dizisi ve birleştirilmiş sözlük kapsamları arasında benzersiz anahtar zorlamasının olmamasının kombinasyonunu kullanabilirsiniz. Örneğin, uygulamanızın durumu ve kullanıcı tercih verileriyle eşitlenen bir kaynak sözlüğü kullanarak belirli bir fırça rengi için kullanıcı tercihlerini sıralı olarak son birleştirilmiş kaynak sözlüğünde depolayabilirsiniz. Ancak, henüz bir kullanıcı tercihi yoksa, ilk MergedDictionaries dosyasında bir ResourceDictionary kaynağı için aynı anahtar dizesini tanımlayabilir ve geri dönüş değeri olarak görev yapabilir. Birincil kaynak sözlüğünde sağladığınız tüm değerlerin, birleştirilmiş sözlükler denetlenmeden önce her zaman denetlendiğini unutmayın; bu nedenle geri dönüş tekniğini kullanmak istiyorsanız, bu kaynağı birincil kaynak sözlüğünde tanımlamayın.

Tema kaynakları ve tema sözlükleri

ThemeResource, StaticResource'a benzer, ancak tema değiştiğinde kaynak araması yeniden değerlendirilir.

Bu örnekte, TextBlock'un ön planını geçerli temadan bir değere ayarlarsınız.

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

Tema sözlüğü, bir kullanıcının cihazında şu anda kullandığı temaya göre değişen kaynakları barındıran özel bir birleştirilmiş sözlük türüdür. Örneğin, "açık" temada beyaz renk fırçası, "koyu" tema ise koyu renk fırçası kullanabilir. Fırça çözümlediği kaynağı değiştirir, ancak aksi takdirde fırçayı kaynak olarak kullanan bir denetimin bileşimi aynı olabilir. Tema değiştirme davranışını kendi şablonlarınızda ve stillerinizde yeniden oluşturmak için, öğeleri ana sözlüklerde birleştirmek üzere MergedDictionaries özelliğini kullanmak yerine ThemeDictionaries özelliğini kullanın.

ThemeDictionaries içindeki her ResourceDictionary öğesinin bir x:Key değeri olmalıdır. Değer, ilgili temayı adlandıran bir dizedir; örneğin, "Varsayılan", "Koyu", "Açık" veya "HighContrast". Dictionary1 Genellikle ve Dictionary2 aynı adlara ancak farklı değerlere sahip kaynakları tanımlar.

Burada, açık tema için kırmızı metin ve koyu tema için mavi metin kullanırsınız.

<!-- 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>

Bu örnekte, TextBlock'un ön planını geçerli temadan bir değere ayarlarsınız.

<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>

tr-TR: Tema sözlükleri için, sistem tema değişikliğini algıladığında ve referans yapmak için ThemeResource işaretleme uzantısı kullanıldığında, kaynak arama için kullanılacak etkin sözlük dinamik olarak değişir. Sistem tarafından yapılan arama davranışı, etkin temayı belirli bir tema sözlüğündeki x:Key ile eşlemeyi temel alır.

Tema sözlüklerinin, Windows Çalışma Zamanı'nın denetimleri için varsayılan olarak kullandığı şablonlara paralel olan varsayılan XAML tasarım kaynaklarında nasıl yapılandırıldığını incelemek yararlı olabilir. Bir metin düzenleyicisi veya IDE'nizi kullanarak \(Program Files)\Windows Kits\10\DesignTime\CommonConfiguration\Neutral\UAP\<SDK version>\Generic içinde XAML dosyalarını açın. Tema sözlüklerinin generic.xaml dosyasında ilk olarak nasıl tanımlandığına ve her tema sözlüğünde aynı anahtarların nasıl tanımlandığına dikkat edin. Daha sonra bu tür her anahtara, tema sözlüklerinin dışında olan ve daha sonra XAML'de tanımlanan çeşitli anahtarlı öğelerdeki bileşim öğeleri tarafından başvurulur. Ayrıca tasarım için varsayılan denetim şablonlarını değil yalnızca tema kaynaklarını ve ek şablonları içeren ayrı bir themeresources.xaml dosyası vardır. Tema alanları, generic.xaml dosyasında gördüğünüz öğelerin yinelemeleridir.

Stil ve şablonların kopyalarını düzenlemek için XAML tasarım araçlarını kullandığınızda, tasarım araçları XAML tasarım kaynak sözlüklerindeki bölümleri ayıklar ve uygulamanızın ve projenizin parçası olan XAML sözlük öğelerinin yerel kopyaları olarak yerleştirir.

Daha fazla bilgi edinmek ve uygulamanız için kullanılabilen temaya özgü ve sistem kaynaklarının listesi için bkz. XAML tema kaynakları.

XAML kaynak başvuruları için arama davranışı

Arama davranışı , XAML kaynakları sisteminin bir XAML kaynağını bulmaya nasıl çalıştığını açıklayan terimdir. Arama, bir anahtara uygulamanın XAML'sinde bir yerden XAML kaynak başvurusu olarak başvurulduğunda gerçekleşir. İlk olarak, kaynak sistemi, kapsamına göre bir kaynağın var olup olmadığını tahmin edilebilir bir şekilde kontrol eder. İlk kapsamda bir kaynak bulunamazsa kapsam genişler. Arama davranışı, bir XAML kaynağının bir uygulama veya sistem tarafından tanımlanabileceği konumlar ve kapsamlar boyunca devam eder. Olası tüm kaynak arama girişimleri başarısız olursa, hata genellikle sonuçlanır. Genellikle geliştirme sürecinde bu hataları ortadan kaldırmak mümkündür.

XAML kaynak başvuruları için arama davranışı, gerçek kullanımın uygulandığı nesne ve kendi Resources özelliğiyle başlar. Orada bir ResourceDictionary varsa, istenen anahtarı içeren bir öğe için bu ResourceDictionary denetlenir. Genellikle aynı nesne üzerinde bir kaynak tanımlayıp başvurmadığınızdan, bu ilk arama düzeyi nadiren geçerlidir. Aslında, resources özelliği genellikle burada yoktur. XAML'de neredeyse her yerden XAML kaynak başvuruları yapabilirsiniz; FrameworkElement alt sınıflarının özellikleriyle sınırlı değilsiniz.

Arama dizisi daha sonra uygulamanın çalışma zamanı nesne ağacında sonraki üst nesneyi denetler. Bir FrameworkElement.Resources varsa ve resourceDictionary barındırıyorsa, belirtilen anahtar dizesini içeren sözlük öğesi istenir. Kaynak bulunursa, arama dizisi durur ve nesne başvurunun yapıldığı konuma sağlanır. Aksi takdirde, arama davranışı nesne ağacının köküne doğru bir sonraki ebeveyn seviyeye ilerler. Arama, XAML'nin kök öğesine ulaşılana kadar özyinelemeli olarak yukarı doğru devam eder ve olası tüm anlık kaynak konumlarının aramasını tüketer.

Uyarı

Hem bu kaynak arama davranışından yararlanmak hem de XAML işaretleme stilinin kuralı olarak sayfanın kök düzeyinde tüm anlık kaynakları tanımlamak yaygın bir uygulamadır.

İstenen kaynak anlık kaynaklarda bulunamazsa, bir sonraki arama adımı Application.Resources özelliğini denetlemektir. Application.Resources , uygulamanızın gezinti yapısına birden çok sayfa tarafından başvuruda bulunan uygulamaya özgü kaynakları yerleştirmek için en iyi yerdir.

Önemli

ResourceDictionary'e eklenen kaynakların sırası, bunların uygulanma sırasını etkiler. XamlControlsResources Sözlük, birçok varsayılan kaynak anahtarını geçersiz kılar ve bu nedenle, uygulamanızdaki diğer özel stil veya kaynakları geçersiz kılmaması için önce Application.Resources öğesine eklenmelidir.

Denetim şablonlarının başvuru aramasında başka bir olası konumu vardır: tema sözlükleri. Tema sözlüğü, kök olarak ResourceDictionary öğesine sahip tek bir XAML dosyasıdır. Tema sözlüğü, Application.Resourcesbirleştirilmiş bir sözlük olabilir. Tema sözlüğü, şablonlu özel denetim için denetime özgü tema sözlüğü de olabilir.

Son olarak, platform kaynaklarına yönelik bir kaynak araması vardır. Platform kaynakları, sistem kullanıcı arabirimi temalarının her biri için tanımlanan ve bir Windows Çalışma Zamanı uygulamasında kullanıcı arabirimi için kullandığınız tüm denetimlerin varsayılan görünümünü tanımlayan denetim şablonlarını içerir. Platform kaynakları ayrıca sistem genelindeki görünüm ve temalarla ilgili bir dizi adlandırılmış kaynak içerir. Bu kaynaklar teknik olarak bir MergedDictionaries öğesidir ve bu nedenle uygulama yüklendikten sonra XAML veya koddan arama için kullanılabilir. Örneğin, sistem teması kaynakları, uygulama metin rengini işletim sistemi ve kullanıcı tercihlerinden gelen bir sistem penceresinin metin rengiyle eşleştirmek için bir Renk tanımı sağlayan "SystemColorWindowTextColor" adlı bir kaynak içerir. Uygulamanızın diğer XAML stilleri bu stile başvurabilir veya kodunuz bir kaynak arama değeri alabilir (ve örnekte bunu Rengi'e dönüştürebilir).

Daha fazla bilgi edinmek ve XAML kullanan bir Windows uygulamasının kullanabileceği temaya özgü ve sistem kaynaklarının listesi için bkz. XAML tema kaynakları.

İstenen anahtar bu konumların hiçbirinde hala bulunamazsa bir XAML ayrıştırma hatası/özel durumu oluşur. Bazı durumlarda, XAML ayrıştırma özel durumu, XAML işaretleme derleme eylemi veya XAML tasarım ortamı tarafından algılanamayan, çalışma sırasında meydana gelen bir özel durum olabilir.

Kaynak sözlükleri için katmanlı arama davranışı nedeniyle, her kaynak farklı bir düzeyde tanımlandığı sürece, her biri anahtarla aynı dize değerine sahip olan birden çok kaynak öğesini kasıtlı olarak tanımlayabilirsiniz. Başka bir deyişle, anahtarların belirli bir ResourceDictionary içinde benzersiz olması gerekir, ancak benzersizlik gereksinimi bir bütün olarak arama davranışı dizisine genişletilmez. Arama sırasında, XAML kaynak başvurusu için yalnızca başarılı bir şekilde alınan ilk nesne kullanılır ve arama durdurulur. Bu davranışı, uygulamanızın XAML'sinde çeşitli konumlarda anahtara göre aynı XAML kaynağını istemek için kullanabilirsiniz, ancak XAML kaynak başvurusunun yapıldığı kapsama ve belirli bir aramanın davranışına bağlı olarak farklı kaynakları geri alabilirsiniz.

ResourceDictionary içinde ileri başvurular

Belirli bir kaynak sözlüğündeki XAML kaynak başvuruları, bir anahtarla önceden tanımlanmış bir kaynağa başvurmalı ve kaynak başvurusundan önce bu kaynağın sözcük temelli olarak görünmesi gerekir. İleri referanslar bir XAML kaynağı ile çözülemez. Bu nedenle, başka bir kaynağın içinden XAML kaynak başvurularını kullanırsanız, kaynak sözlüğü yapınızı diğer kaynaklar tarafından kullanılan kaynakların önce kaynak sözlüğünde tanımlandığı şekilde tasarlamanız gerekir.

Uygulama düzeyinde tanımlanan kaynaklar, anlık kaynaklara başvuru yapamaz. Uygulama kaynakları aslında ilk kez işlendiğinden (uygulama ilk başlatıldığında ve gezinti sayfası içeriği yüklenmeden önce) bu, ileriye doğru başvuru girişimiyle eşdeğerdir. Ancak, herhangi bir anında kaynak bir uygulama kaynağına başvuru yapabilir ve bu, ileriye doğru başvuru durumlarını önlemeye yönelik kullanışlı bir teknik olabilir.

XAML kaynakları paylaşılabilir olmalıdır

Bir nesnenin ResourceDictionary'de var olması için bu nesne paylaşılabilir olmalıdır.

Paylaşılabilir olmak gerekir, çünkü bir uygulamanın nesne ağacı oluşturulduğunda ve çalışma zamanında kullanıldığında, nesneler ağaçta birden çok konumda bulunamaz. Dahili olarak, kaynak sistemi her XAML kaynağı istendiğinde uygulamanızın nesne grafiğinde kullanılacak kaynak değerlerinin kopyalarını oluşturur.

ResourceDictionary ve Windows Runtime XAML genel olarak paylaşılabilir kullanım için bu nesneleri destekler:

• Stiller ve şablonlar (FrameworkTemplate'dan türetilen stil ve sınıflar)
• Fırçalar ve renkler ( Fırça ve Renk değerlerinden türetilen sınıflar)
• Görsel Taslak dahil animasyon türleri
• Dönüşümler (GeneralTransform'dan türetilen sınıflar )
• Matris ve Matris3D
• Noktası değerleri
• Kalınlık ve CornerRadius gibi kullanıcı arabirimiyle ilgili diğer bazı yapılar
• XAML doğal veri türleri

Gerekli uygulama desenlerini izlerseniz paylaşılabilir bir kaynak olarak özel türleri de kullanabilirsiniz. Bu tür sınıfları yedekleme kodunuzda (veya dahil ettiğiniz çalışma zamanı bileşenlerinde) tanımlar ve ardından bu sınıfları XAML'de kaynak olarak oluşturursunuz. Örnekler nesne veri kaynakları ve veri bağlama için IValueConverter uygulamalarıdır.

Özel türlerin varsayılan bir oluşturucusu olmalıdır, çünkü bir XAML ayrıştırıcısı bir sınıfın örneğini oluştururken varsayılan oluşturucuyu kullanır. Kaynak olarak kullanılan özel türler, devralma zincirinde UIElement sınıfına sahip olamaz, çünkü bir UIElement hiçbir zaman paylaşılamaz; bu, her zaman çalışma zamanı uygulamanızın nesne grafiğinde yalnızca bir konumda bulunan tam bir UI öğesini temsil etmek üzere tasarlanmıştır.

UserControl kullanım kapsamı

UserControl öğesinin kaynak arama davranışı için özel bir durumu vardır çünkü tanım kapsamının ve kullanım kapsamının doğal kavramları vardır. Tanım kapsamından bir XAML kaynak başvurusu yapan bir UserControl, bu kaynağın kendi tanım kapsamı arama sırası içinde aramasını destekleyebilmelidir; yani uygulama kaynaklarına erişemez. UserControl kullanım kapsamı kaynak başvurusu, kullanım sayfası köküne doğru arama dizisi içinde olarak değerlendirilir (yüklenen nesne ağacındaki bir nesneden yapılan diğer kaynak başvuruları gibi) ve uygulama kaynaklarına erişebilir.

ResourceDictionary ve XamlReader.Load

ResourceDictionary öğesini, XamlReader.Load yöntemi için XAML girişinin kökü veya bir parçası olarak kullanabilirsiniz. Bu tür başvuruların tümü yüklenmek üzere gönderilen XAML'de tamamen kendi kendine yer alıyorsa, bu XAML'ye XAML kaynak başvuruları da ekleyebilirsiniz. XamlReader.Load, XAML'yi herhangi bir ResourceDictionary nesnesinin, hatta Application.Resourcesnesnesinin dahi farkında olmayan bir bağlamda ayrıştırır. Ayrıca, {ThemeResource} içinden kullanmaktan kaçının.

Koddan ResourceDictionary'i Kullanma

ResourceDictionary senaryolarının çoğu yalnızca XAML'de işlenir. ResourceDictionary kapsayıcısını ve içindeki kaynakları bir UI tanım dosyasında bir XAML dosyası veya XAML düğümleri kümesi olarak bildirirsiniz. Ardından XAML'nin diğer bölümlerinden bu kaynakları istemek için XAML kaynak başvurularını kullanırsınız. Yine de uygulamanızın, uygulama çalışırken yürütülen kodu kullanarak ResourceDictionary içeriğini ayarlamak isteyebileceği veya bir kaynağın zaten tanımlanmış olup olmadığını görmek için resourceDictionary içeriğini sorgulamak isteyebileceği bazı senaryolar vardır. Bu kod çağrıları bir ResourceDictionary örneğinde yapılır, bu nedenle önce FrameworkElement.Resourcesalarak nesne ağacının herhangi bir yerinde bir ResourceDictionary veya Application.Current.Resourcesbirini almanız gerekir.

C# veya Microsoft Visual Basic kodunda, belirli bir ResourceDictionary içindeki bir kaynağa, dizinleyici (Item) kullanarak başvurabilirsiniz. ResourceDictionary dize anahtarlı bir sözlük olduğundan, dizin oluşturucu tamsayı dizini yerine dize anahtarını kullanır. Visual C++ bileşen uzantıları (C++/CX) kodunda Arama'yı kullanın.

ResourceDictionary'yi incelemek veya değiştirmek için kod kullanıldığında, Arama veya Öğe gibi API'lerin davranışı anlık kaynaklardan uygulama kaynaklarına geçiş yapmaz; bu, yalnızca XAML sayfaları yüklendikçe gerçekleşen bir XAML ayrıştırıcı davranışıdır. Çalışma zamanında anahtarların kapsamı, o sırada kullandığınız ResourceDictionary örneğine özgüdür. Ancak, bu kapsam MergedDictionaries'e uzanıyor.

Ayrıca, ResourceDictionary'de olmayan bir anahtar isterseniz, bir hata olmayabilir; dönüş değeri yalnızca nullolarak döndürülebilir. Yine de döndürülen null değerini bir değer olarak kullanmayı denerseniz hata alabilirsiniz. Hata ResourceDictionary çağrınızdan değil özelliğin ayarlayıcısından gelir. Hatadan kaçınmanın tek yolu, özelliğin null'i geçerli bir değer olarak kabul etmesidir. Bu davranışın XAML ayrıştırma zamanındaki XAML arama davranışıyla nasıl karşıt olduğunu unutmayın; ayrıştırma zamanında XAML'den sağlanan anahtarın çözümlenememesi, özelliğin null kabul etmiş olabileceği durumlarda bile XAML ayrıştırma hatasıyla sonuçlanır.

Birleştirilmiş kaynak sözlükleri, çalışma zamanında birleştirilmiş sözlüğe referans veren birincil kaynak sözlüğünün dizin kapsamına dahil edilir. Başka bir deyişle, birleştirilmiş sözlükte gerçekten tanımlanmış olan nesneleri bulmak için birincil sözlüğün Öğe veya Arama özelliğini kullanabilirsiniz. Bu durumda, arama davranışı ayrıştırma zamanı XAML arama davranışına benzer: Birleştirilmiş sözlüklerde her biri aynı anahtara sahip birden çok nesne varsa, son eklenen sözlükteki nesne döndürülür.

Ekle (C# veya Visual Basic) veya Ekle (C++/CX) çağrısı yaparak var olan bir ResourceDictionary'ye öğe eklemenize izin verilir. Öğeleri anlık kaynaklara veya uygulama kaynaklarına ekleyebilirsiniz. Bu API çağrılarından biri bir anahtar gerektirir ve bu da ResourceDictionary'deki her öğenin bir anahtarı olması gereksinimini karşılar. Ancak, çalışma zamanında bir ResourceDictionary'ye eklediğiniz öğeler XAML kaynak referanslarıyla alakalı değildir. XAML kaynak başvuruları için gerekli arama, uygulama yüklenirken (veya bir tema değişikliği algılandığında) XAML ilk ayrıştırıldığında gerçekleşir. Çalışma zamanında koleksiyonlara eklenen kaynaklar kullanılabilir durumda değildi ve ResourceDictionary'nin değiştirilmesi, kaynağın değerini değiştirseniz bile daha önce alınmış olan bir kaynağı geçersiz kılmaz.

Ayrıca, çalışma zamanında ResourceDictionary'den öğeleri kaldırabilir, bazı veya tüm öğelerin veya diğer işlemlerin kopyalarını oluşturabilirsiniz. ResourceDictionary için üye listesi hangi API'lerin kullanılabilir olduğunu gösterir. ResourceDictionary'nin temel koleksiyon arabirimlerini desteklemek için öngörülen bir API'si olduğundan, API seçeneklerinizin C# veya Visual Basic ile C++/CX arasındaki farklara bağlı olarak farklılık gösterdiğini unutmayın.

ResourceDictionary ve yerelleştirme

XAML Kaynak Sözlüğü başlangıçta yerelleştirilecek dizeler içerebilir. Öyleyse, bu dizeleri ResourceDictionary yerine proje kaynakları olarak depolayın. Dizeleri XAML'nin dışına alın ve bunun yerine sahip olan öğeye bir x:Uid yönergesi değeri verin. Ardından, kaynak dosyasında bir kaynak tanımlayın. XUIDValuebiçiminde bir kaynak adı ve yerelleştirilmesi gereken dizenin kaynak değeri olarakPropertyName sağlayın.

Özel kaynak arama

Gelişmiş senaryolar için, bu konuda açıklanan XAML kaynak başvurusu arama davranışından farklı davranışlara sahip olabilecek bir sınıf uygulayabilirsiniz. Bunu yapmak için CustomXamlResourceLoader sınıfını uygularsınız ve ardından StaticResource veya ThemeResource kullanmak yerine kaynak başvuruları için CustomResource işaretleme uzantısını kullanarak bu davranışa erişebilirsiniz. Çoğu uygulamanın bunu gerektiren senaryoları olmaz. Daha fazla bilgi için bkz. CustomXamlResourceLoader.

İlgili konular

• KaynakSözlüğü
• XAML'ye genel bakış
• StaticResource işaretleme uzantısı
• ThemeResource işaretleme uzantısı
• XAML tema kaynakları
• Stil denetimleri
• x:Key özniteliği