private void RunDesignTimeTagHelpersTest(IEnumerable <TagHelperDescriptor> descriptors)
{
// Arrange
var projectEngine = CreateProjectEngine(builder =>
{
builder.ConfigureDocumentClassifier();
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var projectItem = CreateProjectItemFromFile();
var imports = GetImports(projectEngine, projectItem);
// Act
var codeDocument = projectEngine.ProcessDesignTime(RazorSourceDocument.ReadFrom(projectItem), imports, descriptors.ToList());
// Assert
AssertDocumentNodeMatchesBaseline(codeDocument.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(codeDocument.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(codeDocument);
}
public static RazorProjectEngine CreateProjectEngine(string rootNamespace, string targetProjectDirectory, Action <RazorProjectEngineBuilder> configure = null)
{
var fileSystem = RazorProjectFileSystem.Create(targetProjectDirectory);
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder =>
{
builder
.SetNamespace(rootNamespace)
.SetBaseType("Microsoft.Extensions.RazorViews.BaseView")
.ConfigureClass((document, @class) =>
{
@class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath);
@class.Modifiers.Clear();
@class.Modifiers.Add("internal");
});
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new SuppressChecksumOptionsFeature());
builder.Features.Add(new SuppressMetadataAttributesFeature());
if (configure != null)
{
configure(builder);
}
builder.AddDefaultImports(@"
@using System
@using System.Threading.Tasks
");
});
return(projectEngine);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
InjectDirective.Register(builder);
ModelDirective.Register(builder);
PageDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
builder.Features.Add(new ViewComponentTagHelperDescriptorProvider());
builder.AddTargetExtension(new ViewComponentTagHelperTargetExtension());
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass(builder.Configuration.UseConsolidatedMvcViews));
builder.Features.Add(new MvcViewDocumentClassifierPass(builder.Configuration.UseConsolidatedMvcViews));
builder.Features.Add(new MvcImportProjectFeature());
// The default C# language version for what this Razor configuration supports.
builder.SetCSharpLanguageVersion(LanguageVersion.CSharp8);
}
public static RazorEngine CreateInstance(string baseType)
{
var configuration = RazorConfiguration.Default;
var razorProjectEngine = RazorProjectEngine.Create(configuration,
new NullRazorProjectFileSystem(), builder =>
{
TkInjectDirective.Register(builder);
TkModelDirective.Register(builder);
if (!RazorLanguageVersion.TryParse("3.0", out var razorLanguageVersion) ||
configuration.LanguageVersion.CompareTo(razorLanguageVersion) < 0)
{
NamespaceDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
}
SectionDirective.Register(builder);
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new RazorTemplateDocumentClassifierPass(baseType));
builder.Features.Add(new RazorAssemblyAttributeInjectionPass());
#if NETSTANDARD2_0
builder.Features.Add(new InstrumentationPass());
#endif
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::YJC.Toolkit.Razor.TkRazorHelperResult",
});
OverrideRuntimeNodeWriterTemplateTypeNamePhase.Register(builder);
});
return(razorProjectEngine.Engine);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
//InjectDirective.Register(builder);
//ModelDirective.Register(builder);
//NamespaceDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.AddDefaultImports(new string[] {
"@using System",
"@using System.Linq",
"@using System.Threading.Tasks",
"@Templates"
});
//builder.Features.Add(new DefaultTagHelperDescriptorProvider());
//builder.Features.Add(new ModelExpressionPass());
//builder.Features.Add(new PagesPropertyInjectionPass());
//builder.Features.Add(new RazorPageDocumentClassifierPass());
//builder.Features.Add(new AssemblyAttributeInjectionPass());
//builder.Features.Add(new InstrumentationPass());
}
private void DesignTimeTest()
{
// Arrange
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.ConfigureDocumentClassifier();
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var document = CreateCodeDocument();
// Act
engine.Process(document);
// Assert
AssertDocumentNodeMatchesBaseline(document.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(document.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(document);
}
public static void Register(IRazorEngineBuilder builder)
{
InjectDirective.Register(builder);
ModelDirective.Register(builder);
NamespaceDirective.Register(builder);
PageDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass());
builder.Features.Add(new MvcViewDocumentClassifierPass());
builder.Features.Add(new AssemblyAttributeInjectionPass());
if (!builder.DesignTime)
{
builder.Features.Add(new InstrumentationPass());
}
}
private static RazorProjectEngine CreateProjectEngine()
{
return(RazorProjectEngine.Create(b =>
{
SectionDirective.Register(b);
}));
}
public CSharpScriptRazorGenerator(string directoryRoot)
{
var fileSystem = RazorProjectFileSystem.Create(directoryRoot);
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder =>
{
//builder
// .SetNamespace("Remove")
// .SetBaseType("Microsoft.Extensions.RazorViews.BaseView")
// .ConfigureClass((document, @class) =>
// {
// @class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath);
// @class.Modifiers.Clear();
// @class.Modifiers.Add("internal");
// });
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Remove(builder.Features.OfType <IRazorDocumentClassifierPass>().Single());
builder.Features.Add(new CSharpScriptDocumentClassifierPass());
//configure?.Invoke(builder);
// builder.AddDefaultImports(@"
//@using System
//@using System.Threading.Tasks
//");
});
_projectEngine = projectEngine;
}
private void RunDesignTimeTagHelpersTest(IEnumerable <TagHelperDescriptor> descriptors)
{
// Arrange
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.Features.Add(new ApiSetsIRTestAdapter());
builder.AddTagHelpers(descriptors);
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var document = CreateCodeDocument();
// Act
engine.Process(document);
// Assert
AssertDocumentNodeMatchesBaseline(document.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(document.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(document);
}
static RazorTemplateEngine BuildRazorTemplateEngine(RazorProjectFileSystem fileSystem)
{
var razorConfiguration = Microsoft.AspNetCore.Razor.Language.RazorConfiguration.Default;
var razorProjectEngine = RazorProjectEngine.Create(razorConfiguration, fileSystem, builder =>
{
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
var metadataReferences = AppDomain.CurrentDomain.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => MetadataReference.CreateFromFile(a.Location))
.ToArray();
builder.Features.Add(new DefaultMetadataReferenceFeature {
References = metadataReferences
});
builder.Features.Add(new CompilationTagHelperFeature());
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
//builder.Features.Add(new ViewComponentTagHelperDescriptorProvider());
builder.Features.Add(new DocumentClassifierPass());
//builder.Features.Add(new ViewComponentTagHelperPass());
});
var templateEngine = new RazorTemplateEngine(razorProjectEngine.Engine, fileSystem);
return(templateEngine);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
InjectDirective.Register(builder);
ModelDirective.Register(builder);
NamespaceDirective.Register(builder);
PageDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
builder.Features.Add(new ViewComponentTagHelperDescriptorProvider());
builder.AddTargetExtension(new ViewComponentTagHelperTargetExtension());
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass());
builder.Features.Add(new MvcViewDocumentClassifierPass());
builder.Features.Add(new AssemblyAttributeInjectionPass());
builder.Features.Add(new InstrumentationPass());
builder.SetImportFeature(new MvcImportProjectFeature());
}
private void DesignTimeTest()
{
// Arrange
var projectEngine = CreateProjectEngine(builder =>
{
builder.ConfigureDocumentClassifier();
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
SectionDirective.Register(builder);
});
var projectItem = CreateProjectItemFromFile();
// Act
var codeDocument = projectEngine.ProcessDesignTime(projectItem);
// Assert
AssertDocumentNodeMatchesBaseline(codeDocument.GetDocumentIntermediateNode());
AssertHtmlDocumentMatchesBaseline(codeDocument.GetHtmlDocument());
AssertCSharpDocumentMatchesBaseline(codeDocument.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(codeDocument);
AssertLinePragmas(codeDocument, designTime: true);
}
private RazorEngine GetRazorEngine()
{
var razorEngine = RazorEngine.Create(builder =>
{
InjectDirective.Register(builder);
ModelDirective.Register(builder);
NamespaceDirective.Register(builder);
PageDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
////builder.AddTargetExtension(new TemplateTargetExtension()
////{
//// TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
////});
////builder.Features.Add(new SuppressChecksumOptionsFeature());
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass());
builder.Features.Add(new MvcViewDocumentClassifierPass2(RuntimeTemplatesNamespace, BaseViewName));
builder.Features.Add(new AssemblyAttributeInjectionPass2());
if (!builder.DesignTime)
{
//builder.Features.Add(new InstrumentationPass());
}
});
return(razorEngine);
}
private void RunRuntimeTagHelpersTest(IEnumerable <TagHelperDescriptor> descriptors)
{
// Arrange
var projectEngine = CreateProjectEngine(builder =>
{
builder.ConfigureDocumentClassifier();
builder.AddTagHelpers(descriptors);
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var projectItem = CreateProjectItem();
// Act
var codeDocument = projectEngine.Process(projectItem);
// Assert
AssertDocumentNodeMatchesBaseline(codeDocument.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(codeDocument.GetCSharpDocument());
}
private void _Init(string templateNamespace, string typeName, string basePath)
{
if (string.IsNullOrWhiteSpace(templateNamespace))
{
throw new ArgumentNullException(nameof(templateNamespace), "Cannot be null or empty.");
}
if (string.IsNullOrWhiteSpace(typeName))
{
throw new ArgumentNullException(nameof(typeName), "Cannot be null or empty.");
}
// customize the default engine a little bit
var engine = RazorEngine.Create(b =>
{
InheritsDirective.Register(b); // make sure the engine understand the @inherits directive in the input templates
FunctionsDirective.Register(b); // make sure the engine understand the @function directive in the input templates
SectionDirective.Register(b); // make sure the engine understand the @section directive in the input templates
b.SetNamespace(templateNamespace); // define a namespace for the Template class
b.Build();
});
var project = RazorProject.Create(HostingEnvironment.ContentRootPath);
var templateEngine = new RazorTemplateEngine(engine, project);
// get a razor-templated file. My "hello.txt" template file is defined like this:
//
// @inherits RazorTemplate.MyTemplate
// Hello @Model.Name, welcome to Razor World!
//
var fileInfo = _FindView(typeName, basePath, out var filepath);
// ... parse and generate C# code ...
var codeDoc = RazorCSharpDocument.Create();
var cs = templateEngine.GenerateCode(codeDoc);
// ... use roslyn to parse the C# code ...
//
var tree = CSharpSyntaxTree.ParseText(cs.GeneratedCode);
// ... name the assembly ...
//
string dllName = templateNamespace + "." + typeName;
var compilation = CSharpCompilation.Create(dllName, new[] { tree },
new[]
static RazorProjectEngine CreateProjectEngine(string rootNamespace, string projectDirectory)
{
var fileSystem = RazorProjectFileSystem.Create(projectDirectory);
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => {
builder
.SetNamespace(rootNamespace)
.ConfigureClass((document, @class) => {
@class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath);
});
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
return(projectEngine);
}
public CSharpScriptRazorGenerator(string directoryRoot)
{
var fileSystem = RazorProjectFileSystem.Create(directoryRoot);
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder =>
{
// Register directives.
SectionDirective.Register(builder);
// We replace the default document classifier, because we can't have namespace declaration ins script.
var defaultDocumentClassifier = builder.Features
.OfType <IRazorDocumentClassifierPass>()
.FirstOrDefault(x => x.Order == 1000);
builder.Features.Remove(defaultDocumentClassifier);
builder.Features.Add(new CSharpScriptDocumentClassifierPass());
});
_projectEngine = projectEngine;
}
public DaoGenerator()
{
logger = this.CreateLogger();
engine = RazorEngine.Create(builder =>
{
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new SqlDocumentClassifierPassBase());
});
assembly = GetType().Assembly;
assemblyName = Path.GetRandomFileName();
types = new List <Type>();
syntaxTrees = new List <SyntaxTree>();
Extractor = new Extractor();
}
public Task Run(string[] args)
{
string targetProjectDirectory = AppContext.BaseDirectory;
string rootNamespace = System.IO.Path.GetFileNameWithoutExtension(System.IO.Path.GetTempFileName()).ToLowerInvariant();
RazorProjectFileSystem fileSystem = RazorProjectFileSystem.Create(targetProjectDirectory);
RazorProjectEngine projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder =>
{
builder
.SetNamespace(rootNamespace)
.SetBaseType("Microsoft.Extensions.RazorViews.BaseView")
.ConfigureClass((document, @class) =>
{
@class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath);
@class.Modifiers.Clear();
@class.Modifiers.Add("internal");
});
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
//builder.Features.Add()
//builder.Features.Add(new SuppressChecksumOptionsFeature());
//builder.Features.Add(new SuppressMetadataAttributesFeature());
// configure is always null
//if (configure != null)
//{
// configure(builder);
//}
builder.AddDefaultImports(@"
@using System
@using System.Threading.Tasks");
});
return(Task.Run(() => {
Console.WriteLine("Do nothing");
}));
} // public void Run(string[] args)
private DocumentIntermediateNode Lower(
RazorCodeDocument codeDocument,
Action <RazorProjectEngineBuilder> builder = null,
IEnumerable <TagHelperDescriptor> tagHelpers = null,
bool designTime = false)
{
tagHelpers = tagHelpers ?? new TagHelperDescriptor[0];
Action <RazorProjectEngineBuilder> configureEngine = b =>
{
builder?.Invoke(b);
FunctionsDirective.Register(b);
SectionDirective.Register(b);
b.AddTagHelpers(tagHelpers);
b.Features.Add(new DesignTimeOptionsFeature(designTime));
};
var projectEngine = RazorProjectEngine.Create(configureEngine);
for (var i = 0; i < projectEngine.Phases.Count; i++)
{
var phase = projectEngine.Phases[i];
phase.Execute(codeDocument);
if (phase is IRazorIntermediateNodeLoweringPhase)
{
break;
}
}
var documentNode = codeDocument.GetDocumentIntermediateNode();
Assert.NotNull(documentNode);
return(documentNode);
}
private void RunTimeTest()
{
// Arrange
var projectEngine = CreateProjectEngine(builder =>
{
builder.ConfigureDocumentClassifier();
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var projectItem = CreateProjectItemFromFile();
// Act
var codeDocument = projectEngine.Process(projectItem);
// Assert
AssertDocumentNodeMatchesBaseline(codeDocument.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(codeDocument.GetCSharpDocument());
}
private void RunTimeTest()
{
// Arrange
var engine = RazorEngine.Create(builder =>
{
builder.Features.Add(new ApiSetsIRTestAdapter());
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var document = CreateCodeDocument();
// Act
engine.Process(document);
// Assert
AssertDocumentNodeMatchesBaseline(document.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(document.GetCSharpDocument());
}
public override bool Execute()
{
if (!Directory.Exists(GeneratePath))
{
Directory.CreateDirectory(GeneratePath);
}
if (Configuration.Equals("DEBUG", StringComparison.OrdinalIgnoreCase))
{
var className = $"Debug_{Guid.NewGuid().ToString("N")}";
var code =
$@"using System;
using System.Runtime.Loader;
[assembly: global::Microsoft.AspNetCore.Razor.Hosting.RazorDebugAttribute(@""{Namespace}"", @""{BaseType}"", @""{RazorPath}"", typeof({Namespace}.{className}))]
namespace {Namespace}
{{
public static class {className}
{{
public static object Execute(object debugObj)
{{
AssemblyLoadContext.Default.LoadFromAssemblyPath(@""{DebuggerPath}Microsoft.AspNetCore.Razor.Language.dll"");
AssemblyLoadContext.Default.LoadFromAssemblyPath(@""{DebuggerPath}Microsoft.CodeAnalysis.dll"");
AssemblyLoadContext.Default.LoadFromAssemblyPath(@""{DebuggerPath}Microsoft.CodeAnalysis.CSharp.dll"");
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(@""{DebuggerPath}System.Extensions.RazorCompilation.dll"");
var debugger = assembly.GetType(""System.Extensions.RazorCompilation.RazorDebugger"");
return debugger.GetMethod(""Execute"").Invoke(null, new[] {{ debugObj }});
}}
}}
}}";
var generateFile = Path.Combine(GeneratePath, "Debug.cs");
File.WriteAllText(generateFile, code, Encoding.UTF8);
GenerateFiles = new[] { new TaskItem(generateFile) };
return(true);
}
else
{
var cSharpIdentifier = typeof(RazorProjectEngine).Assembly.GetType("Microsoft.AspNetCore.Razor.Language.CSharpIdentifier");
var sanitizeIdentifier = cSharpIdentifier.GetMethod("SanitizeIdentifier", BindingFlags.Public | BindingFlags.Static);
var engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(RazorPath),
(builder) =>
{
SectionDirective.Register(builder);
builder.SetNamespace(Namespace)
.AddDefaultImports(@"
@using System
@using System.Collections.Generic
@using System.Threading.Tasks
@using Microsoft.AspNetCore.Mvc
");
builder.ConfigureClass(
(document, @class) =>
{
@class.BaseType = BaseType;
var relativePath = document.Source.RelativePath;
@class.ClassName = (string)sanitizeIdentifier.Invoke(null, new[] { relativePath.Substring(0, relativePath.Length - ".cshtml".Length) });
});
});
var generateFiles = new List <ITaskItem>();
foreach (var projectItem in engine.FileSystem.EnumerateItems("/"))
{
var relativePath = projectItem.RelativePhysicalPath;
var className = (string)sanitizeIdentifier.Invoke(null, new object[] { relativePath.Substring(0, relativePath.Length - ".cshtml".Length) });
var generateFile = Path.Combine(GeneratePath, $"{className}.g.cs");
var code = engine.Process(projectItem).GetCSharpDocument().GeneratedCode;
File.WriteAllText(generateFile, code, Encoding.UTF8);
generateFiles.Add(new TaskItem(generateFile));
}
GenerateFiles = generateFiles.ToArray();
return(true);
}
}
private string GetGeneratorResultBak(IEnumerable <string> namespaces, TypeContext context)
{
#pragma warning disable 612, 618
var razorCompiledItemAssembly = typeof(RazorCompiledItemAttribute).Assembly;
//手动加载程序集，防止编译 Razor 类时找不到 DLL
var razorEngine = RazorEngine.Create(builder =>
{
InheritsDirective.Register(builder);
FunctionsDirective.Register(builder);
SectionDirective.Register(builder);
builder
.SetNamespace(DynamicTemplateNamespace)
//.SetBaseType("Microsoft.Extensions.RazorViews.BaseView")
.SetBaseType(BuildTypeName(context.TemplateType, context.ModelType))
.ConfigureClass((document, @class) =>
{
@class.ClassName = context.ClassName;
//if (!str ing.IsNullOrWhiteSpace(document.Source.FilePath))
//{
// @class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath);
//}
@class.Modifiers.Clear();
@class.Modifiers.Add("internal");
});
builder.Features.Add(new SuppressChecksumOptionsFeature());
});
string importString = @"
@using System
@using System.Threading.Tasks
";
importString += String.Join("\r\n", namespaces.Select(n => "@using " + n.Trim())) + "\r\n";
using (var reader = context.TemplateContent.GetTemplateReader())
{
string path = null;
if (string.IsNullOrWhiteSpace(context.TemplateContent.TemplateFile))
{
path = Directory.GetCurrentDirectory();
}
else
{
path = Path.GetDirectoryName(context.TemplateContent.TemplateFile);
}
var razorProject = RazorProjectFileSystem.Create(path);
var templateEngine = new RazorTemplateEngine(razorEngine, razorProject);
templateEngine.Options.DefaultImports = RazorSourceDocument.Create(importString, fileName: null);
RazorPageGeneratorResult result;
if (string.IsNullOrWhiteSpace(context.TemplateContent.TemplateFile))
{
var item = RazorSourceDocument.Create(context.TemplateContent.Template, string.Empty);
var imports = new List <RazorSourceDocument>();
imports.Add(templateEngine.Options.DefaultImports);
var doc = RazorCodeDocument.Create(item, imports);
result = GenerateCodeFile(templateEngine, doc);
}
else
{
var item = razorProject.GetItem(context.TemplateContent.TemplateFile);
result = GenerateCodeFile(templateEngine, item);
}
return(InspectSource(result, context));
}
}
/// <summary>
/// Getting the generated code through Microsoft.AspNetCore.Razor.Language
/// </summary>
/// <param name="dynamicTemplateNamespace"></param>
/// <param name="templateSourceCode"></param>
/// <param name="generatedCSharpClassName"></param>
/// <param name="classBaseType"></param>
/// <param name="templateFile"></param>
/// <returns></returns>
public static string GetGeneratedCode(string dynamicTemplateNamespace,
string templateSourceCode,
string generatedCSharpClassName,
string classBaseType,
string templateFile = null)
{
string systemPath = Directory.GetCurrentDirectory();
string path = null;
if (string.IsNullOrWhiteSpace(templateFile))
{
path = systemPath;
}
else
{
path = Path.GetDirectoryName(templateFile);
}
RazorProjectFileSystem fs = RazorProjectFileSystem.Create(path); // or '.'
RazorProjectEngine engine = RazorProjectEngine.Create(RazorConfiguration.Default, fs, (builder) =>
{
InheritsDirective.Register(builder);
FunctionsDirective.Register(builder);
SectionDirective.Register(builder);
builder.ConfigureClass((document, @class) =>
{
@class.ClassName = generatedCSharpClassName;
});
builder.SetNamespace(dynamicTemplateNamespace); // define a namespace for the Template class
builder.SetBaseType(classBaseType);
builder.AddDefaultImports("@using System",
"@using System.Threading.Tasks",
"@using System.Collections.Generic",
"@using System.Linq",
"@using System.Text",
"@using RazorEngine",
"@using RazorEngine.Templating");
});
string razorRelativePath;
string randomRazorFileFullPath = null;
if (string.IsNullOrEmpty(templateFile))
{
razorRelativePath = Path.GetRandomFileName();
randomRazorFileFullPath = Path.Combine(systemPath, razorRelativePath);
File.AppendAllText(randomRazorFileFullPath, templateSourceCode ?? string.Empty, System.Text.Encoding.UTF8);
}
else
{
razorRelativePath = templateFile;
}
RazorProjectItem item = fs.GetItem(razorRelativePath);
RazorCodeDocument codeDocument = engine.Process(item);
RazorCSharpDocument csharpDocument = codeDocument.GetCSharpDocument();
if (!string.IsNullOrEmpty(randomRazorFileFullPath))
{
try
{
File.Delete(randomRazorFileFullPath);
}
catch (Exception) { }
}
if (csharpDocument.Diagnostics.Any())
{
var diagnostics = string.Join(Environment.NewLine, csharpDocument.Diagnostics);
throw new InvalidOperationException($"One or more parse errors encountered. This will not prevent the generator from continuing: {Environment.NewLine}{diagnostics}.");
}
//Manual loading of assemblies to prevent DLLs from being lost when compiling classes
AppDomain.CurrentDomain.Load(typeof(RazorCompiledItemAttribute).Assembly.FullName);
//手动加载程序集，防止编译的类时找不到 DLL
return(csharpDocument.GeneratedCode);
}
public static List <KeyValuePair <string, Func <object> > > Execute(object debugObj)
{
if (debugObj == null)
{
return(null);
}
var @namespace = (string)debugObj.GetType().GetProperty("Namespace").GetValue(debugObj);
var baseType = (string)debugObj.GetType().GetProperty("BaseType").GetValue(debugObj);
var razorPath = (string)debugObj.GetType().GetProperty("RazorPath").GetValue(debugObj);
var cSharpIdentifier = typeof(RazorProjectEngine).Assembly.GetType("Microsoft.AspNetCore.Razor.Language.CSharpIdentifier");
var sanitizeIdentifier = cSharpIdentifier.GetMethod("SanitizeIdentifier", BindingFlags.Public | BindingFlags.Static);
var engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(razorPath),
(builder) =>
{
SectionDirective.Register(builder);
builder.SetNamespace(@namespace)
.AddDefaultImports(@"
@using System
@using System.Collections.Generic
@using System.Threading.Tasks
@using Microsoft.AspNetCore.Mvc
");
builder.ConfigureClass(
(document, @class) =>
{
@class.BaseType = baseType;
var relativePath = document.Source.RelativePath;
@class.ClassName = (string)sanitizeIdentifier.Invoke(null, new[] { relativePath.Substring(0, relativePath.Length - ".cshtml".Length) });
});
});
var debugItems = new List <KeyValuePair <string, Func <object> > >();
foreach (var projectItem in engine.FileSystem.EnumerateItems("/"))
{
debugItems.Add(new KeyValuePair <string, Func <object> >(
projectItem.FilePath, () => {
var code = engine.Process(projectItem).GetCSharpDocument().GeneratedCode;
var references = new List <MetadataReference>();
foreach (var reference in AssemblyLoadContext.Default.Assemblies)
{
if (reference.IsDynamic || string.IsNullOrEmpty(reference.Location) || !File.Exists(reference.Location))
{
continue;
}
references.Add(MetadataReference.CreateFromFile(reference.Location));
}
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create(
$"Razor_{Guid.NewGuid().ToString("N")}",
new[] { syntaxTree }, references,
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var assemblyStream = new MemoryStream();
var pdbStream = new MemoryStream();
var result = compilation.Emit(assemblyStream, pdbStream);
if (!result.Success)
{
string error = null;
foreach (var diagnostic in result.Diagnostics)
{
if (diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error)
{
error += diagnostic.ToString();
}
}
throw new Exception(error);
}
assemblyStream.Seek(0, SeekOrigin.Begin);
pdbStream.Seek(0, SeekOrigin.Begin);
var assembly = AssemblyLoadContext.Default.LoadFromStream(assemblyStream, pdbStream);
return(Activator.CreateInstance(assembly.GetTypes()[0]));
}));
}
return(debugItems);
}
public async Task <TemplateResult> RunTemplateAsync(string content,
dynamic templateModel)
{
// Don't care about the RazorProject as we already have the content of the .cshtml file
// and don't need to deal with imports.
var fileSystem = RazorProjectFileSystem.Create(Directory.GetCurrentDirectory());
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, (builder) =>
{
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.AddDefaultImports(@"
@using System
@using System.Threading.Tasks
");
});
var templateItem = new TemplateRazorProjectItem(content);
var codeDocument = projectEngine.Process(templateItem);
var generatorResults = codeDocument.GetCSharpDocument();
if (generatorResults.Diagnostics.Any())
{
var messages = generatorResults.Diagnostics.Select(d => d.GetMessage());
return(new TemplateResult()
{
GeneratedText = string.Empty,
ProcessingException = new TemplateProcessingException(messages, generatorResults.GeneratedCode)
});
}
var templateResult = _compilationService.Compile(generatorResults.GeneratedCode);
if (templateResult.Messages.Any())
{
return(new TemplateResult()
{
GeneratedText = string.Empty,
ProcessingException = new TemplateProcessingException(templateResult.Messages, generatorResults.GeneratedCode)
});
}
var compiledObject = Activator.CreateInstance(templateResult.CompiledType);
var result = string.Empty;
if (compiledObject is RazorTemplateBase razorTemplate)
{
razorTemplate.Model = templateModel;
//ToDo: If there are errors executing the code, they are missed here.
result = await razorTemplate.ExecuteTemplate();
}
return(new TemplateResult()
{
GeneratedText = result,
ProcessingException = null
});
}
