typewriter - 在多个打字机模板中使用 "shared logic"？

Question

我们的项目中有多个 Typewriter .tst 模板，并希望在它们之间共享一些通用的逻辑/方法。有办法做到这一点吗？

Answer 1

您可以使用 T4 模板生成打字机模板。将代码放入可重用的 T4 模板 (*.ttinclude) 并创建 tt 文件以将参数传递给此基本模板的呈现方法。

(我使用 Visual Studio 扩展来进行文件嵌套。)

每个 tt 文件看起来像这样；

<#@ template debug="true" hostSpecific="true" #>
<#@ output extension=".tst" #>
<#@ include file="..\ModelsTemplate.ttinclude" #>
<#  this.ModelsTemplate_Render("UserSettings"); #>

...我的 ttinclude 文件看起来像这样(它有点特定于项目，但我将其全部包含在内，以便任何想要尝试的人都可以轻松获得一些东西)；

<#@ IntelliSenseLanguage processor="tangibleT4Editor" language="C#" #>
<#+ 
  void ModelsTemplate_Render(string @subnamespace) {
     ModelsTemplate_Render("MyApp.ViewData", @subnamespace);
  }

  void ModelsTemplate_Render(string @mainnamespace, string @subnamespace) {
     string renderedMainNamespace = @mainnamespace;
#>
// <auto-generated>
//     This code was generated by a tool.
//     Template: <#= Host.TemplateFile #>
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>

${
    // Enable extension methods by adding using Typewriter.Extensions.*
  using Typewriter.Extensions.Types;
  using System.Text.RegularExpressions;

    Template(Settings settings)
    {
        settings.IncludeProject("MyApp.ViewData");
    }

   static string DebugInfo = "";
    string PrintDebugInfo(File f){
      if (string.IsNullOrEmpty(DebugInfo)) {
         return "";
      }

      return "/*" + Environment.NewLine + "Template debug info: " + DebugInfo + Environment.NewLine + "*/";
    }

    string BaseClassFullPath(Class baseClass)
    {
        //DebugInfo = DebugInfo + Environment.NewLine + "baseClass.FullName:" + baseClass.FullName;
        var result = baseClass.Name;

        // Until we find a better way to handle implementations of generic base classes...
        result = result.Replace("<bool?>", "<boolean>");
        result = result.Replace("<int?>", "<number>");
        result = result.Replace("<long?>", "<number>");
      result = result.Replace("<decimal?>", "<number>");
      result = result.Replace("<double?>", "<number>");
      result = result.Replace("<System.Double>", "<number>");
      result = result.Replace("<System.Double?>", "<number>");
      result = result.Replace("<System.DateTime?>", "<Date>");

        return result;
    }

    string NullableFilter(string typeName)
    {
        return typeName.Replace("?", "");
    }

    string TypeFilteredPath(Type type)
    {
        //DebugInfo = DebugInfo + Environment.NewLine + "type:" + type.FullName + " - genericType:" + type.Unwrap().FullName;
        return NullableFilter(type.Name);
    }

    string TypeFiltered(Type type)
    {
      if (type.IsEnumerable)
      {
          var genericType = type.Unwrap();
          if (!genericType.FullName.StartsWith("System")) 
          {
            return TypeFilteredPath(genericType)+"[]";
          }
        }
        return TypeFilteredPath(type);
    }

    string PropertyTypeFiltered(Property prop)
    {
        return TypeFiltered(prop.Type);
    }

    string ImplementedInterfaces(Class c){
        if (!c.Interfaces.Any()){
            return string.Empty;
        }
        return "implements " + string.Join(", ", c.Interfaces.Select(x => x.FullName));
    }

    string ExtendedInterfaces(Interface i){
        if (!i.Interfaces.Any()){
            return string.Empty;
        }
        return "extends " + string.Join(", ", i.Interfaces.Select(x => x.FullName));
    }

    string DescriptionAttributeValue(Attribute a){
        if (!a.FullName.Contains("DescriptionAttribute")){
            return string.Empty;
        }
        return a.Value;
    }

    string GetPropertyDefinitionWithScope(Property p){
      var definition = GetPropertyDefinition(p);
      if (definition != "")
         return "public " + definition;
      else 
         return definition;
    }

    string GetPropertyDefinition(Property p){
      var ignoreAttribute = p.Attributes.SingleOrDefault(x => x.FullName.Contains("TypeScriptIgnoreMemberAttribute"));
      if (ignoreAttribute != null)
         return "";

        var typeAttribute = p.Attributes.SingleOrDefault(x => x.FullName.Contains("TypeScriptTypeAttribute"));
        if (typeAttribute != null) {
            return p.name + ": " + typeAttribute.Value + ";";
        }
        return p.name + ": " + TypeFiltered(p.Type) + ";";
    }

    string WriteImports(Class theClass){
      //return "import { ViewDataEntity } from '../common/ViewDataEntity';";
      var list = new List<string>();

      var typesToImport = theClass.Properties.Select(x => x.Type.Unwrap()).Where(x => x.Namespace.Contains("MyApp.ViewData.")).ToList();
      if (theClass.BaseClass?.Namespace.Contains("MyApp.ViewData.") == true)
        typesToImport.Add(theClass.BaseClass);
      foreach (var impType in typesToImport)
      {
        var modules = impType.Namespace.Replace("MyApp.ViewData.", "").Split('.').ToList();
        string modPart = string.Join("/", modules.Select(x => CamelCase(x)));
        list.Add($"import {{ {impType.Name} }} from '../{modPart}/{impType.Name}';");
      }

      return string.Join(Environment.NewLine, list.Distinct());
    }

    string CamelCase(string value){
      return value.First().ToString().ToLower() + value.Substring(1);
    }
}//namespace <#= renderedMainNamespace #>.<#= @subnamespace #> {

    $Classes(c => c.Namespace.StartsWith("<#= @mainnamespace #>.<#= @subnamespace #>"))[

$WriteImports

    export class $Name$TypeParameters $BaseClass[extends $BaseClassFullPath ] $ImplementedInterfaces {$Properties[
        $GetPropertyDefinitionWithScope]
    }]
    $Interfaces(<#= @mainnamespace #>.<#= @subnamespace #>.*)[
    export interface $Name $ExtendedInterfaces {
        $Properties[
        $GetPropertyDefinition]
    }]
    $Enums(<#= @mainnamespace #>.<#= @subnamespace #>.*)[
    export class $Name {
        $Values[// $Value - "$Attributes[$Value]"
            static $Name = "$Name"; 
        ]
    }]
   $PrintDebugInfo
//}<#+
   }
#>