Skapa satellitsammansättningar för .NET-appar

Artikel
04/08/2023

Resursfiler spelar en central roll i lokaliserade program. De gör det möjligt för ett program att visa strängar, bilder och andra data i användarens språk och kultur och tillhandahålla alternativa data om resurser för användarens språk eller kultur inte är tillgängliga. .NET använder en hub-and-spoke-modell för att hitta och hämta lokaliserade resurser. Hubben är huvudsammansättningen som innehåller den icke-localizable körbara koden och resurserna för en enda kultur, som kallas neutral eller standardkultur. Standardkulturen är återställningskulturen för programmet. den används när inga lokaliserade resurser är tillgängliga. Du använder NeutralResourcesLanguageAttribute attributet för att ange kulturen i programmets standardkultur. Varje eker ansluter till en satellitsammansättning som innehåller resurser för en enda lokaliserad kultur men som inte innehåller någon kod. Eftersom satellitsammansättningarna inte ingår i huvudsammansättningen kan du enkelt uppdatera eller ersätta resurser som motsvarar en specifik kultur utan att ersätta huvudsammansättningen för programmet.

Kommentar

Resurserna i ett programs standardkultur kan också lagras i en satellitsammansättning. För att göra detta tilldelar NeutralResourcesLanguageAttribute du attributet värdet UltimateResourceFallbackLocation.Satellite.

Namn och plats för satellitsammansättning

Hub-and-spoke-modellen kräver att du placerar resurser på specifika platser så att de enkelt kan hittas och användas. Om du inte kompilerar och namnger resurser som förväntat, eller om du inte placerar dem på rätt platser, kommer den vanliga språkkörningen inte att kunna hitta dem och kommer att använda resurserna i standardkulturen i stället. .NET-resurshanteraren representeras av ResourceManager typen och används för att automatiskt komma åt lokaliserade resurser. Resurshanteraren kräver följande:

En enda satellitsammansättning måste innehålla alla resurser för en viss kultur. Med andra ord bör du kompilera flera .txt- eller .resx-filer till en enda binär .resources-fil.
Det måste finnas en separat underkatalog i programkatalogen för varje lokaliserad kultur som lagrar den kulturens resurser. Underkatalognamnet måste vara samma som kulturnamnet. Alternativt kan du lagra dina satellitsammansättningar i den globala sammansättningscachen. I det här fallet måste kulturinformationskomponenten i sammansättningens starka namn ange dess kultur. Mer information finns i Installera satellitsammansättningar i den globala sammansättningscachen.

Kommentar

Om ditt program innehåller resurser för subkulturer placerar du varje subkultur i en separat underkatalog under programkatalogen. Placera inte subkulturer i underkataloger under huvudkulturens katalog.
Satellitsammansättningen måste ha samma namn som programmet och måste använda filnamnstillägget ".resources.dll". Om ett program till exempel heter Example.exe ska namnet på varje satellitsammansättning vara Example.resources.dll. Namnet på satellitsammansättningen anger inte kulturen för dess resursfiler. Satellitsammansättningen visas dock i en katalog som anger kulturen.
Information om satellitsammansättningens kultur måste ingå i sammansättningens metadata. Om du vill lagra kulturnamnet i satellitsammansättningens metadata anger /culture du alternativet när du använder Assembly Linker för att bädda in resurser i satellitsammansättningen.

Följande bild visar en exempelkatalogstruktur och platskrav för program som du inte installerar i den globala sammansättningscachen. Objekten med .txt - och .resources-tillägg levereras inte med det slutliga programmet. Det här är de mellanliggande resursfiler som används för att skapa de slutliga satellitresurssammansättningarna. I det här exemplet kan du ersätta .resx-filer med de .txt filerna. Mer information finns i Paketera och distribuera resurser.

Följande bild visar katalogen för satellitsammansättning:

En satellitsammansättningskatalog med lokaliserade underkataloger för kulturer.

Kompilera satellitsammansättningar

Du använder Resource File Generator (resgen.exe) för att kompilera textfiler eller XML-filer (.resx) som innehåller resurser till binära .resources-filer . Sedan använder du Assembly Linker (al.exe) för att kompilera .resources-filer till satellitsammansättningar. al.exe skapar en sammansättning från de .resources-filer som du anger. Satellitsammansättningar kan endast innehålla resurser. de får inte innehålla någon körbar kod.

Följande al.exe kommando skapar en satellitsammansättning för programmet Example från den tyska resursfilen strings.de.resources.

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

Följande al.exe kommando skapar också en satellitsammansättning för programmet Example från filsträngarna.de.resources. Alternativet /template gör att satellitsammansättningen ärver alla sammansättningsmetadata förutom dess kulturinformation från den överordnade sammansättningen (Example.dll).

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

I följande tabell beskrivs de al.exe alternativ som används i dessa kommandon i detalj:

Alternativ	Description
`-target:lib`	Anger att din satellitsammansättning kompileras till en biblioteksfil (.dll). Eftersom en satellitsammansättning inte innehåller körbar kod och inte är ett programs huvudsammansättning måste du spara satellitsammansättningar som DLL:er.
`-embed:strings.de.resources`	Anger namnet på resursfilen som ska bäddas in när al.exe kompilerar sammansättningen. Du kan bädda in flera .resources-filer i en satellitsammansättning, men om du följer hub-and-spoke-modellen måste du kompilera en satellitsammansättning för varje kultur. Du kan dock skapa separata .resources-filer för strängar och objekt.
`-culture:de`	Anger kulturen för resursen som ska kompileras. Den vanliga språkkörningen använder den här informationen när den söker efter resurser efter en angiven kultur. Om du utelämnar det här alternativet kompilerar al.exe fortfarande resursen, men körningen kan inte hitta den när en användare begär den.
`-out:Example.resources.dll`	Anger namnet på utdatafilen. Namnet måste följa namngivningsstandarden baseName.resources.extension, där baseName är namnet på huvudsammansättningen och tillägget är ett giltigt filnamnstillägg (till exempel .dll). Körningen kan inte fastställa kulturen för en satellitsammansättning baserat på dess utdatafilnamn. du måste använda alternativet /culture för att ange det.
`-template:Example.dll`	Anger en sammansättning från vilken satellitsammansättningen ärver alla sammansättningsmetadata utom kulturfältet. Det här alternativet påverkar endast satellitsammansättningar om du anger en sammansättning som har ett starkt namn.

En fullständig lista över tillgängliga alternativ med al.exe finns i Assembly Linker (al.exe).

Kommentar

Det kan finnas tillfällen när du vill använda .NET Core MSBuild-uppgiften för att kompilera satellitsammansättningar, även om du riktar in dig på .NET Framework. Du kanske till exempel vill använda det deterministiska C#-kompilatoralternativet för att kunna jämföra sammansättningar från olika versioner. I det här fallet anger du GenerateSatelliteAssembliesForCore till i .csproj-filen för att generera satellitsammansättningar med hjälp av csc.exe i stället för Al.exe (Assembly Linker).true

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

.NET Core MSBuild-aktiviteten använder csc.exe i stället för al.exe för att generera satellitsammansättningar som standard. Mer information finns i Gör det enklare att välja "Core"-satellitmonteringsgenerering.

Exempel på satellitsammansättningar

Följande är ett enkelt "Hello world"-exempel som visar en meddelanderuta som innehåller en lokaliserad hälsning. Exemplet innehåller resurser för de engelska (USA), franska (Frankrike) och ryska (Ryssland) kulturer, och dess reservkultur är engelska. Gör följande för att skapa exemplet:

Skapa en resursfil med namnet Greeting.resx eller Greeting.txt som ska innehålla resursen för standardkulturen. Lagra en enskild sträng med namnet HelloString vars värde är "Hello world!" i den här filen.
Om du vill ange att engelska (en) är programmets standardkultur lägger du till följande System.Resources.NeutralResourcesLanguageAttribute attribut i programmets AssemblyInfo-fil eller till huvudkällkodsfilen som ska kompileras till programmets huvudsammansättning.
```
[assembly: NeutralResourcesLanguage("en")]
```
```
<Assembly: NeutralResourcesLanguage("en")>
```
Lägg till stöd för ytterligare kulturer (en-US, fr-FRoch ru-RU) i programmet på följande sätt:
- Skapa en resursfil med namnet Greeting.en-US.resx eller Greeting.en-US.txt för att stödja en-US den engelska kulturen (USA) och lagra i den en enda sträng med namnet HelloString vars värde är "Hi world!".
- För att stödja fr-FR den eller franska kulturen (Frankrike) skapar du en resursfil med namnet Greeting.fr-FR.resx eller Greeting.fr-FR.txt och lagrar i den en enda sträng med namnet HelloString vars värde är "Salut tout le monde!".
- För att stödja den ru-RU eller ryska kulturen (Ryssland) skapar du en resursfil med namnet Greeting.ru-RU.resx eller Greeting.ru-RU.txt och lagrar i den en enda sträng med namnet HelloString vars värde är "Всем привет!".
Använd resgen.exe för att kompilera varje text- eller XML-resursfil till en binär .resources-fil . Utdata är en uppsättning filer som har samma rotfilnamn som .resx - eller .txt-filerna , men ett .resources-tillägg . Om du skapar exemplet med Visual Studio hanteras kompileringsprocessen automatiskt. Om du inte använder Visual Studio kör du följande kommandon för att kompilera .resx-filerna till .resources-filer :
```
resgen Greeting.resx
resgen Greeting.en-us.resx
resgen Greeting.fr-FR.resx
resgen Greeting.ru-RU.resx
```
Om dina resurser finns i textfiler i stället för XML-filer ersätter du .resx-tillägget med .txt.

Kompilera följande källkod tillsammans med resurserna för standardkulturen i programmets huvudsammansättning:

Viktigt!

Om du använder kommandoraden i stället för Visual Studio för att skapa exemplet bör du ändra anropet till klasskonstruktorn till ResourceManager följande: 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

Om programmet heter Exempel och du kompilerar från kommandoraden är kommandot för C#-kompilatorn:

csc Example.cs -res:Greeting.resources

Motsvarande Visual Basic-kompilatorkommando är:

vbc Example.vb -res:Greeting.resources

Skapa en underkatalog i huvudprogramkatalogen för varje lokaliserad kultur som stöds av programmet. Du bör skapa en en-US, en fr-FR och en ru-RU-underkatalog. Visual Studio skapar dessa underkataloger automatiskt som en del av kompileringsprocessen.
Bädda in de enskilda kulturspecifika .resources-filerna i satellitsammansättningar och spara dem i rätt katalog. Kommandot för att göra detta för varje .resources-fil är:
```
al -target:lib -embed:Greeting.culture.resources -culture:culture -out:culture\Example.resources.dll
```
där kultur är namnet på den kultur vars resurser satellitsammansättningen innehåller. Visual Studio hanterar den här processen automatiskt.

Du kan sedan köra exemplet. Den gör slumpmässigt en av de kulturer som stöds till den aktuella kulturen och visar en lokaliserad hälsning.

Installera satellitsammansättningar i den globala sammansättningscachen

I stället för att installera sammansättningar i en lokal programunderkatalog kan du installera dem i den globala sammansättningscachen. Detta är särskilt användbart om du har klassbibliotek och resurssammansättningar för klassbibliotek som används av flera program.

Installation av sammansättningar i den globala sammansättningscachen kräver att de har starka namn. Starka namngivna sammansättningar signeras med ett giltigt offentligt/privat nyckelpar. De innehåller versionsinformation som körningen använder för att avgöra vilken sammansättning som ska användas för att uppfylla en bindningsbegäran. Mer information om starka namn och versionshantering finns i Versionshantering för sammansättning. Mer information om starka namn finns i Starka namngivna sammansättningar.

När du utvecklar ett program är det osannolikt att du har åtkomst till det sista offentliga/privata nyckelparet. Om du vill installera en satellitsammansättning i den globala sammansättningscacheminnet och se till att den fungerar som förväntat kan du använda en teknik som kallas fördröjd signering. När du fördröjer tecknet för en sammansättning reserverar du utrymme i filen för den starka namnsignaturen vid bygget. Den faktiska signeringen fördröjs till senare, när det sista offentliga/privata nyckelparet är tillgängligt. Mer information om fördröjd signering finns i Fördröj signering av en sammansättning.

Hämta den offentliga nyckeln

Om du vill fördröja signeringen av en sammansättning måste du ha åtkomst till den offentliga nyckeln. Du kan antingen hämta den verkliga offentliga nyckeln från organisationen i ditt företag som gör den slutliga signeringen eller skapa en offentlig nyckel med hjälp av verktyget Starkt namn (sn.exe).

Följande Sn.exe kommando skapar ett offentligt/privat testnyckelpar. Alternativet –k anger att Sn.exe ska skapa ett nytt nyckelpar och spara det i en fil med namnet TestKeyPair.snk.

sn –k TestKeyPair.snk

Du kan extrahera den offentliga nyckeln från filen som innehåller testnyckelparet. Följande kommando extraherar den offentliga nyckeln från TestKeyPair.snk och sparar den i PublicKey.snk:

sn –p TestKeyPair.snk PublicKey.snk

Fördröj signering av en sammansättning

När du har hämtat eller skapat den offentliga nyckeln använder du Assembly Linker (al.exe) för att kompilera sammansättningen och ange fördröjd signering.

Följande al.exe kommando skapar en starkt namngiven satellitsammansättning för programmet StringLibrary från filen strings.ja.resources :

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

Alternativet -delay+ anger att Assembly Linker ska fördröja tecknet på sammansättningen. Alternativet -keyfile anger namnet på nyckelfilen som innehåller den offentliga nyckel som ska användas för att fördröja tecknet på sammansättningen.

Signera om en sammansättning

Innan du distribuerar programmet måste du signera om den fördröjningssignerade satellitsammansättningen med det riktiga nyckelparet. Du kan göra detta med hjälp av Sn.exe.

Följande Sn.exe-kommando signerar StringLibrary.resources.dll med nyckelparet som lagras i filen RealKeyPair.snk. Alternativet –R anger att en tidigare signerad eller fördröjd signerad sammansättning ska signeras på nytt.

sn –R StringLibrary.resources.dll RealKeyPair.snk

Installera en satellitsammansättning i global sammansättningscache

När körningen söker efter resurser i återställningsprocessen för resursen ser den först ut i den globala sammansättningscacheminnet . (Mer information finns i avsnittet "Resursåterställningsprocess" i Paketera och distribuera resurser.) Så snart en satellitsammansättning har signerats med ett starkt namn kan den installeras i den globala sammansättningscachen med hjälp av verktyget Global Assembly Cache (gacutil.exe).

Följande Gacutil.exe-kommando installerar StringLibrary.resources.dll* i den globala sammansättningscache:

gacutil -i:StringLibrary.resources.dll

Alternativet /i anger att Gacutil.exe ska installera den angivna sammansättningen i den globala sammansättningscacheminnet. När satellitsammansättningen har installerats i cacheminnet blir de resurser som den innehåller tillgängliga för alla program som är utformade för att använda satellitsammansättningen.

Resurser i den globala sammansättningscachen: Ett exempel

I följande exempel används en metod i ett .NET-klassbibliotek för att extrahera och returnera en lokaliserad hälsning från en resursfil. Biblioteket och dess resurser registreras i den globala sammansättningscacheminnet. Exemplet innehåller resurser för den engelska (USA), franska (Frankrike), ryska (Ryssland) och engelska kulturer. Engelska är standardkulturen; dess resurser lagras i huvudsammansättningen. Exemplet fördröjer först biblioteket och dess satellitsammansättningar med en offentlig nyckel och signerar dem sedan igen med ett offentligt/privat nyckelpar. Gör följande för att skapa exemplet:

Om du inte använder Visual Studio använder du följande kommando för starkt namn (Sn.exe) för att skapa ett offentligt/privat nyckelpar med namnet ResKey.snk:
```
sn –k ResKey.snk
```
Om du använder Visual Studio använder du fliken Signering i dialogrutan Projektegenskaper för att generera nyckelfilen.
Använd följande kommando för starkt namn (Sn.exe) för att skapa en offentlig nyckelfil med namnet PublicKey.snk:
```
sn –p ResKey.snk PublicKey.snk
```
Skapa en resursfil med namnet Strings.resx som ska innehålla resursen för standardkulturen. Lagra en enskild sträng med namnet Greeting vars värde är "Hur gör du?" i filen.
Om du vill ange att "en" är programmets standardkultur lägger du till följande System.Resources.NeutralResourcesLanguageAttribute attribut i programmets AssemblyInfo-fil eller till huvudkällkodsfilen som ska kompileras till programmets huvudsammansättning:
```
[assembly:NeutralResourcesLanguageAttribute("en")]
```
```
<Assembly: NeutralResourcesLanguageAttribute("en")>
```
Lägg till stöd för ytterligare kulturer (kulturerna en-US, fr-FR och ru-RU) i programmet enligt följande:
- För att stödja kulturen "en-US" eller engelska (USA) skapar du en resursfil med namnet Strings.en-US.resx eller Strings.en-US.txt och lagrar i den en enda sträng med namnet Greeting vars värde är "Hello!".
- Skapa en resursfil med namnet Strings.fr-FR.resx eller Strings.fr-FR.txt och lagra en enda sträng med namnet Greeting "Bon jour!", för att stödja kulturen "fr-FR" eller franska (Frankrike).
- Skapa en resursfil med namnet Strings.ru-RU.resx eller Strings.ru-RU.txt och lagra i den en enda sträng med namnet Greeting "Привет!".
Använd resgen.exe för att kompilera varje text- eller XML-resursfil till en binär .resources-fil. Utdata är en uppsättning filer som har samma rotfilnamn som .resx - eller .txt-filerna , men ett .resources-tillägg . Om du skapar exemplet med Visual Studio hanteras kompileringsprocessen automatiskt. Om du inte använder Visual Studio kör du följande kommando för att kompilera .resx-filerna till .resources-filer :
```
resgen filename
```
Där filnamn är den valfria sökvägen, filnamnet och tillägget för .resx - eller textfilen.

Kompilera följande källkod för StringLibrary.vb eller StringLibrary.cs tillsammans med resurserna för standardkulturen i en fördröjning signerad bibliotekssammansättning med namnet StringLibrary.dll:

Viktigt!

Om du använder kommandoraden i stället för Visual Studio för att skapa exemplet bör du ändra anropet till klasskonstruktorn till ResourceManager 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

Kommandot för C#-kompilatorn är:

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

Motsvarande Visual Basic-kompilatorkommando är:

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

Skapa en underkatalog i huvudprogramkatalogen för varje lokaliserad kultur som stöds av programmet. Du bör skapa en en-US, en fr-FR och en ru-RU-underkatalog. Visual Studio skapar dessa underkataloger automatiskt som en del av kompileringsprocessen. Eftersom alla satellitsammansättningar har samma filnamn används underkatalogerna för att lagra enskilda kulturspecifika satellitsammansättningar tills de har signerats med ett offentligt/privat nyckelpar.
Bädda in de enskilda kulturspecifika .resources-filerna i fördröjning av signerade satellitsammansättningar och spara dem i lämplig katalog. Kommandot för att göra detta för varje .resources-fil är:
```
al -target:lib -embed:Strings.culture.resources -culture:culture -out:culture\StringLibrary.resources.dll -delay+ -keyfile:publickey.snk
```
där kultur är namnet på en kultur. I det här exemplet är kulturnamnen en-US, fr-FR och ru-RU.
Signera om StringLibrary.dll med hjälp av verktyget Starkt namn (sn.exe) på följande sätt:
```
sn –R StringLibrary.dll RealKeyPair.snk
```
Signera om de enskilda satellitsammansättningarna. Det gör du genom att använda verktyget Starkt namn (sn.exe) enligt följande för varje satellitsammansättning:
```
sn –R StringLibrary.resources.dll RealKeyPair.snk
```
Registrera StringLibrary.dll och var och en av dess satellitsammansättningar i den globala sammansättningscachen med hjälp av följande kommando:
```
gacutil -i filename
```
där filnamn är namnet på filen som ska registreras.

Om du använder Visual Studio skapar du ett nytt konsolprogramprojekt med namnet Example, lägger till en referens till StringLibrary.dll och följande källkod till det och kompilerar.

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

Kompilera från kommandoraden genom att använda följande kommando för C#-kompilatorn:

csc Example.cs -r:StringLibrary.dll

Kommandoraden för Visual Basic-kompilatorn är:

vbc Example.vb -r:StringLibrary.dll

Kör Example.exe.

Dela via