Generate T4 file when same-class code files have been modified

Question

I have a C# regex-parser program with three files in it, each containing a static class:

1) one static class filled with string dictionaries

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) A class that compiles these values into Regex

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) some code that runs regular expressions based on these strings:

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

I'd like to be able to generate 2) as with a T4 template, as all of this concatenation is identical on every execution:

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

This works, but if I create a new member of MyStringDicts, or add/remove some values from its dictionaries, the T4 template won't recognize them until exclude Patterns.cs from compilation and recompile. As Parser depends on Patterns, this really isn't an option - I need the T4 transformation to take into account changes to other files in the same build.

Things I don't want do do:

Split MyStringDicts into its own project. I'd like to keep the files in one project, as they are a logical unit.
Just move MyStringDicts into the top of Patterns.cs. I need the MyStringDicts members for other purposes, too (for dictionary lookups, or in other T4 templates, for example.)

I adopted the advice here about using T4Toolbox's VolatileAssembly and such, but that seems to only work for the reverse direction, when the class files need to be recompiled after editing the T4 template.

Is what I want possible?

edited for clarity

Could you explain some more about why you're doing this? I can see several ways to deal with this, but it's kind of hard to know which one is suitable in your scenario without some background. — AVee, Jul 03 '12 at 08:50
Btw, these are the ideas i've got. Maybe the hint is enough to get you going. The solution provided by FuleSnabel will probably work, you could also do something similar using the stuff in the EnvDte namespace. But perhaps something simpler will do. You could consider putting the classes you need in T4 in a separate project and just referencing it from the templates. You could also dynamically compile and execute the code you need dynamically inside your T4 templates. — AVee, Jul 03 '12 at 09:03
@AVee thanks for forcing me to do the right thing and include my actual case. — Arithmomaniac, Jul 03 '12 at 16:34

score 5 · Accepted Answer · edited May 23 '17 at 12:15

I just created a small test template which uses EnvDte (Visual Studio Automation) and the T4Toolbox to run through the first file. It picks up the file through the project, so there's no need to compile before running the template. In fact, it even picks up unsaved changes...

This is basically the same approach as FullSnabel uses, but without the need for 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);
                    }
                }
            }
        }
    }
#>

This should work if you want to stick to your original approach.

What you seem to be doing is storing data in a class file. You could consider storing your lists outside code (in an xml or ini file) and generate both files based on that data. That way you avoid the problem all together, it might also make managing the lists easier. If you don't care too much about changes to the list you could also put the dictionaries inside the T4 template itself.

Another alternative might dealing with it fully in code. You could create a subclass of Dictionary which has a 'Pattern' property (or GetPattern() function). The parser would then use AddrVals.USstates.Pattern, and the patterns class won't be needed anymore. This way you won't need any code generation.

Perhaps a wrapper around the actual dictionary would be better because it allows you to hide the actual collection to make sure it's not changed at runtime. See Is there a read-only generic dictionary available in .NET? for an example of that.

I second the notion that the data should be stored in a "content" file rather than code. Makes the whole shebang much easier to read and maintain. — Dan Ling, Jul 05 '12 at 16:12

Just another metaprogrammer · Answer 2 · 2012-06-27T21:01:55.460

Take a look at roslyn. It allows you to compile the source files into syntax trees which you then can inspect and generated code from. It's a CTP but it worked quite well for me.

(Added a Roslyn sample).

I have created a file called class2.cs in my solution:

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

Using the Roslyn CTP (you need the Visual studio SDK as well) I created this simple T4 template which uses Roslyn to parse Class2.cs and produce output based on that:

<#@ 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()");
<#
    }
#>
        }
    }
}

This template produces the following output based on 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()");
            }
    }
}

Hope this helps

I'd really prefer a T4 solution, but I'll take what I can get. Do you have a link to a working example of this? Without one, that's going to be waaay out of my league. — Arithmomaniac, Jun 27 '12 at 19:26
Note; you will use Roslyn to compile the C# code into syntax tree. Then you will use T4 to generate the code. Unfortunately I don't have a working sample right now. — Just another metaprogrammer, Jun 27 '12 at 20:19
My OP may not have been clear... In your example, I want the output `Console.WriteLine("8"); Console.WriteLine("8");`. I edited my post accordingly. Sorry for taking your time! — Arithmomaniac, Jun 27 '12 at 22:06
My bad. So you want the result of the method to be output in T4? I suppose the methods then always have to produce the same result? Anyway, in that case I Think you might need to run the code dom to compile the whole assembly and then execute the method. — Just another metaprogrammer, Jun 28 '12 at 05:00

Generate T4 file when same-class code files have been modified

2 Answers2