Megosztás a következőn keresztül:

System.Resources.ResourceManager osztály

Megjegyzés

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

Fontos

Az osztályból származó metódusok nem megbízható adatokkal való meghívása biztonsági kockázatot jelent. Csak megbízható adatokkal hívja meg ennek az osztálynak a metódusait. További információ: Minden bemenet ellenőrzése.

A ResourceManager osztály egy szerelvénybe beágyazott bináris .resources fájlból vagy különálló .resources fájlból kéri le az erőforrásokat. Ha egy alkalmazást honosítottak, és honosított erőforrásokat telepítettek a műholdas szerelvényekben, akkor keresi a kultúraspecifikus erőforrásokat, biztosítja az erőforrás-tartalékot, ha nem létezik honosított erőforrás, és támogatja az erőforrás-szerializálást.

Asztali alkalmazások

Asztali alkalmazások esetén a ResourceManager osztály bináris erőforrásfájlokból (.resources) kéri le az erőforrásokat. A nyelvi fordító vagy a Assembly Linker (AL.exe) általában beágyazza ezeket az erőforrásfájlokat egy szerelvénybe. Egy ResourceManager objektummal közvetlenül is lekérheti az erőforrásokat egy olyan .resources-fájlból, amely nincs beágyazva egy szerelvénybe, a CreateFileBasedResourceManager metódus meghívásával.

Figyelmeztetés

Ha különálló .resources fájlokat használ egy ASP.NET alkalmazásban, az megszakítja az XCOPY üzembe helyezését, mivel az erőforrások zárolva maradnak, amíg a ReleaseAllResources metódus explicit módon nem bocsátja ki őket. Ha erőforrásokat szeretne üzembe helyezni az ASP.NET-alkalmazásokkal, a .resources fájlokat műhold-összeállításokká kell kompilálnia.

Egy erőforrás-alapú alkalmazásban egy .resources-fájl tartalmazza az alapértelmezett kultúra erőforrásait, amelyek erőforrásait akkor használja a rendszer, ha nem található kultúraspecifikus erőforrás. Ha például egy alkalmazás alapértelmezett kultúrája az angol (en), akkor az angol nyelvű erőforrásokat akkor használja a rendszer, ha egy adott kultúrához nem találhatók honosított erőforrások, például angol (Egyesült Államok) (en-US) vagy francia (franciaországi) (fr-FR). Az alapértelmezett kultúra erőforrásai általában a fő alkalmazásszerelvénybe vannak beágyazva, más honosított kultúrák erőforrásai pedig műholdas szerelvényekbe vannak ágyazva. A műhold-összeállítások csak erőforrásokat tartalmaznak. Ugyanazzal a gyökérfájlnévvel rendelkeznek, mint a fő szerelvény és a .resources.dllkiterjesztése. Azoknál az alkalmazásoknál, amelyeknek szerelvényei nincsenek regisztrálva a globális szerelvény-gyorsítótárban, a műholdas szerelvények egy alkalmazás alkönyvtárában vannak tárolva, melynek neve megfelel a szerelvény nyelvi kultúrájának.

Erőforrások létrehozása

Erőforrás-alapú alkalmazás fejlesztésekor az erőforrás-információkat szövegfájlokban (.txt vagy .restext kiterjesztésű fájlokban) vagy XML-fájlokban (.resx kiterjesztésű fájlokban) tárolja. Ezután a szöveg- vagy XML-fájlokat a erőforrásfájl-generátorral (Resgen.exe) használatával bináris .resources fájlba állítja össze. Ezután beágyazhatja az eredményként kapott .resources fájlt egy végrehajtható vagy tárba egy olyan fordítóbeállítással, mint a C# és a Visual Basic fordítók /resources, vagy a Assembly Linker (AI.exe)használatával ágyazhatja be egy műholdas szerelvénybe. Ha .resx-fájlt tartalmaz a Visual Studio-projektben, a Visual Studio automatikusan kezeli az alapértelmezett és honosított erőforrások fordítását és beágyazását a buildelési folyamat részeként.

Ideális esetben minden olyan nyelvhez létre kell hoznia erőforrásokat, amit az alkalmazás támogat, vagy legalább az egyes nyelvek értelmes részhalmazához. A bináris .resources fájlnevek az elnevezési konvenciót követik: basename.cultureName.resources, ahol basename az alkalmazás vagy egy osztály neve a kívánt részletességi szinttől függően. A CultureInfo.Name tulajdonság cultureNamemeghatározására szolgál. Az alkalmazás alapértelmezett kultúrájához tartozó erőforrásnak a(z) alapnév.resources nevet kell adnia.

Tegyük fel például, hogy egy szerelvény több erőforrással rendelkezik egy myResources alapnévvel rendelkező erőforrásfájlban. Ezeknek az erőforrásfájloknak olyan nevekkel kell rendelkezniük, mint a MyResources.ja-JP.resources for the Japan (japán) kultúra, MyResources.de.resources for the german culture, MyResources.zh-CHS.resources for the egyszerűsített kínai kultúra és MyResources.fr-BE.resources a francia (Belgium) kultúrához. Az alapértelmezett erőforrásfájl neve MyResources.resources legyen. A kultúraspecifikus erőforrásfájlokat általában sateliteszerelvényekbe csomagolják minden kultúrához. Az alapértelmezett erőforrásfájlt be kell ágyazni az alkalmazás főszerelvényébe.

Ne feledje, hogy Assembly Linker lehetővé teszi az erőforrások privátként való megjelölését, de mindig jelölje meg nyilvánosként őket, hogy más ötvözetek elérhessék őket. (Mivel egy műholdas szerelvény nem tartalmaz kódot, a privátként megjelölt erőforrások semmilyen mechanizmuson keresztül nem érhetők el az alkalmazás számára.)

Az erőforrások létrehozásáról, csomagolásáról és üzembe helyezéséről további információt Erőforrásfájlok létrehozása, Műholdas szerelvények létrehozása, valamint Erőforrások csomagolása és üzembe helyezésecímű cikkben talál.

ResourceManager-objektum példányosítása

Az egyik osztálykonstruktor túlterhelésének meghívásával példányosít egy ResourceManager objektumot, amely erőforrásokat kér le egy beágyazott .resources fájlból. Ez szorosan összekapcsol egy ResourceManager objektumot egy adott .resources fájllal és a műholdas szerelvényekhez tartozó lokalizált .resources fájlokkal.

A két leggyakrabban használt konstruktor a következő:

  • ResourceManager(String, Assembly) két megadott információ alapján keresi meg az erőforrásokat: a .resources fájl alapneve és az alapértelmezett .resources fájl szerelvénye alapján. Az alapnév tartalmazza a .resources fájl névterét és gyökérnevét, annak kultúrája vagy kiterjesztése nélkül. Vegye figyelembe, hogy a parancssorból lefordított .resources fájlok általában nem tartalmaznak névtérnevet, míg a Visual Studio-környezetben létrehozott .resources fájlok igen. Ha például egy erőforrásfájl neve MyCompany.StringResources.resources, és a ResourceManager konstruktor egy Example.Mainnevű statikus metódusból van meghívva, az alábbi kód létrehoz egy ResourceManager objektumot, amely le tudja kérni az erőforrásokat az .resources fájlból:

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

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

  • ResourceManager(Type) egy típusobjektum információi alapján megkeresi az erőforrásokat a műholdas szerelvényekben. A típus teljes neve megfelel a .resources fájl alapnevének a fájlnévkiterjesztés nélkül. A Visual Studio Resource Designerrel létrehozott asztali alkalmazásokban a Visual Studio létrehoz egy burkolóosztályt, amelynek teljes neve megegyezik a .resources fájl gyökér nevével. Ha például egy erőforrásfájl neve MyCompany.StringResources.resources, és van egy MyCompany.StringResourcesnevű burkolóosztály, a következő kód létrehoz egy ResourceManager objektumot, amely le tudja kérni az erőforrásokat az .resources fájlból:

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

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

Ha a megfelelő erőforrások nem találhatók, a konstruktorhívás létrehoz egy érvényes ResourceManager objektumot. Az erőforrás lekérésére tett kísérlet azonban MissingManifestResourceException kivételt eredményez. A kivétellel történő bánásmódról a cikk későbbi, Handle MissingManifestResourceException és MissingSatelliteAssemblyException Exceptions szakaszában olvashat.

Az alábbi példa bemutatja, hogyan lehet példányosítani egy ResourceManager objektumot. Egy ShowTime.exenevű végrehajtható fájl forráskódját tartalmazza. A következő, Strings.txt nevű szövegfájlt is tartalmazza, amely egyetlen sztringerőforrást tartalmaz, TimeHeader:

TimeHeader=The current time is

Kötegelt fájl használatával létrehozhatja az erőforrásfájlt, és beágyazhatja a végrehajtható fájlba. A C#-fordítóval végrehajtható fájl létrehozásához a következő kötegfájlt kell használni:

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

A Visual Basic fordítóhoz a következő kötegfájlt használhatja:

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 és kultúraspecifikus erőforrások

A honosított alkalmazások használatához erőforrásokat kell üzembe helyezni, amint az Erőforrások csomagolása és üzembe helyezésecímű cikkben leírtak szerint. Ha a szerelvények megfelelően vannak konfigurálva, az erőforrás-kezelő határozza meg, hogy az aktuális szál Thread.CurrentUICulture tulajdonsága alapján mely erőforrásokat kérje le. (Ez a tulajdonság az aktuális szál felhasználói felületi kultúráját is visszaadja.) Ha például egy alkalmazás a főszerelvény alapértelmezett angol nyelvű erőforrásaival, valamint két műholdas szerelvényben francia és orosz nyelvű erőforrásokkal van lefordítva, és a Thread.CurrentUICulture tulajdonság értéke fr-FR, az erőforrás-kezelő lekéri a francia erőforrásokat.

A CurrentUICulture tulajdonságot explicit módon vagy implicit módon is beállíthatja. A beállítás módja határozza meg, hogy a ResourceManager objektum hogyan kéri le az erőforrásokat a kultúra alapján:

  • Ha kifejezetten egy adott kultúrára állítja be a Thread.CurrentUICulture tulajdonságot, az erőforrás-kezelő mindig lekéri az adott kultúrához tartozó erőforrásokat, függetlenül a felhasználó böngészőjének vagy operációs rendszerének nyelvétől. Fontolja meg az alapértelmezett angol nyelvű erőforrásokból és három műholdas szerelvényekből álló alkalmazást, amely angol (Egyesült Államok), francia (Franciaország) és orosz (Oroszország) erőforrásokat tartalmaz. Ha a CurrentUICulture tulajdonság értéke fr-FR, akkor a ResourceManager objektum mindig lekéri a francia (Franciaország) erőforrásokat, még akkor is, ha a felhasználó operációsrendszer-nyelve nem francia. Mielőtt explicit módon beállítja a tulajdonságot, győződjön meg arról, hogy ez a kívánt viselkedés.

    Az ASP.NET-alkalmazásokban explicit módon kell beállítania a Thread.CurrentUICulture tulajdonságot, mert nem valószínű, hogy a kiszolgálón lévő beállítás megfelel a bejövő ügyfélkéréseknek. Az ASP.NET-alkalmazások a Thread.CurrentUICulture tulajdonságot kifejezetten a felhasználó böngésző elfogadó nyelvére állíthatják be.

    A Thread.CurrentUICulture tulajdonság explicit beállítása az adott szál aktuális felhasználói felületi kultúráját határozza meg. Ez nem befolyásolja az alkalmazás többi szálának jelenlegi felhasználói felületi kultúráját.

  • Az alkalmazástartomány összes szálának felhasználói felületi kultúráját úgy állíthatja be, hogy hozzárendel egy CultureInfo objektumot, amely az adott kultúrát képviseli a statikus CultureInfo.DefaultThreadCurrentUICulture tulajdonsághoz.

  • Ha nem állítja be explicit módon az aktuális felhasználói felületi kultúrát, és nem definiál alapértelmezett kulturális környezetet az aktuális alkalmazástartományhoz, a CultureInfo.CurrentUICulture tulajdonságot implicit módon állítja be a Windows GetUserDefaultUILanguage függvény. Ezt a függvényt a többnyelvű felhasználói felület (MUI) biztosítja, amely lehetővé teszi a felhasználó számára az alapértelmezett nyelv beállítását. Ha a felhasználói felület nyelvét nem a felhasználó állítja be, akkor alapértelmezés szerint a rendszer által telepített nyelvre, vagyis az operációsrendszer-erőforrások nyelvére van beállítva.

Az alábbi egyszerű "Hello world" példa explicit módon állítja be a jelenlegi felhasználói felületi kultúrát. Három kultúrához tartalmaz erőforrásokat: angol (Egyesült Államok) vagy en-US, francia (Franciaország) vagy fr-FR, valamint orosz (Oroszország) vagy ru-RU. A en-US erőforrások egy Greetings.txtnevű szövegfájlban találhatók:

HelloString=Hello world!

A fr-FR erőforrások egy Greetings.fr-FR.txtnevű szövegfájlban találhatók:

HelloString=Salut tout le monde!

A ru-RU erőforrások egy Greetings.ru-RU.txtnevű szövegfájlban találhatók:

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

A példa forráskódja (Example.vb a Visual Basic vagy a C#-verzió Example.cs esetében):

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 {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.
'       Всем привет!

A példa fordításához hozzon létre egy kötegfájlt (.bat), amely a következő parancsokat tartalmazza, és futtassa a parancssorból. Ha C#-ot használ, adja meg a csc-t a vbc helyett, és a Example.cs-t a Example.vbhelyett.

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

Erőforrások lekérése

Meghívja a GetObject(String) és GetString(String) metódusokat egy adott erőforrás eléréséhez. Meghívhatja a GetStream(String) metódust is a nem sztring típusú erőforrások bájttömbként való lekéréséhez. Alapértelmezés szerint a honosított erőforrásokkal rendelkező alkalmazásokban ezek a metódusok a hívást kezdeményező szál aktuális felhasználói felületi kultúrája által meghatározott kultúrához tartozó erőforrást adják vissza. Az előző, ResourceManager és kultúraspecifikus erőforrásokcímű szakaszban további információt talál a szál aktuális felhasználói felületi kultúrájának definiálásáról. Ha az erőforrás-kezelő nem találja az aktuális szál felhasználói felületi kultúrájához tartozó erőforrást, tartalék folyamatot használ a megadott erőforrás lekéréséhez. Ha az erőforrás-kezelő nem talál honosított erőforrásokat, az alapértelmezett kultúra erőforrásait használja. Az erőforrás-visszavételi szabályokról további információt az erőforrások csomagolása és üzembe helyezése című cikk "Erőforrás-tartalékfolyamat" című szakaszában talál.

Megjegyzés

Ha a ResourceManager osztálykonstruktorban megadott .resources fájl nem található, az erőforrás lekérésének kísérlete MissingManifestResourceException vagy MissingSatelliteAssemblyException kivételt eredményez. A kivétellel történő bánásmódról a cikk későbbi, Handle MissingManifestResourceException és MissingSatelliteAssemblyException Exceptions szakaszában olvashat.

Az alábbi példa a GetString metódust használja a kultúraspecifikus erőforrások lekéréséhez. Az .txt angol (en), francia (franciaországi) (fr-FR) és orosz (ru-RU) kultúrák fájljaiból összeállított erőforrásokból áll. A példa a jelenlegi kultúrát és a jelenlegi felhasználói felületi kultúrát angol (Egyesült Államok), francia (Franciaország), orosz (Oroszország) és svéd (Svédország) nyelvre módosítja. Ezután meghívja a GetString metódust a honosított karakterlánc lekéréséhez, amelyet az aktuális nap és hónap megjelenítésével együtt jelenít meg. Figyelje meg, hogy a kimenet a megfelelő honosított sztringet jeleníti meg, kivéve, ha a jelenlegi felhasználói felületi kultúra svéd (Svédország). Mivel a svéd nyelvű erőforrások nem érhetők el, az alkalmazás ehelyett az alapértelmezett kultúra erőforrásait használja, amely angol.

A példához a következő táblázatban felsorolt szövegalapú erőforrásfájlok szükségesek. Mindegyik egy DateStartnevű karakterlánc erőforrással rendelkezik.

Kultúra Fájlnév Erőforrás neve Erőforrás-érték
en-US DateStrings.txt DateStart Ma van
fr-FR DateStrings.fr-FR.txt DateStart Aujourd'hui, c'est le
ru-RU DateStrings.ru-RU.txt DateStart Сегодня

Íme a példa forráskódja (a Visual Basic verzió esetén ShowDate.vb, vagy a kód C# verziójához ShowDate.cs).

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.

A példa fordításához hozzon létre egy kötegfájlt, amely a következő parancsokat tartalmazza, és futtassa a parancssorból. Ha C#-ot használ, adja meg a csc-t a vbc helyett, és a showdate.cs-t a showdate.vbhelyett.

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

A jelenlegi felhasználói felületi kultúrától eltérő adott kultúra erőforrásait kétféleképpen lehet lekérni:

  • Meghívhatja a GetString(String, CultureInfo), GetObject(String, CultureInfo)vagy GetStream(String, CultureInfo) metódust egy adott kultúrához tartozó erőforrás lekéréséhez. Ha nem található honosított erőforrás, az erőforrás-kezelő az erőforrás-visszavételi folyamat segítségével megkeresi a megfelelő erőforrást.
  • Meghívhatja a GetResourceSet metódust egy ResourceSet objektum beszerzéséhez, amely egy adott kultúra erőforrásait jelöli. A metódushívásban meghatározhatja, hogy az erőforrás-kezelő mintavételezi-e a szülőkultúrákat, ha nem talál honosított erőforrásokat, vagy egyszerűen visszaesik az alapértelmezett kultúra erőforrásaira. Ezután a ResourceSet metódusok használatával név alapján érheti el az erőforrásokat (az adott kultúrához honosítva), vagy számba vehet erőforrásokat a készletben.

MissingManifestResourceException és MissingSatelliteAssemblyException kivételek kezelése

Ha megpróbál lekérni egy adott erőforrást, de az erőforrás-kezelő nem találja azt az erőforrást, és vagy nincs meghatározva alapértelmezett kultúra, vagy az alapértelmezett kultúra erőforrásai nem találhatók, az erőforrás-kezelő kivételt MissingManifestResourceException, ha arra számít, hogy megkeresi az erőforrásokat a főszerelvényben, vagy egy MissingSatelliteAssemblyException, ha azt várja, hogy az erőforrásokat egy műholdas szerelvényben találja. Vegye figyelembe, hogy a kivétel akkor fordul elő, ha egy erőforrás-lekérési metódust ( például GetString vagy GetObject) hív meg, és nem akkor, amikor egy ResourceManager objektumot példányosít.

A kivétel általában a következő feltételek mellett történik:

  • A megfelelő erőforrásfájl vagy műholdas szerelvény nem létezik. Ha az erőforrás-kezelő elvárja, hogy az alkalmazás alapértelmezett erőforrásai beágyazódjanak a fő alkalmazásszerelvénybe, azok hiányoznak. Ha a NeutralResourcesLanguageAttribute attribútum azt jelzi, hogy az alkalmazás alapértelmezett erőforrásai egy műholdas szerelvényben találhatók, a szerelvény nem található. Az alkalmazás fordításakor győződjön meg róla, hogy az erőforrások a fő összeállításba vannak ágyazva, vagy hogy létrejön a szükséges műhold-összeállítás, amely megfelelően van elnevezve. A névnek appName.resources.dllformában kell lennie, és egy olyan könyvtárban kell elhelyezkednie, amely annak a kultúrának a nevét viseli, amelynek erőforrásait tartalmazza.

  • Az alkalmazás nem rendelkezik definiált alapértelmezett vagy semleges kultúrával. Adja hozzá a NeutralResourcesLanguageAttribute attribútumot egy forráskódfájlhoz vagy a projektinformációs fájlhoz (Visual Basic-alkalmazáshoz AssemblyInfo.vb vagy egy C#-alkalmazáshoz AssemblyInfo.cs) fájlhoz.

  • A baseName konstruktor ResourceManager(String, Assembly) paramétere nem adja meg a .resources fájl nevét. A névnek tartalmaznia kell az erőforrásfájl teljes névterét, de a fájlnévkiterjesztését nem. A Visual Studióban létrehozott erőforrásfájlok általában névtérneveket tartalmaznak, de a parancssorban létrehozott és lefordított erőforrásfájlok nem. A beágyazott .resources fájlok nevét az alábbi segédprogram összeállításával és futtatásával határozhatja meg. Ez egy konzolalkalmazás, amely parancssori paraméterként fogadja el a főszerelvény vagy a műholdas szerelvény nevét. Megjeleníti azokat a sztringeket, amelyeket baseName paraméterként kell megadni, hogy az erőforrás-kezelő megfelelően azonosíthassa az erőforrást.

    using System;
using System.IO;
using System.Reflection;

public class Example0
{
   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($"{filename} does not exist.");
         return;
      }   
      
      // Try to load the assembly.
      Assembly assem = Assembly.LoadFrom(filename);
      Console.WriteLine($"File: {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: {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

Ha kifejezetten módosítja az alkalmazás jelenlegi kultúráját, ne feledje, hogy az erőforrás-kezelő a CultureInfo.CurrentUICulture tulajdonság értéke alapján kér le egy erőforráskészletet, nem pedig a CultureInfo.CurrentCulture tulajdonság alapján. Ha az egyik értéket módosítja, általában a másikat is módosítania kell.

Erőforrás-verziókezelés

Mivel az alkalmazás alapértelmezett erőforrásait tartalmazó főszerelvény különbözik az alkalmazás műholdszerelvényeitől, a műholdszerelvények ismételt üzembe helyezése nélkül is kiadhatja a főszerelvény új verzióját. A SatelliteContractVersionAttribute attribútumot használja meglévő műholdas szerelvények használatára, és utasítja az erőforrás-kezelőt, hogy ne telepítse újra őket a főszerelvény új verziójával,

A műholdas szerelvények verziószámozási támogatásáról a Erőforrások lekérésecímű cikkben talál további információt.

<satelliteassemblies> konfigurációs fájlcsomópont

Megjegyzés

Ez a szakasz a .NET-keretrendszeralkalmazásokra vonatkozik.

Webhelyről üzembe helyezett és futtatott végrehajtható fájlok (HREF .exe fájlok) esetén a ResourceManager objektum a weben lévő műholdas szerelvényeket is megvizsgálhatja, ami ronthatja az alkalmazás teljesítményét. A teljesítményprobléma kiküszöbölése érdekében ezt a műveletet az alkalmazással üzembe helyezett műholdas szerelvényekre korlátozhatja. Ehhez létre kell hoznia egy <satelliteassemblies> csomópontot az alkalmazás konfigurációs fájljában annak megadásához, hogy az alkalmazáshoz egy adott kulturális csoportot telepített, és hogy a ResourceManager objektum ne próbálja meg az adott csomóponton nem szereplő kulturális környezetek mintavételét.

Megjegyzés

A <satelliteassemblies> csomópont létrehozásának előnyben részesített alternatívája a ClickOnce üzembe helyezési jegyzék funkció használata.

Az alkalmazás konfigurációs fájljában hozzon létre egy, a következőhöz hasonló szakaszt:

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

Módosítsa a konfigurációs információkat az alábbiak szerint:

  • Adjon meg egy vagy több <assembly> csomópontot minden üzembe helyezett főszerelvényhez, ahol minden csomópont egy teljes körű szerelvénynevet ad meg. Adja meg a főszerelvény nevét MainAssemblyNamehelyett, és adja meg a főszerelvénynek megfelelő Version, PublicKeyTokenés Culture attribútumértékeket.

    A Version attribútumhoz adja meg a szerelvény verziószámát. A szerelvény első kiadása lehet például az 1.0.0.0-s verziószám.

    Az PublicKeyToken attribútumhoz adja meg a null kulcsszót, ha nem erős névvel írta alá az összeállítást, vagy ha aláírta az összeállítást, adja meg a nyilvános kulcs jogkivonatát.

    Az Culture attribútumhoz adja meg a neutral kulcsszót, hogy kijelölje a fő szerelvényt, és az ResourceManager osztály csak a <culture> csomópontokban felsorolt kultúrákat vizsgálja.

    A teljes szerelvénynevekről további információt a szerelvénynevekcímű cikkben talál. Az erős névvel ellátott szerelvényekről további információt az Erős nevű szerelvények létrehozása és használatacímű cikkben talál.

  • Adjon meg egy vagy több <culture> csomópontot egy adott kulturális névvel, például "fr-FR", vagy egy semleges kulturális névvel, például "fr" névvel.

Ha erőforrásokra van szükség a <satelliteassemblies> csomópont alatt nem szereplő összeállításhoz, a ResourceManager osztály kutatja a kultúrákat a szabványos vizsgálati szabályokat használva.

Windows 8.x-alkalmazások

Fontos

Bár a ResourceManager osztály támogatott a Windows 8.x-alkalmazásokban, nem javasoljuk a használatát. Ezt az osztályt csak akkor használja, ha a Windows 8.x-alkalmazásokkal használható hordozható osztálytár-projekteket fejleszt. Ha a Windows 8.x-alkalmazásokból szeretne erőforrásokat lekérni, használja inkább a Windows.ApplicationModel.Resources.ResourceLoader osztályt.

Windows 8.x-alkalmazások esetén a ResourceManager osztály lekéri az erőforrásokat a csomagerőforrás-index (PRI) fájljaiból. Egyetlen PRI-fájl (az alkalmazáscsomag PRI-fájlja) tartalmazza az alapértelmezett és a honosított kultúrák erőforrásait is. A MakePRI segédprogrammal létrehoz egy PRI-fájlt egy vagy több XML-erőforrás (.resw) formátumú erőforrásfájlból. A Visual Studio-projektben szereplő erőforrások esetében a Visual Studio kezeli a PRI-fájl automatikus létrehozásának és csomagolásának folyamatát. Ezután a .NET ResourceManager osztály használatával hozzáférhet az alkalmazás vagy a tár erőforrásaihoz.

A Windows 8.x-alkalmazások ResourceManager objektumainak példányosítása ugyanúgy történik, mint az asztali alkalmazások esetében.

Ezután egy adott kultúra erőforrásait úgy érheti el, hogy átadja a lekérendő erőforrás nevét a GetString(String) metódusnak. Ez a metódus alapértelmezés szerint a hívást kezdeményező szál aktuális felhasználói felületi kultúrája által meghatározott kulturális erőforrást adja vissza. Egy adott kultúrához tartozó erőforrásokat úgy is lekérheti, hogy átadja az erőforrás nevét és egy CultureInfo objektumot, amely azt a kultúrát jelöli, amelynek az erőforrását le kell kérni a GetString(String, CultureInfo) metódusba. Ha az aktuális felhasználói felületi kultúrához vagy a megadott kultúrához tartozó erőforrás nem található, az erőforrás-kezelő egy felhasználói felületi nyelvi tartaléklistával keresi meg a megfelelő erőforrást.

Példák

Az alábbi példa bemutatja, hogyan használható az explicit kultúra és az implicit aktuális UI-kultúra a karakterlánc források fő- és műholdas szerelvényből való beszerzéséhez. További információt a műholdas szerelvények létrehozása témakör "A globális szerelvénygyorsítótárban nincs telepítve a műholdas szerelvények könyvtárhelyei" című szakaszában talál.

A példa futtatásához:

  1. Az alkalmazáskönyvtárban hozzon létre egy rmc.txt nevű fájlt, amely a következő erőforrás-sztringeket tartalmazza:

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

  2. Az Erőforrásfájl-generátor használatával hozza létre az rmc.resources erőforrásfájlt a rmc.txt bemeneti fájlból az alábbiak szerint:

    resgen rmc.txt

  3. Hozzon létre egy alkönyvtárat az alkalmazáskönyvtárból, és nevezze el "es-MX" névvel. Ez annak a műholdas "assembly" kulturális neve, amelyet a következő három lépésben fog létrehozni.

  4. Hozzon létre egy rmc.es-MX.txt nevű fájlt a es-MX könyvtárban, amely a következő erőforrás-sztringeket tartalmazza:

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

  5. Az rmc létrehozásához a rmc.es-MX.txt bemeneti fájlból használja a erőforrásfájl-generátort, hogy elkészítse aes-MX.resources erőforrásfájlt, az alábbiak szerint:

    resgen rmc.es-MX.txt

  6. Tegyük fel, hogy a példa fájlneve rmc.vb vagy rmc.cs. Másolja a következő forráskódot egy fájlba. Ezután fordítsa le, és ágyazza be a végrehajtható összeállításba a fő erőforrásfájlt, azaz az rmc.resources-t. Ha a Visual Basic fordítót használja, a szintaxis a következő:

    vbc rmc.vb /resource:rmc.resources

    A C#-fordító megfelelő szintaxisa a következő:

    csc /resource:rmc.resources rmc.cs

  7. A Assembly Linker segítségével hozzon létre egy műholdas szerelvényt. Ha az alkalmazás alapneve rmc, a műholdas szerelvény nevének rmc.resources.dllkell lennie. A műholdas szerelvényt a es-MX könyvtárban kell létrehozni. Ha es-MX az aktuális könyvtár, használja ezt a parancsot:

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

  8. Futtassa a rmc.exe-t a beágyazott erőforrás-sztringek megszerzéséhez és megjelenítéséhez.

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

class Example2
{
    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 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.
  • Last updated on