Tworzenie zestawów satelickich dla aplikacji platformy .NET

Artykuł
03/05/2024

Pliki zasobów odgrywają kluczową rolę w zlokalizowanych aplikacjach. Umożliwiają one aplikacji wyświetlanie ciągów, obrazów i innych danych w języku i kulturze użytkownika oraz udostępnianie alternatywnych danych, jeśli zasoby języka lub kultury użytkownika są niedostępne. Platforma .NET używa modelu piasty i szprych do lokalizowania i pobierania zlokalizowanych zasobów. Piasta jest głównym zestawem zawierającym nielokalizowalny kod wykonywalny i zasoby dla pojedynczej kultury, która jest nazywana kulturą neutralną lub domyślną. Kultura domyślna to kultura rezerwowa dla aplikacji; jest używany, gdy nie są dostępne żadne zlokalizowane zasoby. Atrybut służy NeutralResourcesLanguageAttribute do wyznaczania kultury domyślnej aplikacji. Każda szprycha łączy się z zestawem satelitarnym zawierającym zasoby dla pojedynczej zlokalizowanej kultury, ale nie zawiera żadnego kodu. Ponieważ zestawy satelitarne nie są częścią głównego zestawu, można łatwo aktualizować lub zastępować zasoby odpowiadające konkretnej kulturze bez zastępowania głównego zestawu dla aplikacji.

Uwaga

Zasoby domyślnej kultury aplikacji można również przechowywać w zestawie satelitarnym. W tym celu przypiszesz NeutralResourcesLanguageAttribute atrybutowi wartość UltimateResourceFallbackLocation.Satellite.

Nazwa i lokalizacja zestawu satelitarnego

Model piasty i szprych wymaga umieszczania zasobów w określonych lokalizacjach, aby można było je łatwo znaleźć i używać. Jeśli zasoby nie zostaną skompilowane i nazwane zgodnie z oczekiwaniami lub jeśli nie umieścisz ich w odpowiednich lokalizacjach, środowisko uruchomieniowe języka wspólnego nie będzie mogło je zlokalizować i będzie używać zasobów kultury domyślnej. Menedżer zasobów platformy .NET jest reprezentowany przez ResourceManager typ i jest używany do automatycznego uzyskiwania dostępu do zlokalizowanych zasobów. Menedżer zasobów wymaga następujących elementów:

Pojedynczy zestaw satelitarny musi zawierać wszystkie zasoby dla określonej kultury. Innymi słowy, należy skompilować wiele plików .txt lub resx w jeden binarny plik resources .
W katalogu aplikacji musi istnieć oddzielny podkatalog dla każdej zlokalizowanej kultury, która przechowuje zasoby tej kultury. Nazwa podkatalogu musi być taka sama jak nazwa kultury. Alternatywnie można przechowywać zestawy satelitarne w globalnej pamięci podręcznej zestawów. W takim przypadku składnik informacji o kulturze silnej nazwy zestawu musi wskazywać jego kulturę. Aby uzyskać więcej informacji, zobacz Instalowanie zestawów satelickich w globalnej pamięci podręcznej zestawów.

Uwaga

Jeśli aplikacja zawiera zasoby dla podkultury, umieść każdą podkatalog w osobnym podkatalogu w katalogu aplikacji. Nie umieszczaj podkatalogów w podkatalogach w katalogu głównej kultury.
Zestaw satelitarny musi mieć taką samą nazwę jak aplikacja i musi używać rozszerzenia nazwy pliku ".resources.dll". Jeśli na przykład aplikacja ma nazwę Example.exe, nazwa każdego zestawu satelitarnego powinna być Example.resources.dll. Nazwa zestawu satelitarnego nie wskazuje kultury plików zasobów. Jednak zestaw satelitarny pojawia się w katalogu, który określa kulturę.
Informacje o kulturze zestawu satelitarnego muszą być zawarte w metadanych zestawu. Aby przechowywać nazwę kultury w metadanych zestawu satelitarnego, należy określić /culture opcję, gdy używasz konsolidatora zestawów do osadzania zasobów w zestawie satelitarnym.

Na poniższej ilustracji przedstawiono przykładową strukturę katalogów i wymagania dotyczące lokalizacji dla aplikacji, które nie są instalowane w globalnej pamięci podręcznej zestawów. Elementy z rozszerzeniami .txt i resources nie będą dostarczane z ostateczną aplikacją. Są to pliki zasobów pośrednich używane do tworzenia końcowych zestawów zasobów satelitarnych. W tym przykładzie można zastąpić pliki resx dla plików .txt . Aby uzyskać więcej informacji, zobacz Pakowanie i wdrażanie zasobów.

Na poniższej ilustracji przedstawiono katalog zestawów satelitarnych:

Katalog zestawów satelitarnych z zlokalizowanymi podkatalogami kultur.

Kompilowanie zestawów satelickich

Generator plików zasobów (resgen.exe) służy do kompilowania plików tekstowych lub plików XML (resx), które zawierają zasoby do binarnych plików resources. Następnie użyj narzędzia Assembly Linker (al.exe), aby skompilować pliki resources do zestawów satelitarnych. al.exe tworzy zestaw na podstawie plików resources, które określisz. Zestawy satelitarne mogą zawierać tylko zasoby; nie mogą zawierać żadnego kodu wykonywalnego.

Następujące polecenie al.exe tworzy zestaw satelitarny dla aplikacji Example na podstawie niemieckich plików resources strings.de.resources.

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

Następujące polecenie al.exe tworzy również zestaw satelitarny dla aplikacji Example z pliku strings.de.resources. Opcja /template powoduje, że zestaw satelitarny dziedziczy wszystkie metadane zestawu z wyjątkiem informacji o kulturze z zestawu nadrzędnego (Example.dll).

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

W poniższej tabeli opisano opcje al.exe używane w tych poleceniach bardziej szczegółowo:

Opcja	Opis
`-target:lib`	Określa, że zestaw satelitarny jest kompilowany do pliku biblioteki (.dll). Ponieważ zestaw satelitarny nie zawiera kodu wykonywalnego i nie jest głównym zestawem aplikacji, należy zapisać zestawy satelitarne jako biblioteki DLL.
`-embed:strings.de.resources`	Określa nazwę pliku zasobu do osadzenia podczas al.exe kompilowania zestawu. Możesz osadzić wiele plików resources w zestawie satelitarnym, ale jeśli obserwujesz model piasty i szprych, musisz skompilować jeden zestaw satelitarny dla każdej kultury. Można jednak utworzyć oddzielne pliki resources dla ciągów i obiektów.
`-culture:de`	Określa kulturę zasobu do skompilowania. Środowisko uruchomieniowe języka wspólnego używa tych informacji podczas wyszukiwania zasobów dla określonej kultury. Jeśli pominiesz tę opcję, al.exe będzie nadal kompilować zasób, ale środowisko uruchomieniowe nie będzie mogło go znaleźć, gdy użytkownik zażąda go.
`-out:Example.resources.dll`	Określa nazwę pliku wyjściowego. Nazwa musi być zgodna ze standardową nazwą baseName.resources.extension, gdzie baseName jest nazwą głównego zestawu, a rozszerzenie jest prawidłowym rozszerzeniem nazwy pliku (na przykład .dll). Środowisko uruchomieniowe nie może określić kultury zestawu satelitarnego na podstawie jego nazwy pliku wyjściowego; Należy użyć /culture opcji, aby ją określić.
`-template:Example.dll`	Określa zestaw, z którego zestaw satelitarny będzie dziedziczyć wszystkie metadane zestawu z wyjątkiem pola kultury. Ta opcja ma wpływ na zestawy satelitarne tylko wtedy, gdy określisz zestaw, który ma silną nazwę.

Aby uzyskać pełną listę opcji dostępnych w al.exe, zobacz Assembly Linker (al.exe).

Uwaga

Czasami warto użyć zadania MSBuild platformy .NET Core do kompilowania zestawów satelickich, mimo że jest przeznaczony program .NET Framework. Na przykład możesz użyć opcji deterministycznej kompilatora języka C#, aby móc porównywać zestawy z różnych kompilacji. W tym przypadku ustaw wartość GenerateSatelliteAssembliesForCore true w pliku csproj, aby wygenerować zestawy satelitarne przy użyciu csc.exe zamiast Al.exe (Konsolidator zestawu).

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

Zadanie MSBuild platformy .NET Core używa csc.exe zamiast al.exe do generowania zestawów satelickich domyślnie. Aby uzyskać więcej informacji, zobacz Ułatwianie zgody na generowanie zestawu satelitarnego "Core".

Przykład zestawów satelickich

Poniżej przedstawiono prosty przykład "Hello world", który wyświetla pole komunikatu zawierające zlokalizowane powitanie. Przykład obejmuje zasoby dla kultur angielskich (Stany Zjednoczone), francuski (Francja) i rosyjski (Rosja), a jego kultura rezerwowa to angielski. Aby utworzyć przykład, wykonaj następujące czynności:

Utwórz plik zasobu o nazwie Greeting.resx lub Greeting.txt , aby zawierać zasób dla kultury domyślnej. Zapisz jeden ciąg o nazwie HelloString , którego wartość to "Hello world!" w tym pliku.
Aby wskazać, że angielski (en) jest domyślną kulturą aplikacji, dodaj następujący System.Resources.NeutralResourcesLanguageAttribute atrybut do pliku AssemblyInfo aplikacji lub do głównego pliku kodu źródłowego, który zostanie skompilowany do głównego zestawu aplikacji.
```
[assembly: NeutralResourcesLanguage("en")]
```
```
<Assembly: NeutralResourcesLanguage("en")>
```
Dodaj obsługę dodatkowych kultur (en-US, fr-FR, i ru-RU) do aplikacji w następujący sposób:
- Aby obsługiwać en-US kulturę języka angielskiego (Stany Zjednoczone), utwórz plik zasobu o nazwie Greeting.en-US.resx lub Greeting.en-US.txt i zapisz w nim pojedynczy ciąg o nazwie HelloString , którego wartość to "Hi world!".
- Aby obsługiwać fr-FR kulturę lub francuską (Francja), utwórz plik zasobu o nazwie Greeting.fr-FR.resx lub Greeting.fr-FR.txt i zapisz w nim pojedynczy ciąg o nazwie HelloString , którego wartość tout le monde!".
- Aby obsługiwać ru-RU kulturę lub rosyjską (Rosja), utwórz plik zasobu o nazwie Greeting.ru-RU.resx lub Greeting.ru-RU.txt i zapisz w nim pojedynczy ciąg o nazwie HelloString , którego wartość to "Всем привет!".
Użyj resgen.exe , aby skompilować każdy plik tekstowy lub plik zasobów XML do binarnego pliku resources . Dane wyjściowe to zestaw plików, które mają taką samą nazwę pliku głównego jak pliki resx lub .txt , ale rozszerzenie resources . Jeśli tworzysz przykład za pomocą programu Visual Studio, proces kompilacji jest obsługiwany automatycznie. Jeśli nie używasz programu Visual Studio, uruchom następujące polecenia, aby skompilować pliki resx do plików resources :
```
resgen Greeting.resx
resgen Greeting.en-us.resx
resgen Greeting.fr-FR.resx
resgen Greeting.ru-RU.resx
```
Jeśli zasoby znajdują się w plikach tekstowych zamiast plików XML, zastąp rozszerzenie resx .txt.

Skompiluj następujący kod źródłowy wraz z zasobami dla kultury domyślnej w głównym zestawie aplikacji:

Ważne

Jeśli używasz wiersza polecenia, a nie programu Visual Studio do utworzenia przykładu, należy zmodyfikować wywołanie konstruktora ResourceManager klasy na następujące: 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

Jeśli aplikacja ma nazwę Przykład i kompilujesz z wiersza polecenia, polecenie kompilatora języka C# to:

csc Example.cs -res:Greeting.resources

Odpowiednie polecenie kompilatora języka Visual Basic to:

vbc Example.vb -res:Greeting.resources

Utwórz podkatalog w głównym katalogu aplikacji dla każdej zlokalizowanej kultury obsługiwanej przez aplikację. Należy utworzyć podkatalog en-US, fr-FR i ru-RU . Program Visual Studio automatycznie tworzy te podkatalogi w ramach procesu kompilacji.
Osadź poszczególne pliki resources specyficzne dla kultury w zestawach satelickich i zapisz je w odpowiednim katalogu. Polecenie, które należy wykonać dla każdego pliku resources , to:
```
al -target:lib -embed:Greeting.culture.resources -culture:culture -out:culture\Example.resources.dll
```
gdzie kultura jest nazwą kultury, której zasoby zawiera zestaw satelitarny. Program Visual Studio automatycznie obsługuje ten proces.

Następnie możesz uruchomić przykład. Losowo utworzy jedną z obsługiwanych kultur bieżącą kulturę i wyświetli zlokalizowane powitanie.

Instalowanie zestawów satelickich w globalnej pamięci podręcznej zestawów

Zamiast instalować zestawy w podkatalogu aplikacji lokalnej, można je zainstalować w globalnej pamięci podręcznej zestawów. Jest to szczególnie przydatne, jeśli masz biblioteki klas i zestawy zasobów biblioteki klas, które są używane przez wiele aplikacji.

Instalowanie zestawów w globalnej pamięci podręcznej zestawów wymaga, aby miały silne nazwy. Zestawy o silnych nazwach są podpisane z prawidłową parą kluczy publicznych/prywatnych. Zawierają informacje o wersji używane przez środowisko uruchomieniowe w celu określenia, który zestaw ma być używany do spełnienia żądania powiązania. Aby uzyskać więcej informacji na temat silnych nazw i przechowywania wersji, zobacz Przechowywanie wersji zestawów. Aby uzyskać więcej informacji na temat silnych nazw, zobacz Zestawy o silnych nazwach.

Podczas tworzenia aplikacji jest mało prawdopodobne, że będziesz mieć dostęp do ostatniej pary kluczy publicznych/prywatnych. Aby zainstalować zestaw satelitarny w globalnej pamięci podręcznej zestawów i upewnić się, że działa zgodnie z oczekiwaniami, możesz użyć techniki nazywanej opóźnionym podpisywaniem. Gdy opóźnisz podpisywanie zestawu, w czasie kompilacji zarezerwowasz miejsce w pliku dla podpisu silnej nazwy. Rzeczywiste podpisywanie jest opóźnione do późniejszego czasu, gdy dostępna jest ostateczna para kluczy publicznych/prywatnych. Aby uzyskać więcej informacji na temat opóźnionego podpisywania, zobacz Opóźnianie podpisywania zestawu.

Uzyskiwanie klucza publicznego

Aby opóźnić podpisywanie zestawu, musisz mieć dostęp do klucza publicznego. Możesz uzyskać prawdziwy klucz publiczny z organizacji w firmie, która wykona ostateczne podpisywanie, lub utworzyć klucz publiczny przy użyciu narzędzia Strong Name (sn.exe).

Następujące polecenie Sn.exe tworzy testową parę kluczy publicznych/prywatnych. Opcja –k określa, że Sn.exe powinna utworzyć nową parę kluczy i zapisać ją w pliku o nazwie TestKeyPair.snk.

sn –k TestKeyPair.snk

Klucz publiczny można wyodrębnić z pliku zawierającego parę kluczy testowych. Następujące polecenie wyodrębnia klucz publiczny z pliku TestKeyPair.snk i zapisuje go w pliku PublicKey.snk:

sn –p TestKeyPair.snk PublicKey.snk

Opóźnienie podpisywania zestawu

Po uzyskaniu lub utworzeniu klucza publicznego użyj konsolidatora zestawów (al.exe), aby skompilować zestaw i określić opóźnione podpisywanie.

Następujące polecenie al.exe tworzy zestaw satelitarny o silnej nazwie dla aplikacji StringLibrary z pliku strings.ja.resources :

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

Opcja -delay+ określa, że konsolidator zestawu powinien opóźnić podpisywanie zestawu. Opcja -keyfile określa nazwę pliku klucza, który zawiera klucz publiczny do użycia w celu opóźnienia podpisywania zestawu.

Ponowne podpisywanie zestawu

Przed wdrożeniem aplikacji należy ponownie podpisać zestaw satelitarny z podpisem opóźnienia przy użyciu rzeczywistej pary kluczy. Można to zrobić przy użyciu Sn.exe.

Następujące polecenie Sn.exe podpisuje StringLibrary.resources.dll z parą kluczy przechowywaną w pliku RealKeyPair.snk. Opcja –R określa, że wcześniej podpisany lub opóźniony zestaw ma zostać ponownie podpisany.

sn –R StringLibrary.resources.dll RealKeyPair.snk

Instalowanie zestawu satelitarnego w globalnej pamięci podręcznej zestawów

Gdy środowisko uruchomieniowe wyszukuje zasoby w procesie rezerwowym zasobu, najpierw wygląda w globalnej pamięci podręcznej zestawów . (Aby uzyskać więcej informacji, zobacz sekcję "Proces rezerwowy zasobów" w sekcji Pakowanie i wdrażanie zasobów). Gdy tylko zestaw satelitarny jest podpisany za pomocą silnej nazwy, można go zainstalować w globalnej pamięci podręcznej zestawów przy użyciu narzędzia global assembly Cache (gacutil.exe).

Następujące polecenie Gacutil.exe instaluje StringLibrary.resources.dll* w globalnej pamięci podręcznej zestawów:

gacutil -i:StringLibrary.resources.dll

/ i opcja określa, że Gacutil.exe powinien zainstalować określony zestaw w globalnej pamięci podręcznej zestawów. Po zainstalowaniu zestawu satelitarnego w pamięci podręcznej zasoby, które zawiera, staną się dostępne dla wszystkich aplikacji przeznaczonych do korzystania z zestawu satelitarnego.

Zasoby w globalnej pamięci podręcznej zestawów: przykład

W poniższym przykładzie użyto metody w bibliotece klas platformy .NET w celu wyodrębnienia i zwrócenia zlokalizowanego powitania z pliku zasobu. Biblioteka i jej zasoby są rejestrowane w globalnej pamięci podręcznej zestawów. Przykład obejmuje zasoby dla języka angielskiego (Stany Zjednoczone), francuskiego (Francja), rosyjskiego (Rosja) i angielskich kultur. Język angielski jest kulturą domyślną; jego zasoby są przechowywane w głównym zestawie. Przykład początkowo opóźnia bibliotekę i jej zestawy satelitarne z kluczem publicznym, a następnie ponownie podpisuje je za pomocą pary kluczy publicznych/prywatnych. Aby utworzyć przykład, wykonaj następujące czynności:

Jeśli nie używasz programu Visual Studio, użyj następującego polecenia Strong Name Tool (Sn.exe), aby utworzyć parę kluczy publicznych/prywatnych o nazwie ResKey.snk:
```
sn –k ResKey.snk
```
Jeśli używasz programu Visual Studio, użyj karty Podpisywanie okna dialogowego Właściwości projektu, aby wygenerować plik klucza.
Użyj następującego polecenia Strong Name Tool (Sn.exe), aby utworzyć plik klucza publicznego o nazwie PublicKey.snk:
```
sn –p ResKey.snk PublicKey.snk
```
Utwórz plik zasobu o nazwie Strings.resx zawierający zasób dla kultury domyślnej. Zapisz w tym pliku pojedynczy ciąg o nazwie Greeting , którego wartość to "Jak to zrobić?".
Aby wskazać, że "en" jest domyślną kulturą aplikacji, dodaj następujący System.Resources.NeutralResourcesLanguageAttribute atrybut do pliku AssemblyInfo aplikacji lub do głównego pliku kodu źródłowego, który zostanie skompilowany do głównego zestawu aplikacji:
```
[assembly:NeutralResourcesLanguageAttribute("en")]
```
```
<Assembly: NeutralResourcesLanguageAttribute("en")>
```
Dodaj obsługę dodatkowych kultur (kultur en-US, fr-FR i ru-RU) do aplikacji w następujący sposób:
- Aby obsługiwać kulturę "en-US" lub angielską (Stany Zjednoczone), utwórz plik zasobu o nazwie Strings.en-US.resx lub Strings.en-US.txt i zapisz w nim pojedynczy ciąg o nazwie o nazwie Greeting "Hello!".
- Aby obsługiwać kulturę "fr-FR" lub francuską (Francja), utwórz plik zasobu o nazwie Strings.fr-FR.resx lub Strings.fr-FR.txt i zapisz w nim pojedynczy ciąg o nazwie o nazwie Greeting "Bon jour!".
- Aby obsługiwać kulturę "ru-RU" lub rosyjską (Rosja), utwórz plik zasobu o nazwie Strings.ru-RU.resx lub Strings.ru-RU.txt i zapisz w nim pojedynczy ciąg o nazwie Greeting , którego wartość to "Привет!".
Użyj resgen.exe , aby skompilować każdy plik tekstowy lub plik zasobów XML do binarnego pliku resources. Dane wyjściowe to zestaw plików, które mają taką samą nazwę pliku głównego jak pliki resx lub .txt , ale rozszerzenie resources . Jeśli tworzysz przykład za pomocą programu Visual Studio, proces kompilacji jest obsługiwany automatycznie. Jeśli nie używasz programu Visual Studio, uruchom następujące polecenie, aby skompilować pliki resx do plików resources :
```
resgen filename
```
Gdzie nazwa pliku jest opcjonalną ścieżką, nazwą pliku i rozszerzeniem pliku resx lub pliku tekstowego.

Skompiluj następujący kod źródłowy dla StringLibrary.vb lub StringLibrary.cs wraz z zasobami dla kultury domyślnej w zestaw biblioteki z podpisem opóźnionym o nazwie StringLibrary.dll:

Ważne

Jeśli używasz wiersza polecenia, a nie programu Visual Studio do utworzenia przykładu, należy zmodyfikować wywołanie konstruktora ResourceManager klasy na 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

Polecenie kompilatora języka C# to:

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

Odpowiednie polecenie kompilatora języka Visual Basic to:

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

Utwórz podkatalog w głównym katalogu aplikacji dla każdej zlokalizowanej kultury obsługiwanej przez aplikację. Należy utworzyć podkatalog en-US, fr-FR i ru-RU . Program Visual Studio automatycznie tworzy te podkatalogi w ramach procesu kompilacji. Ponieważ wszystkie zestawy satelitarne mają taką samą nazwę pliku, podkatalogi są używane do przechowywania pojedynczych zestawów satelickich specyficznych dla kultury, dopóki nie zostaną podpisane przy użyciu pary kluczy publicznych/prywatnych.
Osadź poszczególne pliki resources specyficzne dla kultury w opóźnionym zestawach satelickich i zapisz je w odpowiednim katalogu. Polecenie, które należy wykonać dla każdego pliku resources , to:
```
al -target:lib -embed:Strings.culture.resources -culture:culture -out:culture\StringLibrary.resources.dll -delay+ -keyfile:publickey.snk
```
gdzie kultura jest nazwą kultury. W tym przykładzie nazwy kultury to en-US, fr-FR i ru-RU.
Ponownie podpisać StringLibrary.dll przy użyciu narzędzia strong name (sn.exe) w następujący sposób:
```
sn –R StringLibrary.dll RealKeyPair.snk
```
Ponownie podpisać poszczególne zestawy satelitarne. W tym celu użyj narzędzia Strong Name (sn.exe) w następujący sposób dla każdego zestawu satelitarnego:
```
sn –R StringLibrary.resources.dll RealKeyPair.snk
```
Zarejestruj StringLibrary.dll i każdy z jego zestawów satelickich w globalnej pamięci podręcznej zestawów, używając następującego polecenia:
```
gacutil -i filename
```
gdzie nazwa pliku jest nazwą pliku do zarejestrowania.

Jeśli używasz programu Visual Studio, utwórz nowy projekt aplikacja konsolowa o nazwie Example, dodaj odwołanie do StringLibrary.dll i następującego kodu źródłowego do niego i skompiluj go.

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

Aby skompilować z poziomu wiersza polecenia, użyj następującego polecenia dla kompilatora języka C#:

csc Example.cs -r:StringLibrary.dll

Wiersz polecenia kompilatora języka Visual Basic to:

vbc Example.vb -r:StringLibrary.dll

Uruchom Example.exe.

Udostępnij za pośrednictwem