.NET/VS 最强大的功能之一就是多语言的支持，通过利用 Resource File (.resx) 资源文件。可以让界面根据当前运行环境自动显示对应的语言。内置的很多有需要文字的类也有对应的支持，如 DisplayAttribute, RquiredAttribute 等。

如何使用？

首先，在你的工程文件创建一个 Resources 文件夹（当然也可以是其它名称，i18n之类的也可以）。然后在文件夹内添加一个 Resource File (.resx)文件，文件名你可以自定，比如说我们这里叫 Resource.resx ，Resource.resx 就会成为默认的本地化资源文件。在程序运行的过程中，如何没有找到合适的资源文件，就会使用这个默认的资源文件。

然后，双击打开 Resource.resx 文件，添加相应的名值和内容，可以是文字，图片，文本文档和 Object 格式。比如说我们添加一个名为 APP_NAME 值为 Hello world 的文字项。在需要使用到Hello world 的地方，我们使用 Resources.Resource.APP_NAME 即可得到相应的文字。针对 DisplayAttribute ，我们需要使用这样的方式让 DisplayName 实现本地化：

1

[Display(Name = "APP_NAME", ResourceType = typeof(Resources.Resource)]

这样在使用 Html.LabelFor 的时候，相应的文字也会变化。

后期，在需要添加新的本地化资源时，只需将 Resource.resx 复制一份，重命名为：Resource.{culture}.resx 即可！比如说默认的是英文的，现在要增加简体中文的支持，就是重命名为 Resource.zh-Hans.resx。很方便吧！

不需要多语言支持也建议使用

即使你Programming的过程中短期内无需支持多语言，在一开始就使用多语言支持的策略也是有好处的。抛开后期扩展不讲，一般情况下我们在程序Programming过程中不可避免地要和错误和错误信息打交道，执行逻辑中若遇到问题我们需要向调用方返回一个错误码和错误信息，处理的情况不外乎使用 enum 或者 string 来处理这样的情况。string 最大的问题是无智能感知，万一拼错了整个程序就无法正常运行，enum 的问题就是中文处理起来不便，通过使用 Resource.resx + DisplayAttribute 的方式也可以绑定错误信息进行处理。但这样要定义一个 enum 再定义 DisplayAttribute 再添加 resource 键值太麻烦了，而且也没有智能感知，容易打错!

更好的方式？

显然，我们需要的是一个 ERROR_CODE 和它对应的 ERROR_MESSAGE, 我们就可以满足错误子系统的需求。如果可以通过 Resources.Resource.APP_NAME 这样的方式去引用 ERROR_CODE 和 ERROR_MESSAGE 即可实现智能感知防止输错的问题，整个引用也会简单很多，更快速，不易出错。 Resource.resx 是通过自动生成一个对应的 cs 文件实现 Resources.Resource.APP_NAME 这样的智能感知引用（你只要点击一个 resx 文件的+号就能看到对应的 cs 文件）。

如果我们可以操纵这个 cs 文件的生成那就不OK了？那么，如何实现？一番 google 之后，我发现 T4 就是真爱！

T4 真是太他娘好用了，在相同文件夹内，新建一个 Text Template (.tt)文件，将它的名称改成跟源文件同名，它就会根据同名文件（后缀不同）生成对应的文件（默认是cs文件）然后包含到工程中！这个真是简单直白！在我们开始应用 TT 之前，先要把 Resource.resx 属性中的 Custom Tool 去掉（这个就是为什么 .resx 会自动生成.cs 文件的原因，清空它就不会再生成 .cs 文件）。然后把 tt 文件改成 Resource.tt ，最后把这个我在网上偷来的模板内容粘贴到 tt 文件里面：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328


/*
T4Resx Version 0.1
Maintained by Kenneth Baltrinic
http://blog.baltrinic.com

Related blog posts: http://blog.baltrinic.com/software-development/dotnet/t4-template-replace-resxfilecodegenerator

The certain parts of this template were copied from the T4MVC template which is distributed under the MvcContrib license (http://mvccontrib.codeplex.com/license)

This template if free for redistribution in accordance with the same license.
*/
#>
<#@ template debug="true" hostspecific="true" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="Microsoft.VisualStudio.Shell.Interop.8.0" #>
<#@ assembly name="EnvDTE" #>
<#@ assembly name="EnvDTE80" #>
<#@ assembly name="VSLangProj" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="Microsoft.VisualStudio.Shell.Interop" #>
<#@ import namespace="EnvDTE" #>
<#@ import namespace="EnvDTE80" #>
<#@ import namespace="Microsoft.VisualStudio.TextTemplating" #>
<#
   var serviceProvider = Host as IServiceProvider;
    if (serviceProvider != null) {
        Dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
    }

    // Fail if we couldn't get the DTE. This can happen when trying to run in TextTransform.exe
    if (Dte == null) {
        throw new Exception("T4MVC can only execute through the Visual Studio host");
    }

    Project = GetProjectContainingT4File(Dte);

    if (Project == null) {
        Error("Could not find the VS Project containing the T4 file.");
        return"XX";
    }

     AppRoot = Path.GetDirectoryName(Project.FullName) + '\';
     RootNamespace = Project.Properties.Item("RootNamespace").Value.ToString();
#>
using System.Threading;
using System.Web;

<#
try{
    AllEntries = new List<ResourceEntry>();
    FindResourceFilesRecursivlyAndRecordEntries(Project.ProjectItems, "");
    AllEntries.Sort( new Comparison<ResourceEntry>( (e1, e2) => (e1.Path + e1.File + e1.Name).CompareTo(e2.Path + e2.File + e2.Name)));

    var currentNamespace = "";
    var currentClass = "";
    var thisIsFirstEntryInClass = true;
    var names = new List<string>();
    foreach(var entry in AllEntries)
    {
        //WriteLine("//" + entry.Path + ":" + entry.File+ ":" + entry.Name);

        var newNamespace = ("Resources." + entry.Path + ".").Replace(".Resources.", ".");
        newNamespace = RootNamespace + "." + newNamespace.Substring(0, newNamespace.Length-1);
        var newClass = entry.File;

        bool namesapceIsChanging = newNamespace != currentNamespace;
        bool classIsChanging = namesapceIsChanging || newClass != currentClass;

        //Close out current class if class is changing and there is a current class
        if(classIsChanging &amp;&amp; currentClass != "")
        {
            EmitNamesInnerClass(names);
            WriteLine("t}");
        }

        if(namesapceIsChanging)
        {
            //Close out current namespace if one exists
            if( currentNamespace != "" )
                WriteLine("}");

            currentNamespace = newNamespace;

            //open new namespace
            WriteLine(string.Format("namespace {0}", currentNamespace));
            WriteLine("{");

        }

        if(classIsChanging)
        {
            currentClass = newClass;
            WriteLine(string.Format("tpublic class {0}", currentClass));
            WriteLine("t{");
            thisIsFirstEntryInClass = true;

        //Emit code for the ResourceManager property and GetResourceString method for the current class
        #>
    private static global::System.Resources.ResourceManager resourceMan;

    /// <summary>
    ///   Returns the cached ResourceManager instance used by this class.
    /// </summary>
    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
    public static global::System.Resources.ResourceManager ResourceManager
        {
      get
            {
        if (object.ReferenceEquals(resourceMan, null))
                {
          global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("<#=string.Format("{0}.{1}{2}", RootNamespace, entry.Path + "." + entry.File, entry.Type) #>", typeof(<#=entry.File#>).Assembly);
          resourceMan = temp;
        }
        return resourceMan;
      }
    }

    /// <summary>
    ///   Returns the formatted resource string.
    /// </summary>
    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
    public static string GetResourceString(string key, params string[] tokens)
        {
            var culture = Thread.CurrentThread.CurrentCulture;
      var str = ResourceManager.GetString(key, culture);

            for(int i = 0; i < tokens.Length; i += 2)
                str = str.Replace(tokens[i], tokens[i+1]);

        return str;
    }

    /// <summary>
    ///   Returns the resource string.
    /// </summary>
    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
    public static string GetString(string key)
        {
            return ResourceManager.GetString(key);
    }
        <#
        }

        //Emit the static resource string access method for the current entry
        if(entry.Comment != null)
        {
            if(!thisIsFirstEntryInClass) WriteLine("");
            WriteLine(string.Format("rntt///<summary>rntt///{0}rntt///</summary>", entry.Comment.Replace("rn", "rntt///")));
        }
        else
            WriteLine("");

        //Select all tokens between braces that constitute valid identifiers
        var tokens = Regex.Matches(entry.Value, @"{(([A-Za-z]{1}w*?)|([A-Za-z_]{1}w+?))?}").Cast<Match>().Select(m => m.Value);

        if(tokens.Any())
        {
            var inParams = tokens.Aggregate("", (list, value) => list += ", string " + value)
                .Replace("{", "").Replace("}", "");
            if(inParams.Length > 0 ) inParams = inParams.Substring(1);
            var outParams = tokens.Aggregate("", (list, value) => list += ", "" + value +"", " + value.Replace("{", "").Replace("}", "") );

            if(entry.Value.StartsWith("HTML:"))
                WriteLine(string.Format("ttpublic static HtmlString {0}({1}) {{ return GetResourceHtmlString("{0}"{2}); }}",  entry.Name, inParams, outParams));
            else
                WriteLine(string.Format("ttpublic static string {0}({1}) {{ return GetResourceString("{0}"{2}); }}",  entry.Name, inParams, outParams));
        }
        else
        {
            if(entry.Value.StartsWith("HTML:"))
                WriteLine(string.Format("ttpublic static HtmlString {0} {{ get {{ return GetResourceHtmlString("{0}"); }} }}",  entry.Name));
            else
            {
                WriteLine(string.Format("ttpublic static string {0} {{ get {{ return GetResourceString("{0}"); }} }}",  entry.Name));
                //WriteLine(string.Format("ttinternal static string V{0} {{ get {{ return GetResourceString("{0}"); }} }}",  entry.Name));
                }
        }
        names.Add(entry.Name);

        thisIsFirstEntryInClass = false;

    } // foreach(var entry in AllEntries)

    //close out the current class when done
    if(currentClass != "")
    {
        EmitNamesInnerClass(names);
        WriteLine("t}");
    }
}
catch(Exception ex)
{
    Error(ex.ToString());
}
#>
}
<#+
    const string Kind_PhysicalFolder = "{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}";
    bool AlwaysKeepTemplateDirty = true;
    static DTE Dte;
    static Project Project;
    static string AppRoot;
    static string RootNamespace;
    static List<ResourceEntry> AllEntries;

void FindResourceFilesRecursivlyAndRecordEntries(ProjectItems items, string path)
{
    foreach(ProjectItem item in items)
    {
        if(Path.GetExtension(item.Name) == ".resx")
            RecordEntriesInResourceFile(item, path);
        if(item.Kind == Kind_PhysicalFolder)
            FindResourceFilesRecursivlyAndRecordEntries(item.ProjectItems, path+"."+item.Name);
    }
}

void RecordEntriesInResourceFile(ProjectItem item, string path)
{
    //skip resource files except those for the default culture
    if(Regex.IsMatch(item.Name, @".*.[a-zA-z]{2}(-[a-zA-z]{2})?.resx"))
            return;

    var filePath = (string)item.Properties.Item("FullPath").Value;
    var xml = new XmlDocument();
    xml.Load(filePath);
    var entries = xml.DocumentElement.SelectNodes("//data");

    var parentFile = item.Name.Replace(".resx", "");
    var fileType = Path.GetExtension(parentFile);
    if(fileType != null &amp;&amp; fileType != "")
        parentFile = parentFile.Replace(fileType, "");

    foreach (XmlElement entryElement in entries)
    {
        var entry = new ResourceEntry
        {
            Path = path.Substring(1),
            File = MakeIntoValidIdentifier(parentFile),
            Type = fileType,
            Name = MakeIntoValidIdentifier(entryElement.Attributes["name"].Value)
        };
        var valueElement = entryElement.SelectSingleNode("value");
        if(valueElement != null)
            entry.Value = valueElement.InnerText;
        var commentElement = entryElement.SelectSingleNode("comment");
        if(commentElement != null)
            entry.Comment = commentElement.InnerText;

        AllEntries.Add(entry);
    }
}

string MakeIntoValidIdentifier(string arbitraryString)
{
    var validIdentifier = Regex.Replace(arbitraryString, @"[^A-Za-z0-9-._]", " ");
    validIdentifier = ConvertToPascalCase(validIdentifier);
    if (Regex.IsMatch(validIdentifier, @"^d")) validIdentifier = "_" + validIdentifier;
    return validIdentifier;
}

string ConvertToPascalCase(string phrase)
{
    string[] splittedPhrase = phrase.Split(' ', '-', '.');
    var sb = new StringBuilder();

    sb = new StringBuilder();

    foreach (String s in splittedPhrase)
    {
        char[] splittedPhraseChars = s.ToCharArray();
        if (splittedPhraseChars.Length > 0)
        {
            splittedPhraseChars[0] = ((new String(splittedPhraseChars[0], 1)).ToUpper().ToCharArray())[0];
        }
        sb.Append(new String(splittedPhraseChars));
    }
    return sb.ToString();
}

void EmitNamesInnerClass(List<string> names)
{
    if(names.Any())
    {
        WriteLine("rnttpublic static class Names");
        WriteLine("tt{");
        foreach(var name in names)
            WriteLine(string.Format("tttpublic const string {0} = "{0}";", name));
        WriteLine("tt}");

        names.Clear();
    }
}

Project GetProjectContainingT4File(DTE dte) {

    // Find the .tt file's ProjectItem
    ProjectItem projectItem = dte.Solution.FindProjectItem(Host.TemplateFile);

    // If the .tt file is not opened, open it
    if (projectItem.Document == null)
        projectItem.Open(Constants.vsViewKindCode);

    if (AlwaysKeepTemplateDirty) {
        // Mark the .tt file as unsaved. This way it will be saved and update itself next time the
        // project is built. Basically, it keeps marking itself as unsaved to make the next build work.
        // Note: this is certainly hacky, but is the best I could come up with so far.
        projectItem.Document.Saved = false;
    }

    return projectItem.ContainingProject;
}

struct ResourceEntry
{
    public string Path { get; set; }
    public string File { get; set; }
    public string Type { get; set; }
    public string Name { get; set; }
    public string Value { get; set; }
    public string Comment { get; set; }
}
#>

保存之后你会发现，就会自动生成新的 Resource.cs 文件，并且多了一个 Names 的 nested Class。现在我们可以通过 Resource.Names.APP_NAME 引用到 APP_NAME, Resource.APP_NAME 引用到 Hello world。KEY和VALUE都有了，这样我们就可以同时智能感知到 ERROR_CODE 和 ERROR_MESSAGE了。

但是还有一个问题，由于 t4 引擎是在 tt 文件改动后，或者要手动调用 Run Custom Tool 才会生成新的 .cs 文件。而修改源文件 Resource.resx 是不会生成新文件的！这样很不方便，每次添加新项都要去点好几个鼠标！太不科学了！

接近完美的解决方案

这个方法需要有 VS 能支持 Extension ，也就是说 Express 版肯定是不行的。现有免费版本中只有 Community 版可以支持到，推荐使用（法律上讲公司、商业组织是不能使用的）。总之在 TOOL菜单下面有个 Extensions And Updates ，在里面 Online 搜索 T4 TOOLBOX，安装，重启VS。

然后要做两个设定，

首先把 Resource.tt 的 Custom Tool 清空（同样也是为什么 tt 文件能产生 cs 文件的原理，它通过这个 Custom Tool 属性让 VS 在它变动时自动执行）。

然后把 Resource.resx 的 Custom Tool 设定为 T4Toolbox.TemplatedFileGenerator

这样就OK了，现在每次更改 Resource.resx 就会自动生成新版本的 .cs 文件。

VS2013 Community使用T4 Toolbox实现更改Resource文件自动生成cs文件

Contents

如何使用？

不需要多语言支持也建议使用

更好的方式？

接近完美的解决方案