Műholdas szerelvények létrehozása .NET-alkalmazásokhoz

Cikk
03/02/2024

Az erőforrásfájlok központi szerepet játszanak a honosított alkalmazásokban. Lehetővé teszik, hogy egy alkalmazás sztringeket, képeket és egyéb adatokat jelenítsen meg a felhasználó nyelvén és kultúrájában, és alternatív adatokat biztosítson, ha a felhasználó nyelvének vagy kultúrájának erőforrásai nem érhetők el. A .NET egy küllős modellt használ a honosított erőforrások megkereséséhez és lekéréséhez. A központ az a fő szerelvény, amely tartalmazza a nem honosítható végrehajtható kódot és az erőforrásokat egyetlen kultúrához, amelyet semleges vagy alapértelmezett kultúrának neveznek. Az alapértelmezett kultúra az alkalmazás tartalék kultúrája; akkor használatos, ha nem érhetők el honosított erőforrások. Az attribútum használatával NeutralResourcesLanguageAttribute kijelölheti az alkalmazás alapértelmezett kultúrájának kultúráját. Minden küllő egy műholdas szerelvényhez csatlakozik, amely egyetlen honosított kultúrához tartozó erőforrásokat tartalmaz, de nem tartalmaz kódot. Mivel a műholdas szerelvények nem részei a főszerelvénynek, egyszerűen frissítheti vagy lecserélheti az adott kultúrának megfelelő erőforrásokat anélkül, hogy lecserélte volna az alkalmazás fő szerelvényét.

Feljegyzés

Az alkalmazás alapértelmezett kultúrájának erőforrásai műholdas szerelvényben is tárolhatók. Ehhez az attribútumot a NeutralResourcesLanguageAttribute következő értékhez rendelheti UltimateResourceFallbackLocation.Satellite: .

Műholdas szerelvény neve és helye

A küllős modellhez szükség van arra, hogy az erőforrásokat meghatározott helyeken helyezze el, hogy azok könnyen elhelyezhetők és használhatók legyenek. Ha nem a várt módon fordítja le és adja el az erőforrásokat, vagy ha nem a megfelelő helyre helyezi őket, a közös nyelvi futtatókörnyezet nem fogja tudni megtalálni őket, és ehelyett az alapértelmezett kultúra erőforrásait fogja használni. A .NET-erőforrás-kezelőt a ResourceManager típus jelöli, és a honosított erőforrások automatikus elérésére szolgál. Az erőforrás-kezelőnek a következőkre van szüksége:

Egyetlen műholdas szerelvénynek tartalmaznia kell egy adott kultúrához szükséges összes erőforrást. Más szóval több .txt vagy .resx fájlt kell egyetlen bináris .resources fájlba lefordítani.
Az alkalmazáskönyvtárban külön alkönyvtárnak kell lennie minden olyan honosított kultúrához, amely az adott kultúra erőforrásait tárolja. Az alkönyvtár nevének meg kell egyeznie a kulturális környezet nevével. Alternatív megoldásként a műholdas szerelvényeket a globális szerelvény-gyorsítótárban is tárolhatja. Ebben az esetben a szerelvény erős nevének kulturális információs összetevőjének meg kell jelölnie annak kultúráját. További információ: Műholdas szerelvények telepítése a globális szerelvénygyorsítótárban.

Feljegyzés

Ha az alkalmazás szubkultúrákhoz tartalmaz erőforrásokat, helyezze az egyes szubkultúrákat egy külön alkönyvtárba az alkalmazáskönyvtár alatt. A szubkultúrákat ne helyezze alkönyvtárakba a fő kulturális könyvtáruk alá.
A műholdas szerelvénynek ugyanazzal a névvel kell rendelkeznie, mint az alkalmazásnak, és a ".resources.dll" fájlnévkiterjesztést kell használnia. Ha például egy alkalmazás neve Example.exe, az egyes műholdszerelvények nevét Example.resources.dll kell megadni. A műholdas szerelvény neve nem jelzi az erőforrásfájlok kultúráját. A műholdas szerelvény azonban megjelenik egy olyan könyvtárban, amely meghatározza a kultúrát.
A műholdas szerelvény kultúrájával kapcsolatos információkat fel kell venni a szerelvény metaadataiba. A kultúra nevének a műholdas szerelvény metaadataiban való tárolásához meg kell adnia azt a lehetőséget, amikor az /culture Assembly Linker használatával ágyazza be az erőforrásokat a műholdas szerelvénybe.

Az alábbi ábra egy mintakönyvtár-struktúrát és helykövetelményeket mutat be a globális szerelvény-gyorsítótárban nem telepített alkalmazásokhoz. A .txt és .resources kiterjesztésű elemek nem lesznek a végső alkalmazással együtt szállítva. Ezek a köztes erőforrásfájlok a végső műholdas erőforrás-szerelvények létrehozásához. Ebben a példában a .resx fájlokat helyettesítheti a .txt fájlokra. További információ: Erőforrások csomagolása és üzembe helyezése.

Az alábbi képen a műholdas szerelvény könyvtára látható:

A satellite assembly directory with localized cultures subdirectories.

Műholdas szerelvények fordítása

Az erőforrásfájl-generátor (resgen.exe) használatával olyan szövegfájlokat vagy XML-fájlokat (.resx) állíthat össze, amelyek erőforrásokat tartalmaznak bináris .resources fájlokhoz. Ezután a Assembly Linker (al.exe) használatával .resources fájlokat fordíthat műholdas szerelvényekbe. al.exe létrehoz egy szerelvényt a megadott .resources fájlokból. A műholdas szerelvények csak erőforrásokat tartalmazhatnak; nem tartalmazhatnak végrehajtható kódot.

Az alábbi al.exe parancs létrehoz egy műholdas szerelvényt az alkalmazáshoz Example a német resources file strings.de.resources fájlból.

al -target:lib -embed:strings.de.resources -culture:de -out:Example.resources.dll

Az alábbi al.exe parancs egy műholdas szerelvényt is létrehoz az alkalmazáshoz Example a strings.de.resources fájlból. A /template beállítás hatására a műholdas szerelvény örökli az összes szerelvény metaadatait, kivéve a szülőszerelvény kulturális adatait (Example.dll).

al -target:lib -embed:strings.de.resources -culture:de -out:Example.resources.dll -template:Example.dll

Az alábbi táblázat részletesebben ismerteti az ezekben a parancsokban használt al.exe beállításokat:

Lehetőség	Leírás
`-target:lib`	Megadja, hogy a műholdas szerelvény egy kódtárfájlba (.dll) legyen lefordítva. Mivel egy műholdas szerelvény nem tartalmaz végrehajtható kódot, és nem az alkalmazás fő szerelvénye, a műholdas szerelvényeket DLL-ként kell mentenie.
`-embed:strings.de.resources`	Megadja a beágyazandó erőforrásfájl nevét, amikor al.exe lefordítja a szerelvényt. Több .resources fájlt is beágyazhat egy műholdas szerelvénybe, de ha a küllős modellt követi, minden kultúrához össze kell állítania egy műholdas szerelvényt. Sztringekhez és objektumokhoz azonban külön .resources fájlokat hozhat létre.
`-culture:de`	A lefordítandó erőforrás kulturális környezetét határozza meg. A közös nyelvi futtatókörnyezet ezt az információt használja, amikor egy adott kultúrához tartozó erőforrásokat keres. Ha kihagyja ezt a beállítást, al.exe továbbra is lefordítja az erőforrást, de a futtatókörnyezet nem fogja tudni megtalálni, amikor egy felhasználó kéri.
`-out:Example.resources.dll`	Megadja a kimeneti fájl nevét. A névnek a standard baseName.resources nevet kell követnie.kiterjesztés, ahol a baseName a főszerelvény neve, és a kiterjesztés érvényes fájlnévkiterjesztés (például .dll). A futtatókörnyezet nem tudja meghatározni egy műholdas szerelvény kultúráját a kimeneti fájl neve alapján; a /culture kapcsolót kell használnia a beállítás megadásához.
`-template:Example.dll`	Olyan szerelvényt ad meg, amelyből a műholdas szerelvény örökli az összes szerelvény metaadatait a kulturális mező kivételével. Ez a beállítás csak akkor érinti a műholdas szerelvényeket, ha erős névvel rendelkező szerelvényt ad meg.

A al.exe elérhető lehetőségek teljes listáját lásd: Assembly Linker (al.exe).

Feljegyzés

Előfordulhatnak olyan esetek, amikor a .NET Core MSBuild feladatot szeretné használni a műholdas szerelvények fordításához, még akkor is, ha .NET-keretrendszer céloz meg. Előfordulhat például, hogy a C#-fordító determinisztikus beállításával összehasonlíthatja a különböző buildekből származó szerelvényeket. Ebben az esetben állítsa a GenerateSatelliteAssembliesForCore értéket a .csproj fájlba, hogy a Al.exe (Assembly Linker) helyett a csc.exe használatával hozzon létre műholdas szerelvényeket.true

<Project>
    <PropertyGroup>
        <GenerateSatelliteAssembliesForCore>true</GenerateSatelliteAssembliesForCore>
    </PropertyGroup>
</Project>

A .NET Core MSBuild feladat alapértelmezés szerint al.exe helyett csc.exe használ a műholdas szerelvények létrehozásához. További információt a "Core" műholdas szerelvény létrehozásának megkönnyítése című témakörben talál.

Példa műholdas szerelvényekre

Az alábbiakban egy egyszerű "Hello world" példa látható, amely egy honosított üdvözlést tartalmazó üzenetmezőt jelenít meg. A példa az angol (Egyesült Államok), a francia (Franciaország) és az orosz (Oroszország) kultúrák erőforrásait tartalmazza, a tartalék kultúrája pedig az angol. A példa létrehozásához tegye a következőket:

Hozzon létre egy Greeting.resx vagy Greeting.txt nevű erőforrásfájlt, amely az alapértelmezett kultúra erőforrását tartalmazza. Egyetlen sztringet HelloString tárolhat ebben a fájlban, amelynek értéke "Hello world!"
Annak jelzéséhez, hogy az angol (en) az alkalmazás alapértelmezett kultúrája, adja hozzá az alábbi System.Resources.NeutralResourcesLanguageAttribute attribútumot az alkalmazás AssemblyInfo-fájljába vagy az alkalmazás fő szerelvényébe lefordítandó fő forráskódfájlhoz.
```
[assembly: NeutralResourcesLanguage("en")]
```
```
<Assembly: NeutralResourcesLanguage("en")>
```
További kultúrák (en-USfr-FRés ru-RU) támogatásának hozzáadása az alkalmazáshoz az alábbiak szerint:
- Az en-US angol (Egyesült Államok) kultúra támogatásához hozzon létre egy Greeting.en-US.resx vagy Greeting.en-US.txt nevű erőforrásfájlt, és tároljon benne egyetlen sztringetHelloString, amelynek értéke "Hi world!".
- A francia (franciaországifr-FR) kultúra támogatásához hozzon létre egy Greeting.fr-FR.resx vagy Greeting.fr-FR.txt nevű erőforrásfájlt, és tároljon benne egyetlen sztringetHelloString, amelynek értéke "Salut tout le monde!".
- Az orosz (oroszországi) kultúra támogatásához ru-RU hozzon létre egy Greeting.ru-RU.resx vagy Greeting.ru-RU.txt nevű erőforrásfájlt, és tároljon benne egyetlen sztringetHelloString, amelynek értéke "Всем привет!".
A resgen.exe használatával lefordíthatja az egyes szöveg- vagy XML-erőforrásfájlokat egy bináris .resources fájlba. A kimenet olyan fájlok készlete, amelyek gyökérfájlnevük megegyezik a .resx vagy a .txt fájl nevével, de .resources kiterjesztéssel rendelkeznek. Ha a példát a Visual Studióval hozza létre, a rendszer automatikusan kezeli a fordítási folyamatot. Ha nem a Visual Studiót használja, futtassa az alábbi parancsokat a .resx fájlok .resources fájlokba való fordításához:
```
resgen Greeting.resx
resgen Greeting.en-us.resx
resgen Greeting.fr-FR.resx
resgen Greeting.ru-RU.resx
```
Ha az erőforrások XML-fájlok helyett szövegfájlokban találhatók, cserélje le a .resx bővítményt .txt.

Fordítsa le a következő forráskódot az alapértelmezett kultúra erőforrásaival együtt az alkalmazás fő szerelvényébe:

Fontos

Ha a példa létrehozásához a Visual Studio helyett a parancssort használja, módosítsa az osztálykonstruktor hívását a ResourceManager következőre: ResourceManager rm = new ResourceManager("Greeting", typeof(Example).Assembly);

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

class Example
{
   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;

      try {
         CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
         Thread.CurrentThread.CurrentCulture = newCulture;
         Thread.CurrentThread.CurrentUICulture = newCulture;
         ResourceManager rm = new ResourceManager("Example.Greeting",
                                                  typeof(Example).Assembly);
         string greeting = String.Format("The current culture is {0}.\n{1}",
                                         Thread.CurrentThread.CurrentUICulture.Name,
                                         rm.GetString("HelloString"));

         MessageBox.Show(greeting);
      }
      catch (CultureNotFoundException e) {
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName);
      }
      finally {
         Thread.CurrentThread.CurrentCulture = originalCulture;
         Thread.CurrentThread.CurrentUICulture = originalCulture;
      }
   }
}

Imports System.Globalization
Imports System.Resources
Imports System.Threading

Module Module1

    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

        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, My.Resources.Greetings.HelloString)

            MsgBox(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

Ha az alkalmazás neve Példa , és a parancssorból származik, a C#-fordító parancsa a következő:

csc Example.cs -res:Greeting.resources

A megfelelő Visual Basic fordítóparancs a következő:

vbc Example.vb -res:Greeting.resources

Hozzon létre egy alkönyvtárat a fő alkalmazáskönyvtárban az alkalmazás által támogatott minden honosított kultúrához. Létre kell hoznia egy en-US-t, egy fr-FR-t és egy ru-RU alkönyvtárat. A Visual Studio automatikusan létrehozza ezeket az alkönyvtárakat a fordítási folyamat részeként.
Ágyazza be az egyes kultúraspecifikus .resources fájlokat műholdas szerelvényekbe, és mentse őket a megfelelő könyvtárba. Az egyes .resources-fájlokhoz a következő parancsot kell végrehajtani:
```
al -target:lib -embed:Greeting.culture.resources -culture:culture -out:culture\Example.resources.dll
```
ahol a kultúra annak a kultúrának a neve, amelynek erőforrásait a műholdas szerelvény tartalmazza. A Visual Studio automatikusan kezeli ezt a folyamatot.

Ezután futtathatja a példát. Véletlenszerűen teszi az egyik támogatott kultúrát a jelenlegi kultúrává, és lokalizált üdvözlést jelenít meg.

Műholdas szerelvények telepítése a globális szerelvénygyorsítótárban

Ahelyett, hogy helyi alkalmazás alkönyvtárában telepítené a szerelvényeket, telepítheti őket a globális szerelvény-gyorsítótárba. Ez különösen akkor hasznos, ha több alkalmazás által használt osztálykódtárakat és osztálytár-erőforrás-szerelvényeket használ.

A szerelvények globális szerelvény-gyorsítótárban való telepítéséhez erős nevekre van szükség. Az erős névvel ellátott szerelvények érvényes nyilvános/titkos kulcspárokkal vannak aláírva. A futtatókörnyezet által a kötési kérések teljesítéséhez használandó szerelvény meghatározásához használt verzióinformációkat tartalmazzák. További információ az erős nevekről és a verziószámozásról: Assembly versioning. Az erős nevekről további információt az Erős nevű szerelvények című témakörben talál.

Alkalmazás fejlesztésekor nem valószínű, hogy hozzáfér a végső nyilvános/titkos kulcspárhoz. Ha egy műholdas szerelvényt szeretne telepíteni a globális szerelvény-gyorsítótárba, és meggyőződni arról, hogy az elvárt módon működik, használhat egy késleltetett aláírás nevű technikát. Ha késlelteti a szerelvény aláírását, a létrehozáskor helyet foglal a fájlban az erős névajánláshoz. A tényleges aláírás későbbre halasztódik, amikor a végső nyilvános/titkos kulcspár elérhető. A késleltetett aláírásról további információt a szerelvény aláírásának késleltetése című témakörben talál.

A nyilvános kulcs beszerzése

A szerelvény aláírásának késleltetéséhez hozzáféréssel kell rendelkeznie a nyilvános kulcshoz. Beszerezheti a valódi nyilvános kulcsot a cégen belüli szervezettől, amely elvégezi a végleges aláírást, vagy létrehozhat egy nyilvános kulcsot az Erős név eszközzel (sn.exe) keresztül.

A következő Sn.exe parancs létrehoz egy nyilvános/titkos kulcspár tesztelését. A –k beállítás azt határozza meg, hogy Sn.exe hozzon létre egy új kulcspárt, és mentse egy TestKeyPair.snk nevű fájlba.

sn –k TestKeyPair.snk

A nyilvános kulcsot kinyerheti a tesztkulcspárt tartalmazó fájlból. A következő parancs kinyeri a nyilvános kulcsot a TestKeyPair.snk fájlból, és menti a PublicKey.snk fájlban:

sn –p TestKeyPair.snk PublicKey.snk

Szerelvény aláírásának késleltetése

A nyilvános kulcs beszerzése vagy létrehozása után a assembly linker (al.exe) használatával lefordíthatja a szerelvényt, és megadhatja a késleltetett aláírást.

A következő al.exe parancs egy erős nevű műholdas szerelvényt hoz létre a StringLibrary alkalmazáshoz a strings.ja.resources fájlból:

al -target:lib -embed:strings.ja.resources -culture:ja -out:StringLibrary.resources.dll -delay+ -keyfile:PublicKey.snk

A -delay+ beállítás azt határozza meg, hogy a Assembly Linkernek késleltetnie kell a szerelvény aláírását. A -keyfile beállítás megadja annak a kulcsfájlnak a nevét, amely a szerelvény aláírásának késleltetéséhez használandó nyilvános kulcsot tartalmazza.

Szerelvény újbóli aláírása

Az alkalmazás üzembe helyezése előtt újra alá kell írnia a késleltetett aláírt műholdas szerelvényt a valódi kulcspárral. Ezt a Sn.exe használatával teheti meg.

Az alábbi Sn.exe parancs aláírja StringLibrary.resources.dll a RealKeyPair.snk fájlban tárolt kulcspárral. Az –R beállítás azt határozza meg, hogy egy korábban aláírt vagy késleltetett aláírt szerelvényt újra alá kell írni.

sn –R StringLibrary.resources.dll RealKeyPair.snk

Műholdas szerelvény telepítése a globális szerelvény-gyorsítótárban

Amikor a futtatókörnyezet erőforrásokat keres az erőforrás-tartalék folyamatban, először a globális szerelvény-gyorsítótárban fog keresni. (További információ: "Resource Fallback Process" (Erőforrás-tartalékfolyamat) szakasz Erőforrások csomagolása és üzembe helyezése.) Amint egy műholdas szerelvény erős névvel van aláírva, a globális szerelvénygyorsítótárban a Globális szerelvénygyorsítótár eszközzel (gacutil.exe) telepítheti.

A következő Gacutil.exe parancs telepíti StringLibrary.resources.dll* a globális szerelvény-gyorsítótárban:

gacutil -i:StringLibrary.resources.dll

A /i beállítás azt határozza meg, hogy Gacutil.exe telepítse a megadott szerelvényt a globális szerelvény-gyorsítótárba. Miután telepítette a műholdas szerelvényt a gyorsítótárba, a benne található erőforrások elérhetővé válnak a műholdas szerelvény használatára tervezett összes alkalmazás számára.

Erőforrások a globális szerelvénygyorsítótárban: példa

Az alábbi példa egy .NET-osztálytár metódusával nyer ki és ad vissza egy honosított üdvözlést egy erőforrásfájlból. A kódtár és erőforrásai a globális szerelvény-gyorsítótárban vannak regisztrálva. A példa az angol (Egyesült Államok), a francia (Franciaország), az orosz (Oroszország) és az angol kultúrák erőforrásait tartalmazza. Az alapértelmezett kultúra az angol; az erőforrások a főszerelvényben vannak tárolva. A példa kezdetben nyilvános kulccsal késlelteti a kódtárat és a műholdas szerelvényeket, majd újra aláírja őket egy nyilvános/titkos kulcspárral. A példa létrehozásához tegye a következőket:

Ha nem a Visual Studiót használja, a következő Erős név eszköz (Sn.exe) paranccsal hozzon létre egy ResKey.snk nevű nyilvános/privát kulcspárt:
```
sn –k ResKey.snk
```
Ha Visual Studiót használ, a projekt tulajdonságai párbeszédpanel Aláírás lapján hozza létre a kulcsfájlt.
A következő Strong Name Tool (Sn.exe) paranccsal hozzon létre egy PublicKey.snk nevű nyilvános kulcsfájlt:
```
sn –p ResKey.snk PublicKey.snk
```
Hozzon létre egy Strings.resx nevű erőforrásfájlt, amely az alapértelmezett kultúra erőforrását tartalmazza. Egyetlen sztringet Greeting tárolhat a fájlban, amelynek az értéke "Hogyan működik?"
Ha azt szeretné jelezni, hogy az "en" az alkalmazás alapértelmezett kultúrája, adja hozzá a következő System.Resources.NeutralResourcesLanguageAttribute attribútumot az alkalmazás AssemblyInfo-fájljába vagy az alkalmazás fő szerelvényébe lefordítandó fő forráskódfájlhoz:
```
[assembly:NeutralResourcesLanguageAttribute("en")]
```
```
<Assembly: NeutralResourcesLanguageAttribute("en")>
```
További kultúrák (az en-US, fr-FR és ru-RU kultúrák) támogatása az alkalmazáshoz az alábbiak szerint:
- Az "en-US" vagy az angol (Egyesült Államok) kultúra támogatásához hozzon létre egy Strings.en-US.resx vagy Strings.en-US.txt nevű erőforrásfájlt, és tároljon benne egyetlen sztringetGreeting, amelynek értéke "Hello!".
- Az "fr-FR" vagy a francia (Franciaország) kultúra támogatásához hozzon létre egy Strings.fr-FR.resx vagy Strings.fr-FR.txt nevű erőforrásfájlt, és tároljon benne egyetlen sztringetGreeting, amelynek értéke "Bon jour!".
- Az "ru-RU" vagy az orosz (Oroszország) kultúra támogatásához hozzon létre egy Strings.ru-RU.resx vagy Strings.ru-RU.txt nevű erőforrásfájlt, és tároljon benne egyetlen sztringetGreeting, amelynek értéke "Привет!".
A resgen.exe használatával lefordíthatja az egyes szöveg- vagy XML-erőforrásfájlokat egy bináris .resources fájlba. A kimenet olyan fájlok készlete, amelyek gyökérfájlnevük megegyezik a .resx vagy a .txt fájl nevével, de .resources kiterjesztéssel rendelkeznek. Ha a példát a Visual Studióval hozza létre, a rendszer automatikusan kezeli a fordítási folyamatot. Ha nem a Visual Studiót használja, futtassa a következő parancsot a .resx fájlok .resources fájlokba való fordításához:
```
resgen filename
```
Ahol a fájlnév a .resx vagy szövegfájl opcionális elérési útja, fájlneve és kiterjesztése.

Állítsa össze a következő forráskódot StringLibrary.vb vagy StringLibrary.cs, valamint az alapértelmezett kultúra erőforrásait egy StringLibrary.dll nevű késleltetett aláírt kódtár-szerelvénybe:

Fontos

Ha a példa létrehozásához a Visual Studio helyett a parancssort használja, módosítsa az osztálykonstruktor hívását ResourceManager a következőre ResourceManager rm = new ResourceManager("Strings",typeof(Example).Assembly);.

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

[assembly:NeutralResourcesLanguageAttribute("en")]

public class StringLibrary
{
   public string GetGreeting()
   {
      ResourceManager rm = new ResourceManager("Strings",
                           Assembly.GetAssembly(typeof(StringLibrary)));
      string greeting = rm.GetString("Greeting");
      return greeting;
   }
}

Imports System.Globalization
Imports System.Reflection
Imports System.Resources
Imports System.Threading

<Assembly: NeutralResourcesLanguageAttribute("en")>

Public Class StringLibrary
    Public Function GetGreeting() As String
        Dim rm As New ResourceManager("Strings", _
                                      Assembly.GetAssembly(GetType(StringLibrary)))
        Dim greeting As String = rm.GetString("Greeting")
        Return greeting
    End Function
End Class

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

csc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.cs

A megfelelő Visual Basic fordítóparancs a következő:

vbc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.vb

Hozzon létre egy alkönyvtárat a fő alkalmazáskönyvtárban az alkalmazás által támogatott minden honosított kultúrához. Létre kell hoznia egy en-US-t, egy fr-FR-t és egy ru-RU alkönyvtárat. A Visual Studio automatikusan létrehozza ezeket az alkönyvtárakat a fordítási folyamat részeként. Mivel minden műholdas szerelvénynek ugyanaz a fájlneve, az alkönyvtárak az egyes kultúraspecifikus műholdas szerelvények tárolására szolgálnak, amíg a rendszer nem ír alá nyilvános/titkos kulcspárt.
Ágyazza be az egyes kultúraspecifikus .resources fájlokat a késleltetett aláírt műholdas szerelvényekbe, és mentse őket a megfelelő könyvtárba. Az egyes .resources-fájlokhoz a következő parancsot kell végrehajtani:
```
al -target:lib -embed:Strings.culture.resources -culture:culture -out:culture\StringLibrary.resources.dll -delay+ -keyfile:publickey.snk
```
ahol a kultúra a kultúra neve. Ebben a példában a kultúra neve en-US, fr-FR és ru-RU.
Írja alá újra a StringLibrary.dll az Erős név eszközzel (sn.exe) az alábbiak szerint:
```
sn –R StringLibrary.dll RealKeyPair.snk
```
Írja alá újra az egyes műholdas szerelvényeket. Ehhez használja az Erős név eszközt (sn.exe) az egyes műholdszerelvények esetében az alábbiak szerint:
```
sn –R StringLibrary.resources.dll RealKeyPair.snk
```
Regisztrálja StringLibrary.dll és az összes műholdas szerelvényét a globális szerelvény-gyorsítótárban az alábbi paranccsal:
```
gacutil -i filename
```
ahol a fájlnév a regisztrálandó fájl neve.

Ha Visual Studiót használ, hozzon létre egy új konzolalkalmazás-projektet , Exampleadjon hozzá egy hivatkozást a StringLibrary.dll és a következő forráskódhoz, és fordítsa le.

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

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-GB", "en-US", "fr-FR", "ru-RU" };
      Random rnd = new Random();
      string cultureName = cultureNames[rnd.Next(0, cultureNames.Length)];
      Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName);
      Console.WriteLine("The current UI culture is {0}",
                        Thread.CurrentThread.CurrentUICulture.Name);
      StringLibrary strLib = new StringLibrary();
      string greeting = strLib.GetGreeting();
      Console.WriteLine(greeting);
   }
}

Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim cultureNames() As String = {"en-GB", "en-US", "fr-FR", "ru-RU"}
        Dim rnd As New Random()
        Dim cultureName As String = cultureNames(rnd.Next(0, cultureNames.Length))
        Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName)
        Console.WriteLine("The current UI culture is {0}",
                          Thread.CurrentThread.CurrentUICulture.Name)
        Dim strLib As New StringLibrary()
        Dim greeting As String = strLib.GetGreeting()
        Console.WriteLine(greeting)
    End Sub
End Module

A parancssorból való fordításhoz használja a következő parancsot a C# fordítóhoz:

csc Example.cs -r:StringLibrary.dll

A Visual Basic fordító parancssora a következő:

vbc Example.vb -r:StringLibrary.dll

Futtassa a Example.exe.

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