7

我有一个 C# 正则表达式解析器程序，其中包含三个文件，每个文件都包含一个静态类：

1) 一个用字符串字典填充的静态类

static class MyStringDicts
{
    internal static readonly Dictionary<string, string> USstates =
        new Dictionary<string, string>()
        {
            { "ALABAMA", "AL" },
            { "ALASKA", "AK" },
            { "AMERICAN SAMOA", "AS" },
            { "ARIZONA", "AZ" },
            { "ARKANSAS", "AR" }
             // and so on
        }
    // and some other dictionaries
}

2) 将这些值编译成正则表达式的类

public static class Patterns
{       
    Public static readonly string StateUS =
        @"\b(?<STATE>" + CharTree.GenerateRegex(Enumerable.Union(
            AddrVals.USstates.Keys,
            AddrVals.USstates.Values))
        + @")\b";

    //and some more like these
}

3）一些基于这些字符串运行正则表达式的代码：

public static class Parser
{   
    // heavily simplified example
    public static GroupCollection SearchStringForStates(string str)
    {
        return Regex.Match(str, 
            "^" + Patterns.StateUS, 
            RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase).Groups;
    }
}

我希望能够像 T4 模板一样生成 2)，因为所有这些连接在每次执行时都是相同的：

@"\b(?<STATE><#=CharTree.GenerateRegex(Enumerable.Union(
    AddrVals.USstates.Keys,
    AddrVals.USstates.Values)#>)\b";

这可行，但如果我创建 的新成员MyStringDicts，或从其字典中添加/删除某些值，则 T4 模板将无法识别它们，直到从编译和重新编译中排除 Patterns.cs。视情况而Parser定Patterns，这确实不是一个选项 - 我需要 T4 转换来考虑对同一构建中其他文件的更改。

我不想做的事情：

  • 拆分MyStringDicts成自己的项目。我想将文件保存在一个项目中，因为它们是一个逻辑单元。
  • 只需移动MyStringDicts到 Patterns.cs 的顶部。我还需要将 MyStringDicts 成员用于其他目的（例如，用于字典查找或其他 T4 模板。）

我在这里采纳了关于使用 T4ToolboxVolatileAssembly等的建议，但这似乎只适用于相反的方向，即在编辑 T4 模板后需要重新编译类文件时。

我想要的可能吗？

为清楚起见进行了编辑

4

2 回答 2

5

我刚刚创建了一个小测试模板，它使用 EnvDte（Visual Studio 自动化）和 T4Toolbox 来运行第一个文件。它通过项目获取文件，因此在运行模板之前无需编译。事实上，它甚至会拾取未保存的更改...

这与 FullSnabel 使用的方法基本相同，但不需要 Roslyn。

<#@ template debug="false" hostspecific="True" language="C#" #>
<#@ output extension=".cs" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ dte processor="T4Toolbox.DteProcessor" #>
<#@ TransformationContext processor="T4Toolbox.TransformationContextProcessor" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="EnvDTE" #>
<#@ assembly name="EnvDTE80" #>
<#@ import namespace="T4Toolbox" #>
<#@ import namespace="EnvDTE" #> 
<#@ import namespace="EnvDTE80" #>
<#
    ProjectItem projectItem = TransformationContext.FindProjectItem("Dictionaries.cs");
    FileCodeModel codeModel = projectItem.FileCodeModel;

    foreach (CodeElement element in codeModel.CodeElements)
    {
        CodeNamespace ns = element as CodeNamespace;
        if(ns != null)
        {
            foreach(CodeElement ele in ns.Children)
            {
                CodeClass cl = ele as CodeClass;

                if(cl != null && cl.Name == "Dictionaries")
                {
                    foreach(CodeElement member in cl.Members)
                    {
                        // Generate stuff...
                        this.WriteLine(member.Name);
                    }
                }
            }
        }
    }
#>

如果您想坚持原来的方法，这应该可行。

您似乎正在做的是将数据存储在类文件中。您可以考虑将列表存储在代码之外（在 xml 或 ini 文件中）并根据该数据生成这两个文件。这样一来，您就可以避免所有问题，也可能使管理列表更容易。如果您不太关心列表的更改，您也可以将字典放入 T4 模板本身。

另一种选择可能会在代码中完全处理它。您可以创建具有“模式”属性（或 GetPattern() 函数）的 Dictionary 子类。然后解析器将使用 AddrVals.USstates.Pattern，并且不再需要模式类。这样您就不需要任何代码生成。

也许实际字典的包装器会更好，因为它允许您隐藏实际集合以确保它在运行时不会更改。请参阅.NET 中是否有可用的只读通用字典？举个例子。

于 2012-07-04T12:16:08.910 回答
4

看看罗斯林。它允许您将源文件编译成语法树，然后您可以检查并从中生成代码。这是一个 CTP，但对我来说效果很好。

（添加了 Roslyn 示例）。

我在我的解决方案中创建了一个名为 class2.cs 的文件：

namespace StackOverflow
{
    class Class2
    {
        public static int One() { return 8; }
        public static int Eight(int x, double z) { return 8; }
    }
}

使用 Roslyn CTP（您还需要Visual Studio SDK）我创建了这个简单的 T4 模板，它使用 Roslyn 来解析 Class2.cs 并基于此生成输出：

<#@ template    hostspecific= "true"                            #>
<#@ assembly    name        = "System.Core"                     #>
<#@ assembly    name        = "Roslyn.Compilers"                #>
<#@ assembly    name        = "Roslyn.Compilers.CSharp"         #>
<#@ import      namespace   = "System.IO"                       #>
<#@ import      namespace   = "System.Linq"                     #>
<#@ import      namespace   = "Roslyn.Compilers.CSharp"         #>

<#

    var host    = Path.GetFullPath(Host.ResolvePath(@".\Class2.cs"));
    var content = File.ReadAllText(host);

    var tree = SyntaxTree.ParseCompilationUnit(content);

    var methods = tree
        .GetRoot()
        .ChildNodes()
        .OfType<NamespaceDeclarationSyntax>()
        .SelectMany(x => x.ChildNodes())
        .OfType<ClassDeclarationSyntax>()
        .SelectMany(x => x.ChildNodes())
        .OfType<MethodDeclarationSyntax>()
        .ToArray()
        ;
#>            

namespace StackOverflow
{
    using System;

    static partial class Program
    {
        public static void Main()
        {
<#
    foreach (var method in methods)
    {
        var parent = (ClassDeclarationSyntax)method.Parent;
        var types = method
            .ParameterList
            .ChildNodes()
            .OfType<ParameterSyntax>()
            .Select(t => t.Type.PlainName)
            .ToArray()
            ;

        var plist = string.Join(", ", types);
#>
            Console.WriteLine("<#=parent.Identifier.ValueText#>.<#=method.Identifier.ValueText#>(<#=plist#>).ToString()");
<#
    }
#>
        }
    }
}

此模板基于 Class2.cs 生成以下输出：

namespace StackOverflow
{
    using System;

    static partial class Program
    {
        public static void Main()
        {
                Console.WriteLine("Class2.One().ToString()");
                Console.WriteLine("Class2.Eight(int, double).ToString()");
            }
    }
}

希望这可以帮助

于 2012-06-27T19:06:37.937 回答