Skapa resursfiler för .NET-appar

Du kan inkludera resurser, till exempel strängar, bilder eller objektdata, i resursfiler för att göra dem lättillgängliga för ditt program. .NET Framework erbjuder fem sätt att skapa resursfiler:

• Skapa en textfil som innehåller strängresurser. Du kan använda Resource File Generator (resgen.exe) för att konvertera textfilen till en binär resursfil (.resources). Du kan sedan bädda in den binära resursfilen i ett körbart program eller ett programbibliotek med hjälp av en språkkompilator, eller bädda in den i en satellitsammansättning med hjälp av Assembly Linker (Al.exe). Mer information finns i avsnittet Resurser i textfiler .

• Skapa en XML-resursfil (.resx) som innehåller sträng-, bild- eller objektdata. Du kan använda Resource File Generator (resgen.exe) för att konvertera .resx-filen till en binär resursfil (.resources). Du kan sedan bädda in den binära resursfilen i ett körbart program eller ett programbibliotek med hjälp av en språkkompilator, eller bädda in den i en satellitsammansättning med hjälp av Assembly Linker (Al.exe). Mer information finns i avsnittet Resurser i .resx Files .

• Skapa en XML-resursfil (.resx) programmatiskt med hjälp av typer i System.Resources namnområdet. Du kan skapa en .resx-fil, räkna upp dess resurser och hämta specifika resurser efter namn. Mer information finns i Arbeta med .resx Files programmatiskt.

• Skapa en binär resursfil (.resources) programmatiskt. Du kan sedan bädda in filen i ett körbart program eller ett programbibliotek med hjälp av en språkkompilator, eller bädda in den i en satellitsammansättning med hjälp av Assembly Linker (Al.exe). Mer information finns i avsnittet Resurser i .resources Files .

• Använd Visual Studio för att skapa en resursfil och inkludera den i projektet. Visual Studio innehåller en resursredigerare som gör att du kan lägga till, ta bort och ändra resurser. Vid kompileringstillfället konverteras resursfilen automatiskt till en binär .resources-fil och bäddas in i en programsammansättning eller satellitsammansättning. Mer information finns i avsnittet Resursfiler i Visual Studio .

Resurser i textfiler

Du kan använda textfiler (.txt eller .restext) för att endast lagra strängresurser. För icke-strängresurser använder du .resx-filer eller skapar dem programmatiskt. Textfiler som innehåller strängresurser har följande format:

# This is an optional comment.
name = value

; This is another optional comment.
name = value

; The following supports conditional compilation if X is defined.
#ifdef X
name1=value1
name2=value2
#endif

# The following supports conditional compilation if Y is undefined.
#if !Y
name1=value1
name2=value2
#endif

Resursfilformatet för .txt- och .restext-filer är identiskt. Filtillägget .restext fungerar bara för att göra textfiler omedelbart identifierbara som textbaserade resursfiler.

Strängresurser visas som namn/värde-par , där namnet är en sträng som identifierar resursen och värdet är resurssträngen som returneras när du skickar namnet till en resurshämtningsmetod, till exempel ResourceManager.GetString. namn och värde måste avgränsas med ett likhetstecken (=). Till exempel:

FileMenuName=File
EditMenuName=Edit
ViewMenuName=View
HelpMenuName=Help

Tomma strängar (dvs. en resurs vars värde är String.Empty) tillåts i textfiler. Till exempel:

EmptyString=

Från och med .NET Framework 4.5 och i alla versioner av .NET Core stöder textfiler villkorlig kompilering med symbolen#ifdef... #endif och #if !symbol#endif...-konstruktionerna. Du kan sedan använda växeln /define med Resource File Generator (resgen.exe) för att definiera symboler. Varje resurs kräver en egen #ifdefsymbol... #endif eller #if !symbol... #endif konstruktion. Om du använder en #ifdef instruktion och symbol definieras inkluderas den associerade resursen i .resources-filen. Annars ingår den inte. Om du använder en #if ! instruktion och symbol inte har definierats inkluderas den associerade resursen i .resources-filen. Annars ingår den inte.

Kommentarer är valfria i textfiler och föregås antingen av ett semikolon (;) eller ett pundtecken (#) i början av en rad. Rader som innehåller kommentarer kan placeras var som helst i filen. Kommentarer ingår inte i en kompilerad .resources-fil som skapas med hjälp av Resource File Generator (resgen.exe).

Tomma rader i textfilerna anses vara blanksteg och ignoreras.

I följande exempel definieras två strängresurser med namnet OKButton och CancelButton.

#Define resources for buttons in the user interface.
OKButton=OK
CancelButton=Cancel

Om textfilen innehåller duplicerade förekomster av namn visar Resursfilgenerator (resgen.exe) en varning och ignorerar det andra namnet.

värdet får inte innehålla nya radtecken, men du kan använda escape-tecken i C-språkformat, till exempel \n för att representera en ny rad och \t för att representera en flik. Du kan också inkludera ett omvänt snedstreck om det är undantaget (till exempel "\\"). Dessutom tillåts en tom sträng.

Spara resurser i textfilformat med hjälp av UTF-8-kodning eller UTF-16-kodning i antingen lite endiansk eller storslutande byteordning. Resursfilgenerator (resgen.exe), som konverterar en .txt fil till en .resources-fil, behandlar dock filer som UTF-8 som standard. Om du vill att Resgen.exe ska känna igen en fil som kodades med UTF-16 måste du inkludera ett Unicode-byteordningsmärke (U+FEFF) i början av filen.

Om du vill bädda in en resursfil i textformat i en .NET-sammansättning måste du konvertera filen till en binär resursfil (.resources) med hjälp av Resursfilgenerator (resgen.exe). Du kan sedan bädda in .resources-filen i en .NET-sammansättning med hjälp av en språkkompilator eller bädda in den i en satellitsammansättning med hjälp av Assembly Linker (Al.exe).

I följande exempel används en resursfil i textformat med namnet GreetingResources.txt för ett enkelt "Hello World"-konsolprogram. Textfilen definierar två strängar prompt och greeting, som uppmanar användaren att ange sitt namn och visa en hälsning.

# GreetingResources.txt
# A resource file in text format for a "Hello World" application.
#
# Initial prompt to the user.
prompt=Enter your name:
# Format string to display the result.
greeting=Hello, {0}!

Textfilen konverteras till en .resources-fil med hjälp av följande kommando:

resgen GreetingResources.txt

I följande exempel visas källkoden för ett konsolprogram som använder .resources-filen för att visa meddelanden för användaren.

using System;
using System.Reflection;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("GreetingResources",
                               typeof(Example).Assembly);
      Console.Write(rm.GetString("prompt"));
      string name = Console.ReadLine();
      Console.WriteLine(rm.GetString("greeting"), name);
   }
}
// The example displays output like the following:
//       Enter your name: Wilberforce
//       Hello, Wilberforce!

Imports System.Reflection
Imports System.Resources

Module Example
    Public Sub Main()
        Dim rm As New ResourceManager("GreetingResources",
                                      GetType(Example).Assembly())
        Console.Write(rm.GetString("prompt"))
        Dim name As String = Console.ReadLine()
        Console.WriteLine(rm.GetString("greeting"), name)
    End Sub
End Module
' The example displays output like the following:
'       Enter your name: Wilberforce
'       Hello, Wilberforce!

Om du använder Visual Basic och källkodsfilen heter Greeting.vb, skapar följande kommando en körbar fil som innehåller den inbäddade .resources-filen:

vbc greeting.vb -resource:GreetingResources.resources

Om du använder C#, och källkodsfilen heter Greeting.cs, skapar följande kommando en körbar fil som innehåller den inbäddade .resources-filen:

csc greeting.cs -resource:GreetingResources.resources

Resurser i .resx-filer

Till skillnad från textfiler, som bara kan lagra strängresurser, kan XML-resursfiler (.resx) lagra strängar, binära data som bilder, ikoner och ljudklipp och programmatiska objekt. En .resx-fil innehåller ett standardhuvud, som beskriver formatet för resursposterna och anger versionsinformationen för DEN XML som används för att parsa data. Resursfildata följer XML-huvudet. Varje dataobjekt består av ett namn/värde-par som finns i en data tagg. Dess name attribut definierar resursnamnet och den kapslade value taggen innehåller resursvärdet. För strängdata innehåller taggen value strängen.

Följande tagg definierar till exempel data en strängresurs med namnet prompt vars värde är "Ange ditt namn:".

<data name="prompt" xml:space="preserve">
  <value>Enter your name:</value>
</data>

För resursobjekt innehåller datataggen ett type attribut som anger resursens datatyp. För objekt som består av binära data innehåller taggen data även ett mimetype attribut som anger base64 typen av binära data.

I följande exempel visas en del av en .resx-fil som innehåller en Int32 resurs och en bitmappsbild.

<data name="i1" type="System.Int32, mscorlib">
  <value>20</value>
</data>

<data name="flag" type="System.Drawing.Bitmap, System.Drawing,
    Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
    mimetype="application/x-microsoft.net.object.bytearray.base64">
  <value>
    AAEAAAD/////AQAAAAAAAAAMAgAAADtTeX…
  </value>
</data>

Resurser i .resources-filer

Du kan använda System.Resources.ResourceWriter klassen för att programmatiskt skapa en binär resursfil (.resources) direkt från kod. Du kan också använda Resursfilgenerator (resgen.exe) för att skapa en .resources-fil från en textfil eller en .resx-fil. .resources-filen kan innehålla binära data (bytematriser) och objektdata utöver strängdata. Programmatiskt skapa en .resources-fil kräver följande steg:

1. Skapa ett ResourceWriter objekt med ett unikt filnamn. Du kan göra detta genom att ange antingen ett filnamn eller en filström till en ResourceWriter klasskonstruktor.

2. Anropa en av överlagringarna av metoden för varje namngiven ResourceWriter.AddResource resurs som ska läggas till i filen. Resursen kan vara en sträng, ett objekt eller en samling binära data (en bytematris).

3. ResourceWriter.Close Anropa metoden för att skriva resurserna till filen och stänga objektetResourceWriter.

I följande exempel skapas programmässigt en .resources-fil med namnet CarResources.resources som lagrar sex strängar, en ikon och två programdefinierade objekt (två Automobile objekt). Klassen Automobile , som definieras och instansieras i exemplet, taggas med SerializableAttribute attributet, vilket gör att den kan bevaras av den binära serialiseringsformaterren.

using System;
using System.Drawing;
using System.Resources;

[Serializable()] public class Automobile
{
   private string carMake;
   private string carModel;
   private int carYear;
   private int carDoors;
   private int carCylinders;

   public Automobile(string make, string model, int year) :
                     this(make, model, year, 0, 0)
   { }

   public Automobile(string make, string model, int year,
                     int doors, int cylinders)
   {
      this.carMake = make;
      this.carModel = model;
      this.carYear = year;
      this.carDoors = doors;
      this.carCylinders = cylinders;
   }

   public string Make {
      get { return this.carMake; }
   }

   public string Model {
      get { return this.carModel; }
   }

   public int Year {
      get { return this.carYear; }
   }

   public int Doors {
      get {
         return this.carDoors; }
   }

   public int Cylinders {
      get {
         return this.carCylinders; }
   }
}

public class Example
{
   public static void Main()
   {
      // Instantiate an Automobile object.
      Automobile car1 = new Automobile("Ford", "Model N", 1906, 0, 4);
      Automobile car2 = new Automobile("Ford", "Model T", 1909, 2, 4);
      // Define a resource file named CarResources.resx.
      using (ResourceWriter rw = new ResourceWriter(@".\CarResources.resources"))
      {
         rw.AddResource("Title", "Classic American Cars");
         rw.AddResource("HeaderString1", "Make");
         rw.AddResource("HeaderString2", "Model");
         rw.AddResource("HeaderString3", "Year");
         rw.AddResource("HeaderString4", "Doors");
         rw.AddResource("HeaderString5", "Cylinders");
         rw.AddResource("Information", SystemIcons.Information);
         rw.AddResource("EarlyAuto1", car1);
         rw.AddResource("EarlyAuto2", car2);
      }
   }
}

Imports System.Drawing
Imports System.Resources

<Serializable()> Public Class Automobile
    Private carMake As String
    Private carModel As String
    Private carYear As Integer
    Private carDoors AS Integer
    Private carCylinders As Integer

    Public Sub New(make As String, model As String, year As Integer)
        Me.New(make, model, year, 0, 0)
    End Sub

    Public Sub New(make As String, model As String, year As Integer,
                   doors As Integer, cylinders As Integer)
        Me.carMake = make
        Me.carModel = model
        Me.carYear = year
        Me.carDoors = doors
        Me.carCylinders = cylinders
    End Sub

    Public ReadOnly Property Make As String
        Get
            Return Me.carMake
        End Get
    End Property

    Public ReadOnly Property Model As String
        Get
            Return Me.carModel
        End Get
    End Property

    Public ReadOnly Property Year As Integer
        Get
            Return Me.carYear
        End Get
    End Property

    Public ReadOnly Property Doors As Integer
        Get
            Return Me.carDoors
        End Get
    End Property

    Public ReadOnly Property Cylinders As Integer
        Get
            Return Me.carCylinders
        End Get
    End Property
End Class

Module Example
    Public Sub Main()
        ' Instantiate an Automobile object.
        Dim car1 As New Automobile("Ford", "Model N", 1906, 0, 4)
        Dim car2 As New Automobile("Ford", "Model T", 1909, 2, 4)
        ' Define a resource file named CarResources.resx.
        Using rw As New ResourceWriter(".\CarResources.resources")
            rw.AddResource("Title", "Classic American Cars")
            rw.AddResource("HeaderString1", "Make")
            rw.AddResource("HeaderString2", "Model")
            rw.AddResource("HeaderString3", "Year")
            rw.AddResource("HeaderString4", "Doors")
            rw.AddResource("HeaderString5", "Cylinders")
            rw.AddResource("Information", SystemIcons.Information)
            rw.AddResource("EarlyAuto1", car1)
            rw.AddResource("EarlyAuto2", car2)
        End Using
    End Sub
End Module

När du har skapat .resources-filen kan du bädda in den i en körbar körbar fil eller ett bibliotek genom att inkludera språkkompilatorns /resource växel eller bädda in den i en satellitsammansättning med hjälp av Assembly Linker (Al.exe).

Resursfiler i Visual Studio

När du lägger till en resursfil i Ditt Visual Studio-projekt skapar Visual Studio en .resx-fil i projektkatalogen. Visual Studio innehåller resursredigerare som gör att du kan lägga till strängar, bilder och binära objekt. Eftersom redigeringsprogram är utformade för att endast hantera statiska data kan de inte användas för att lagra programmatiska objekt. du måste skriva objektdata till antingen en .resx-fil eller till en .resources-fil programmatiskt. Mer information finns i Arbeta med .resx-filer programmatiskt och avsnittet Resurser i .resources-filer .

Om du lägger till lokaliserade resurser ger du dem samma rotfilnamn som huvudresursfilen. Du bör också ange deras kultur i filnamnet. Om du till exempel lägger till en resursfil med namnet Resources.resx kan du också skapa resursfiler med namnet Resources.en-US.resx och Resources.fr-FR.resx för att lagra lokaliserade resurser för de engelska (USA) respektive franska (Frankrike). Du bör också ange programmets standardkultur. Det här är den kultur vars resurser används om det inte finns några lokaliserade resurser för en viss kultur.

Ange standardkulturen i Istraživač rešenja i Visual Studio:

• Öppna projektegenskaperna, högerklicka på projektet och välj Egenskaper (eller Alt + Retur när projektet har valts).
• Välj fliken Paket .
• I området Allmänt väljer du lämpligt språk/kultur från kontrollen För neutralt språk för sammansättning.
• Spara dina ändringar.

Vid kompileringstiden konverterar Visual Studio först .resx-filerna i ett projekt till binära resursfiler (.resources) och lagrar dem i en underkatalog i projektets obj-katalog . Visual Studio bäddar in alla resursfiler som inte innehåller lokaliserade resurser i huvudsammansättningen som genereras av projektet. Om några resursfiler innehåller lokaliserade resurser bäddar Visual Studio in dem i separata satellitsammansättningar för varje lokaliserad kultur. Sedan lagras varje satellitsammansättning i en katalog vars namn motsvarar den lokaliserade kulturen. Till exempel lagras lokaliserade engelska resurser (USA) i en satellitsammansättning i underkatalogen en-US.

Se även

• System.Resources
• Resurser i .NET Apps
• Paketera och distribuera resurser