ResourceContext Classe

Définition

Espace de noms:

Windows.ApplicationModel.Resources.Core

Encapsule tous les facteurs (ResourceQualifier) susceptibles d’affecter la sélection des ressources.

public ref class ResourceContext sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
class ResourceContext final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
public sealed class ResourceContext

function ResourceContext()

Public NotInheritable Class ResourceContext

Héritage

Object Platform::Object IInspectable ResourceContext

Attributs

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Configuration requise pour Windows

Famille d’appareils	Windows 10 (introduit dans 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduit dans v1.0)

Exemples

Cet exemple est basé sur le scénario 12 de l’exemple ressources d’application et de localisation. Consultez l’exemple pour obtenir la solution complète.

private async void Scenario12Button_Show_Click(object sender, RoutedEventArgs e)
{
    // Two coding patterns will be used:
    //   1. Get a ResourceContext on the UI thread using GetForCurrentView and pass 
    //      to the non-UI thread
    //   2. Get a ResourceContext on the non-UI thread using GetForViewIndependentUse
    //
    // Two analogous patterns could be used for ResourceLoader instead of ResourceContext.

    // pattern 1: get a ResourceContext for the UI thread
    ResourceContext defaultContextForUiThread = ResourceContext.GetForCurrentView();

    // pattern 2: we'll create a view-independent context in the non-UI worker thread

    // We need some things in order to display results in the UI (doing that
    // for purposes of this sample, to show that work was actually done in the
    // worker thread):
    List<string> uiDependentResourceList = new List<string>();
    List<string> uiIndependentResourceList = new List<string>();

    // use a worker thread for the heavy lifting so the UI isn't blocked
    await Windows.System.Threading.ThreadPool.RunAsync(
        (source) =>
        {
            ResourceMap stringResourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("Resources");

            // pattern 1: the defaultContextForUiThread variable was created above and is visible here

            // pattern 2: get a view-independent ResourceContext
            ResourceContext defaultViewIndependentResourceContext = ResourceContext.GetForViewIndependentUse();

            // NOTE: The ResourceContext obtained using GetForViewIndependentUse() has no scale qualifier
            // value set. If this ResourceContext is used in its default state to retrieve a resource, that 
            // will work provided that the resource does not have any scale-qualified variants. But if the
            // resource has any scale-qualified variants, then that will fail at runtime.
            //
            // A scale qualifier value on this ResourceContext can be set programmatically. If that is done,
            // then the ResourceContext can be used to retrieve a resource that has scale-qualified variants.
            // But if the scale qualifier is reset (e.g., using the ResourceContext.Reset() method), then
            // it will return to the default state with no scale qualifier value set, and cannot be used
            // to retrieve any resource that has scale-qualified variants.

            // simulate processing a number of items
            // just using a single string resource: that's sufficient to demonstrate 
            for (var i = 0; i < 4; i++)
            {
                // pattern 1: use the ResourceContext from the UI thread
                string listItem1 = stringResourceMap.GetValue("string1", defaultContextForUiThread).ValueAsString;
                uiDependentResourceList.Add(listItem1);

                // pattern 2: use the view-independent ResourceContext
                string listItem2 = stringResourceMap.GetValue("string1", defaultViewIndependentResourceContext).ValueAsString;
                uiIndependentResourceList.Add(listItem2);
            }
        });

    // Display the results in one go. (A more finessed design might add results
    // in the UI asynchronously, but that goes beyond what this sample is 
    // demonstrating.)
    ViewDependentResourcesList.ItemsSource = uiDependentResourceList;
    ViewIndependentResourcesList.ItemsSource = uiIndependentResourceList;
}

void Scenario12::Scenario12Button_Show_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    // Two coding patterns will be used:
    //   1. Get a ResourceContext on the UI thread using GetForCurrentView and pass 
    //      to the non-UI thread
    //   2. Get a ResourceContext on the non-UI thread using GetForViewIndependentUse
    //
    // Two analogous patterns could be used for ResourceLoader instead of ResourceContext.

    // pattern 1: get a ResourceContext for the UI thread
    ResourceContext^ defaultContextForUiThread = ResourceContext::GetForCurrentView();

    // pattern 2: we'll create a view-independent context in the non-UI worker thread

    // We need some things in order to display results in the UI (doing that
    // for purposes of this sample, to show that work was actually done in the
    // worker thread): a pair of vectors to capture data, and a pair of variable 
    // references to the controls where the results will be displayed (needed to
    // pass to the .then lambda).
    Platform::Collections::Vector<Platform::String^>^ uiDependentResourceItems = ref new Platform::Collections::Vector<Platform::String^>();
    Platform::Collections::Vector<Platform::String^>^ uiIndependentResourceItems = ref new Platform::Collections::Vector<Platform::String^>();
    ItemsControl^ viewDependentListControl = ViewDependentResourcesList;
    ItemsControl^ viewIndependentListControl = ViewIndependentResourcesList;


    // use a worker thread for the heavy lifting so the UI isn't blocked
    concurrency::create_task(
        Windows::System::Threading::ThreadPool::RunAsync(
            ref new Windows::System::Threading::WorkItemHandler(
            [defaultContextForUiThread, uiDependentResourceItems, uiIndependentResourceItems](Windows::Foundation::IAsyncAction^ /*action*/)
        {
            // This is happening asynchronously on a background worker thread,
            // not on the UI thread.
            ResourceMap^ stringResourceMap = ResourceManager::Current->MainResourceMap->GetSubtree("Resources");

            // coding pattern 1: the defaultContextForUiThread variable was created above and has been captured to use here

            // coding pattern 2: get a view-independent ResourceContext
            ResourceContext^ defaultViewIndependentResourceContext = ResourceContext::GetForViewIndependentUse();

            // NOTE: The ResourceContext obtained using GetForViewIndependentUse() has no scale qualifier
            // value set. If this ResourceContext is used in its default state to retrieve a resource, that 
            // will work provided that the resource does not have any scale-qualified variants. But if the
            // resource has any scale-qualified variants, then that will fail at runtime.
            //
            // A scale qualifier value on this ResourceContext can be set programmatically. If that is done,
            // then the ResourceContext can be used to retrieve a resource that has scale-qualified variants.
            // But if the scale qualifier is reset (e.g., using the ResourceContext::Reset() method), then
            // it will return to the default state with no scale qualifier value set, and cannot be used
            // to retrieve any resource that has scale-qualified variants.

            // simulate processing a number of items
            // just using a single string resource: that's sufficient to demonstrate 
            for (auto i = 0; i < 4; i++)
            {
                // pattern 1: use the ResourceContext from the UI thread
                Platform::String^ item1 = stringResourceMap->GetValue("string1", defaultContextForUiThread)->ValueAsString;
                uiDependentResourceItems->Append(item1);

                // pattern 2: use the view-independent ResourceContext
                Platform::String^ item2 = stringResourceMap->GetValue("string1", defaultViewIndependentResourceContext)->ValueAsString;
                uiIndependentResourceItems->Append(item2);
            }
        }))
    ).then([uiDependentResourceItems, uiIndependentResourceItems, viewDependentListControl, viewIndependentListControl]
    {
        // After the async work is complete, this will execute on the UI thread.

        // Display the results in one go. (A more finessed design might add results
        // in the UI asynchronously, but that goes beyond what this sample is 
        // demonstrating.)
        viewDependentListControl->ItemsSource = uiDependentResourceItems;
        viewIndependentListControl->ItemsSource = uiIndependentResourceItems;
    });
}

Remarques

Les ressources peuvent être sensibles à la mise à l’échelle, et différentes vues appartenant à une application peuvent s’afficher simultanément sur différents appareils d’affichage, qui peuvent utiliser différentes échelles. Pour cette raison, un ResourceContext est généralement associé à une vue spécifique et doit être obtenu à l’aide de GetForCurrentView. (Vous pouvez obtenir un ResourceContext indépendant de l’affichage à l’aide de GetForViewIndependentUse, mais notez que la fonctionnalité dépendante de la mise à l’échelle échoue si elle est appelée sur un ResourceContext qui n’est pas associé à une vue.)

Ne créez pas de instance de ResourceContext à l’aide du constructeur, car il est déconseillé et susceptible d’être supprimé dans une version ultérieure.

Sauf indication contraire, les méthodes de cette classe peuvent être appelées sur n’importe quel thread.

Historique des versions

Version de Windows	Version du SDK	Valeur ajoutée
1903	18362	GetForUIContext

Constructeurs

ResourceContext()

Crée un objet ResourceContext cloné. Notes Le constructeur ResourceContext peut être modifié ou indisponible pour les versions après Windows 8.1. Utilisez plutôt GetForCurrentView et Clone.

Propriétés

Languages	Obtient ou définit le qualificateur de langue pour ce contexte.
QualifierValues	Obtient une carte observable et accessible en écriture de tous les qualificateurs pris en charge, indexés par nom.

Méthodes

Clone()	Crée un clone de ce ResourceContext, avec des qualificateurs identiques.
CreateMatchingContext(IIterable<ResourceQualifier>)	Crée un ResourceContext qui correspond à un ensemble de qualificateurs fourni. Notes CreateMatchingContext peut être modifié ou indisponible pour les versions après Windows 8.1. Utilisez plutôt ResourceContext.GetForCurrentView.OverrideToMatch.
GetForCurrentView()	Obtient un ResourceContext par défaut associé à l’affichage actuel de l’application en cours d’exécution.
GetForUIContext(UIContext)	Obtient un ResourceContext par défaut associé au UIContext spécifié pour l’application en cours d’exécution.
GetForViewIndependentUse()	Obtient un ResourceContext par défaut non associé à aucune vue.
OverrideToMatch(IIterable<ResourceQualifier>)	Remplace les valeurs de qualificateur fournies par ce contexte pour correspondre à une liste spécifiée de ResourceQualifierrésolus. En règle générale, les resourceQualifierrésolus sont associés à une ressource qui a été recherchée précédemment.
Reset()	Réinitialise les valeurs remplacées pour tous les qualificateurs sur le instance ResourceContext donné.
Reset(IIterable<String>)	Réinitialise les valeurs remplacées pour les qualificateurs spécifiés sur le instance ResourceContext donné.
ResetGlobalQualifierValues()	Supprime les remplacements de qualificateur des contextes par défaut de toutes les vues de l’application.
ResetGlobalQualifierValues(IIterable<String>)	Supprime les remplacements de qualificateurs pour les qualificateurs spécifiés des contextes par défaut de tous les affichages de l’application.
SetGlobalQualifierValue(String, String)	Applique un remplacement de valeur de qualificateur unique aux contextes par défaut de toutes les vues de l’application actuelle.
SetGlobalQualifierValue(String, String, ResourceQualifierPersistence)	Applique un remplacement de valeur de qualificateur unique aux contextes par défaut de toutes les vues pour l’application actuelle et spécifie la persistance de la substitution.

Voir aussi

• ResourceQualifier
• Exemple de ressources d’application et de localisation