Resgen.exe (resursfilgenerator)

Resursfilgeneratorn (Resgen.exe) konverterar textfiler (.txt eller .restext) och XML-baserade resursformatfiler (.resx) till vanliga binärfiler för språkkörning (.resources) som kan bäddas in i en körbar binär körbar fil eller satellitsammansättning. Mer information finns i Skapa resursfiler.

Resgen.exe är ett verktyg för resurskonvertering för generell användning som utför följande uppgifter:

• Konverterar .txt- eller .restext-filer till .resources- eller .resx-filer. (Formatet för .restext-filer är identiskt med formatet för .txt filer. Med .restext-tillägget kan du dock lättare identifiera textfiler som innehåller resursdefinitioner.)

• Konverterar .resources-filer till text- eller .resx-filer.

• Konverterar .resx-filer till text- eller .resources-filer.

• Extraherar strängresurserna från en sammansättning till en .resw-fil som är lämplig för användning i en Windows 8.x Store-app.

• Skapar en starkt typinskriven klass som ger åtkomst till enskilda namngivna resurser och till instansen ResourceManager .

Om Resgen.exe misslyckas av någon anledning är returvärdet –1.

Om du vill få hjälp med Resgen.exe kan du använda följande kommando, utan några angivna alternativ, för att visa kommandosyntaxen och alternativen för Resgen.exe:

resgen

Du kan också använda växeln /? :

resgen /?

Om du använder Resgen.exe för att generera binära .resources-filer kan du använda en språkkompilator för att bädda in de binära filerna i körbara sammansättningar, eller använda Assembly Linker (Al.exe) för att kompilera dem i satellitsammansättningar.

Det här verktyget installeras automatiskt med Visual Studio. Om du vill köra verktyget använder du Visual Studio Developer Command Prompt eller Visual Studio Developer PowerShell.

Skriv följande vid kommandotolken:

Syntax

resgen  [-define:symbol1[,symbol2,...]] [/useSourcePath] filename.extension  | /compile filename.extension... [outputFilename.extension] [/r:assembly] [/str:lang[,namespace[,class[,file]]] [/publicclass]]

resgen filename.extension [outputDirectory]

Parametrar

Resgen.exe och resursfiltyper

För att Resgen.exe ska kunna konvertera resurser måste text- och .resx-filer följa rätt format.

Textfiler (.txt och .restext)

Textfiler (.txt eller .restext) får endast innehålla strängresurser. Strängresurser är användbara om du skriver ett program som måste ha strängar översatta till flera språk. Du kan till exempel enkelt regionalisera menysträngar med hjälp av lämplig strängresurs. Resgen.exe läser textfiler som innehåller namn/värde-par, där namnet är en sträng som beskriver resursen och värdet är själva resurssträngen.

En textfil som innehåller resurser måste sparas med UTF-8- eller Unicode-kodning (UTF-16) om den inte bara innehåller tecken i det grundläggande latinska intervallet (till U+007F). Resgen.exe tar bort utökade ANSI-tecken när en textfil som sparas med ANSI-kodning bearbetas.

Resgen.exe kontrollerar textfilen efter dubbletter av resursnamn. Om textfilen innehåller dubbletter av resursnamn genererar Resgen.exe en varning och ignorerar det andra värdet.

.resx-filer

Resursfilformatet .resx består av XML-poster. Du kan ange strängresurser i dessa XML-poster, precis som i textfiler. En viktig fördel med .resx-filer jämfört med textfiler är att du också kan ange eller bädda in objekt. När du visar en .resx-fil kan du se den binära formen av ett inbäddat objekt (till exempel en bild) när den här binära informationen är en del av resursmanifestet. Precis som med textfiler kan du öppna en .resx-fil med en textredigerare (till exempel Anteckningar eller Microsoft Word) och skriva, parsa och ändra dess innehåll. Observera att detta kräver goda kunskaper om XML-taggar och .resx-filstrukturen. Mer information om filformatet .resx finns i avsnittet "Resurser i .resx Files" i Skapa resursfiler.

För att kunna skapa en .resources-fil som innehåller inbäddade icke-strängsobjekt måste du antingen använda Resgen.exe för att konvertera en .resx-fil som innehåller objekt eller lägga till objektresurserna i filen direkt från koden genom att anropa metoderna som tillhandahålls av ResourceWriter klassen.

Om din .resx- eller .resources-fil innehåller objekt och du använder Resgen.exe för att konvertera den till en textfil konverteras alla strängresurser korrekt, men datatyperna för de icke-strängobjekten skrivs också till filen som strängar. Du förlorar de inbäddade objekten i konverteringen och Resgen.exe rapporterar att ett fel uppstod när resurserna skulle hämtas.

Konvertera mellan resursfiltyper

När du konverterar mellan olika resursfiltyper kanske Resgen.exe inte kan utföra konverteringen eller förlora information om specifika resurser, beroende på käll- och målfiltyperna. I följande tabell anges vilka typer av konverteringar som lyckas när du konverterar från en resursfiltyp till en annan.

*I Windows 8.x Store-appar använder du .resw-filer för att skapa resurser. Trots skillnaden i filnamnstillägg är .resw-filformatet identiskt med filformatet .resx, förutom att .resw-filer endast kan innehålla strängar och filsökvägar. Du kan konvertera .resx-filer som bara innehåller strängar och filsökvägar till .resw-filer genom att helt enkelt ändra filnamnstillägget.

Utföra specifika Resgen.exe uppgifter

Du kan använda Resgen.exe på olika sätt: kompilera en textbaserad eller XML-baserad resursfil till en binär fil, konvertera mellan resursfilformat och generera en klass som omsluter ResourceManager funktioner och ger åtkomst till resurser. Det här avsnittet innehåller detaljerad information om varje uppgift:

• Kompilera resurser till en binär fil

• Konvertera mellan resursfiltyper

• Kompilera eller konvertera flera filer

• Exportera resurser till en .resw-fil

• Villkorlig kompilering av resurser

• Generera en starkt typad resursklass

Kompilera resurser till en binär fil

Den vanligaste användningen av Resgen.exe är att kompilera en textbaserad resursfil (en .txt- eller .restextfil) eller en XML-baserad resursfil (en .resx-fil) till en binär .resources-fil. Utdatafilen kan sedan bäddas in i en huvudsammansättning av en språkkompilator eller i en satellitsammansättning av Assembly Linker (AL.exe).

Syntaxen för att kompilera en resursfil är:

resgen inputFilename [outputFilename]

där parametrarna är:

inputFilename Filnamnet, inklusive tillägget, för resursfilen som ska kompileras. Resgen.exe kompilerar endast filer med tillägg av .txt, .restext eller .resx.

outputFilename Namnet på utdatafilen. Om du utelämnar outputFilenameskapar Resgen.exe en .resources-fil med rotfilnamnet inputFilename i samma katalog som inputFilename. Om outputFilename innehåller en katalogsökväg måste katalogen finnas.

Du anger ett fullständigt kvalificerat namnområde för .resources-filen genom att ange den i filnamnet och separera den från rotfilnamnet med en punkt. Om outputFilename är är MyCompany.Libraries.Strings.resourcestill exempel namnområdet MyCompany.Libraries.

Följande kommando läser namn/värde-paren i Resources.txt och skriver en binär .resources-fil med namnet Resources.resources. Eftersom utdatafilens namn inte uttryckligen anges får den samma namn som indatafilen som standard.

resgen Resources.txt

Följande kommando läser namn/värde-paren i Resources.restext och skriver en binär resursfil med namnet StringResources.resources.

resgen Resources.restext StringResources.resources

Följande kommando läser en XML-baserad indatafil med namnet Resources.resx och skriver en binär .resources-fil med namnet Resources.resources.

resgen Resources.resx Resources.resources

Konvertera mellan resursfiltyper

Förutom att kompilera textbaserade eller XML-baserade resursfiler till binära .resources-filer kan Resgen.exe konvertera alla filtyper som stöds till andra filtyper som stöds. Det innebär att den kan utföra följande konverteringar:

• .txt- och .restext-filer till .resx-filer.

• .resx-filer till .txt- och .restext-filer.

• .resources-filer till .txt- och .restext-filer.

• .resources-filer till .resx-filer.

Syntaxen är densamma som i föregående avsnitt.

Dessutom kan du använda Resgen.exe för att konvertera inbäddade resurser i en .NET Framework-sammansättning till en .resw-fil för Windows 8.x Store-appar.

Följande kommando läser en binär resursfil Resources.resources och skriver en XML-baserad utdatafil med namnet Resources.resx.

resgen Resources.resources Resources.resx

Följande kommando läser en textbaserad resursfil med namnet StringResources.txt och skriver en XML-baserad resursfil med namnet LibraryResources.resx. Förutom att innehålla strängresurser kan .resx-filen också användas för att lagra icke-strängresurser.

resgen StringResources.txt LibraryResources.resx

Följande två kommandon läser en XML-baserad resursfil med namnet Resources.resx och skriver textfiler med namnet Resources.txt och Resources.restext. Observera att om resx-filen innehåller inbäddade objekt konverteras de inte korrekt till textfilerna.

resgen Resources.resx Resources.txt
resgen Resources.resx Resources.restext

Kompilera eller konvertera flera filer

Du kan använda växeln /compile för att konvertera en lista över resursfiler från ett format till ett annat i en enda åtgärd. Syntax:

resgen /compile filename.extension [filename.extension...]

Följande kommando kompilerar tre filer, StringResources.txt, TableResources.resw och ImageResources.resw, till separata .resources-filer med namnet StringResources.resources, TableResources.resources och ImageResources.resources.

resgen /compile StringResources.txt TableResources.resx ImageResources.resx

Exportera resurser till en .resw-fil

Om du utvecklar en Windows 8.x Store-app kanske du vill använda resurser från en befintlig skrivbordsapp. De två typerna av program stöder dock olika filformat. I skrivbordsappar kompileras resurser i text (.txt eller .restext) eller .resx-filer till binära .resources-filer. I Windows 8.x Store-appar kompileras .resw-filer till PRI-filer (Binary Package Resource Index). Du kan använda Resgen.exe för att överbrygga det här gapet genom att extrahera resurser från en körbar eller en satellitsammansättning och skriva dem till en eller flera .resw-filer som kan användas när du utvecklar en Windows 8.x Store-app.

Syntaxen för att generera .resw-filer från en sammansättning är:

resgen filename.extension  [outputDirectory]

där parametrarna är:

filename.extension Namnet på en .NET Framework-sammansättning (en körbar eller .DLL). Om filen inte innehåller några resurser skapar Resgen.exe inga filer.

outputDirectory Den befintliga katalog som .resw-filerna ska skrivas till. Om outputDirectory utelämnas skrivs .resw-filer till den aktuella katalogen. Resgen.exe skapar en .resw-fil för varje .resources-fil i sammansättningen. Rotfilens namn på .resw-filen är samma som rotnamnet för .resources-filen.

Följande kommando skapar en .resw-fil i katalogen Win8Resources för varje .resources-fil som är inbäddad i MyApp.exe:

resgen MyApp.exe Win8Resources

Villkorlig kompilering av resurser

Från och med .NET Framework 4.5 stöder Resgen.exe villkorlig kompilering av strängresurser i textfiler (.txt och .restext). På så sätt kan du använda en enda textbaserad resursfil i flera byggkonfigurationer.

I en .txt- eller .restext-fil använder #ifdefdu ...#endifskapa för att inkludera en resurs i den binära .resources-filen om en symbol har definierats, och du använder ... #endif -konstruktionen #if !för att inkludera en resurs om en symbol inte har definierats. Vid kompileringstillfället definierar du sedan symboler med hjälp /define: av alternativet följt av en kommaavgränsad lista med symboler. Jämförelsen är skiftlägeskänslig. Fallet med symboler som definieras av /define måste matcha fallet med symboler i textfilerna som ska kompileras.

Följande fil med namnet UIResources.text innehåller till exempel en strängresurs med namnet AppTitle som kan ta ett av tre värden, beroende på om symboler med namnet PRODUCTION, CONSULTeller RETAIL definieras.

#ifdef PRODUCTION
AppTitle=My Software Company Project Manager
#endif
#ifdef CONSULT
AppTitle=My Consulting Company Project Manager
#endif
#ifdef RETAIL
AppTitle=My Retail Store Project Manager
#endif
FileMenuName=File

Filen kan sedan kompileras till en binär .resources-fil med följande kommando:

resgen /define:CONSULT UIResources.restext

Detta skapar en .resources-fil som innehåller två strängresurser. Värdet för resursen AppTitle är "My Consulting Company Project Manager".

Generera en starkt typad resursklass

Resgen.exe stöder starkt inskrivna resurser, vilket kapslar in åtkomst till resurser genom att skapa klasser som innehåller en uppsättning statiska skrivskyddade egenskaper. Detta är ett alternativ till att anropa metoderna för ResourceManager klassen direkt för att hämta resurser. Du kan aktivera starkt skrivet resursstöd med hjälp /str av alternativet i Resgen.exe, som omsluter klassens funktioner StronglyTypedResourceBuilder . När du anger /str alternativet är utdata från Resgen.exe en klass som innehåller starkt skrivna egenskaper som matchar de resurser som refereras i indataparametern. Den här klassen ger starkt skrivskyddad skrivskyddad åtkomst till de resurser som är tillgängliga i den bearbetade filen.

Syntaxen för att skapa en starkt typad resurs är:

resgen inputFilename [outputFilename] /str:language[,namespace,[classname[,filename]]] [/publicClass]

Parametrarna och växlarna är:

inputFilename Filnamnet, inklusive tillägget, för resursfilen som du vill generera en resursklass med stark typ för. Filen kan vara en textbaserad, XML-baserad eller binär .resources-fil. det kan ha ett tillägg av .txt, .restext, .resw eller .resources.

outputFilename Namnet på utdatafilen. Om outputFilename innehåller en katalogsökväg måste katalogen finnas. Om du utelämnar outputFilenameskapar Resgen.exe en .resources-fil med rotfilnamnet inputFilename i samma katalog som inputFilename.

outputFilename kan vara en textbaserad, XML-baserad eller binär .resources-fil. Om filtillägget för outputFilename skiljer sig från filnamnstillägget inputFilenameför utför Resgen.exe filkonverteringen.

Om inputFilename är en .resources-fil kopierar Resgen.exe .resources-filen om outputFilename den också är en .resources-fil. Om outputFilename utelämnas skriver inputFilename Resgen.exe över med en identisk .resources-fil.

språk Det språk som källkoden ska genereras för den starkt typerade resursklassen på. Möjliga värden är cs, C#, och csharp för C#-kod och visualbasic vb för Visual Basic-kod och vbscript vbs för VBScript-kod, och c++, mcoch cpp för C++-kod.

namespace Namnområdet som innehåller resursklassen med starkt typ. Resursfilen och resursklassen ska ha samma namnområde. Information om hur du anger namnområdet i finns i outputFilenameKompilera resurser till en binär fil. Om namnområdet utelämnas finns resursklassen inte i ett namnområde.

classname Namnet på den starkt typerade resursklassen. Detta bör motsvara rotnamnet för .resources-filen. Om Resgen.exe till exempel genererar en .resources-fil med namnet MyCompany.Libraries.Strings.resources, är namnet på den starkt typerade resursklassen Strängar. Om klassnamn utelämnas härleds den genererade klassen från rotnamnet outputFilenameför . Om outputFilename utelämnas härleds den genererade klassen från rotnamnet inputFilenameför .

classname får inte innehålla ogiltiga tecken, till exempel inbäddade blanksteg. Om klassnamn innehåller inbäddade blanksteg, eller om klassnamn genereras som standard från inputFilename och inputFilename innehåller inbäddade blanksteg, ersätter Resgen.exe alla ogiltiga tecken med ett understreck (_).

filename Namnet på klassfilen.

/publicclass Gör den starkt typerade resursklassen offentlig i stället internal för (i C#) eller Friend (i Visual Basic). Detta gör att resurserna kan nås utanför sammansättningen där de är inbäddade.

Den starkt typerade resursklassen har följande medlemmar:

• En parameterlös konstruktor som kan användas för att instansiera resursklassen med starkt typ.

• En static (C#) eller Shared (Visual Basic) och skrivskyddad ResourceManager egenskap, som returnerar den ResourceManager instans som hanterar den starkt inskrivna resursen.

• En statisk Culture egenskap som gör att du kan ange den kultur som används för resurshämtning. Som standard är nulldess värde , vilket innebär att den aktuella användargränssnittskulturen används.

• En static (C#) eller Shared (Visual Basic) och skrivskyddad egenskap för varje resurs i .resources-filen. Namnet på egenskapen är namnet på resursen.-

Följande kommando kompilerar till exempel en resursfil med namnet StringResources.txt till StringResources.resources och genererar en klass med namnet StringResources i en Visual Basic-källkodsfil med namnet StringResources.vb som kan användas för att komma åt Resource Manager.

resgen StringResources.txt /str:vb,,StringResources

Se även

• Verktyg
• Resurser i .NET-appar
• Skapa resursfiler
• Al.exe (Assembly Linker)
• Kommandoradsgränssnitt för utvecklare