ResourceManager ResourceManager ResourceManager ResourceManager Class

Définition

Représente un gestionnaire de ressources qui facilite l'accès aux ressources spécifiques à une culture au moment de l'exécution.Represents a resource manager that provides convenient access to culture-specific resources at run time.

public ref class ResourceManager
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class ResourceManager
type ResourceManager = class
Public Class ResourceManager
Héritage
ResourceManagerResourceManagerResourceManagerResourceManager
Dérivé
Attributs

Exemples

L’exemple suivant montre comment utiliser une culture explicite et la culture d’interface utilisateur actuelle implicite pour obtenir des ressources de type chaîne à partir d’un assembly principal et d’un assembly satellite.The following example demonstrates how to use an explicit culture and the implicit current UI culture to obtain string resources from a main assembly and a satellite assembly. Pour plus d’informations, consultez la section « emplacements des répertoires pour les assemblys satellites non installés dans le global assembly cache » de la rubrique création d’assemblys satellites .For more information, see the "Directory Locations for Satellite Assemblies Not Installed in the Global Assembly Cache" section of the Creating Satellite Assemblies topic.

Pour exécuter cet exemple :To run this example:

  1. Dans le répertoire de l’application, créez un fichier nommé RMC. txt qui contient les chaînes de ressources suivantes :In the app directory, create a file named rmc.txt that contains the following resource strings:

    
    day=Friday  
    year=2006  
    holiday="Cinco de Mayo"  
    
    
  2. Utilisez le Générateur de fichiers de ressources pour générer le fichier de ressources RMC. Resources à partir du fichier d’entrée RMC. txt comme suit :Use the Resource File Generator to generate the rmc.resources resource file from the rmc.txt input file as follows:

    resgen rmc.txt  
    
  3. Créez un sous-répertoire du répertoire de l’application et nommez-le « es-MX ».Create a subdirectory of the app directory and name it "es-MX". Il s’agit du nom de culture de l’assembly satellite que vous allez créer au cours des trois étapes suivantes.This is the culture name of the satellite assembly that you will create in the next three steps.

  4. Créez un fichier nommé rmc.es-MX. txt dans le répertoire es-MX qui contient les chaînes de ressources suivantes :Create a file named rmc.es-MX.txt in the es-MX directory that contains the following resource strings:

    
    day=Viernes  
    year=2006  
    holiday="Cinco de Mayo"  
    
    
  5. Utilisez le Générateur de fichiers de ressources pour générer le fichier de ressources RMC.es-MX. Resources à partir du fichier d’entrée RMC.es-MX. txt comme suit :Use the Resource File Generator to generate the rmc.es-MX.resources resource file from the rmc.es-MX.txt input file as follows:

    resgen rmc.es-MX.txt  
    
  6. Supposons que le nom de fichier de cet exemple soit RMC. vb ou rmc.cs.Assume that the filename for this example is rmc.vb or rmc.cs. Copiez le code source suivant dans un fichier.Copy the following source code into a file. Puis compilez-la et incorporez le fichier de ressources de l’assembly principal, RMC. Resources, dans l’assembly exécutable.Then compile it and embed the main assembly resource file, rmc.resources, in the executable assembly. Si vous utilisez le compilateur Visual Basic, la syntaxe est la suivante :If you are using the Visual Basic compiler, the syntax is:

    vbc rmc.vb /resource:rmc.resources  
    

    La syntaxe correspondante pour le C# compilateur est la suivante :The corresponding syntax for the C# compiler is:

    csc /resource:rmc.resources rmc.cs  
    
  7. Utilisez Assembly Linker pour créer un assembly satellite.Use the Assembly Linker to create a satellite assembly. Si le nom de base de l’application est RMC, le nom de l’assembly satellite doit être RMC. resources. dll.If the base name of the app is rmc, the satellite assembly name must be rmc.resources.dll. L’assembly satellite doit être créé dans le répertoire es-MX.The satellite assembly should be created in the es-MX directory. Si es-MX est le répertoire actif, utilisez la commande suivante :If es-MX is the current directory, use this command:

    al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dll   
    
  8. Exécutez RMC. exe pour obtenir et afficher les chaînes de ressources incorporées.Run rmc.exe to obtain and display the embedded resource strings.

using System;
using System.Resources;
using System.Reflection;
using System.Threading;
using System.Globalization;

class Example 
{
    public static void Main() 
    {
    string day;
    string year;
    string holiday;
    string celebrate = "{0} will occur on {1} in {2}.\n";

    // Create a resource manager. 
    ResourceManager rm = new ResourceManager("rmc", 
                             typeof(Example).Assembly);

    Console.WriteLine("Obtain resources using the current UI culture.");

    // Get the resource strings for the day, year, and holiday 
    // using the current UI culture. 
    day  = rm.GetString("day");
    year = rm.GetString("year");
    holiday = rm.GetString("holiday");
    Console.WriteLine(celebrate, holiday, day, year);

    // Obtain the es-MX culture.
    CultureInfo ci = new CultureInfo("es-MX");

    Console.WriteLine("Obtain resources using the es-MX culture.");

   // Get the resource strings for the day, year, and holiday 
   // using the specified culture. 
    day  = rm.GetString("day", ci);
    year = rm.GetString("year", ci);
    holiday = rm.GetString("holiday", ci);
// ---------------------------------------------------------------
// Alternatively, comment the preceding 3 code statements and 
// uncomment the following 4 code statements:
// ----------------------------------------------------------------
// Set the current UI culture to "es-MX" (Spanish-Mexico).
//    Thread.CurrentThread.CurrentUICulture = ci;

// Get the resource strings for the day, year, and holiday 
// using the current UI culture. Use those strings to 
// display a message. 
//    day  = rm.GetString("day");
//    year = rm.GetString("year");
//    holiday = rm.GetString("holiday");
// ---------------------------------------------------------------

// Regardless of the alternative that you choose, display a message 
// using the retrieved resource strings.
    Console.WriteLine(celebrate, holiday, day, year);
    }
}
/*
This example displays the following output:

   Obtain resources using the current UI culture.
   "5th of May" will occur on Friday in 2006.
   
   Obtain resources using the es-MX culture.
   "Cinco de Mayo" will occur on Viernes in 2006.
*/
Imports System.Resources
Imports System.Reflection
Imports System.Threading
Imports System.Globalization

Class Example
    Public Shared Sub Main() 
        Dim day As String
        Dim year As String
        Dim holiday As String
        Dim celebrate As String = "{0} will occur on {1} in {2}." & vbCrLf

        ' Create a resource manager. 
        Dim rm As New ResourceManager("rmc", GetType(Example).Assembly)

        Console.WriteLine("Obtain resources using the current UI culture.")

        ' Get the resource strings for the day, year, and holiday 
        ' using the current UI culture. 
        day = rm.GetString("day")
        year = rm.GetString("year")
        holiday = rm.GetString("holiday")
        Console.WriteLine(celebrate, holiday, day, year)

        ' Obtain the es-MX culture.
        Dim ci As New CultureInfo("es-MX")

        Console.WriteLine("Obtain resources using the es-MX culture.")

        ' Get the resource strings for the day, year, and holiday 
        ' using the es-MX culture.  
        day = rm.GetString("day", ci)
        year = rm.GetString("year", ci)
        holiday = rm.GetString("holiday", ci)

        ' ---------------------------------------------------------------
        ' Alternatively, comment the preceding 3 code statements and 
        ' uncomment the following 4 code statements:
        ' ----------------------------------------------------------------
        ' Set the current UI culture to "es-MX" (Spanish-Mexico).
        '    Thread.CurrentThread.CurrentUICulture = ci
        ' Get the resource strings for the day, year, and holiday 
        ' using the current UI culture. 
        '    day  = rm.GetString("day")
        '    year = rm.GetString("year")
        '    holiday = rm.GetString("holiday")
        ' ---------------------------------------------------------------

        ' Regardless of the alternative that you choose, display a message 
        ' using the retrieved resource strings.
        Console.WriteLine(celebrate, holiday, day, year)
    End Sub 
End Class
' This example displays the following output:
'Obtain resources using the current UI culture.
'"5th of May" will occur on Friday in 2006.
'
'Obtain resources using the es-MX culture.
'"Cinco de Mayo" will occur on Viernes in 2006.

Remarques

Important

L’appel de méthodes de cette classe avec des données non approuvées est un risque de sécurité.Calling methods from this class with untrusted data is a security risk. Appelez les méthodes de cette classe avec des données approuvées uniquement.Call the methods from this class only with trusted data. Pour plus d’informations, consultez Validation des données.For more information, see Data Validation.

La ResourceManager classe récupère les ressources d’un fichier. Resources binaire incorporé dans un assembly ou à partir d’un fichier. Resources autonome.The ResourceManager class retrieves resources from a binary .resources file that is embedded in an assembly or from a standalone .resources file. Si une application a été localisée et que des ressources localisées ont été déployées dans des assemblys satellites, elle recherche des ressources spécifiques à la culture, fournit une ressource de secours lorsqu’une ressource localisée n’existe pas et prend en charge la sérialisation des ressources.If an app has been localized and localized resources have been deployed in satellite assemblies, it looks up culture-specific resources, provides resource fallback when a localized resource does not exist, and supports resource serialization.

Pour plus d’informations sur la création et la gestion des ressources Windows 8.x StoreWindows 8.x Store dans les applications de bureau et les applications, consultez les sections suivantes :For more information about creating and managing resources in desktop apps and Windows 8.x StoreWindows 8.x Store apps, see the following sections:

Applications de bureauDesktop Apps

Pour les applications de bureau ResourceManager , la classe récupère les ressources des fichiers de ressources binaires (. Resources).For desktop apps, the ResourceManager class retrieves resources from binary resource (.resources) files. En règle générale, un compilateur de langage ou Assembly Linker (al. exe) incorpore ces fichiers de ressources dans un assembly.Typically, a language compiler or the Assembly Linker (AL.exe) embeds these resource files in an assembly. Vous pouvez également utiliser un ResourceManager objet pour récupérer des ressources directement à partir d’un fichier. Resources qui n’est pas incorporé CreateFileBasedResourceManager dans un assembly, en appelant la méthode.You can also use a ResourceManager object to retrieve resources directly from a .resources file that is not embedded in an assembly, by calling the CreateFileBasedResourceManager method.

Attention

L’utilisation de fichiers. Resources autonomes dans une application ASP.net interrompt le déploiement de xcopy, car les ressources restent verrouillées jusqu’à ce qu’elles soient explicitement libérées par la ReleaseAllResources méthode.Using standalone .resources files in an ASP.NET app will break XCOPY deployment, because the resources remain locked until they are explicitly released by the ReleaseAllResources method. Si vous souhaitez déployer des ressources avec vos applications ASP.NET, vous devez compiler vos fichiers. Resources en assemblys satellites.If you want to deploy resources with your ASP.NET apps, you should compile your .resources files into satellite assemblies.

Dans une application basée sur les ressources, un fichier. Resources contient les ressources de la culture par défaut dont les ressources sont utilisées si aucune ressource spécifique de la culture ne peut être trouvée.In a resource-based app, one .resources file contains the resources of the default culture whose resources are used if no culture-specific resources can be found. Par exemple, si la culture par défaut d’une application est l’anglais (en), les ressources en langue anglaise sont utilisées chaque fois que les ressources localisées sont introuvables pour une culture spécifique, comme l’anglais (États-Unis) (en-US) ou français (France) (fr-FR).For example, if an app's default culture is English (en), the English language resources are used whenever localized resources cannot be found for a specific culture, such as English (United States) (en-US) or French (France) (fr-FR). En règle générale, les ressources pour la culture par défaut sont incorporées dans l’assembly d’application principal, et les ressources pour d’autres cultures localisées sont incorporées dans les assemblys satellites.Typically, the resources for the default culture are embedded in the main app assembly, and resources for other localized cultures are embedded in satellite assemblies. Les assemblys satellites contiennent uniquement des ressources.Satellite assemblies contain only resources. Ils ont le même nom de fichier racine que l’assembly principal et une extension. resources. dll.They have the same root file name as the main assembly and an extension of .resources.dll. Pour les applications dont les assemblys ne sont pas inscrits dans le Global Assembly Cache, les assemblys satellites sont stockés dans un sous-répertoire d’application dont le nom correspond à la culture de l’assembly.For apps whose assemblies are not registered in the global assembly cache, satellite assemblies are stored in an app subdirectory whose name corresponds to the assembly's culture.

Création de ressourcesCreating Resources

Lorsque vous développez une application basée sur les ressources, vous stockez des informations sur les ressources dans des fichiers texte (fichiers qui ont une extension. txt ou. restext) ou des fichiers XML (fichiers dotés de l’extension. resx).When you develop a resource-based app, you store resource information in text files (files that have a .txt or .restext extension) or XML files (files that have a .resx extension). Vous compilez ensuite le texte ou les fichiers XML avec le Générateur de fichiers de ressources (Resgen. exe) pour créer un fichier. Resources binaire.You then compile the text or XML files with the Resource File Generator (Resgen.exe) to create a binary .resources file. Vous pouvez ensuite incorporer le fichier. Resources résultant dans un exécutable ou une bibliothèque à l’aide d' /resources une option C# du compilateur, par exemple pour les compilateurs et Visual Basic, ou vous pouvez l’incorporer dans un assembly satellite à l’aide de.You can then embed the resulting .resources file in an executable or library by using a compiler option such as /resources for the C# and Visual Basic compilers, or you can embed it in a satellite assembly by using the . Si vous incluez un fichier. resx dans votre projet Visual Studio, Visual Studio gère automatiquement la compilation et l’incorporation des ressources par défaut et localisées dans le cadre du processus de génération.If you include a .resx file in your Visual Studio project, Visual Studio handles the compilation and embedding of default and localized resources automatically as part of the build process.

Dans l’idéal, vous devez créer des ressources pour chaque langue prise en charge par votre application, ou au moins pour un sous-ensemble significatif de chaque langue.Ideally, you should create resources for every language your app supports, or at least for a meaningful subset of each language. Les noms de fichiers. resources binaires suivent la Convention d’affectation de noms BaseName. cultureName. Resources, où BaseName est le nom de l’application ou le nom d’une classe, selon le niveau de détail souhaité.The binary .resources file names follow the naming convention basename.cultureName.resources, where basename is the name of the app or the name of a class, depending on the level of detail you want. La CultureInfo.Name propriété est utilisée pour déterminer le cultureName.The CultureInfo.Name property is used to determine cultureName. Une ressource pour la culture par défaut de l’application doit être nommée BaseName. resources.A resource for the app's default culture should be named basename.resources.

Par exemple, supposons qu’un assembly possède plusieurs ressources dans un fichier de ressources qui porte le nom de base MyResources.For example, suppose that an assembly has several resources in a resource file that has the base name MyResources. Ces fichiers de ressources doivent avoir des noms tels que MyResources. ja-JP. Resources pour la culture japonaise (japonaise), MyResources. de. Resources pour la culture allemande, MyResources. zh-CHS. Resources pour la culture chinois simplifié, et MyResources.fr-est. Resources pour la culture français (Belgique).These resource files should have names such as MyResources.ja-JP.resources for the Japan (Japanese) culture, MyResources.de.resources for the German culture, MyResources.zh-CHS.resources for the simplified Chinese culture, and MyResources.fr-BE.resources for the French (Belgium) culture. Le fichier de ressources par défaut doit être nommé MyResources. resources.The default resource file should be named MyResources.resources. Les fichiers de ressources spécifiques à la culture sont généralement empaquetés dans des assemblys satellites pour chaque culture.The culture-specific resource files are commonly packaged in satellite assemblies for each culture. Le fichier de ressources par défaut doit être incorporé dans l’assembly principal de l’application.The default resource file should be embedded in the app's main assembly.

Notez que Assembly Linker permet aux ressources d’être marquées comme privées, mais vous devez toujours les marquer comme étant publiques afin qu’elles soient accessibles aux autres assemblys.Note that Assembly Linker allows resources to be marked as private, but you should always mark them as public so they can be accessed by other assemblies. (Étant donné qu’un assembly satellite ne contient pas de code, les ressources marquées comme privées ne sont pas disponibles pour votre application via un mécanisme quelconque.)(Because a satellite assembly contains no code, resources that are marked as private are unavailable to your app through any mechanism.)

Pour plus d’informations sur la création, l’empaquetage et le déploiement de ressources, consultez les articles création de fichiers de ressources, création d' assemblys satelliteset empaquetage et déploiement de ressources.For more information about creating, packaging, and deploying resources, see the articles Creating Resource Files, Creating Satellite Assemblies, and Packaging and Deploying Resources.

Instanciation d’un objet ResourceManagerInstantiating a ResourceManager Object

Vous instanciez ResourceManager un objet qui récupère des ressources à partir d’un fichier. Resources incorporé en appelant l’une de ses surcharges de constructeur de classe.You instantiate a ResourceManager object that retrieves resources from an embedded .resources file by calling one of its class constructor overloads. Cela couple étroitement un ResourceManager objet à un fichier. Resources particulier et à tous les fichiers. Resources localisés associés dans les assemblys satellites.This tightly couples a ResourceManager object with a particular .resources file and with any associated localized .resources files in satellite assemblies.

Les deux constructeurs les plus couramment appelés sont :The two most commonly called constructors are:

  • ResourceManager(String, Assembly)recherche des ressources en fonction de deux éléments d’informations que vous fournissez : le nom de base du fichier. Resources et l’assembly dans lequel réside le fichier. resources par défaut.ResourceManager(String, Assembly) looks up resources based on two pieces of information that you supply: the base name of the .resources file, and the assembly in which the default .resources file resides. Le nom de base comprend l’espace de noms et le nom racine du fichier. Resources, sans sa culture ou son extension.The base name includes the namespace and root name of the .resources file, without its culture or extension. Notez que les fichiers. Resources compilés à partir de la ligne de commande n’incluent généralement pas de nom d’espace de noms, contrairement aux fichiers. Resources créés dans l’environnement Visual Studio.Note that .resources files that are compiled from the command line typically do not include a namespace name, whereas .resources files that are created in the Visual Studio environment do. Par exemple, si un fichier de ressources est nommé MyCompany. StringResources. Resources et que le ResourceManager constructeur est appelé à partir d’une méthode statique nommée Example.Main, ResourceManager le code suivant instancie un objet qui peut récupérer des ressources à partir de. fichier de ressources :For example, if a resource file is named MyCompany.StringResources.resources and the ResourceManager constructor is called from a static method named Example.Main, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager("MyCompany.StringResources", 
                                             typeof(Example).Assembly);
    
    Dim rm As New ResourceManager("MyCompany.StringResources",
                                  GetType(Example).Assembly)
    
  • ResourceManager(Type)recherche des ressources dans les assemblys satellites en fonction des informations d’un objet de type.ResourceManager(Type) looks up resources in satellite assemblies based on information from a type object. Le nom qualifié complet du type correspond au nom de base du fichier. Resources sans son extension de nom de fichier.The type's fully qualified name corresponds to the base name of the .resources file without its file name extension. Dans les applications de bureau créées à l’aide du concepteur de ressources de Visual Studio, Visual Studio crée une classe wrapper dont le nom qualifié complet est le même que le nom racine du fichier. resources.In desktop apps that are created by using the Visual Studio Resource Designer, Visual Studio creates a wrapper class whose fully qualified name is the same as the root name of the .resources file. Par exemple, si un fichier de ressources est nommé MyCompany. StringResources. Resources et qu’il existe MyCompany.StringResourcesune classe wrapper nommée, le code ResourceManager suivant instancie un objet qui peut récupérer des ressources à partir du fichier. Resources :For example, if a resource file is named MyCompany.StringResources.resources and there is a wrapper class named MyCompany.StringResources, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));
    
    Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
    

Si les ressources appropriées sont introuvables, l’appel de constructeur crée ResourceManager un objet valide.If the appropriate resources cannot be found, the constructor call creates a valid ResourceManager object. Toutefois, la tentative de récupération d’une ressource lève une MissingManifestResourceException exception.However, the attempt to retrieve a resource throws a MissingManifestResourceException exception. Pour plus d’informations sur le traitement de l’exception, consultez la section gestion des exceptions MissingManifestResourceException et MissingSatelliteAssembly plus loin dans cet article.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssembly Exceptions section later in this article.

L’exemple suivant montre comment instancier un ResourceManager objet.The following example shows how to instantiate a ResourceManager object. Il contient le code source d’un exécutable nommé ShowTime. exe.It contains the source code for an executable named ShowTime.exe. Il inclut également le fichier texte suivant nommé Strings. txt qui contient une seule ressource TimeHeaderde type chaîne :It also includes the following text file named Strings.txt that contains a single string resource, TimeHeader:

TimeHeader=The current time is  

Vous pouvez utiliser un fichier de commandes pour générer le fichier de ressources et l’incorporer dans l’exécutable.You can use a batch file to generate the resource file and embed it into the executable. Voici le fichier de commandes pour générer un exécutable à l’aide du C# compilateur :Here's the batch file to generate an executable by using the C# compiler:

  
resgen strings.txt  
csc ShowTime.cs /resource:strings.resources  
  

Pour le compilateur Visual Basic, vous pouvez utiliser le fichier de commandes suivant :For the Visual Basic compiler, you can use the following batch file:

  
resgen strings.txt  
vbc ShowTime.vb /resource:strings.resources  
  
using System;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("Strings", 
                               typeof(Example).Assembly);
      string timeString = rm.GetString("TimeHeader");
      Console.WriteLine("{0} {1:T}", timeString, DateTime.Now);   
   }
}
// The example displays output like the following:
//        The current time is 2:03:14 PM
Imports System.Resources

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("Strings", GetType(Example).Assembly)
      Dim timeString As String = rm.GetString("TimeHeader")
      Console.WriteLine("{0} {1:T}", timeString, Date.Now)   
   End Sub
End Module
' The example displays output similar to the following:
'       The current time is 2:03:14 PM

Ressources spécifiques à ResourceManager et à la cultureResourceManager and Culture-Specific Resources

Une application localisée requiert le déploiement des ressources, comme indiqué dans l’article empaquetage et déploiement de ressources.A localized app requires resources to be deployed, as discussed in the article Packaging and Deploying Resources. Si les assemblys sont correctement configurés, le gestionnaire des ressources détermine les ressources à récupérer en fonction de la Thread.CurrentUICulture propriété du thread actuel.If the assemblies are properly configured, the resource manager determines which resources to retrieve based on the current thread's Thread.CurrentUICulture property. (Cette propriété retourne également la culture d’interface utilisateur du thread actuel.) Par exemple, si une application est compilée avec les ressources de langue anglaise par défaut dans l’assembly principal et avec les ressources de langue française et russe Thread.CurrentUICulture dans deux assemblys satellites, et si la propriété est définie sur fr-fr, le gestionnaire des ressources récupère le français. situées.(That property also returns the current thread's UI culture.) For example, if an app is compiled with default English language resources in the main assembly and with French and Russian language resources in two satellite assemblies, and the Thread.CurrentUICulture property is set to fr-FR, the resource manager retrieves the French resources.

Vous pouvez définir la CurrentUICulture propriété explicitement ou implicitement.You can set the CurrentUICulture property explicitly or implicitly. La façon dont vous le définissez détermine la ResourceManager façon dont l’objet récupère les ressources en fonction de la culture :The way you set it determines how the ResourceManager object retrieves resources based on culture:

  • Si vous définissez explicitement la Thread.CurrentUICulture propriété sur une culture spécifique, le gestionnaire des ressources récupère toujours les ressources pour cette culture, quel que soit le navigateur ou la langue du système d’exploitation de l’utilisateur.If you explicitly set the Thread.CurrentUICulture property to a specific culture, the resource manager always retrieves the resources for that culture, regardless of the user's browser or operating system language. Prenons l’exemple d’une application compilée avec des ressources en langue anglaise par défaut et de trois assemblys satellites contenant des ressources pour l’anglais (États-Unis), le français (France) et le russe (Russie).Consider an app that is compiled with default English language resources and three satellite assemblies that contain resources for English (United States), French (France), and Russian (Russia). Si la CurrentUICulture propriété a la valeur fr-fr, l' ResourceManager objet récupère toujours les ressources françaises (France), même si la langue du système d’exploitation de l’utilisateur n’est pas le français.If the CurrentUICulture property is set to fr-FR, the ResourceManager object always retrieves the French (France) resources, even if the user's operating system language is not French. Assurez-vous qu’il s’agit du comportement souhaité avant de définir la propriété explicitement.Make sure that this is the desired behavior before you set the property explicitly.

    Dans les applications ASP.net, vous devez définir Thread.CurrentUICulture explicitement la propriété, car il est peu probable que le paramètre sur le serveur corresponde aux demandes entrantes des clients.In ASP.NET apps, you must set the Thread.CurrentUICulture property explicitly, because it is unlikely that the setting on the server will match incoming client requests. Une application ASP.net peut définir la Thread.CurrentUICulture propriété explicitement sur la langue acceptée par le navigateur de l’utilisateur.An ASP.NET app can set the Thread.CurrentUICulture property explicitly to the user's browser accept language.

    La définition explicite Thread.CurrentUICulture de la propriété définit la culture d’interface utilisateur actuelle pour ce thread.Explicitly setting the Thread.CurrentUICulture property defines the current UI culture for that thread. Elle n’affecte pas la culture d’interface utilisateur actuelle de tous les autres threads dans une application.It does not affect the current UI culture of any other threads in an app.

  • Vous pouvez définir la culture d’interface utilisateur de tous les threads dans un domaine d' CultureInfo application en affectant à la propriété statique CultureInfo.DefaultThreadCurrentUICulture un objet qui représente cette culture.You can set the UI culture of all threads in an app domain by assigning a CultureInfo object that represents that culture to the static CultureInfo.DefaultThreadCurrentUICulture property.

  • Si vous ne définissez pas explicitement la culture d’interface utilisateur actuelle et que vous ne définissez pas de culture par défaut pour le domaine CultureInfo.CurrentUICulture d’application actuel, la propriété est définie GetUserDefaultUILanguage implicitement par la fonction Windows.If you do not explicitly set the current UI culture and you do not define a default culture for the current app domain, the CultureInfo.CurrentUICulture property is set implicitly by the Windows GetUserDefaultUILanguage function. Cette fonction est fournie par l’interface utilisateur multilingue (MUI), qui permet à l’utilisateur de définir la langue par défaut.This function is provided by the Multilingual User Interface (MUI), which enables the user to set the default language. Si la langue de l’interface utilisateur n’est pas définie par l’utilisateur, elle prend par défaut la langue installée par le système, qui est la langue des ressources du système d’exploitation.If the UI language is not set by the user, it defaults to the system-installed language, which is the language of operating system resources.

L’exemple « Hello World » simple suivant définit la culture d’interface utilisateur actuelle explicitement.The following simple "Hello world" example sets the current UI culture explicitly. Il contient des ressources pour trois cultures : Anglais (États-Unis) ou en-US, français (France) ou fr-FR et russe (Russie) ou ru-RU.It contains resources for three cultures: English (United States) or en-US, French (France) or fr-FR, and Russian (Russia) or ru-RU. Les ressources en-US sont contenues dans un fichier texte nommé Greetings. txt :The en-US resources are contained in a text file named Greetings.txt:

HelloString=Hello world!  

Les ressources fr-FR sont contenues dans un fichier texte nommé Greetings.fr Strings.fr. txt :The fr-FR resources are contained in a text file named Greetings.fr-FR.txt:

HelloString=Salut tout le monde!  

Les ressources ru-RU sont contenues dans un fichier texte nommé Greetings.ru Strings.ru. txt :The ru-RU resources are contained in a text file named Greetings.ru-RU.txt:

HelloString=Всем привет!  

Voici le code source de l’exemple (exemple. vb pour la version Visual Basic ou Example.cs pour la C# version) :Here's the source code for the example (Example.vb for the Visual Basic version or Example.cs for the C# version):

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Create array of supported cultures
      string[] cultures = {"en-CA", "en-US", "fr-FR", "ru-RU" };
      Random rnd = new Random();
      int cultureNdx = rnd.Next(0, cultures.Length);
      CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
      ResourceManager rm = new ResourceManager("Greetings", typeof(Example).Assembly);
      try {
         CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
         Thread.CurrentThread.CurrentCulture = newCulture;
         Thread.CurrentThread.CurrentUICulture = newCulture;
         string greeting = String.Format("The current culture is {0}.\n{1}",
                                         Thread.CurrentThread.CurrentUICulture.Name,
                                         rm.GetString("HelloString"));
         Console.WriteLine(greeting);
      }
      catch (CultureNotFoundException e) {
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName);
      }
      finally {
         Thread.CurrentThread.CurrentCulture = originalCulture;
         Thread.CurrentThread.CurrentUICulture = originalCulture;
      }
   }
}
// The example displays output like the following:
//       The current culture is ru-RU.
//       Всем привет!
Imports System.Globalization
Imports System.Resources
Imports System.Threading

Module Example
   Sub Main()
      ' Create array of supported cultures
      Dim cultures() As String = {"en-CA", "en-US", "fr-FR", "ru-RU" }
      Dim rnd As New Random()
      Dim cultureNdx As Integer = rnd.Next(0, cultures.Length)
      Dim originalCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      Dim rm As New ResourceManager("Greetings", GetType(Example).Assembly)
      Try
         Dim newCulture As New CultureInfo(cultures(cultureNdx))
         Thread.CurrentThread.CurrentCulture = newCulture
         Thread.CurrentThread.CurrentUICulture = newCulture
         Dim greeting As String = String.Format("The current culture is {0}.{1}{2}",
                                                Thread.CurrentThread.CurrentUICulture.Name,
                                                vbCrLf, rm.GetString("HelloString"))

         Console.WriteLine(greeting)
      Catch e As CultureNotFoundException
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName)
      Finally
         Thread.CurrentThread.CurrentCulture = originalCulture
         Thread.CurrentThread.CurrentUICulture = originalCulture
      End Try
   End Sub
End Module
' The example displays output like the following:
'       The current culture is ru-RU.
'       Всем привет!

Pour compiler cet exemple, créez un fichier de commandes (. bat) qui contient les commandes suivantes et exécutez-le à partir de l’invite de commandes.To compile this example, create a batch (.bat) file that contains the following commands and run it from the command prompt. Si vous utilisez, C#spécifiez csc à la vbc place Example.cs de et Example.vbau lieu de.If you're using C#, specify csc instead of vbc and Example.cs instead of Example.vb.

resgen Greetings.txt   
vbc Example.vb /resource:Greetings.resources  
  
resgen Greetings.fr-FR.txt  
Md fr-FR  
al /embed:Greetings.fr-FR.resources /culture:fr-FR /out:fr-FR\Example.resources.dll  
  
resgen Greetings.ru-RU.txt  
Md ru-RU  
al /embed:Greetings.ru-RU.resources /culture:ru-RU /out:ru-RU\Example.resources.dll  

Récupération de ressourcesRetrieving Resources

Vous appelez les GetObject(String) méthodes GetString(String) et pour accéder à une ressource spécifique.You call the GetObject(String) and GetString(String) methods to access a specific resource. Vous pouvez également appeler la GetStream(String) méthode pour récupérer des ressources qui ne sont pas des chaînes en tant que tableau d’octets.You can also call the GetStream(String) method to retrieve non-string resources as a byte array. Par défaut, dans une application qui a des ressources localisées, ces méthodes retournent la ressource pour la culture déterminée par la culture d’interface utilisateur actuelle du thread qui a effectué l’appel.By default, in an app that has localized resources, these methods return the resource for the culture determined by the current UI culture of the thread that made the call. Pour plus d’informations sur la façon dont la culture d’interface utilisateur actuelle d’un thread est définie, consultez la section précédente, ResourceManager et les ressources spécifiquesà la culture.See the previous section, ResourceManager and Culture-Specific Resources, for more information about how the current UI culture of a thread is defined. Si le gestionnaire de ressources ne peut pas trouver la ressource pour la culture d’interface utilisateur du thread actuel, il utilise un processus de secours pour récupérer la ressource spécifiée.If the resource manager cannot find the resource for the current thread's UI culture, it uses a fallback process to retrieve the specified resource. Si le gestionnaire de ressources ne peut pas trouver de ressources localisées, il utilise les ressources de la culture par défaut.If the resource manager cannot find any localized resources, it uses the resources of the default culture. Pour plus d’informations sur les règles de secours pour les ressources, consultez la section « processus de secours pour les ressources » de l’article empaquetage et déploiement de ressources.For more information about resource fallback rules, see the "Resource Fallback Process" section of the article Packaging and Deploying Resources.

Notes

Si le fichier. Resources spécifié ResourceManager dans le constructeur de classe est introuvable, la tentative de récupération d' MissingManifestResourceException une MissingSatelliteAssemblyException ressource lève une exception ou.If the .resources file specified in the ResourceManager class constructor cannot be found, the attempt to retrieve a resource throws a MissingManifestResourceException or MissingSatelliteAssemblyException exception. Pour plus d’informations sur la gestion de l’exception, consultez la section gestion des exceptions MissingManifestResourceException et MissingSatelliteAssemblyException plus loin dans cette rubrique.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions section later in this topic.

L’exemple suivant utilise la GetString méthode pour récupérer des ressources spécifiques à la culture.The following example uses the GetString method to retrieve culture-specific resources. Il se compose de ressources compilées à partir de fichiers. txt pour les cultures anglais (en), français (France) (fr-FR) et russe (Espagne).It consists of resources compiled from .txt files for the English (en), French (France) (fr-FR), and Russian (Russia) (ru-RU) cultures. L’exemple modifie la culture actuelle et la culture d’interface utilisateur actuelle en anglais (États-Unis), français (France), russe (Russie) et suédois (Suède).The example changes the current culture and current UI culture to English (United States), French (France), Russian (Russia), and Swedish (Sweden). Elle appelle ensuite la GetString méthode pour récupérer la chaîne localisée, qu’elle affiche avec le jour et le mois actuels.It then calls the GetString method to retrieve the localized string, which it displays along with the current day and month. Notez que la sortie affiche la chaîne localisée appropriée, sauf lorsque la culture d’interface utilisateur actuelle est suédoise (Suède).Notice that the output displays the appropriate localized string except when the current UI culture is Swedish (Sweden). Étant donné que les ressources de langue suédoise ne sont pas disponibles, l’application utilise à la place les ressources de la culture par défaut, qui est l’anglais.Because Swedish language resources are unavailable, the app instead uses the resources of the default culture, which is English.

L’exemple requiert les fichiers de ressources textuels listés dans le tableau suivant.The example requires the text-based resource files listed in following table. Chaque a une seule ressource de chaîne DateStartnommée.Each has a single string resource named DateStart.

cultureCulture Nom de fichierFile name Nom de la ressourceResource name Valeur de la ressourceResource value
en-USen-US DateStrings.txtDateStrings.txt DateStart Aujourd’huiToday is
fr-FRfr-FR DateStrings.fr-FR.txtDateStrings.fr-FR.txt DateStart Aujourd’hui, c’est leAujourd'hui, c'est le
ru-RUru-RU DateStrings.ru Strings.ru. txtDateStrings.ru-RU.txt DateStart СегодняСегодня

Voici le code source de l’exemple (ShowDate. vb pour la version Visual Basic ou ShowDate.cs pour la C# version du code).Here's the source code for the example (ShowDate.vb for the Visual Basic version or ShowDate.cs for the C# version of the code).

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

[assembly:NeutralResourcesLanguage("en")]

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "ru-RU", "sv-SE" };
      ResourceManager rm = new ResourceManager("DateStrings",
                                               typeof(Example).Assembly);
      
      foreach (var cultureName in cultureNames) {
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Thread.CurrentThread.CurrentCulture = culture; 
         Thread.CurrentThread.CurrentUICulture = culture;

         Console.WriteLine("Current UI Culture: {0}", 
                           CultureInfo.CurrentUICulture.Name);
         string dateString = rm.GetString("DateStart");
         Console.WriteLine("{0} {1:M}.\n", dateString, DateTime.Now);                           
      }                                           
   }
}
// The example displays output similar to the following:
//       Current UI Culture: en-US
//       Today is February 03.
//       
//       Current UI Culture: fr-FR
//       Aujourd'hui, c'est le 3 février
//       
//       Current UI Culture: ru-RU
//       Сегодня февраля 03.
//       
//       Current UI Culture: sv-SE
//       Today is den 3 februari.
Imports System.Globalization
Imports System.Resources
Imports System.Threading

<Assembly:NeutralResourcesLanguage("en")>

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "ru-RU", "sv-SE" }
      Dim rm As New ResourceManager("DateStrings",
                                    GetType(Example).Assembly)
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Thread.CurrentThread.CurrentCulture = culture 
         Thread.CurrentThread.CurrentUICulture = culture

         Console.WriteLine("Current UI Culture: {0}", 
                           CultureInfo.CurrentUICulture.Name)
         Dim dateString As String = rm.GetString("DateStart")
         Console.WriteLine("{0} {1:M}.", dateString, Date.Now)                           
         Console.WriteLine()
      Next                                           
   End Sub
End Module
' The example displays output similar to the following:
'       Current UI Culture: en-US
'       Today is February 03.
'       
'       Current UI Culture: fr-FR
'       Aujourd'hui, c'est le 3 février
'       
'       Current UI Culture: ru-RU
'       Сегодня февраля 03.
'       
'       Current UI Culture: sv-SE
'       Today is den 3 februari.

Pour compiler cet exemple, créez un fichier de commandes qui contient les commandes suivantes et exécutez-le à partir de l’invite de commandes.To compile this example, create a batch file that contains the following commands and run it from the command prompt. Si vous utilisez, C#spécifiez csc à la vbc place showdate.cs de et showdate.vbau lieu de.If you're using C#, specify csc instead of vbc and showdate.cs instead of showdate.vb.

  
resgen DateStrings.txt  
vbc showdate.vb /resource:DateStrings.resources  
  
md fr-FR  
resgen DateStrings.fr-FR.txt  
al /out:fr-FR\Showdate.resources.dll /culture:fr-FR /embed:DateStrings.fr-FR.resources   
  
md ru-RU  
resgen DateStrings.ru-RU.txt  
al /out:ru-RU\Showdate.resources.dll /culture:ru-RU /embed:DateStrings.ru-RU.resources  
  

Il existe deux façons de récupérer les ressources d’une culture spécifique autre que la culture d’interface utilisateur actuelle :There are two ways to retrieve the resources of a specific culture other than the current UI culture:

  • Vous pouvez appeler la GetString(String, CultureInfo)méthode GetObject(String, CultureInfo), ou GetStream(String, CultureInfo) pour récupérer une ressource pour une culture spécifique.You can call the GetString(String, CultureInfo), GetObject(String, CultureInfo), or GetStream(String, CultureInfo) method to retrieve a resource for a specific culture. Si une ressource localisée est introuvable, le gestionnaire des ressources utilise le processus de secours des ressources pour localiser une ressource appropriée.If a localized resource cannot be found, the resource manager uses the resource fallback process to locate an appropriate resource.

  • Vous pouvez appeler la GetResourceSet méthode pour obtenir un ResourceSet objet qui représente les ressources pour une culture particulière.You can call the GetResourceSet method to obtain a ResourceSet object that represents the resources for a particular culture. Dans l’appel de méthode, vous pouvez déterminer si le gestionnaire de ressources recherche les cultures parentes s’il ne parvient pas à trouver des ressources localisées, ou s’il revient simplement aux ressources de la culture par défaut.In the method call, you can determine whether the resource manager probes for parent cultures if it is unable to find localized resources, or whether it simply falls back to the resources of the default culture. Vous pouvez ensuite utiliser les ResourceSet méthodes pour accéder aux ressources (localisées pour cette culture) par nom ou pour énumérer les ressources dans le jeu.You can then use the ResourceSet methods to access the resources (localized for that culture) by name, or to enumerate the resources in the set.

Gestion des exceptions MissingManifestResourceException et MissingSatelliteAssemblyExceptionHandling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions

Si vous essayez de récupérer une ressource spécifique, mais que le gestionnaire de ressources ne peut pas trouver cette ressource et qu’aucune culture par défaut n’a été définie ou que les ressources de la culture par défaut ne peuvent MissingManifestResourceException pas être localisées, Resource Manager lève une exception si elle s’attend à trouver les ressources dans l’assembly principal ou MissingSatelliteAssemblyException un s’il s’attend à trouver les ressources dans un assembly satellite.If you try to retrieve a specific resource, but the resource manager cannot find that resource and either no default culture has been defined or the resources of the default culture cannot be located, the resource manager throws a MissingManifestResourceException exception if it expects to find the resources in the main assembly or a MissingSatelliteAssemblyException if it expects to find the resources in a satellite assembly. Notez que l’exception est levée lorsque vous appelez une méthode de récupération de ressource telle GetString que GetObjectou, et non quand vous instanciez un ResourceManager objet.Note that the exception is thrown when you call a resource retrieval method such as GetString or GetObject, and not when you instantiate a ResourceManager object.

L’exception est généralement levée dans les conditions suivantes :The exception is typically thrown under the following conditions:

  • Le fichier de ressources ou l’assembly satellite approprié n’existe pas.The appropriate resource file or satellite assembly does not exist. Si le gestionnaire de ressources s’attend à ce que les ressources par défaut de l’application soient incorporées dans l’assembly d’application principal, elles sont absentes.If the resource manager expects the app's default resources to be embedded in the main app assembly, they are absent. Si l' NeutralResourcesLanguageAttribute attribut indique que les ressources par défaut de l’application résident dans un assembly satellite, cet assembly est introuvable.If the NeutralResourcesLanguageAttribute attribute indicates that the app's default resources reside in a satellite assembly, that assembly cannot be found. Quand vous compilez votre application, assurez-vous que les ressources sont incorporées dans l’assembly principal ou que l’assembly satellite nécessaire est généré et qu’il est nommé de manière appropriée.When you compile your app, make sure that resources are embedded in the main assembly or that the necessary satellite assembly is generated and is named appropriately. Son nom doit prendre la forme appname. resources. dll, et il doit se trouver dans un répertoire nommé d’après la culture dont il contient les ressources.Its name should take the form appName.resources.dll, and it should be located in a directory named after the culture whose resources it contains.

  • Aucune culture neutre ou par défaut n’est définie pour votre application.Your app doesn't have a default or neutral culture defined. Ajoutez l' NeutralResourcesLanguageAttribute attribut à un fichier de code source ou au fichier d’informations du projet (AssemblyInfo. vb pour une application Visual Basic ou AssemblyInfo.cs C# pour un fichier d’application).Add the NeutralResourcesLanguageAttribute attribute to a source code file or to the project information file (AssemblyInfo.vb for a Visual Basic app or AssemblyInfo.cs for a C# app) file.

  • Le baseName paramètre dans le ResourceManager(String, Assembly) constructeur ne spécifie pas le nom d’un fichier. resources.The baseName parameter in the ResourceManager(String, Assembly) constructor does not specify the name of a .resources file. Le nom doit inclure l’espace de noms complet du fichier de ressources, mais pas son extension de nom de fichier.The name should include the resource file's fully qualified namespace but not its file name extension. En règle générale, les fichiers de ressources qui sont créés dans Visual Studio incluent des noms d’espaces de noms, mais pas les fichiers de ressources qui sont créés et compilés à l’invite de commandes.Typically, resource files that are created in Visual Studio include namespace names, but resource files that are created and compiled at the command prompt do not. Vous pouvez déterminer les noms des fichiers. Resources incorporés en compilant et en exécutant l’utilitaire suivant.You can determine the names of embedded .resources files by compiling and running the following utility. Il s’agit d’une application console qui accepte le nom d’un assembly principal ou d’un assembly satellite en tant que paramètre de ligne de commande.This is a console app that accepts the name of a main assembly or satellite assembly as a command-line parameter. Elle affiche les chaînes qui doivent être fournies en tant baseName que paramètre afin que le gestionnaire de ressources puisse correctement identifier la ressource.It displays the strings that should be provided as the baseName parameter so that the resource manager can correctly identify the resource.

    using System;
    using System.IO;
    using System.Reflection;
    using System.Resources;
    
    public class Example
    {
       public static void Main()
       {
          if (Environment.GetCommandLineArgs().Length == 1) { 
             Console.WriteLine("No filename.");
             return;
          }
          
          string filename = Environment.GetCommandLineArgs()[1].Trim();
          // Check whether the file exists.
          if (! File.Exists(filename)) {
             Console.WriteLine("{0} does not exist.", filename);
             return;
          }   
          
          // Try to load the assembly.
          Assembly assem = Assembly.LoadFrom(filename);
          Console.WriteLine("File: {0}", filename);
             
          // Enumerate the resource files.
          string[] resNames = assem.GetManifestResourceNames();
          if (resNames.Length == 0)
             Console.WriteLine("   No resources found.");
    
          foreach (var resName in resNames)
             Console.WriteLine("   Resource: {0}", resName.Replace(".resources", ""));
    
          Console.WriteLine();
       }
    }
    
    Imports System.IO
    Imports System.Reflection
    Imports System.Resources
    
    Module Example
       Public Sub Main()
          If Environment.GetCommandLineArgs.Length = 1 Then 
             Console.WriteLine("No filename.")
             Exit Sub
          End If
          Dim filename As String = Environment.GetCommandLineArgs(1).Trim()
          ' Check whether the file exists.
          If Not File.Exists(filename) Then
             Console.WriteLine("{0} does not exist.", filename)
             Exit Sub
          End If   
          
          ' Try to load the assembly.
          Dim assem As Assembly = Assembly.LoadFrom(filename)
          Console.WriteLine("File: {0}", filename)
             
          ' Enumerate the resource files.
          Dim resNames() As String = assem.GetManifestResourceNames()
          If resNames.Length = 0 Then
             Console.WriteLine("   No resources found.")
          End If
          For Each resName In resNames
             Console.WriteLine("   Resource: {0}", resName.Replace(".resources", ""))
          Next
          Console.WriteLine()
       End Sub
    End Module
    

Si vous modifiez explicitement la culture actuelle de votre application, vous devez également garder à l’esprit que le gestionnaire de ressources récupère un jeu de ressources en fonction de CultureInfo.CurrentUICulture la valeur de la propriété CultureInfo.CurrentCulture , et non de la propriété.If you are changing the current culture of your application explicitly, you should also remember that the resource manager retrieves a resource set based on the value of the CultureInfo.CurrentUICulture property, and not the CultureInfo.CurrentCulture property. En règle générale, si vous modifiez une valeur, vous devez également modifier l’autre.Typically, if you change one value, you should also change the other.

Contrôle de version des ressourcesResource Versioning

Étant donné que l’assembly principal qui contient les ressources par défaut d’une application est distinct des assemblys satellites de l’application, vous pouvez publier une nouvelle version de votre assembly principal sans redéployer les assemblys satellites.Because the main assembly that contains an app's default resources is separate from the app's satellite assemblies, you can release a new version of your main assembly without redeploying the satellite assemblies. Vous utilisez l' SatelliteContractVersionAttribute attribut pour utiliser des assemblys satellites existants et ordonner au gestionnaire des ressources de ne pas les redéployer avec une nouvelle version de votre assembly principal,You use the SatelliteContractVersionAttribute attribute to use existing satellite assemblies and instruct the resource manager not to redeploy them with a new version of your main assembly,

Pour plus d’informations sur la prise en charge du contrôle de version pour les assemblys satellites, consultez l’article récupération des ressources.For more information about versioning support for satellite assemblies, see the article Retrieving Resources.

<satelliteassemblies > nœud du fichier de configuration<satelliteassemblies> Configuration File Node

Pour les exécutables déployés et exécutés à partir d’un site Web (fichiers href ResourceManager . exe), l’objet peut détecter les assemblys satellites sur le Web, ce qui peut nuire aux performances de votre application.For executables that are deployed and run from a website (HREF .exe files), the ResourceManager object may probe for satellite assemblies over the web, which can hurt your app's performance. Pour éliminer le problème de performances, vous pouvez limiter cette détection aux assemblys satellites que vous avez déployés avec votre application.To eliminate the performance problem, you can limit this probing to the satellite assemblies that you have deployed with your app. Pour ce faire, vous créez un <satelliteassemblies> nœud dans le fichier de configuration de votre application afin de spécifier que vous avez déployé un ensemble spécifique de cultures pour votre application, ResourceManager et que l’objet ne doit pas essayer de sonder une culture qui n’est pas listée dans ce nœud.To do this, you create a <satelliteassemblies> node in your app's configuration file to specify that you have deployed a specific set of cultures for your app, and that the ResourceManager object should not try to probe for any culture that is not listed in that node.

Notes

L’alternative préférée à la création <satelliteassemblies> d’un nœud consiste à utiliser la fonctionnalité de manifeste de déploiement ClickOnce .The preferred alternative to creating a <satelliteassemblies> node is to use the ClickOnce Deployment Manifest feature.

Dans le fichier de configuration de votre application, créez une section semblable à la suivante :In your app's configuration file, create a section similar to the following:

<?xml version ="1.0"?>  
<configuration>  
    <satelliteassemblies>  
        <assembly name="MainAssemblyName, Version=versionNumber, Culture=neutral, PublicKeyToken=null|yourPublicKeyToken">  
            <culture>cultureName1</culture>  
            <culture>cultureName2</culture>  
            <culture>cultureName3</culture>  
        </assembly>  
    </satelliteassemblies>  
</configuration>  

Modifiez les informations de configuration comme suit :Edit this configuration information as follows:

  • Spécifiez un ou <assembly> plusieurs nœuds pour chaque assembly principal que vous déployez, où chaque nœud spécifie un nom d’assembly qualifié complet.Specify one or more <assembly> nodes for each main assembly that you deploy, where each node specifies a fully qualified assembly name. Spécifiez le nom de votre assembly principal à la place de MainAssemblyNameet Versionspécifiez les Culture valeurs d’attribut, PublicKeyTokenet qui correspondent à votre assembly principal.Specify the name of your main assembly in place of MainAssemblyName, and specify the Version, PublicKeyToken, and Culture attribute values that correspond to your main assembly.

    Pour l' Version attribut, spécifiez le numéro de version de votre assembly.For the Version attribute, specify the version number of your assembly. Par exemple, la première version de votre assembly peut être le numéro de version 1.0.0.0.For example, the first release of your assembly might be version number 1.0.0.0.

    Pour l' PublicKeyToken attribut, spécifiez le null mot clé si vous n’avez pas signé votre assembly avec un nom fort, ou spécifiez votre jeton de clé publique si vous avez signé votre assembly.For the PublicKeyToken attribute, specify the keyword null if you have not signed your assembly with a strong name, or specify your public key token if you have signed your assembly.

    Pour l' Culture attribut, spécifiez le neutral mot clé pour désigner l’assembly principal ResourceManager et forcez la classe à détecter uniquement les cultures <culture> listées dans les nœuds.For the Culture attribute, specify the keyword neutral to designate the main assembly and cause the ResourceManager class to probe only for the cultures listed in the <culture> nodes.

    Pour plus d’informations sur les noms d’assembly qualifiés complets, consultez l’article noms d’assembly.For more information about fully qualified assembly names, see the article Assembly Names. Pour plus d’informations sur les assemblys avec nom fort, consultez l’article création et utilisation d’assemblys avec nom fort.For more information about strong-named assemblies, see the article Creating and Using Strong-Named Assemblies.

  • Spécifiez un ou <culture> plusieurs nœuds avec un nom de culture spécifique, tel que « fr-fr », ou un nom de culture neutre, tel que « fr ».Specify one or more <culture> nodes with a specific culture name, such as "fr-FR", or a neutral culture name, such as "fr".

Si des ressources sont nécessaires pour un assembly qui n' <satelliteassemblies> est pas répertorié ResourceManager sous le nœud, la classe sonde les cultures à l’aide des règles de détection standard.If resources are needed for any assembly not listed under the <satelliteassemblies> node, the ResourceManager class probes for cultures using standard probing rules.

Applications Windows 8.x StoreWindows 8.x StoreWindows 8.x StoreWindows 8.x Store Apps

Important

Bien que ResourceManager la classe soit prise Windows 8.x StoreWindows 8.x Store en charge dans les applications, nous ne recommandons pas son utilisation.Although the ResourceManager class is supported in Windows 8.x StoreWindows 8.x Store apps, we do not recommend its use. Utilisez cette classe uniquement lorsque vous développez Bibliothèque de classes portablePortable Class Library des projets qui peuvent être utilisés avec des Windows 8.x StoreWindows 8.x Store applications.Use this class only when you develop Bibliothèque de classes portablePortable Class Library projects that can be used with Windows 8.x StoreWindows 8.x Store apps. Pour récupérer des ressources Windows 8.x StoreWindows 8.x Store à partir d’applications, utilisez la classe Windows. ApplicationModel. resources. ResourceLoader à la place.To retrieve resources from Windows 8.x StoreWindows 8.x Store apps, use the Windows.ApplicationModel.Resources.ResourceLoader class instead.

Pour Windows 8.x StoreWindows 8.x Store les applications, ResourceManager la classe récupère les ressources des fichiers d’index de ressources de package (PRI).For Windows 8.x StoreWindows 8.x Store apps, the ResourceManager class retrieves resources from package resource index (PRI) files. Un fichier PRI unique (fichier PRI de package d’application) contient les ressources pour la culture par défaut et pour toutes les cultures localisées.A single PRI file (the application package PRI file) contains the resources for both the default culture and any localized cultures. Vous utilisez l’utilitaire MakePRI pour créer un fichier PRI à partir d’un ou de plusieurs fichiers de ressources au format de ressource XML (. resw).You use the MakePRI utility to create a PRI file from one or more resource files that are in XML resource (.resw) format. Pour les ressources incluses dans un projet Visual Studio, Visual Studio gère le processus de création et d’empaquetage automatique du fichier PRI.For resources that are included in a Visual Studio project, Visual Studio handles the process of creating and packaging the PRI file automatically. Vous pouvez ensuite utiliser la classe ResourceManager .NET Framework pour accéder aux ressources de l’application ou de la bibliothèque.You can then use the .NET Framework ResourceManager class to access the app's or library's resources.

Vous pouvez instancier ResourceManager un objet pour Windows 8.x StoreWindows 8.x Store une application de la même façon que pour une application de bureau.You can instantiate a ResourceManager object for a Windows 8.x StoreWindows 8.x Store app in the same way that you do for a desktop app.

Vous pouvez ensuite accéder aux ressources d’une culture particulière en passant le nom de la ressource à récupérer à la GetString(String) méthode.You can then access the resources for a particular culture by passing the name of the resource to be retrieved to the GetString(String) method. Par défaut, cette méthode retourne la ressource pour la culture déterminée par la culture d’interface utilisateur actuelle du thread qui a effectué l’appel.By default, this method returns the resource for the culture determined by the current UI culture of the thread that made the call. Vous pouvez également récupérer les ressources pour une culture spécifique en passant le nom de la ressource et un CultureInfo objet qui représente la culture dont la ressource doit être récupérée dans la GetString(String, CultureInfo) méthode.You can also retrieve the resources for a specific culture by passing the name of the resource and a CultureInfo object that represents the culture whose resource is to be retrieved to the GetString(String, CultureInfo) method. Si la ressource pour la culture d’interface utilisateur actuelle ou la culture spécifiée est introuvable, le gestionnaire des ressources utilise une liste de secours pour la langue de l’interface utilisateur pour localiser une ressource appropriée.If the resource for the current UI culture or the specified culture cannot be found, the resource manager uses a UI language fallback list to locate a suitable resource.

Constructeurs

ResourceManager() ResourceManager() ResourceManager() ResourceManager()

Initialise une nouvelle instance de la classe ResourceManager avec des valeurs par défaut.Initializes a new instance of the ResourceManager class with default values.

ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly)

Initialise une nouvelle instance de la classe ResourceManager qui recherche les ressources contenues dans les fichiers portant le nom racine spécifié dans l'assembly donné.Initializes a new instance of the ResourceManager class that looks up resources contained in files with the specified root name in the given assembly.

ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type)

Initialise une nouvelle instance de la classe ResourceManager qui utilise une classe ResourceSet spécifiée pour rechercher les ressources contenues dans les fichiers portant le nom racine spécifié dans l'assembly donné.Initializes a new instance of the ResourceManager class that uses a specified ResourceSet class to look up resources contained in files with the specified root name in the given assembly.

ResourceManager(Type) ResourceManager(Type) ResourceManager(Type) ResourceManager(Type)

Initialise une nouvelle instance de la classe ResourceManager qui recherche des ressources dans les assemblys satellites en fonction d'informations provenant de l'objet de type spécifié.Initializes a new instance of the ResourceManager class that looks up resources in satellite assemblies based on information from the specified type object.

Champs

BaseNameField BaseNameField BaseNameField BaseNameField

Spécifie le nom racine des fichiers de ressources dans lesquels ResourceManager recherche les ressources.Specifies the root name of the resource files that the ResourceManager searches for resources.

HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber

Spécifie la version des en-têtes de fichier de ressources que l'implémentation actuelle de ResourceManager peut interpréter et obtenir.Specifies the version of resource file headers that the current implementation of ResourceManager can interpret and produce.

MagicNumber MagicNumber MagicNumber MagicNumber

Contient le nombre utilisé pour identifier les fichiers de ressources.Holds the number used to identify resource files.

MainAssembly MainAssembly MainAssembly MainAssembly

Spécifie l'assembly principal qui contient les ressources.Specifies the main assembly that contains the resources.

ResourceSets ResourceSets ResourceSets ResourceSets

Contient Hashtable qui retourne un mappage des cultures aux objets ResourceSet.Contains a Hashtable that returns a mapping from cultures to ResourceSet objects.

Propriétés

BaseName BaseName BaseName BaseName

Obtient le nom racine des fichiers de ressources dans lesquels ResourceManager recherche les ressources.Gets the root name of the resource files that the ResourceManager searches for resources.

FallbackLocation FallbackLocation FallbackLocation FallbackLocation

Obtient ou définit l'emplacement à partir duquel récupérer les ressources de secours par défaut.Gets or sets the location from which to retrieve default fallback resources.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase

Obtient ou définit une valeur indiquant si le gestionnaire de ressources autorise les recherches de ressources ne respectant pas la casse dans les méthodes GetString(String) et GetObject(String).Gets or sets a value that indicates whether the resource manager allows case-insensitive resource lookups in the GetString(String) and GetObject(String) methods.

ResourceSetType ResourceSetType ResourceSetType ResourceSetType

Obtient le type de l'objet d'ensemble de ressources que le gestionnaire des ressources utilise pour construire un objet ResourceSet.Gets the type of the resource set object that the resource manager uses to construct a ResourceSet object.

Méthodes

CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type)

Retourne un objet ResourceManager qui recherche les ressources dans un répertoire spécifique, plutôt que dans le manifeste d'assembly.Returns a ResourceManager object that searches a specific directory instead of an assembly manifest for resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly)

Retourne des informations spécifiques à la culture pour les ressources par défaut de l'assembly principal en récupérant la valeur de l'attribut NeutralResourcesLanguageAttribute sur un assembly spécifié.Returns culture-specific information for the main assembly's default resources by retrieving the value of the NeutralResourcesLanguageAttribute attribute on a specified assembly.

GetObject(String) GetObject(String) GetObject(String) GetObject(String)

Retourne la valeur de la ressource non-chaîne spécifiée.Returns the value of the specified non-string resource.

GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo)

Obtient la valeur de la ressource non-chaîne spécifiée localisée pour la culture spécifiée.Gets the value of the specified non-string resource localized for the specified culture.

GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo)

Génère le nom du fichier de ressources pour l'objet CultureInfo donné.Generates the name of the resource file for the given CultureInfo object.

GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean)

Récupère la ressource définie pour une culture particulière.Retrieves the resource set for a particular culture.

GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly)

Retourne la version spécifiée par l'attribut SatelliteContractVersionAttribute dans l'assembly donné.Returns the version specified by the SatelliteContractVersionAttribute attribute in the given assembly.

GetStream(String) GetStream(String) GetStream(String) GetStream(String)

Retourne un objet de flux de mémoire non managé à partir de la ressource spécifiée.Returns an unmanaged memory stream object from the specified resource.

GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo)

Retourne un objet de flux de mémoire non managé à partir de la ressource spécifiée, à l'aide de la culture spécifiée.Returns an unmanaged memory stream object from the specified resource, using the specified culture.

GetString(String) GetString(String) GetString(String) GetString(String)

Retourne la valeur de la ressource de chaîne spécifiée.Returns the value of the specified string resource.

GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo)

Retourne la valeur de la ressource de type chaîne localisée pour la culture spécifiée.Returns the value of the string resource localized for the specified culture.

GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean)

Fournit l'implémentation utilisée pour rechercher un jeu de ressources.Provides the implementation for finding a resource set.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ReleaseAllResources() ReleaseAllResources() ReleaseAllResources() ReleaseAllResources()

Indique au gestionnaire de ressources d'appeler la méthode Close() sur tous les objets ResourceSet et de libérer toutes les ressources.Tells the resource manager to call the Close() method on all ResourceSet objects and release all resources.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi