I needed to code up an adapter layer between the domain and the ui. For now, and until something more specific is needed, just expose out the public methods of the domain and their result types. There is more that the adapter is encapsulating but the premise remains.
Added my Nuget packages for code generation: T4EnvDte and T4MultiFile.
As it turns out some of the code that was useful for this operation required a modification of T4EnvDte. So I added an assembly reference to EnvDTE80.
This was to finally write usable code to get all the projects in a solution recursing through solution folders.
Let's have a look at the actual T4 line by line, that uses the new code so we can see what is required for this task.
<#@ template debug="True" language="C#" hostspecific="True" #>
<#@ output extension=".txt"#>
<#@ include file="MultipleOutputHelper.ttinclude" #>
<#@ import namespace="EnvDTE"#>
<# EnvDTE.DTE Dte; #>
<#@ include file="EnvDteHelper.ttinclude" #>
<# bool doMultiFile=true;#>
This is the basic start of the file, with 2 variables declared thus far. Dte and doMultiFile. One is the Visual studio com object, the other is a flag telling T4MultiFile if we want to generated multiple files or all into one.
Main file output
Last run at <#=DateTime.UtcNow.ToString()#>
This simple code is all that is going to the main file output, a simple date/time string for showing when the file was last run. The usefulness is debatable in any proper source controlled scenario.
<# var manager = Manager.Create(Host, GenerationEnvironment);
var targetNs=System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("NamespaceHint"); //1
var projects= RecurseSolutionProjects(Dte); //2
var project = projects.First(p=>p.Name=="Company.Domain"); //3
var toGen= RecurseProjectItems(project).Where(pi=>pi.Name.StartsWith("Org")); //4
foreach(var p in toGen){
var className=Before(p.Name,".")+"Adapter"; //1
manager.StartNewFile(className+".generated.cs"); //2
var fcModel= p.FileCodeModel; //3
var ns=fcModel.CodeElements.OfType<EnvDTE.CodeNamespace>().First(); //4
var codeClass= ns.Children.OfType<EnvDTE.CodeClass>().First(); //5
var codeMethods= codeClass.Children.OfType<EnvDTE.CodeFunction>(); //6
#>
This is all the setup and starting the file per type looping.
targetNs asks what the proper namespace for our current file output location would beprojects gets all the projects in the current solution using the new EnvDte helper codeproject the actual project name we are looking fortoGen gets the projectItems in the source project we are interested in
Now we look over those items we will be generating
className holds the name of the new adapter class- tell the helper to start a new file for the class
fcModel holds the FileCodeModel of the current source projectItemns holds the namespace that wraps our target class and assumes there is only one namespace in the source filecodeClassholds the reference to the target class and assumes there is only one class in the source filecodeMethods gets all the methods of the source class
the meat of the individual file generation
//<#=p.Name#> <# /* 1 */ #>
using <#= ns.Name#>; <# /* 2 */ #>
namespace <#=targetNs#>{ <# /* 3 */ #>
public class <#=className#>{ <# /* 4 */ #>
<# foreach (var m in codeMethods.Where(m=>m.Access==EnvDTE.vsCMAccess.vsCMAccessPublic)){ var parms= m.Parameters.OfType<CodeParameter>(); #> <# /* 5-5.1 */ #>
public <#= m.Type.AsFullName#> <#=m.Name#>(<#=parms.Any()? parms.Select(parm=>parm.Type.AsString+" "+parm.Name).Aggregate((s1,s2)=>s1+","+s2):string.Empty#>){ <# /* 5.2 */ #>
return <#=Before(p.Name,".")#>.Instance.<#=m.Name#>(<#=parms.Any()?parms.Select(parm=>parm.Name).Aggregate((s1,s2)=>s1+","+s2):string.Empty#>); <# /* 5.3 */ #>
}
<# } #>
}
}
<#
manager.EndBlock();
} //end foreach
- adds a comment of the source file name
- adds a using clause for the source file's namespace
- adds a namespace for our new file
- adds a class to our new adapter
- loop over the public methods in the class
parms holds a reference to the parameters of the method if any- Generate the method signature
- Generate the method return code (which includes the singleton-based
Instance property requirement of this domain layer
- close up the single file generator and the foreach
the last little bits of code that complete the file
manager.Process(doMultiFile);
#>
<#+
string Before(string text, string delimiter)
{
return text.Substring(0,text.IndexOf(delimiter,StringComparison.CurrentCulture));
}
#>
So there we see using T4EnvDte and T4MultiFile together to generate specific classes from another project in the solution. I welcome any and all questions or suggestions for improvement
