ResourceManager Třída

Definice

public ref class ResourceManager

public class ResourceManager

[System.Serializable]
public class ResourceManager

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ResourceManager

type ResourceManager = class

[<System.Serializable>]
type ResourceManager = class

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ResourceManager = class

Public Class ResourceManager

Dědičnost

Object

ResourceManager

Odvozené

System.ComponentModel.ComponentResourceManager

Atributy

SerializableAttribute ComVisibleAttribute

Příklady

Následující příklad ukazuje, jak použít explicitní jazykovou verzi a implicitní aktuální jazykovou verzi uživatelského rozhraní k získání řetězcových prostředků z hlavního sestavení a satelitního sestavení.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. Další informace naleznete v části umístění adresáře pro satelitní sestavení, která nejsou nainstalovaná v globální mezipaměti sestavení (GAC) v tématu Vytváření satelitních sestavení .For more information, see the "Directory Locations for Satellite Assemblies Not Installed in the Global Assembly Cache" section of the Creating Satellite Assemblies topic.

Chcete-li spustit tento příklad:To run this example:

1. V adresáři aplikace vytvořte soubor s názvem rmc.txt, který obsahuje následující řetězce prostředků: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. Pomocí generátoru souborů prostředků vygenerujte soubor prostředků RMC. Resources ze vstupního souboru rmc.txt následujícím způsobem:Use the Resource File Generator to generate the rmc.resources resource file from the rmc.txt input file as follows:

   resgen rmc.txt
   

3. Vytvořte podadresář adresáře aplikace a pojmenujte ho "ES-MX".Create a subdirectory of the app directory and name it "es-MX". Toto je název jazykové verze satelitního sestavení, které budete vytvářet v následujících třech krocích.This is the culture name of the satellite assembly that you will create in the next three steps.

4. V adresáři ES-MX vytvořte soubor s názvem rmc.es-MX.txt, který obsahuje následující řetězce prostředků: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. Pomocí generátoru souborů prostředků vygenerujte soubor prostředků RMC.ES-MX. Resources ze vstupního souboru rmc.es-MX.txt následujícím způsobem: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. Předpokládejme, že název souboru pro tento příklad je RMC. vb nebo RMC. cs.Assume that the filename for this example is rmc.vb or rmc.cs. Zkopírujte následující zdrojový kód do souboru.Copy the following source code into a file. Potom jej zkompilujte a vložte do spustitelného sestavení soubor prostředků hlavního sestavení RMC. Resources.Then compile it and embed the main assembly resource file, rmc.resources, in the executable assembly. Pokud používáte Visual Basic kompilátor, syntaxe je:If you are using the Visual Basic compiler, the syntax is:

   vbc rmc.vb /resource:rmc.resources
   

   Odpovídající syntaxe pro kompilátor jazyka C# je:The corresponding syntax for the C# compiler is:

   csc /resource:rmc.resources rmc.cs
   

7. Použijte linker sestavení pro vytvoření satelitního sestavení.Use the Assembly Linker to create a satellite assembly. Pokud je základní název aplikace RMC, musí být název satelitního sestavení rmc.resources.dll.If the base name of the app is rmc, the satellite assembly name must be rmc.resources.dll. Satelitní sestavení by se mělo vytvořit v adresáři ES-MX.The satellite assembly should be created in the es-MX directory. Pokud je aktuální adresář ES-MX, použijte tento příkaz:If es-MX is the current directory, use this command:

   al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dll
   

8. Spusťte rmc.exe pro získání a zobrazení řetězců integrovaných prostředků.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.

Poznámky

ResourceManagerTřída načte prostředky z binárního souboru. Resources, který je vložen do sestavení nebo ze samostatného souboru. Resources.The ResourceManager class retrieves resources from a binary .resources file that is embedded in an assembly or from a standalone .resources file. Pokud byla aplikace lokalizována a lokalizované prostředky byly nasazeny v satelitních sestaveních, vyhledává prostředky specifické pro jazykovou verzi, poskytuje záložní prostředek, pokud lokalizovaný prostředek neexistuje a podporuje serializaci prostředků.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.

Další informace o vytváření a správě prostředků v aplikacích klasické pracovní plochy a v aplikacích pro Windows 8. x Store najdete v následujících částech:For more information about creating and managing resources in desktop apps and Windows 8.x Store apps, see the following sections:

• Desktopové aplikaceDesktop Apps

  • Vytváření prostředkůCreating Resources

  • Vytvoření instance objektu ResourceManagerInstantiating a ResourceManager Object

  • ResourceManager a prostředky specifické pro jazykovou verziResourceManager and Culture-Specific Resources

  • Načítání prostředkůRetrieving Resources

  • Zpracování výjimek MissingManifestResourceException a MissingSatelliteAssemblyExceptionHandling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions

  • Správa verzí prostředkůResource Versioning

  • <satelliteassemblies> Uzel konfiguračního souboru<satelliteassemblies> Configuration File Node

• Aplikace pro Windows StoreWindows Store Apps

Aplikace pro stolní počítačeDesktop Apps

U aplikací klasické pracovní plochy ResourceManager Třída načítá prostředky z binárních souborů prostředků (. Resources).For desktop apps, the ResourceManager class retrieves resources from binary resource (.resources) files. Kompilátor jazyka nebo linker sestavení (AL.exe) obvykle vloží tyto soubory prostředků do sestavení.Typically, a language compiler or the Assembly Linker (AL.exe) embeds these resource files in an assembly. Můžete také použít ResourceManager objekt pro načtení prostředků přímo ze souboru. Resources, který není vložen do sestavení, voláním CreateFileBasedResourceManager metody.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.

V aplikaci založené na zdrojích obsahuje jeden soubor. Resources prostředky výchozí jazykové verze, jejichž prostředky se používají, pokud nelze najít žádné prostředky specifické pro jazykovou verzi.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. Pokud má například výchozí jazykovou verzi aplikace angličtinu (EN), použijí se prostředky anglické jazykové verze, když se pro konkrétní jazykovou verzi nenaleznou lokalizované prostředky, jako je například angličtina (USA) (EN-US) nebo francouzština (Francie) (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). Obvykle jsou prostředky pro výchozí jazykovou verzi vloženy do hlavního sestavení aplikace a prostředky pro jiné lokalizované jazykové verze jsou vloženy do satelitních sestavení.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. Satelitní sestavení obsahují pouze prostředky.Satellite assemblies contain only resources. Mají stejný název kořenového souboru jako hlavní sestavení a rozšíření .resources.dll.They have the same root file name as the main assembly and an extension of .resources.dll. Pro aplikace, jejichž sestavení nejsou registrována v globální mezipaměti sestavení (GAC), jsou satelitní sestavení uložena v podadresáři aplikace, jehož název odpovídá jazykové verzi sestavení.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.

Vytváření prostředkůCreating Resources

Při vývoji aplikace založené na prostředku ukládáte informace o prostředcích v textových souborech (soubory s příponou. txt nebo. restext) nebo soubory XML (soubory s příponou. 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). Potom zkompilujete textový soubor nebo soubory XML pomocí generátoru souborů prostředků (Resgen.exe) pro vytvoření binárního souboru. Resources.You then compile the text or XML files with the Resource File Generator (Resgen.exe) to create a binary .resources file. Výsledný soubor. Resources můžete vložit do spustitelného souboru nebo knihovny pomocí možnosti kompilátoru, jako je například /resources pro kompilátory jazyka C# a Visual Basic, nebo jej můžete vložit do satelitního sestavení pomocí linkeru sestavení (AI.exe).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 Assembly Linker (AI.exe). Pokud zahrnete soubor RESX do projektu sady Visual Studio, aplikace Visual Studio zpracuje kompilaci a vkládání výchozích a lokalizovaných prostředků automaticky v rámci procesu sestavení.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.

V ideálním případě byste měli vytvořit prostředky pro všechny jazyky, které vaše aplikace podporuje, nebo alespoň pro smysluplnou podmnožinu každého jazyka.Ideally, you should create resources for every language your app supports, or at least for a meaningful subset of each language. Názvy binárních souborů. Resources se řídí názvem Base. culture. Resources, kde Base , je název aplikace nebo název třídy v závislosti na požadované úrovni podrobností.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. CultureInfo.NameVlastnost se používá k určení jazykové verze.The CultureInfo.Name property is used to determine cultureName. Prostředek pro výchozí jazykovou verzi aplikace by měl mít název " Base. Resources".A resource for the app's default culture should be named basename.resources.

Předpokládejme například, že sestavení má několik prostředků v souboru prostředků, který má základní název MyResources.For example, suppose that an assembly has several resources in a resource file that has the base name MyResources. Tyto soubory prostředků by měly mít názvy jako MyResources. ja-JP. Resources pro japonskou (japonštinu) jazykovou verzi MyResources. de. Resources pro německou jazykovou verzi, MyResources. zh-CHS. Resources pro zjednodušenou čínskou jazykovou verzi a MyResources.fr-. Resources pro jazykovou verzi francouzštiny (Belgie)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. Výchozí soubor prostředků by měl mít název MyResources. Resources.The default resource file should be named MyResources.resources. Soubory prostředků specifické pro jazykovou verzi jsou obvykle zabaleny do satelitních sestavení pro každou jazykovou verzi.The culture-specific resource files are commonly packaged in satellite assemblies for each culture. Výchozí soubor prostředků by měl být vložen do hlavního sestavení aplikace.The default resource file should be embedded in the app's main assembly.

Všimněte si, že linker sestavení umožňuje, aby prostředky byly označeny jako soukromé, ale měli byste je vždy označit jako veřejné, aby k nim měli k dispozici další sestavení.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. (Protože satelitní sestavení neobsahuje žádný kód, prostředky, které jsou označeny jako soukromé, nejsou k dispozici pro vaši aplikaci prostřednictvím jakéhokoliv mechanismu.)(Because a satellite assembly contains no code, resources that are marked as private are unavailable to your app through any mechanism.)

Další informace o vytváření, balení a nasazování prostředků naleznete v článcích vytváření souborů prostředků, Vytváření satelitních sestavenía balení a nasazení prostředků.For more information about creating, packaging, and deploying resources, see the articles Creating Resource Files, Creating Satellite Assemblies, and Packaging and Deploying Resources.

Vytvoření instance objektu ResourceManagerInstantiating a ResourceManager Object

Vytvoříte instanci ResourceManager objektu, který načte prostředky z vloženého souboru. Resources voláním jednoho z jeho přetížení konstruktoru třídy.You instantiate a ResourceManager object that retrieves resources from an embedded .resources file by calling one of its class constructor overloads. Tím se těsně Couples ResourceManager objekt s konkrétním souborem. Resources a všemi přidruženými lokalizovanými soubory. Resources v satelitních sestaveních.This tightly couples a ResourceManager object with a particular .resources file and with any associated localized .resources files in satellite assemblies.

Dva nejčastěji volané konstruktory jsou:The two most commonly called constructors are:

• ResourceManager(String, Assembly) vyhledá prostředky na základě dvou informací, které zadáte: základní název souboru. Resources a sestavení, ve kterém se nachází soubor default. Resources.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. Základní název zahrnuje obor názvů a kořenový název souboru. Resources bez jeho jazykové verze nebo rozšíření.The base name includes the namespace and root name of the .resources file, without its culture or extension. Všimněte si, že soubory. Resources, které jsou kompilovány z příkazového řádku, obvykle neobsahují název oboru názvů, zatímco soubory. Resources, které jsou vytvořeny v prostředí sady 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. Například pokud má soubor prostředků název spolecnost. StringResources. Resources a ResourceManager konstruktor je volán ze statické metody s názvem Example.Main , následující kód vytvoří instanci ResourceManager objektu, který může načíst prostředky ze souboru. Resources: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) vyhledá prostředky v satelitních sestaveních na základě informací z objektu typu.ResourceManager(Type) looks up resources in satellite assemblies based on information from a type object. Plně kvalifikovaný název typu odpovídá základnímu názvu souboru. Resources bez přípony názvu souboru.The type's fully qualified name corresponds to the base name of the .resources file without its file name extension. V aplikacích klasické pracovní plochy, které jsou vytvořeny pomocí Návrháře prostředků sady Visual Studio, vytvoří Visual Studio obálkovou třídu, jejíž plně kvalifikovaný název je stejný jako kořenový název souboru. 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. Například pokud má soubor prostředků název spolecnost. StringResources. Resources a je k dispozici Obálková třída s názvem MyCompany.StringResources , následující kód vytvoří instanci ResourceManager objektu, který může načíst prostředky ze souboru. 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))
  

Pokud nelze nalézt odpovídající prostředky, volání konstruktoru vytvoří platný ResourceManager objekt.If the appropriate resources cannot be found, the constructor call creates a valid ResourceManager object. Pokus o načtení prostředku však vyvolá MissingManifestResourceException výjimku.However, the attempt to retrieve a resource throws a MissingManifestResourceException exception. Informace o řešení výjimky najdete v části zpracování výjimek MissingManifestResourceException a MissingSatelliteAssembly dále v tomto článku.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssembly Exceptions section later in this article.

Následující příklad ukazuje, jak vytvořit instanci ResourceManager objektu.The following example shows how to instantiate a ResourceManager object. Obsahuje zdrojový kód pro spustitelný soubor s názvem ShowTime.exe.It contains the source code for an executable named ShowTime.exe. Obsahuje také následující textový soubor s názvem Strings.txt, který obsahuje jeden prostředek řetězce TimeHeader :It also includes the following text file named Strings.txt that contains a single string resource, TimeHeader:

TimeHeader=The current time is

Pomocí dávkového souboru můžete vygenerovat soubor prostředků a vložit ho do spustitelného souboru.You can use a batch file to generate the resource file and embed it into the executable. Zde je dávkový soubor pro vygenerování spustitelného souboru pomocí kompilátoru jazyka C#:Here's the batch file to generate an executable by using the C# compiler:

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

Pro Visual Basic kompilátor můžete použít následující dávkový soubor: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

ResourceManager a prostředky specifické pro jazykovou verziResourceManager and Culture-Specific Resources

Lokalizovaná aplikace vyžaduje nasazení prostředků, jak je popsáno v článku o vytváření balíčků a nasazování prostředků.A localized app requires resources to be deployed, as discussed in the article Packaging and Deploying Resources. Pokud jsou sestavení správně nakonfigurovaná, správce prostředků určí, které prostředky se mají načíst na základě vlastnosti aktuálního vlákna Thread.CurrentUICulture .If the assemblies are properly configured, the resource manager determines which resources to retrieve based on the current thread's Thread.CurrentUICulture property. (Tato vlastnost také vrátí jazykovou verzi aktuálního vlákna.) Například pokud je aplikace kompilována s výchozími prostředky anglické jazykové verze v hlavním sestavení a s francouzskými a ruskými jazykovými prostředky ve dvou satelitních sestaveních a Thread.CurrentUICulture vlastnost je nastavena na hodnotu fr-FR, správce prostředků načte francouzské prostředky.(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.

Vlastnost můžete nastavit CurrentUICulture explicitně nebo implicitně.You can set the CurrentUICulture property explicitly or implicitly. Způsob, jakým nastavíte, určuje způsob, jakým ResourceManager objekt načítá prostředky na základě jazykové verze:The way you set it determines how the ResourceManager object retrieves resources based on culture:

• Pokud jste vlastnost explicitně nastavili Thread.CurrentUICulture na konkrétní jazykovou verzi, správce prostředků vždy načte prostředky pro tuto jazykovou verzi bez ohledu na to, jestli je uživatel nebo jazyk operačního systému.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. Zvažte aplikaci, která je zkompilována s výchozími prostředky anglické jazykové verze a třemi satelitními sestaveními, která obsahují prostředky pro angličtinu (USA), francouzština (Francie) a ruština (Rusko).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). Pokud CurrentUICulture je vlastnost nastavena na hodnotu fr-FR, ResourceManager objekt vždy načte francouzština (Francie) prostředky, i když jazyk operačního systému uživatele není francouzština.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. Ujistěte se, že se jedná o požadované chování před tím, než nastavíte vlastnost explicitně.Make sure that this is the desired behavior before you set the property explicitly.

  V aplikacích ASP.NET je nutné Thread.CurrentUICulture vlastnost nastavit explicitně, protože je pravděpodobné, že nastavení na serveru budou odpovídat příchozím požadavkům klientů.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. Aplikace ASP.NET může Thread.CurrentUICulture explicitně nastavit vlastnost na jazyk přijmout prohlížeče uživatele.An ASP.NET app can set the Thread.CurrentUICulture property explicitly to the user's browser accept language.

  Explicitní nastavení Thread.CurrentUICulture vlastnosti definuje aktuální jazykovou verzi uživatelského rozhraní pro toto vlákno.Explicitly setting the Thread.CurrentUICulture property defines the current UI culture for that thread. Nemá vliv na aktuální jazykovou verzi uživatelského rozhraní všech ostatních vláken v aplikaci.It does not affect the current UI culture of any other threads in an app.

• Můžete nastavit jazykovou verzi pro všechna vlákna v doméně aplikace přiřazením CultureInfo objektu, který představuje tuto jazykovou verzi pro statickou CultureInfo.DefaultThreadCurrentUICulture vlastnost.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.

• Pokud nenastavíte explicitně aktuální jazykovou verzi uživatelského rozhraní a nedefinujete výchozí jazykovou verzi pro aktuální doménu aplikace, CultureInfo.CurrentUICulture vlastnost je implicitně nastavena GetUserDefaultUILanguage funkcí 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. Tuto funkci poskytuje rozhraní MUI (Multilingual User Interface), které uživateli umožňuje nastavit výchozí jazyk.This function is provided by the Multilingual User Interface (MUI), which enables the user to set the default language. Pokud není jazyk uživatelského rozhraní nastavený uživatelem, použije se výchozí jazyk instalovaný systémem, který je jazykem prostředků operačního systému.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.

Následující jednoduchý příklad "Hello World" explicitně nastaví aktuální jazykovou verzi uživatelského rozhraní.The following simple "Hello world" example sets the current UI culture explicitly. Obsahuje prostředky pro tři jazykové verze: angličtinu (USA) nebo en-US, francouzština (Francie) nebo fr-FR a ruština (Rusko) nebo 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. Prostředky en-US jsou obsaženy v textovém souboru s názvem Greetings.txt:The en-US resources are contained in a text file named Greetings.txt:

HelloString=Hello world!

Prostředky fr-FR jsou obsaženy v textovém souboru s názvem Greetings.fr-FR.txt:The fr-FR resources are contained in a text file named Greetings.fr-FR.txt:

HelloString=Salut tout le monde!

Prostředky ru-RU jsou obsaženy v textovém souboru s názvem Greetings.ru-RU.txt:The ru-RU resources are contained in a text file named Greetings.ru-RU.txt:

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

Zde je zdrojový kód pro příklad (příklad. vb pro verzi Visual Basic nebo příklad. cs pro verzi jazyka C#):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.
'       Всем привет!

Chcete-li tento příklad zkompilovat, vytvořte soubor dávky (. bat), který obsahuje následující příkazy a spusťte jej z příkazového řádku.To compile this example, create a batch (.bat) file that contains the following commands and run it from the command prompt. Pokud používáte jazyk C#, zadejte csc místo vbc a Example.cs místo Example.vb .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

Načítání prostředkůRetrieving Resources

Zavoláte GetObject(String) GetString(String) metody a pro přístup k určitému prostředku.You call the GetObject(String) and GetString(String) methods to access a specific resource. Můžete také volat GetStream(String) metodu pro načtení neřetězcových prostředků jako bajtové pole.You can also call the GetStream(String) method to retrieve non-string resources as a byte array. Ve výchozím nastavení v aplikaci, která má lokalizované prostředky, tyto metody vrátí prostředek pro jazykovou verzi určenou aktuální jazykovou verzí uživatelského rozhraní vlákna, které provedlo volání.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. Další informace o tom, jak se definuje aktuální jazyková verze uživatelského rozhraní vlákna, najdete v předchozí části, ResourceManager a Culture-Specificch prostředcích.See the previous section, ResourceManager and Culture-Specific Resources, for more information about how the current UI culture of a thread is defined. Pokud správce prostředků nemůže najít prostředek pro jazykovou verzi aktuálního vlákna, používá záložní proces k načtení zadaného prostředku.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. Pokud správce prostředků nemůže najít žádné lokalizované prostředky, používá prostředky výchozí jazykové verze.If the resource manager cannot find any localized resources, it uses the resources of the default culture. Další informace o pravidlech pro použití náhradních prostředků najdete v části "proces záložního prostředku" v článku vytváření balíčků a nasazování prostředků.For more information about resource fallback rules, see the "Resource Fallback Process" section of the article Packaging and Deploying Resources.

Následující příklad používá GetString metodu pro načtení prostředků specifických pro jazykovou verzi.The following example uses the GetString method to retrieve culture-specific resources. Skládá se z prostředků kompilovaných ze souborů. txt pro anglické (EN), francouzština (Francie) (fr-FR) a ruština (Rusko) (ru-RU) kultur.It consists of resources compiled from .txt files for the English (en), French (France) (fr-FR), and Russian (Russia) (ru-RU) cultures. V příkladu se změní aktuální jazyková verze a aktuální jazyková verze uživatelského rozhraní na angličtinu (USA), francouzština (Francie), ruština (Rusko) a švédština (Švédsko).The example changes the current culture and current UI culture to English (United States), French (France), Russian (Russia), and Swedish (Sweden). Poté volá GetString metodu pro načtení lokalizovaného řetězce, který se zobrazí spolu s aktuálním dnem a měsícem.It then calls the GetString method to retrieve the localized string, which it displays along with the current day and month. Všimněte si, že výstup zobrazuje příslušný lokalizovaný řetězec s výjimkou případů, kdy je aktuální jazyková verze uživatelského rozhraní Švédština (Švédsko).Notice that the output displays the appropriate localized string except when the current UI culture is Swedish (Sweden). Vzhledem k tomu, že prostředky švédského jazyka nejsou k dispozici, aplikace místo toho používá prostředky výchozí jazykové verze, což je angličtina.Because Swedish language resources are unavailable, the app instead uses the resources of the default culture, which is English.

Příklad vyžaduje textové soubory prostředků uvedené v následující tabulce.The example requires the text-based resource files listed in following table. Každá z nich má jeden prostředek řetězce s názvem DateStart .Each has a single string resource named DateStart.

Zde je zdrojový kód pro příklad (ShowDate. vb pro verzi Visual Basic nebo ShowDate. cs pro verzi kódu v jazyce C#).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.

Pokud chcete tento příklad zkompilovat, vytvořte dávkový soubor, který obsahuje následující příkazy a spusťte ho z příkazového řádku.To compile this example, create a batch file that contains the following commands and run it from the command prompt. Pokud používáte jazyk C#, zadejte csc místo vbc a showdate.cs místo showdate.vb .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

Existují dva způsoby, jak načíst prostředky určité jazykové verze jiné než aktuální jazyková verze uživatelského rozhraní:There are two ways to retrieve the resources of a specific culture other than the current UI culture:

• Můžete zavolat GetString(String, CultureInfo) GetObject(String, CultureInfo) metodu, nebo GetStream(String, CultureInfo) pro načtení prostředku pro konkrétní jazykovou verzi.You can call the GetString(String, CultureInfo), GetObject(String, CultureInfo), or GetStream(String, CultureInfo) method to retrieve a resource for a specific culture. Pokud nelze nalézt lokalizovaný prostředek, správce prostředků použije k vyhledání příslušného prostředku proces použití náhradního prostředku.If a localized resource cannot be found, the resource manager uses the resource fallback process to locate an appropriate resource.

• Můžete zavolat GetResourceSet metodu pro získání ResourceSet objektu, který představuje prostředky pro konkrétní jazykovou verzi.You can call the GetResourceSet method to obtain a ResourceSet object that represents the resources for a particular culture. Ve volání metody můžete určit, zda se má u nadřazených jazykových verzí zjistit, jestli se nedaří najít lokalizované prostředky, nebo jestli se jednoduše vrátí k prostředkům výchozí jazykové verze.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. Pak můžete použít ResourceSet metody pro přístup k prostředkům (lokalizovaným pro danou jazykovou verzi) podle názvu nebo k zobrazení výčtu prostředků v sadě.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.

Zpracování výjimek MissingManifestResourceException a MissingSatelliteAssemblyExceptionHandling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions

Pokud se pokusíte načíst konkrétní prostředek, ale správce prostředků nemůže najít tento prostředek, ani nebyla definována žádná výchozí jazyková verze, nebo nelze najít prostředky výchozí jazykové verze, správce prostředků vyvolá MissingManifestResourceException výjimku, pokud očekává nalezení prostředků v hlavním sestavení nebo v MissingSatelliteAssemblyException případě, že očekává nalezení prostředků v satelitním sestavení.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. Všimněte si, že výjimka je vyvolána při volání metody načtení prostředku, jako je GetString nebo GetObject , a ne při vytváření instance ResourceManager objektu.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.

Výjimka je obvykle vyvolána za následujících podmínek:The exception is typically thrown under the following conditions:

• Příslušný soubor prostředků nebo satelitní sestavení neexistují.The appropriate resource file or satellite assembly does not exist. Pokud správce prostředků očekává, že výchozí prostředky aplikace budou vloženy do hlavního sestavení aplikace, chybí.If the resource manager expects the app's default resources to be embedded in the main app assembly, they are absent. Pokud NeutralResourcesLanguageAttribute atribut označuje, že se výchozí prostředky aplikace nacházejí v satelitním sestavení, toto sestavení nebylo nalezeno.If the NeutralResourcesLanguageAttribute attribute indicates that the app's default resources reside in a satellite assembly, that assembly cannot be found. Při kompilaci aplikace zajistěte, aby byly prostředky vloženy do hlavního sestavení nebo aby bylo vygenerováno potřebné satelitní sestavení a je pojmenováno správně.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. Jeho název by měl mít formu appName.resources.dll a měl by být umístěn v adresáři s názvem po jazykové verzi, jejíž prostředky obsahuje.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.

• Vaše aplikace nemá definovánu výchozí nebo neutrální jazykovou verzi.Your app doesn't have a default or neutral culture defined. Přidejte NeutralResourcesLanguageAttribute atribut do souboru se zdrojovým kódem nebo do souboru s informacemi o projektu (AssemblyInfo. vb pro Visual Basic aplikaci nebo soubor AssemblyInfo. cs pro aplikaci v jazyce C#).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.

• baseNameParametr v ResourceManager(String, Assembly) konstruktoru neurčuje název souboru. Resources.The baseName parameter in the ResourceManager(String, Assembly) constructor does not specify the name of a .resources file. Název by měl obsahovat plně kvalifikovaný obor názvů souboru prostředků, ale ne jeho příponu názvu souboru.The name should include the resource file's fully qualified namespace but not its file name extension. Obvykle soubory prostředků, které jsou vytvořeny v aplikaci Visual Studio, obsahují názvy oborů názvů, ale soubory prostředků, které jsou vytvořeny a kompilovány na příkazovém řádku, nikoli.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. Názvy integrovaných souborů. Resources můžete určit zkompilováním a spuštěním následujícího nástroje.You can determine the names of embedded .resources files by compiling and running the following utility. Toto je Konzolová aplikace, která přijímá název hlavního sestavení nebo satelitního sestavení jako parametr příkazového řádku.This is a console app that accepts the name of a main assembly or satellite assembly as a command-line parameter. Zobrazuje řetězce, které by měly být zadány jako baseName parametr, aby správce prostředků mohl správně identifikovat prostředek.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
  

Pokud měníte aktuální jazykovou verzi vaší aplikace explicitně, měli byste si také uvědomit, že správce prostředků načte sadu prostředků na základě hodnoty CultureInfo.CurrentUICulture vlastnosti, a nikoli CultureInfo.CurrentCulture Vlastnosti.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. Pokud například změníte jednu hodnotu, měli byste také změnit druhou.Typically, if you change one value, you should also change the other.

Správa verzí prostředkůResource Versioning

Vzhledem k tomu, že hlavní sestavení obsahující výchozí prostředky aplikace je oddělené od satelitních sestavení aplikace, můžete uvolnit novou verzi hlavního sestavení bez nutnosti opětovného nasazení satelitních sestavení.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. Použijte SatelliteContractVersionAttribute atribut pro použití existujících satelitních sestavení a sdělte správci prostředků, aby je nemuseli znovu nasazovat novou verzí vašeho hlavního sestavení,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,

Další informace o podpoře správy verzí pro satelitní sestavení naleznete v článku načtení prostředků.For more information about versioning support for satellite assemblies, see the article Retrieving Resources.

<satelliteassemblies> Uzel konfiguračního souboru<satelliteassemblies> Configuration File Node

Pro spustitelné soubory, které jsou nasazeny a spouštěny z webu (soubory HREF. exe), ResourceManager může objekt testovat satelitní sestavení přes web, což může snížit výkon vaší aplikace.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. Chcete-li odstranit potíže s výkonem, můžete toto zjišťování omezit na satelitní sestavení, která jste nasadili s vaší aplikací.To eliminate the performance problem, you can limit this probing to the satellite assemblies that you have deployed with your app. Chcete-li to provést, vytvořte <satelliteassemblies> uzel v konfiguračním souboru vaší aplikace, abyste určili, že jste nasadili konkrétní sadu jazykových verzí pro vaši aplikaci a že ResourceManager by se objekt neměl pokoušet o sondu pro žádnou jazykovou verzi, která není uvedená v tomto uzlu.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.

V konfiguračním souboru vaší aplikace vytvořte oddíl podobný následujícímu: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>

Upravte tyto informace o konfiguraci následujícím způsobem:Edit this configuration information as follows:

• Zadejte jeden nebo více <assembly> uzlů pro každé hlavní sestavení, které nasadíte, kde každý uzel Určuje plně kvalifikovaný název sestavení.Specify one or more <assembly> nodes for each main assembly that you deploy, where each node specifies a fully qualified assembly name. Zadejte název hlavního sestavení místo MainAssemblyName a zadejte Version PublicKeyToken hodnoty atributů, a, Culture které odpovídají vašemu hlavnímu sestavení.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.

  Pro Version atribut zadejte číslo verze sestavení.For the Version attribute, specify the version number of your assembly. Například první verze sestavení může být číslo verze 1.0.0.0.For example, the first release of your assembly might be version number 1.0.0.0.

  Pro PublicKeyToken atribut zadejte klíčové slovo, null Pokud jste sestavení nepodepsali pomocí silného názvu, nebo zadejte token veřejného klíče, pokud jste si zaregistrovali vaše sestavení.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.

  Pro Culture atribut zadejte klíčové slovo pro neutral Určení hlavního sestavení a způsobí, že se třída bude testovat ResourceManager pouze pro jazykové verze uvedené v <culture> uzlech.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.

  Další informace o plně kvalifikovaných názvech sestavení naleznete v článku názvy sestavení.For more information about fully qualified assembly names, see the article Assembly Names. Další informace o sestavení se silným názvem naleznete v článku Vytvoření a použití sestavení se silným názvem.For more information about strong-named assemblies, see the article Create and use strong-named assemblies.

• Zadejte jeden nebo více <culture> uzlů s názvem konkrétní jazykové verze, například "fr-FR" nebo neutrální název jazykové verze, například "fr".Specify one or more <culture> nodes with a specific culture name, such as "fr-FR", or a neutral culture name, such as "fr".

Pokud jsou prostředky požadovány pro jakékoli sestavení, které není uvedeno pod <satelliteassemblies> uzlem, ResourceManager sondy třídy pro jazykové verze pomocí standardních pravidel zjišťování.If resources are needed for any assembly not listed under the <satelliteassemblies> node, the ResourceManager class probes for cultures using standard probing rules.

Aplikace pro Store v systému Windows 8. xWindows 8.x Store Apps

Pro aplikace Windows 8. x ze Storu ResourceManager Třída načítá prostředky ze souborů indexu prostředků balíčku (PRI).For Windows 8.x Store apps, the ResourceManager class retrieves resources from package resource index (PRI) files. Jeden soubor PRI (soubor PRI balíčku aplikace) obsahuje prostředky pro výchozí jazykovou verzi i pro všechny lokalizované kultury.A single PRI file (the application package PRI file) contains the resources for both the default culture and any localized cultures. Pomocí nástroje předány MakePRI vytvoříte soubor PRI z jednoho nebo více souborů prostředků, které jsou ve formátu XML Resource (. resw).You use the MakePRI utility to create a PRI file from one or more resource files that are in XML resource (.resw) format. Pro prostředky, které jsou součástí projektu sady Visual Studio, aplikace Visual Studio zpracovává proces vytváření a balení souboru PRI automaticky.For resources that are included in a Visual Studio project, Visual Studio handles the process of creating and packaging the PRI file automatically. Pak můžete použít ResourceManager třídu .NET Framework pro přístup k prostředkům aplikace nebo knihovny.You can then use the .NET Framework ResourceManager class to access the app's or library's resources.

Můžete vytvořit instanci ResourceManager objektu pro aplikaci Windows 8. x Store stejným způsobem jako desktopovou aplikaci.You can instantiate a ResourceManager object for a Windows 8.x Store app in the same way that you do for a desktop app.

Pak můžete získat přístup k prostředkům konkrétní jazykové verze předáním názvu prostředku, který se má načíst do GetString(String) metody.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. Ve výchozím nastavení tato metoda vrátí prostředek pro jazykovou verzi určenou aktuální jazykovou verzí uživatelského rozhraní vlákna, které provedlo volání.By default, this method returns the resource for the culture determined by the current UI culture of the thread that made the call. Můžete také načíst prostředky pro konkrétní jazykovou verzi předáním názvu prostředku a CultureInfo objektu, který představuje jazykovou verzi, jejíž prostředek má být načten do GetString(String, CultureInfo) metody.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. Pokud se prostředek pro aktuální jazykovou verzi uživatelského rozhraní nebo zadanou jazykovou verzi nenajde, správce prostředků použije seznam záložních jazyků s uživatelským rozhraním k nalezení vhodného prostředku.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.

Konstruktory

Pole

Vlastnosti

Metody

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také

• CultureInfo
• CurrentUICulture
• SatelliteContractVersionAttribute
• Prostředky v aplikacíchResources in Applications