Resgen.exe (Resource File Generator)
The Resource File Generator (Resgen.exe) converts text (.txt or .restext) files and XML-based resource format (.resx) files to common language runtime binary (.resources) files that can be embedded in a runtime binary executable or satellite assembly. (See Creating Resource Files.)
Resgen.exe is a general-purpose resource conversion utility that performs the following tasks:
Converts .txt or .restext files to .resources or .resx files. (The format of .restext files is identical to the format of .txt files. However, the .restext extension helps you identify text files that contain resource definitions more easily.)
Converts .resources files to text or .resx files.
Converts .resx files to text or .resources files.
Extracts the string resources from an assembly into a .resw file that is suitable for use in a Windows 8.x Store app.
Creates a strongly typed class that provides access to individual named resources and to the ResourceManager instance.
If Resgen.exe fails for any reason, the return value is –1.
To get help with Resgen.exe, you can use the following command, with no options specified, to display the command syntax and options for Resgen.exe:
You can also use the
If you use Resgen.exe to generate binary .resources files, you can use a language compiler to embed the binary files into executable assemblies, or you can use the Assembly Linker (Al.exe) to compile them into satellite assemblies.
This tool is automatically installed with Visual Studio. To run the tool, use the Developer Command Prompt for Visual Studio (or the Visual Studio Command Prompt in Windows 7). For more information, see Command Prompts.
At the command prompt, type the following:
resgen [-define:symbol1[,symbol2,...]] [/useSourcePath] filename.extension | /compile filename.extension... [outputFilename.extension] [/r:assembly] [/str:lang[,namespace[,class[,file]]] [/publicclass]]
resgen filename.extension [outputDirectory]
|Parameter or switch||Description|
||Starting with the .NET Framework 4.5, supports conditional compilation in text-based (.txt or .restext) resource files. If symbol corresponds to a symbol included in the input text file within a
For more information about this option, see Conditionally Compiling Resources later in this topic.
||Specifies that the input file's current directory is to be used to resolve relative file paths.|
||Enables you to specify multiple .resx or text files to convert to multiple .resources files in a single bulk operation. If you do not specify this option, you can specify only one input file argument. Output files are named filename.resources.
This option cannot be used with the
For more information about this option, see Compiling or Converting Multiple Files later in this topic.
||References metadata from the specified assembly. It is used when converting .resx files and allows Resgen.exe to serialize or deserialize object resources. It is similar to the
||Specifies the name of the input file to convert. If you're using the first, lengthier command-line syntax presented before this table,
.txt or .restext
A text file to convert to a .resources or a .resx file. Text files can contain only string resources. For information about the file format, see the "Resources in Text Files" section of Creating Resource Files.
An XML-based resource file to convert to a .resources or a text (.txt or .restext) file.
A binary resource file to convert to a .resx or a text (.txt or .restext) file.
If you're using the second, shorter command-line syntax presented before this table,
.exe or .dll
A .NET Framework assembly (executable or library) whose string resources are to be extracted to a .resw file for use in developing Windows 8.x Store apps.
||Specifies the name and type of the resource file to create.
This argument is optional when converting from a .txt, .restext, or .resx file to a .resources file. If you do not specify
||For Windows 8.x Store apps, specifies the directory in which a .resw file that contains the string resources in
||Creates a strongly typed resource class file in the programming language specified in the
- For C#:
- For Visual Basic:
- For VBScript:
- For C++:
For more information about this option, see Generating a Strongly Typed Resource Class later in this topic.
||Creates a strongly typed resource class as a public class. By default, the resource class is
This option is ignored if the
Resgen.exe and Resource File Types
In order for Resgen.exe to successfully convert resources, text and .resx files must follow the correct format.
Text (.txt and .restext) Files
Text (.txt or .restext) files may contain only string resources. String resources are useful if you are writing an application that must have strings translated into several languages. For example, you can easily regionalize menu strings by using the appropriate string resource. Resgen.exe reads text files that contain name/value pairs, where the name is a string that describes the resource and the value is the resource string itself.
For information about the format of .txt and .restext files, see the "Resources in Text Files" section of Creating Resource Files.
A text file that contains resources must be saved with UTF-8 or Unicode (UTF-16) encoding unless it contains only characters in the Basic Latin range (to U+007F). Resgen.exe removes extended ANSI characters when it processes a text file that is saved using ANSI encoding.
Resgen.exe checks the text file for duplicate resource names. If the text file contains duplicate resource names, Resgen.exe will emit a warning and ignore the second value.
The .resx resource file format consists of XML entries. You can specify string resources within these XML entries, as you would in text files. A primary advantage of .resx files over text files is that you can also specify or embed objects. When you view a .resx file, you can see the binary form of an embedded object (for example, a picture) when this binary information is a part of the resource manifest. As with text files, you can open a .resx file with a text editor (such as Notepad or Microsoft Word) and write, parse, and manipulate its contents. Note that this requires a good knowledge of XML tags and the .resx file structure. For more details on the .resx file format, see the "Resources in .resx Files" section of Creating Resource Files.
In order to create a .resources file that contains embedded nonstring objects, you must either use Resgen.exe to convert a .resx file containing objects or add the object resources to your file directly from code by calling the methods provided by the ResourceWriter class.
If your .resx or .resources file contains objects and you use Resgen.exe to convert it to a text file, all the string resources will be converted correctly, but the data types of the nonstring objects will also be written to the file as strings. You will lose the embedded objects in the conversion, and Resgen.exe will report that an error occurred in retrieving the resources.
Converting Between Resources File Types
When you convert between different resource file types, Resgen.exe may not be able to perform the conversion or may lose information about specific resources, depending on the source and target file types. The following table specifies the types of conversions that are successful when converting from one resource file type to another.
|Convert from||To text file||To .resx file||To .resw file||To .resources file|
|Text (.txt or .restext) file||--||No issues||Not supported||No issues|
|.resx file||Conversion fails if file contains non-string resources (including file links)||--||Not supported||No issues|
|.resources file||Conversion fails if file contains non-string resources (including file links)||No issues||Not supported||--|
|.exe or .dll assembly||Not supported||Not supported||Only string resources (including path names) are recognized as resources||Not supported|
Performing Specific Resgen.exe Tasks
You can use Resgen.exe in diverse ways: to compile a text-based or XML-based resource file into a binary file, to convert between resource file formats, and to generate a class that wraps ResourceManager functionality and provides access to resources. This section provides detailed information about each task:
Compiling Resources into a Binary File
The most common use of Resgen.exe is to compile a text-based resource file (a .txt or .restext file) or an XML-based resource file (a .resx file) into a binary .resources file. The output file then can be embedded in a main assembly by a language compiler or in a satellite assembly by Assembly Linker (AL.exe).
The syntax to compile a resource file is:
resgen inputFilename [outputFilename]
where the parameters are:
The file name, including the extension, of the resource file to compile. Resgen.exe only compiles files with extensions of .txt, .restext, or .resx.
The name of the output file. If you omit
outputFilename, Resgen.exe creates a .resources file with the root file name of
inputFilename in the same directory as
outputFilename includes a directory path, the directory must exist.
You provide a fully qualified namespace for the .resources file by specifying it in the file name and separating it from the root file name by a period. For example, if
MyCompany.Libraries.Strings.resources, the namespace is MyCompany.Libraries.
The following command reads the name/value pairs in Resources.txt and writes a binary .resources file named Resources.resources. Because the output file name is not specified explicitly, it receives the same name as the input file by default.
The following command reads the name/value pairs in Resources.restext and writes a binary resources file named StringResources.resources.
resgen Resources.restext StringResources.resources
The following command reads an XML-based input file named Resources.resx and writes a binary .resources file named Resources.resources.
resgen Resources.resx Resources.resources
Converting Between Resource File Types
In addition to compiling text-based or XML-based resource files into binary .resources files, Resgen.exe can convert any supported file type to any other supported file type. This means that it can perform the following conversions:
.txt and .restext files to .resx files.
.resx files to .txt and .restext files.
.resources files to .txt and .restext files.
.resources files to .resx files.
The syntax is the same as that shown in the previous section.
In addition, you can use Resgen.exe to convert embedded resources in a .NET Framework assembly to a .resw file tor Windows 8.x Store apps.
The following command reads a binary resources file Resources.resources and writes an XML-based output file named Resources.resx.
resgen Resources.resources Resources.resx
The following command reads a text-based resources file named StringResources.txt and writes an XML-based resources file named LibraryResources.resx. In addition to containing string resources, the .resx file could also be used to store non-string resources.
resgen StringResources.txt LibraryResources.resx
The following two commands read an XML-based resources file named Resources.resx and write text files named Resources.txt and Resources.restext. Note that if the .resx file contains any embedded objects, they will not be accurately converted into the text files.
resgen Resources.resx Resources.txt resgen Resources.resx Resources.restext
Compiling or Converting Multiple Files
You can use the
/compile switch to convert a list of resource files from one format to another in a single operation. The syntax is:
resgen /compile filename.extension [filename.extension...]
The following command compiles three files, StringResources.txt, TableResources.resw, and ImageResources.resw, into separate .resources files named StringResources.resources, TableResources.resources, and ImageResources.resources.
resgen /compile StringResources.txt TableResources.resx ImageResources.resx
Exporting Resources to a .resw File
If you're developing a Windows 8.x Store app, you may want to use resources from an existing desktop app. However, the two kinds of applications support different file formats. In desktop apps, resources in text (.txt or .restext) or .resx files are compiled into binary .resources files. In Windows 8.x Store apps, .resw files are compiled into binary package resource index (PRI) files. You can use Resgen.exe to bridge this gap by extracting resources from an executable or a satellite assembly and writing them to one or more .resw files that can be used when developing a Windows 8.x Store app.
Visual Studio automatically handles all conversions necessary for incorporating the resources in a portable library into a Windows 8.x Store app. Using Resgen.exe directly to convert the resources in an assembly to .resw file format is of interest only to developers who want to develop a Windows 8.x Store app outside of Visual Studio.
The syntax to generate .resw files from an assembly is:
resgen filename.extension [outputDirectory]
where the parameters are:
The name of a .NET Framework assembly (an executable or .DLL). If the file contains no resources, Resgen.exe does not create any files.
The existing directory to which to write the .resw files. If
outputDirectory is omitted, .resw files are written to the current directory. Resgen.exe creates one .resw file for each .resources file in the assembly. The root file name of the .resw file is the same as the root name of the .resources file.
The following command creates a .resw file in the Win8Resources directory for each .resources file embedded in MyApp.exe:
resgen MyApp.exe Win8Resources
Conditionally Compiling Resources
Starting with the .NET Framework 4.5, Resgen.exe supports conditional compilation of string resources in text (.txt and .restext) files. This enables you to use a single text-based resource file in multiple build configurations.
In a .txt or .restext file, you use the
#endif construct to include a resource in the binary .resources file if a symbol is defined, and you use the
#endif construct to include a resource if a symbol is not defined. At compile time, you then define symbols by using the
/define: option followed by a comma-delimited list of symbols. The comparison is cased-sensitive; the case of symbols defined by
/define must match the case of symbols in the text files to be compiled.
For example, the following file named UIResources.rext includes a string resource named
AppTitle that can take one of three values, depending on whether symbols named
RETAIL are defined.
#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
The file can then be compiled into a binary .resources file with the following command:
resgen /define:CONSULT UIResources.restext
This produces a .resources file that contains two string resources. The value of the
AppTitle resource is "My Consulting Company Project Manager".
Generating a Strongly Typed Resource Class
Resgen.exe supports strongly typed resources, which encapsulates access to resources by creating classes that contain a set of static read-only properties. This provides an alternative to calling the methods of the ResourceManager class directly to retrieve resources. You can enable strongly typed resource support by using the
/str option in Resgen.exe, which wraps the functionality of the StronglyTypedResourceBuilder class. When you specify the
/str option, the output of Resgen.exe is a class that contains strongly typed properties that match the resources that are referenced in the input parameter. This class provides strongly typed read-only access to the resources that are available in the file processed.
The syntax to create a strongly typed resource is:
resgen inputFilename [outputFilename] /str:language[,namespace,[classname[,filename]]] [/publicClass]
The parameters and switches are:
The file name, including the extension, of the resource file for which to generate a strongly typed resource class. The file can be a text-based, XML-based, or binary .resources file; it can have an extension of .txt, .restext, .resw, or .resources.
The name of the output file. If
outputFilename includes a directory path, the directory must exist. If you omit
outputFilename, Resgen.exe creates a .resources file with the root file name of
inputFilename in the same directory as
outputFilename can be a text-based, XML-based, or binary .resources file. If the file extension of
outputFilename is different from the file extension of
inputFilename, Resgen.exe performs the file conversion.
inputFilename is a .resources file, Resgen.exe copies the .resources file if
outputFilename is also a .resources file. If
outputFilename is omitted, Resgen.exe overwrites
inputFilename with an identical .resources file.
The language in which to generate source code for the strongly-typed resource class. Possible values are
csharp for C# code,
visualbasic for Visual Basic code,
vbscript for VBScript code, and
cpp for C++ code.
The namespace that contains the strongly typed resource class. The .resources file and the resource class should have the same namespace. For information about specifying the namespace in the
outputFilename, see Compiling Resources into a Binary File. If namespace is omitted, the resource class is not contained in a namespace.
The name of the strongly typed resource class. This should correspond to the root name of the .resources file. For example, if Resgen.exe generates a .resources file named MyCompany.Libraries.Strings.resources, the name of the strongly typed resource class is Strings. If classname is omitted, the generated class is derived from the root name of
outputFilename is omitted, the generated class is derived from the root name of
classname cannot contain invalid characters such as embedded spaces. If classname contains embedded spaces, or if classname is generated by default from inputFilename, and inputFilename contains embedded spaces, Resgen.exe replaces all invalid characters with an underscore (_).
The name of the class file.
Makes the strongly typed resource class public rather than
internal (in C#) or
Friend (in Visual Basic). This allows the resources to be accessed from outside the assembly in which they are embedded.
When you create a strongly typed resource class, the name of your .resources file must match the namespace and class name of the generated code. However, Resgen.exe allows you to specify options that produce a .resources file that has an incompatible name. To work around this behavior, rename the output file after it has been generated.
The strongly typed resource class has the following members:
A parameterless constructor, which can be used to instantiate the strongly typed resource class.
Shared(Visual Basic) and read-only
ResourceManagerproperty, which returns the ResourceManager instance that manages the strongly typed resource.
Cultureproperty, which allows you to set the culture used for resource retrieval. By default, its value is
null, which means that the current UI culture is used.
Shared(Visual Basic) and read-only property for each resource in the .resources file. The name of the property is the name of the resource.-
For example, the following command compiles a resource file named StringResources.txt into StringResources.resources and generates a class named
StringResources in a Visual Basic source code file named StringResources.vb that can be used to access the Resource Manager.
resgen StringResources.txt /str:vb,,StringResources