VS.NET 基于 CodeDOM 的字符串资源管理自定义工具

重写的 GenerateCode 方法提供了 fileName 和 fileContents 参数。它们代表基本语言文件（自定义工具正在运行的文件）的名称和内容。为了与其他属于同一资源集的文件进行比较，有必要也获取它们的内容，遍历每个资源，并执行必要的验证。通过正则表达式检查每个字符串中参数的数量是否匹配。

//Compare all different-language resource files and 
//raise an error in case of inconsistencies with the base resource file
string ParameterMatchExpression = @"(\{[^\}\{]+\})";
string path = Path.GetDirectoryName(fileName);
DirectoryInfo folder = new DirectoryInfo(path);
//Create a sorted list of string resources from the base resource file 
//Sorted list is used to perform validation in alphabetical order
ResXResourceReader reader = new ResXResourceReader(fileName);
IDictionaryEnumerator enumerator = reader.GetEnumerator();
SortedList baseList = new SortedList();
while (enumerator.MoveNext())
{
    MatchCollection mc = 
        Regex.Matches(enumerator.Value.ToString(), 
        ParameterMatchExpression);
    //The resource name is the key argument and
        //the number of String.Format arguments is the value argument
    baseList.Add(enumerator.Key, mc.Count);
}
reader.Close();

//Get all other .resx files in the same folder
foreach(FileInfo file in folder.GetFiles("*.resx"))
{
    //Consider only files with the same name 
        //(for instance - Strings.de.resx has
        // the same name as Strings.en.resx)
    if ((file.FullName!=fileName) && 
     (Helper.GetBaseFileName(file.Name) == 
       Helper.GetBaseFileName(Path.GetFileNameWithoutExtension(fileName))))
    {
        //Create a sorted list of string resources 
        //from the found resource file
        reader = new ResXResourceReader(file.FullName);
        enumerator = reader.GetEnumerator();
        SortedList list = new SortedList();
        while (enumerator.MoveNext())
        {
            MatchCollection mc = 
                Regex.Matches(enumerator.Value.ToString(), 
                ParameterMatchExpression);
            list.Add(enumerator.Key, mc.Count);
        }
        reader.Close();

        enumerator = baseList.GetEnumerator();
        try
        {                    
            //iterate through the sorted list created 
            //from a base resource file and
            //compare its key and value with the ones from 
            //the sorted list created from the other file
            while (enumerator.MoveNext())
            {
                if (list.ContainsKey(enumerator.Key)==false)
                {
                    throw new Exception("Resource " + 
                        enumerator.Key.ToString() + 
                        " is missing in the file " + file.Name);
                }
                if (!list[enumerator.Key].Equals(enumerator.Value))
                {
                    throw new Exception("Resource " + 
                        enumerator.Key.ToString() + 
                        " in the file " + file.Name + 
                        " has incorrect number of arguments.");
                }
            }
        }
        catch (Exception ex)
        {
            //The exception will be thrown in the VS.NET environment
            throw (ex);
        }
    }
}

找到 BaseName 并执行验证后，一切都已准备好进行代码生成，除了选择代码生成的语言。同样，EnvDTE 使这项任务变得容易。

CodeDomProvider provider = null;
switch(proj.CodeModel.Language)
{
    case CodeModelLanguageConstants.vsCMLanguageCSharp:
        provider = new Microsoft.CSharp.CSharpCodeProvider();
        break;
    case CodeModelLanguageConstants.vsCMLanguageVB:
        provider = new Microsoft.VisualBasic.VBCodeProvider();
        break;
}

所选提供程序用于 CodeDOM 代码生成过程。所有与此过程相关的代码都打包到一个名为 CodeDomResourceClassGenerator 的独立类中。重写的 GenerateCode 方法中的其余代码将所有必要的参数传递给静态 CodeDomResourceClassGenerator.GenerateCode 方法，并从中获取生成的代码。它返回一个字节数组，该数组将用于构造类文件，该文件将位于项目层次结构中的 .resx 文件下方。

//This is the value of the .resx file "Custom Tool Namespace" property
string classNameSpace = FileNameSpace != String.Empty ? 
         FileNameSpace : Assembly.GetExecutingAssembly().GetName().Name;
            
return CodeDomResourceClassGenerator.GenerateCode(
    provider,
    fileName,
    fileContents,
    baseName,
    classNameSpace
);

CodeDomResourceClassGenerator.GenerateCode 方法构建 CodeDOM 图，这是一种语言无关的蓝图，它告诉选定的 CodeDomProvider 如何生成代码。在生成代码字符串后，将其解析为所需的字节数组。

internal class CodeDomResourceClassGenerator
{
    public static byte[] GenerateCode(CodeDomProvider provider,
                                      string fileName, 
                                      string fileContents, 
                                      string baseName, 
                                      string classNameSpace)
    {
        CodeCompileUnit compileUnit = BuildGraph(fileName, 
                fileContents, baseName, classNameSpace);
        ICodeGenerator gen = provider.CreateGenerator();

        using(StringWriter writer = new StringWriter())
        using(IndentedTextWriter tw = new IndentedTextWriter(writer))
        {
            gen.GenerateCodeFromCompileUnit(compileUnit, 
                             tw, new CodeGeneratorOptions());
            string code = writer.ToString().Trim();
            return System.Text.Encoding.ASCII.GetBytes(code);
        }
     }
         
...

所有代码生成的核心都包含在 BuildGraph 方法中，该方法将在下一节中进行更详细的解释。

构建 CodeDOM 图

在深入 CodeDOM 建模之前，必须知道生成的文件的预期外观。以下 C# 示例显示了资源工具生成文件的预期设计

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

// ------------------------------------------------------------------------
// <autogeneratedinfo>
//     This code was generated by:
//         ResourceClassGenerator custom tool for VS.NET
//
//     It contains classes defined from the contents of the resource file:
//         [.resx file location]
//
//     Generated: [Date & Time of generation]
//  </autogeneratedinfo>
// ------------------------------------------------------------------------
namespace CSharpTest.Resources {

/// <summary>
/// Provides access to an assembly's string resources
/// </summary>
class ResourceFormatter 
{

    private static System.Resources.ResourceManager _ResourceManager;
    /// <summary>
    /// ResourceManager property with lazy initialization
    /// </summary>
    /// <value>An instance of the ResourceManager class.</value>
    private static System.Resources.ResourceManager ResourceManager {
        get 
        {
            if ((_ResourceManager == null)) 
            {
                _ResourceManager = new System.Resources.ResourceManager(
                          [BaseName], 
                          System.Reflection.Assembly.GetExecutingAssembly());
            }
            return _ResourceManager;
        }
    }

    /// <summary>
    /// Loads an unformatted string
    /// </summary>
    /// <param name="resourceId">Identifier of string resource</param>
    /// <returns>string</returns>
    public static string GetString(string resourceId) 
    {
        return ResourceFormatter.ResourceManager.GetString(resourceId);
    }

    /// <summary>
    /// Loads a formatted string
    /// </summary>
    /// <param name="resourceId">Identifier of string resource</param>
    /// <param name="objects">Array of objects 
    ///              to be passed to string.Format</param>
    /// <returns>string</returns>
    public static string GetString(string resourceId, object[] args) 
    {
        string format = 
           ResourceFormatter.ResourceManager.GetString(resourceId);
        return string.Format(format, args);
    }
}

/// <summary>
/// Access to resource identifier lbl1
/// </summary>
class lbl1 
{
    public static string GetString() 
    {
        return ResourceFormatter.GetString("lbl1");
    }
}

/// <summary>
/// Access to resource identifier lbl2
/// </summary>
class lbl2
{
    public static string GetString(object arg0, object arg1)
    {
        return ResourceFormatter.GetString("lbl2", 
                           new object[] {arg0, arg1});
    }
}

...

所有这些代码语句都需要转换为适当的 CodeDOM 表达式。代码树中的顶级对象是 CodeCompileUnit。

private static CodeCompileUnit BuildGraph(string fileName, 
                                          string fileContents, 
                                          string baseName, 
                                          string classNameSpace)
    {
    CodeCompileUnit compileUnit = new CodeCompileUnit();
    ...

CodeCompileUnit 包含一组 CodeNamespace 对象，这些对象代表生成代码中的命名空间。大多数编程元素在 CodeDOM 对象模型中都有相应的表示，类可以通过 CodeTypeDeclaration 对象添加到命名空间，字段可以通过 CodeMemberField 对象添加到类中，依此类推。关键在于，CodeDOM 只能在处理所有语言中都存在的元素时，才能生成所有语言有效的代码。因此，例如，不支持 VB.NET 的 With 语句，也不支持预处理器指令（包括广受欢迎的 region 指令）。这可以通过某些称为片段的 CodeDom 类（如 CodeSnippetStatement、CodeSnippetExpression 等）来实现，根据 MSDN 的说法，这些类被解释为直接包含在源代码中的字面代码片段，而无需修改。但是，这可能会破坏语言的中立性，并且 CodeDOM 可能无法为某些语言生成有效的代码。

考虑到所有这些，我决定不使用片段并保持语言的独立性。这就是为什么生成的代码设计不包含 region 指令。它们可能有助于将基类 ResourceFormatter 与众多资源类分开，但这并不重要，因为整个资源工具的理念是基于“设置好就不用管”的原则，无需浏览或更改生成的代码。只需在资源更改时重新生成即可。

尽管如此，即使遵循严格的语言兼容性规则，也存在一些棘手的问题需要解决。默认情况下，VB.NET CodeDOM 提供程序输出 Option Strict Off（控制是否允许隐式类型转换）和 Option Explicit On（控制是否需要声明变量）。每个有自尊的 VB 程序员都会始终将这两个选项都设置为 On。我在一本出色的书——Kathleen Dollard 的《Code Generation in Microsoft .NET》中找到了解决此问题的方法。以下是其内容

//Just for VB.NET
compileUnit.UserData.Add("AllowLateBound", false);
compileUnit.UserData.Add("RequireVariableDeclaration", true);

确实，我用Reflector 进行了检查，这在 Microsoft.VisualBasic.VBCodeGenerator.GenerateCompileUnitStart 方法（在 System.dll 中）中是硬编码的，而在 Microsoft.CSharp.CSharpCodeGenerator.GenerateCompileUnitStart 中没有类似的东西。另一个重要问题的答案也可以在这些方法中找到。使用 CodeDOM 生成的每个文件顶部都有如下注释

//------------------------------------------------------
// <AUTOGENERATED>
//     This code was generated by a tool.
//     Runtime Version: [Version number]
//
//     Changes to this file may cause incorrect behavior 
//     and will be lost if the code is regenerated.
// </AUTOGENERATED>
//------------------------------------------------------

由于我想添加更多代码生成注释（例如源 .resx 文件位置和生成时间），我认为在这里添加它们很合适，但这不可能，因为这在 VBCodeGenerator 和 CSharpCodeGenerator 的 GenerateCompileUnitStart 方法中也是硬编码的。因此，我使用了不同的 <autogeneratedinfo> 注释标签。

前面提到的那本书中的另一个绝佳建议是关于 VB.NET Imports 和 C# using 语句。它们通过 CodeNamespace.Imports 属性添加，该属性代表 CodeNamespaceImportCollection。VB 提供程序始终将 Imports 语句放在文件顶部，命名空间之外，并且在 VB.NET 中 Imports 适用于整个文件。在 C# 中，using 语句可以放在每个命名空间下方，C# 提供程序会将其放在命名空间声明下方。如果想要完全相同的结果，应该采用 VB.NET 的方法，并将 C# using 语句放在命名空间之外。书中的绝妙技巧是添加一个以空字符串作为命名空间名称的 CodeNamespace，这样就不会输出命名空间声明

//Dummy namespace, so the Import statements would appear 
//above the main namespace declaration
CodeNamespace dummyNamespace = new CodeNamespace("");
compileUnit.Namespaces.Add(dummyNamespace);

//Namespace Import
dummyNamespace.Imports.Add(new CodeNamespaceImport("System"));
dummyNamespace.Imports.Add(new CodeNamespaceImport("System.Resources"));
dummyNamespace.Imports.Add(new CodeNamespaceImport("System.Reflection"));

现在所有先决条件都已满足，剩下的就是纯粹的 CodeDOM 建模。一个更复杂的编程语句可能需要十几个 CodeDOM 语句。因此，下面的代码进行了注释，显示了上面设计的资源工具类文件中的每个语句如何用相应的 CodeDOM 语句块表示。

//Namespace
CodeNamespace nSpace = new CodeNamespace(classNameSpace);
compileUnit.Namespaces.Add(nSpace);

//Namespace comments
nSpace.Comments.Add(new CodeCommentStatement(
    "-----------------------------" + 
    "------------------------------------------------"));
nSpace.Comments.Add(new 
    CodeCommentStatement(" <AUTOGENERATEDINFO>"));
nSpace.Comments.Add(new 
    CodeCommentStatement("     This code was generated by:"));
nSpace.Comments.Add(new 
    CodeCommentStatement("       ResourceClassGenerator" + 
    " custom tool for VS.NET"));
nSpace.Comments.Add(new CodeCommentStatement(""));
nSpace.Comments.Add(new CodeCommentStatement(
    "     It contains classes defined from the" + 
    " contents of the resource file:"));
nSpace.Comments.Add(new CodeCommentStatement("       " 
    + fileName));
nSpace.Comments.Add(new CodeCommentStatement(""));
nSpace.Comments.Add(new CodeCommentStatement(
    "     Generated: " + DateTime.Now.ToString("f", 
    new System.Globalization.CultureInfo("en-US"))));
nSpace.Comments.Add(new CodeCommentStatement(" </AUTOGENERATEDINFO>"));
nSpace.Comments.Add(new CodeCommentStatement(
    "-----------------------------------" + 
    "------------------------------------------"));

//Class ResourceFormatter
CodeTypeDeclaration cResourceFormatter = 
    new CodeTypeDeclaration("ResourceFormatter");
//This is automatically internal, 
//only nested classes can be private
cResourceFormatter.TypeAttributes = 
            System.Reflection.TypeAttributes.NotPublic;
//ResourceFormatter Comments
cResourceFormatter.Comments.Add(new 
    CodeCommentStatement("<SUMMARY>", true));
cResourceFormatter.Comments.Add(new CodeCommentStatement(
    "Provides access to an assembly's string resources", true));
cResourceFormatter.Comments.Add(new 
    CodeCommentStatement("</SUMMARY>", true));
nSpace.Types.Add(cResourceFormatter);

//Field _ResourceManager
CodeMemberField fResourceManager = 
    new CodeMemberField(typeof(System.Resources.ResourceManager), 
    "_ResourceManager");
fResourceManager.Attributes = 
    (MemberAttributes)((int)MemberAttributes.Static + 
    (int)MemberAttributes.Private);
cResourceFormatter.Members.Add(fResourceManager);

//Property ResourceManager
CodeMemberProperty pResourceManager = new CodeMemberProperty();
pResourceManager.Name = "ResourceManager";
pResourceManager.Type = new 
    CodeTypeReference(typeof(System.Resources.ResourceManager));
pResourceManager.Attributes = 
    (MemberAttributes)((int)MemberAttributes.Static 
    + (int)MemberAttributes.Private);
//It is read-only property
pResourceManager.HasSet = false;
//ResourceManager Comments
pResourceManager.Comments.Add(new 
    CodeCommentStatement("<SUMMARY>", true));
pResourceManager.Comments.Add(new CodeCommentStatement(
    "ResourceManager property with lazy initialization", true));
pResourceManager.Comments.Add(new 
    CodeCommentStatement("</SUMMARY>", true));
pResourceManager.Comments.Add(new CodeCommentStatement(
    "<VALUE>An instance of the ResourceManager" + 
    " class.</VALUE>", true));

CodeVariableReferenceExpression _ResourceManager = 
     new CodeVariableReferenceExpression("_ResourceManager");
            
//ResourceManager assignment line inside the if block
CodeAssignStatement assignResourceManager = new CodeAssignStatement
(
    _ResourceManager,
    new CodeObjectCreateExpression
    (
        typeof(System.Resources.ResourceManager), 
        new CodeExpression[]
        {
            new CodePrimitiveExpression(baseName),
            new CodeMethodInvokeExpression
            (
              new 
               CodeTypeReferenceExpression(typeof(System.Reflection.Assembly)),
               "GetExecutingAssembly",
               new CodeExpression[] {}
            )
        }
    )
);

//ResourceManager if block - for lazy initialization
CodeConditionStatement ifBlock = new CodeConditionStatement
(
    new CodeBinaryOperatorExpression
    (
        _ResourceManager,
        CodeBinaryOperatorType.IdentityEquality,
        new CodePrimitiveExpression(null)
    ),
    new CodeStatement[]    
    {
        assignResourceManager
    }
);

pResourceManager.GetStatements.Add(ifBlock);
pResourceManager.GetStatements.Add(new 
         CodeMethodReturnStatement(_ResourceManager));
cResourceFormatter.Members.Add(pResourceManager);

//GetString method
CodeMemberMethod mGetString = new CodeMemberMethod();
mGetString.Name = "GetString";
mGetString.Attributes = (MemberAttributes)
         ((int)MemberAttributes.Static + 
         (int)MemberAttributes.Public);
mGetString.ReturnType = new CodeTypeReference(typeof(string));
mGetString.Parameters.Add(new 
  CodeParameterDeclarationExpression(typeof(string), 
  "resourceId"));
//GetString method comments
mGetString.Comments.Add(new 
  CodeCommentStatement("<SUMMARY>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("Loads an unformatted string", true));
mGetString.Comments.Add(new CodeCommentStatement("</SUMMARY>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("<PARAM name='\"resourceId\"'>Identifier" 
  + " of string resource</PARAM>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("<RETURNS>string</RETURNS>", true));
//GetString method statements
CodePropertyReferenceExpression propExp = 
    new CodePropertyReferenceExpression(new 
    CodeTypeReferenceExpression("ResourceFormatter"), 
    "ResourceManager");
CodeMethodInvokeExpression invokeResourceManager = 
    new CodeMethodInvokeExpression(propExp, 
    "GetString", 
    new CodeExpression[] {new 
    CodeArgumentReferenceExpression("resourceId")});                    
mGetString.Statements.Add(new 
    CodeMethodReturnStatement(invokeResourceManager));
cResourceFormatter.Members.Add(mGetString);

//The second overloaded GetString method
mGetString = new CodeMemberMethod();
mGetString.Name = "GetString";
mGetString.Attributes = 
  (MemberAttributes)((int)MemberAttributes.Static 
  + (int)MemberAttributes.Public);
mGetString.ReturnType = new CodeTypeReference(typeof(string));
mGetString.Parameters.Add(new 
  CodeParameterDeclarationExpression(typeof(string), 
  "resourceId"));
CodeParameterDeclarationExpression objects = 
    new CodeParameterDeclarationExpression(typeof(object[]), "args");
mGetString.Parameters.Add(objects);
//The second GetString method comments
mGetString.Comments.Add(new 
  CodeCommentStatement("<SUMMARY>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("Loads a formatted string", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("</SUMMARY>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("<PARAM name='\"resourceId\"'>Identifier" 
  + " of string resource</PARAM>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("<PARAM name='\"objects\"'>Array" + 
  " of objects to be passed to string.Format</PARAM>", true));
mGetString.Comments.Add(new 
  CodeCommentStatement("<RETURNS>string</RETURNS>", true));
//The second GetString method statements
mGetString.Statements.Add(
    new CodeVariableDeclarationStatement(typeof(string), 
    "format", invokeResourceManager));
CodeMethodInvokeExpression invokeStringFormat = 
   new CodeMethodInvokeExpression(
    new CodeTypeReferenceExpression(typeof(string)), 
    "Format", 
    new CodeExpression[] 
    {
        new CodeArgumentReferenceExpression("format"),
        new CodeArgumentReferenceExpression("args")
    } 
);
mGetString.Statements.Add(new CodeMethodReturnStatement(invokeStringFormat));
cResourceFormatter.Members.Add(mGetString);

//Iterate through every resource and create 
//the static class with the appropriate GetString method
using(Stream inputStream = new 
  MemoryStream(System.Text.Encoding.UTF8.GetBytes(fileContents)))
using(ResXResourceReader resReader = 
            new ResXResourceReader(inputStream))
{
    IDictionaryEnumerator resEnumerator = resReader.GetEnumerator();
    SortedList sList = new SortedList();
    while(resEnumerator.MoveNext())
    {
        sList.Add(resEnumerator.Key, resEnumerator.Value);
    }
    resEnumerator = sList.GetEnumerator();

    // Create a class definition for each string entry  
    while(resEnumerator.MoveNext())
    {
        string resKey = (string)resEnumerator.Key;

        //Resource class
        CodeTypeDeclaration cResource = new CodeTypeDeclaration(resKey);
        //Class is automatically internal, only nested classes can be private
        cResource.TypeAttributes = System.Reflection.TypeAttributes.NotPublic;
        //Resource class comments
        cResource.Comments.Add(new 
          CodeCommentStatement("<SUMMARY>", true));
        cResource.Comments.Add(new 
          CodeCommentStatement("Access to resource identifier " 
          + resKey, true));
        cResource.Comments.Add(new 
          CodeCommentStatement("</SUMMARY>", true));
        nSpace.Types.Add(cResource);

        mGetString = new CodeMemberMethod();
        mGetString.Name = "GetString";
        mGetString.Attributes = 
                    (MemberAttributes)((int)MemberAttributes.Static 
                    + (int)MemberAttributes.Public);
        mGetString.ReturnType = new CodeTypeReference(typeof(string));

        //It is necessary to know how many replaceable 
        //parameters the string has
        string ParameterMatchExpression = @"(\{[^\}\{]+\})";
        MatchCollection mc = Regex.Matches(resEnumerator.Value.ToString(), 
                     ParameterMatchExpression);
        //Don't include duplicates in count
        // as String.Format argument can be specified
        //more than once, ie: "First: {0},
        // Second: {1}, First again: {0}" 
        StringCollection parameters = new StringCollection();
        foreach(Match match in mc)
        {
            if(!parameters.Contains(match.Value))
            {
                parameters.Add(match.Value);
            }
        }

        CodeExpression[] getStringParams;
        if (parameters.Count>0)
        {
            CodeExpression[] args = new CodeExpression[parameters.Count];
            //Create the argument lists
            for(int i = 0; i < parameters.Count; i++)
            {
                mGetString.Parameters.Add(
                  new CodeParameterDeclarationExpression(typeof(object), 
                  "arg" + i.ToString()));
                args[i] = new 
                  CodeArgumentReferenceExpression("arg" + i.ToString());
            }
            getStringParams = new CodeExpression[2];
            getStringParams[1] = new 
              CodeArrayCreateExpression(typeof(object), args);
        }
        else
        {
            getStringParams = new CodeExpression[1];
        }
        //The first parameter(key) is allways the same regardless of
        //whether additional args exist or not
        getStringParams[0] = new CodePrimitiveExpression(resKey);

        //Resource class statements
        CodeMethodInvokeExpression invokeGetString = 
                          new CodeMethodInvokeExpression
        (
            new CodeTypeReferenceExpression("ResourceFormatter"),
            "GetString",
            getStringParams
        );
        mGetString.Statements.Add(new 
          CodeMethodReturnStatement(invokeGetString));
        cResource.Members.Add(mGetString);
    }
}

就是这样，在 BuildGraph 方法的末尾，一个填充好的 CodeCompileUnit 会被返回到 GenerateCode 方法。

安装和用法

以下是 ResourceClassGenerator 自定义工具安装所需的步骤

1. 由于我不能且无意在可下载的源代码中分发 BaseCodeGeneratorWithSite，请从上面提到的位置（GotDotNet 用户示例：BaseCodeGeneratorWithSite）下载其源代码，将其包含在 ResourceClassGenerator 项目的“引用”列表中，并进行构建。

   重要提示： 请务必根据您打算使用 ResourceClassGenerator 的 VS.NET 版本（2002/2003）包含正确版本的 BaseCodeGeneratorWithSite.dll，否则该工具可能无法正常工作。

2. 使用 regasm 将已构建的 ResourceClassGenerator 版本注册到 COM。
3. 设置适当的注册表设置，以便 VS.NET 能够识别它。这些设置的位置类似于 HKLM\Software\Microsoft\VisualStudio\7.x\Generators\packageguid。C# 环境 ({FAE04EC1-301F-11d3-BF4B-00C04F79EFBC}) 与 VB.NET 环境 ({164B10B9-B200-11D0-8C61-00A0C91E29D5}) 的 packageguid 不同。应在这些位置添加一个新密钥以及适当的值。例如，对于 VS.NET 2003 C# 环境，这些注册表设置将如下所示
   • 键

     [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\7.1\Generators\{FAE04EC1-301F-11d3-BF4B-00C04F79EFBC}\ResourceClassGenerator]

   • 默认值

     @="C# 代码生成器用于字符串资源类"

   • Guid 属性的值

     "CLSID"="{8442788C-A1A7-4475-A0C6-C2B83BD4221F}"

   • 最后

     "GeneratesDesignTimeSource"=dword:00000001

您无需手动执行最后两个步骤，可下载项目已包含一个 Setup.bat 文件。它会自动检测当前的 VS.NET 版本，将 ResourceClassGenerator 注册到 COM，并为 C# 和 VB.NET 设置适当的注册表设置。还有一个 Uninstall.bat 文件，用于撤消所有这些步骤。这两个文件都位于项目输出路径（当前设置为 redist 文件夹）中，并且始终需要位于已构建的 .dll 所在的文件夹中。如果您同时安装了 VS.NET 2002 和 VS.NET 2003，则该工具将始终为 2003 版本安装，并且您需要对这些 .bat 文件进行少量修改，才能在此特定情况下为 2002 版本安装/卸载它。

安装后，可以通过在所需 .resx 文件的“属性”窗口中设置 CustomTool 属性来轻松使用该工具。其值应设置为 ResourceClassGenerator。通过右键单击 .resx 文件并选择“运行自定义工具”选项来启动它。