ResourceManager Třída

Definice

Obor názvů:

System.Resources

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

ResourceManager.cs

Představuje správce prostředků, který poskytuje pohodlný přístup k prostředkům specifické pro jazykovou verzi za běhu.

public ref class ResourceManager

public class ResourceManager

type ResourceManager = class

Public Class ResourceManager

Dědičnost

Object

ResourceManager

Odvozené

System.ComponentModel.ComponentResourceManager

Příklady

Následující příklad ukazuje, jak použít explicitní jazyk a aktuální implicitní jazyk rozhraní k získání řetězcových prostředků z hlavní sestavy a satelitní sestavy. Další informace naleznete v části Umístění adresářů pro satelitní sestavení, která nejsou nainstalována v globální mezipaměti pro sestavení, v tématu Vytváření satelitních sestavení.

Abyste spustili tento příklad:

1. V adresáři aplikace vytvořte soubor s názvem rmc.txt, který obsahuje následující řetězce prostředků:

   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:

   resgen rmc.txt
   

3. Vytvořte podadresář adresáře aplikace a pojmenujte ho "es-MX". Toto je název kultury satelitního sestavení, které vytvoříte v dalších třech krocích.

4. ** Vytvořte soubor s názvem rmc.es-MX.txt v adresáři es-MX, který obsahuje následující řetězce prostředků:

   day=Viernes
   year=2006
   holiday="Cinco de Mayo"
   

5. K vygenerování rmc použijte generátor souborů prostředků .es-MXsoubor prostředků .resources ze vstupního souboru rmc.es-MX.txt následujícím způsobem:

   resgen rmc.es-MX.txt
   

6. Předpokládejme, že název souboru tohoto příkladu je rmc.vb nebo rmc.cs. Zkopírujte následující zdrojový kód do souboru. Potom ho zkompilujte a vložte do spustitelného sestavení soubor prostředků hlavního sestavení rmc.resources. Pokud používáte kompilátor jazyka Visual Basic, syntaxe je:

   vbc rmc.vb /resource:rmc.resources
   

   Odpovídající syntaxe kompilátoru jazyka C# je:

   csc /resource:rmc.resources rmc.cs
   

7. Pomocí Assembly Linker vytvořte satelitní sestavení. Pokud je základní název aplikace rmc, musí být název satelitního sestavení rmc.resources.dll. Satelitní sestavení by mělo být vytvořeno v adresáři es-MX. Pokud je es-MX aktuálním adresářem, použijte tento příkaz:

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

8. Spusťte rmc.exe, abyste získali a zobrazili vložené řetězce prostředků.

   using System;
   using System.Globalization;
   using System.Resources;
   
   class Example4
   {
       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(Example4).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 Example4
       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(Example4).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

Důležité

Volání metod z této třídy s nedůvěryhodnými daty představuje bezpečnostní riziko. Volejte metody z této třídy pouze s důvěryhodnými daty. Další informace naleznete v tématu Ověření všech vstupů.

Třída ResourceManager načte prostředky z binárního souboru .resources, který je vložen do sestavení nebo ze samostatného souboru .resources. Pokud byla aplikace lokalizována a lokalizované prostředky byly nasazeny v satelitních sestaveních, vyhledá prostředky specifické pro jazykovou verzi, poskytuje záložní prostředek v případě, že lokalizovaný prostředek neexistuje, a podporuje serializaci prostředků.

Desktopové aplikace

U desktopových aplikací třída ResourceManager načítá prostředky z binárních souborů prostředků (.resources). Jazykový kompilátor nebo linker sestavení (AL.exe) obvykle vkládá tyto soubory prostředků do sestavení. Také můžete použít objekt ResourceManager k tomu, abyste načetli prostředky přímo ze souboru .resources, který není vložen do sestavení, a to voláním metody CreateFileBasedResourceManager.

Caution

Použití samostatných souborů .resources v aplikaci ASP.NET přeruší nasazení XCOPY, protože prostředky zůstanou uzamčené, dokud je metoda explicitně nevyvolá ReleaseAllResources . Pokud chcete nasadit prostředky s aplikacemi ASP.NET, měli byste soubory .resources zkompilovat do satelitních sestavení.

V aplikaci založené na prostředcí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. Pokud je například výchozí jazyková verze aplikace angličtina (en), použijí se prostředky anglického jazyka vždy, když lokalizované prostředky nelze najít pro konkrétní jazykovou verzi, například angličtinu (USA) (en-US) nebo francouzštinu (Francie) (fr-FR). Prostředky výchozí jazykové verze jsou obvykle vloženy do hlavního sestavení aplikace a prostředky pro jiné lokalizované jazykové verze jsou vloženy do satelitních sestavení. Satelitní sestavení obsahují pouze zdroje. Mají stejný název kořenového souboru jako hlavní sestavení a příponu .resources.dll. U aplikací, jejichž sestavení nejsou registrována v globální mezipaměti sestavení, jsou satelitní sestavení uložena v podadresáři aplikace, jejíž název odpovídá kultuře sestavení.

Vytvoření zdrojů

Při vývoji aplikace založené na prostředcích ukládáte informace o prostředcích do textových souborů (souborů, které mají příponu .txt nebo .restext) nebo XML (soubory s příponou .resx). Potom zkompilujete text nebo soubory XML pomocí generátoru souborů prostředků (Resgen.exe) a vytvoříte binární soubor .resources. Výsledný soubor .resources pak můžete vložit do spustitelného souboru nebo knihovny pomocí možnosti kompilátoru, například /resources pro kompilátory C# a Visual Basic, nebo ho můžete vložit do satelitního sestavení pomocí linkeru sestavení (AL.exe). Pokud do projektu sady Visual Studio zahrnete soubor .resx, Visual Studio zpracuje kompilaci a vkládání výchozích a lokalizovaných prostředků automaticky jako součást procesu sestavení.

V ideálním případě byste měli vytvářet prostředky pro každý jazyk, který vaše aplikace podporuje, nebo alespoň pro smysluplnou podmnožinu každého jazyka. Názvy binárních souborů .resources dodržují konvenci pojmenování basename.cultureName.resources, kde basename je název aplikace nebo název třídy v závislosti na požadované úrovni podrobností. Vlastnost CultureInfo.Name slouží k určení cultureName. Prostředek pro výchozí jazykovou verzi aplikace by měl mít název basename.resources.

Předpokládejme například, že sestavení má v souboru prostředků několik prostředků se základním názvem MyResources. Tyto soubory prostředků by měly mít názvy, jako jsou MyResources.ja-JP.resources pro japonskou (japonskou) kulturu, MyResources.de.resources pro německou kulturu, MyResources.zh-CHS.resources pro zjednodušenou čínskou kulturu a MyResources.fr-BE.resources pro francouzskou kulturu (Belgie). Výchozí soubor prostředků by měl mít název MyResources.resources. Soubory prostředků specifické pro jednotlivé kultury jsou obvykle zabalené do satelitních sestavení pro každou kulturu. Výchozí soubor prostředků by měl být vložen do hlavního sestavení aplikace.

Všimněte si, že Assembly Linker umožňuje, aby byly prostředky označené jako soukromé, ale měli byste je vždy označit jako veřejné, aby k nim bylo možné přistupovat jinými sestaveními. (Vzhledem k tomu, že satelitní sestavení neobsahuje žádný kód, prostředky označené jako soukromé nejsou pro vaši aplikaci dostupné prostřednictvím jakéhokoli mechanismu.)

Další informace o vytváření, balení a nasazování prostředků najdete v článcích Vytváření souborů prostředků, Vytváření satelitních sestavení a balení a nasazování prostředků.

Vytvoření instance objektu ResourceManager

Vytvoříte instanci objektu ResourceManager, který získává prostředky z vloženého souboru .resources voláním jednoho z přetížených konstruktorů třídy. Toto úzce spojuje ResourceManager objekt se zvláštním souborem .resources a s libovolnými přidruženými lokalizovanými soubory .resources v satelitních sestaveních.

Mezi dva nejčastěji označované konstruktory patří:

• 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í výchozí soubor .resources. Základní název zahrnuje obor názvů a kořenový název souboru .resources bez jeho jazykové verze nebo přípony. Všimněte si, že soubory .resources kompilované z příkazového řádku obvykle neobsahují název oboru názvů, zatímco soubory .resources vytvořené v prostředí sady Visual Studio ho mají. Pokud je například soubor prostředků s názvem MyCompany.StringResources.resources a ResourceManager konstruktor je volán ze statické metody s názvem Example.Main, následující kód vytvoří instanci objektu ResourceManager , který může načíst prostředky ze souboru .resources:

  ResourceManager rm = new ResourceManager("MyCompany.StringResources",
                                           typeof(CtorExample).Assembly);
  

  Dim rm As New ResourceManager("MyCompany.StringResources",
                              GetType(Example2).Assembly)
  

• ResourceManager(Type) vyhledá prostředky v satelitních sestaveních na základě informací z typového objektu. Plně kvalifikovaný název typu odpovídá základnímu názvu souboru .resources bez přípony názvu souboru. V desktopových aplikacích vytvořených pomocí Návrháře prostředků sady Visual Studio vytvoří Visual Studio třídu obálky, jejíž plně kvalifikovaný název je stejný jako kořenový název souboru .resources. Pokud je například soubor prostředků s názvem MyCompany.StringResources.resources a existuje obálková třída s názvem MyCompany.StringResources, následující kód vytvoří instanci objektu ResourceManager , který může načíst prostředky ze souboru .resources:

  ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));
  

  Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
  

Pokud nelze najít příslušné prostředky, volání konstruktoru vytvoří platný ResourceManager objekt. Pokus o načtení prostředku však vyvolá MissingManifestResourceException výjimku. Pro informace o řešení výjimky naleznete v části Handle MissingManifestResourceException a MissingSatelliteAssemblyException Výjimky dále v tomto článku.

Následující příklad ukazuje, jak vytvořit instanci objektu ResourceManager . Obsahuje zdrojový kód spustitelného souboru s názvem ShowTime.exe. Obsahuje také následující textový soubor s názvem Strings.txt, který obsahuje jeden řetězec zdroje: 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. Tady je dávkový soubor pro vygenerování spustitelného souboru pomocí kompilátoru jazyka C#:

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

Pro kompilátor jazyka Visual Basic můžete použít následující dávkový soubor:

resgen strings.txt
vbc ShowTime.vb /resource:strings.resources

using System;
using System.Resources;

public class ShowTimeEx
{
    public static void Main()
    {
        ResourceManager rm = new ResourceManager("Strings",
                                 typeof(Example).Assembly);
        string timeString = rm.GetString("TimeHeader");
        Console.WriteLine($"{timeString} {DateTime.Now:T}");
    }
}

// The example displays output like the following:
//        The current time is 2:03:14 PM

Imports System.Resources

Module Example6
    Public Sub Main()
        Dim rm As New ResourceManager("Strings", GetType(Example6).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 kulturně specifické prostředky

Lokalizovaná aplikace vyžaduje nasazení prostředků, jak je popsáno v článku Balení a nasazování prostředků. Pokud jsou sestavení správně nakonfigurovaná, správce prostředků určuje, které prostředky se mají načíst na základě vlastnosti aktuálního Thread.CurrentUICulture vlákna. (Tato vlastnost také vrátí jazykovou verzi uživatelského rozhraní aktuálního vlákna.) Pokud je například aplikace zkompilována s výchozími prostředky anglického jazyka v hlavním sestavení a s francouzskými a ruskými prostředky ve dvou satelitních sestaveních a Thread.CurrentUICulture vlastnost je nastavena na fr-FR, správce prostředků načte francouzské prostředky.

Vlastnost můžete explicitně nebo implicitně nastavit CurrentUICulture . Způsob, jak to nastavíte, určí, jak ResourceManager objekt načítá prostředky podle kulturního kontextu.

• Pokud vlastnost Thread.CurrentUICulture explicitně nastavíte na konkrétní jazyk, správce prostředků vždy načte prostředky pro daný jazyk bez ohledu na prohlížeč nebo jazyk operačního systému uživatele. Představte si aplikaci, která je zkompilovaná s výchozími prostředky anglického jazyka a třemi satelitními sestaveními, které obsahují prostředky pro angličtinu (Spojené státy), francouzštinu (Francie) a ruštinu (Rusko). Pokud je vlastnost CurrentUICulture nastavena na fr-FR, objekt ResourceManager vždy načte francouzské (francouzské) prostředky, i když jazyk operačního systému uživatele není francouzština. Před explicitně nastavením vlastnosti se ujistěte, že se jedná o požadované chování.

  V ASP.NET aplikacích musíte vlastnost nastavit Thread.CurrentUICulture explicitně, protože je nepravděpodobné, že by nastavení na serveru odpovídalo příchozím žádostem klienta. Aplikace ASP.NET může vlastnost explicitně nastavit Thread.CurrentUICulture na jazyk, který přijímá prohlížeč uživatele.

  Výslovné nastavení vlastnosti Thread.CurrentUICulture definuje aktuální jazykovou verzi uživatelského rozhraní pro dané vlákno. Nemá vliv na aktuální kulturu uživatelského rozhraní žádného jiného vlákna v aplikaci.

• Jazykovou verzi uživatelského rozhraní všech vláken v doméně aplikace můžete nastavit přiřazením objektu CultureInfo , který představuje tuto jazykovou verzi statické CultureInfo.DefaultThreadCurrentUICulture vlastnosti.

• Pokud explicitně nenastavíte aktuální jazykovou verzi uživatelského rozhraní a nedefinujete výchozí jazykovou verzi pro aktuální doménu aplikace, CultureInfo.CurrentUICulture vlastnost se nastaví implicitně funkcí Systému Windows GetUserDefaultUILanguage . Tuto funkci poskytuje vícejazyčné uživatelské rozhraní (MUI), které uživateli umožňuje nastavit výchozí jazyk. Pokud uživatel nenastavil jazyk uživatelského rozhraní, je výchozí jazyk nainstalovaný systémem, což je jazyk prostředků operačního systému.

Následující jednoduchý příklad „Ahoj světe“ explicitně nastaví aktuální jazykovou verzi uživatelského rozhraní. Obsahuje zdroje pro tři kultury: angličtina (Spojené státy) nebo en-US, francouzština (Francie) nebo fr-FR, ruština (Rusko) nebo ru-RU. Prostředky en-US jsou obsaženy v textovém souboru s názvem Greetings.txt:

HelloString=Hello world!

Prostředky fr-FR jsou obsaženy v textovém souboru s názvem 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:

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

Tady je zdrojový kód pro příklad (Example.vb pro verzi Jazyka Visual Basic nebo Example.cs pro verzi jazyka C#):

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

public class Example1
{
    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(Example1).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 {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 dávkový soubor (.bat), který obsahuje následující příkazy, a spusťte jej z příkazového řádku. Pokud používáte jazyk C#, zadejte csc místo vbc a Example.cs místo .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

Získat prostředky

Zavoláte metody GetObject(String) a GetString(String) pro přístup ke konkrétnímu prostředku. Můžete také volat metodu GetStream(String) pro načtení neřetězcových prostředků jako pole bajtů. Ve výchozím nastavení tyto metody v aplikaci, která má lokalizované zdroje, vrátí zdroj pro kulturu určenou aktuální kulturou uživatelského rozhraní vlákna, které provedlo volání. Další informace o způsobu definování aktuální kultury uživatelského rozhraní vlákna najdete v předchozí části ResourceManager a prostředky specifické pro kulturu. Pokud správce prostředků nemůže najít prostředek pro kulturní nastavení uživatelského rozhraní aktuálního vlákna, použije k načtení zadaného prostředku náhradní proces. Pokud Správce prostředků nemůže najít žádné lokalizované prostředky, použije prostředky výchozí jazykové verze. Další informace o pravidlech pro použití náhradních prostředků najdete v části Proces náhradního prostředku v článku Balení a nasazování prostředků.

Note

Pokud nelze najít soubor .resources zadaný v konstruktoru třídy ResourceManager, dojde při pokusu o načtení prostředku k vyvolání výjimky MissingManifestResourceException nebo MissingSatelliteAssemblyException. Pro informace o řešení výjimky naleznete v části Handle MissingManifestResourceException a MissingSatelliteAssemblyException Výjimky dále v tomto článku.

Následující příklad používá metodu GetString k načtení kulturně specifických prostředků. Skládá se ze zdrojů zkompilovaných ze souborů .txt pro anglické (en), francouzské (Francie) (fr-FR) a ruské (Rusko) (ru-RU) kultury. Příklad změní aktuální kulturu a aktuální jazykovou verzi uživatelského rozhraní na angličtinu (Spojené státy), francouzštinu (Francie), ruštinu (Rusko) a švédštinu (Švédsko). Potom zavolá metodu GetString k načtení lokalizovaného řetězce, který se zobrazí spolu s aktuálním dnem a měsícem. Všimněte si, že výstup zobrazí odpovídající lokalizovaný řetězec s výjimkou případů, kdy je aktuální jazyková verze uživatelského rozhraní švédština (Švédsko). 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.

Příklad vyžaduje textové soubory prostředků uvedené v následující tabulce. Každý má jeden řetězcový zdroj s názvem DateStart.

Kultura	Název souboru	Název prostředku	Hodnota zdroje
en-US	DateStrings.txt	DateStart	Dnes je
fr-FR	DateStrings.fr-FR.txt	DateStart	Dnes je to.
ru-RU	DateStrings.ru-RU.txt	DateStart	Сегодня

Tady je zdrojový kód pro příklad (ShowDate.vb pro verzi jazyka Visual Basic nebo ShowDate.cs pro verzi kódu jazyka C#).

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

[assembly: NeutralResourcesLanguage("en")]

public class ShowDateEx
{
    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: {CultureInfo.CurrentUICulture.Name}");
            string dateString = rm.GetString("DateStart");
            Console.WriteLine($"{dateString} {DateTime.Now:M}.\n");
        }
    }
}

// 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 Example5
    Public Sub Main()
        Dim cultureNames() As String = {"en-US", "fr-FR", "ru-RU", "sv-SE"}
        Dim rm As New ResourceManager("DateStrings",
                                    GetType(Example5).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. Pokud používáte jazyk C#, zadejte csc místo vbc a showdate.cs místo .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 konkrétní kultury, jiné než aktuální kultura uživatelského rozhraní:

• Můžete zavolat metodu GetString(String, CultureInfo), GetObject(String, CultureInfo) nebo GetStream(String, CultureInfo) pro načtení prostředku pro konkrétní jazykovou verzi. Pokud nelze najít lokalizovaný prostředek, správce prostředků použije proces náhradního prostředku k vyhledání příslušného prostředku.
• Můžete volat metodu GetResourceSet k získání objektu ResourceSet, který představuje prostředky pro konkrétní jazykovou verzi. Ve volání metody můžete určit, jestli správce prostředků testuje nadřazené jazykové verze, pokud nedokáže najít lokalizované prostředky, nebo jestli se jednoduše vrátí k prostředkům výchozí jazykové verze. 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 vytvoření výčtu prostředků v sadě.

Zpracování výjimek MissingManifestResourceException a MissingSatelliteAssemblyException

Pokud se pokusíte načíst konkrétní prostředek, ale správce prostředků nemůže tento prostředek najít a buď není definována žádná výchozí jazyková verze, nebo prostředky výchozí jazykové verze nelze najít, správce MissingManifestResourceException prostředků vyvolá výjimku, pokud očekává, že najde prostředky v hlavním sestavení nebo MissingSatelliteAssemblyException pokud očekává, že najde prostředky ve satelitním sestavení. Všimněte si, že výjimka je vyvolána při volání metody načtení prostředku, například GetString nebo GetObject, a ne při vytvoření instance objektu ResourceManager .

Výjimka se obvykle vyvolá za následujících podmínek:

• Příslušný soubor prostředků nebo satelitní sestavení neexistuje. Pokud správce prostředků očekává, že se výchozí prostředky aplikace vloží do hlavního sestavení aplikace, chybí. NeutralResourcesLanguageAttribute Pokud atribut označuje, že výchozí prostředky aplikace se nacházejí v satelitním sestavení, nelze toto sestavení najít. Při kompilaci aplikace se ujistěte, že jsou prostředky vloženy do hlavního sestavení nebo že se vygeneruje potřebné satelitní sestavení a správně se jmenuje. Jeho název by měl mít tvar appName.resources.dlla měl by být umístěn v adresáři pojmenovaném po jazykové verzi, jejíž prostředky obsahuje.

• Vaše aplikace nemá definovanou výchozí nebo neutrální kulturu. NeutralResourcesLanguageAttribute Přidejte atribut do souboru zdrojového kódu nebo do informačního souboru projektu (AssemblyInfo.vb pro soubor aplikace jazyka Visual Basic nebo AssemblyInfo.cs pro aplikaci jazyka C#).

• Parametr baseName v konstruktoru ResourceManager(String, Assembly) nezadá název souboru .resources. Název by měl obsahovat plně kvalifikovaný obor názvů souboru prostředků, ale neměl by zahrnovat jeho příponu. Soubory prostředků vytvořené v sadě Visual Studio obvykle obsahují názvy oborů, ale soubory prostředků vytvořené a kompilované na příkazovém řádku ne. Názvy vložených souborů .resources můžete určit kompilací a spuštěním následujícího nástroje. Jedná se o konzolovou aplikaci, která přijímá název hlavního sestavení nebo satelitního sestavení jako parametr příkazového řádku. Zobrazuje řetězce, které je třeba zadat jako baseName parametr, aby správce prostředků mohl prostředek správně identifikovat.

  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 explicitně měníte aktuální kulturu své aplikace, měli byste si také uvědomit, že správce prostředků načte sadu prostředků na základě hodnoty vlastnosti CultureInfo.CurrentUICulture, a ne CultureInfo.CurrentCulture. Obvykle platí, že pokud změníte jednu hodnotu, měli byste také změnit druhou.

Verzování prostředků

Vzhledem k tomu, že hlavní sestavení, které obsahuje výchozí prostředky aplikace, je oddělené od satelitních sestavení aplikace, můžete vydat novou verzi hlavního sestavení bez opětovného nasazení satelitních sestavení. Atribut SatelliteContractVersionAttribute dává správci prostředků pokyn, aby používal existující satelitní sestavení a aby je znovu nasadil novou verzí hlavního sestavení.

Další informace o podpoře verzování satelitních sestavení najdete v článku Načítání prostředků.

Konstruktory

Name	Description
ResourceManager()	Inicializuje novou instanci ResourceManager třídy s výchozími hodnotami.
ResourceManager(String, Assembly, Type)	Inicializuje novou instanci ResourceManager třídy, která používá zadanou ResourceSet třídu k vyhledání prostředků obsažených v souborech se zadaným kořenovým názvem v daném sestavení.
ResourceManager(String, Assembly)	Inicializuje novou instanci ResourceManager třídy, která vyhledá prostředky obsažené v souborech se zadaným kořenovým názvem v daném sestavení.
ResourceManager(Type)	Inicializuje novou instanci ResourceManager třídy, která vyhledá prostředky v satelitních sestaveních na základě informací ze zadaného objektu typu.

Pole

Name	Description
HeaderVersionNumber	Určuje verzi hlaviček souboru prostředků, které může aktuální implementace ResourceManager interpretovat a vytvářet.
MagicNumber	Obsahuje číslo použité k identifikaci souborů prostředků.
MainAssembly	Určuje hlavní sestavení, které obsahuje prostředky.

Vlastnosti

Name	Description
BaseName	Získá kořenový název souborů prostředků, které ResourceManager hledá prostředky.
FallbackLocation	Získá nebo nastaví umístění, ze kterého se mají načíst výchozí záložní prostředky.
IgnoreCase	Získá nebo nastaví hodnotu, která určuje, zda Správce prostředků umožňuje vyhledávání prostředků nerozlišující malá a velká písmena v GetString(String) a GetObject(String) metody.
ResourceSetType	Získá typ objektu sady prostředků, který správce prostředků používá k vytvoření ResourceSet objektu.

Metody

Name	Description
CreateFileBasedResourceManager(String, String, Type)	ResourceManager Vrátí objekt, který hledá konkrétní adresář místo manifestu sestavení pro prostředky.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetNeutralResourcesLanguage(Assembly)	Vrátí informace specifické pro jazykovou verzi pro výchozí prostředky hlavního sestavení načtením hodnoty atributu NeutralResourcesLanguageAttribute v zadaném sestavení.
GetObject(String, CultureInfo)	Získá hodnotu zadaného neřetězcového prostředku lokalizovaného pro zadanou jazykovou verzi.
GetObject(String)	Vrátí hodnotu zadaného neřetězcového prostředku.
GetResourceFileName(CultureInfo)	Vygeneruje název souboru prostředků pro daný objekt CultureInfo.
GetResourceSet(CultureInfo, Boolean, Boolean)	Načte sadu prostředků pro konkrétní jazykovou verzi.
GetSatelliteContractVersion(Assembly)	Vrátí verzi určenou atributem SatelliteContractVersionAttribute v daném sestavení.
GetStream(String, CultureInfo)	Vrátí nespravovaný objekt datového proudu paměti ze zadaného prostředku pomocí zadané jazykové verze.
GetStream(String)	Vrátí nespravovaný objekt datového proudu paměti ze zadaného prostředku.
GetString(String, CultureInfo)	Vrátí hodnotu řetězcového prostředku lokalizovaného pro zadanou jazykovou verzi.
GetString(String)	Vrátí hodnotu zadaného řetězcového prostředku.
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InternalGetResourceSet(CultureInfo, Boolean, Boolean)	Poskytuje implementaci pro vyhledání sady prostředků.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ReleaseAllResources()	Řekne správci prostředků, aby volal metodu Close() pro všechny objekty ResourceSet a uvolnil všechny prostředky.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

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

Tento typ je bezpečný pro přístup z více vláken.

Viz také

• CultureInfo
• CurrentUICulture
• SatelliteContractVersionAttribute
• Prostředky v aplikacích