string getCSharpCode(string cshtmlFilePath, string rootNamespace)
{
var basePath = Path.GetDirectoryName(cshtmlFilePath);
var fileName = Path.GetFileName(cshtmlFilePath);
var fileNameNoExtension = Path.GetFileNameWithoutExtension(fileName);
var codeLang = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(codeLang);
host.DefaultBaseClass = "TchApp.Razor.TchRazorPage";
host.GeneratedClassContext = new GeneratedClassContext(
executeMethodName: GeneratedClassContext.DefaultExecuteMethodName,
writeMethodName: GeneratedClassContext.DefaultWriteMethodName,
writeLiteralMethodName: GeneratedClassContext.DefaultWriteLiteralMethodName,
writeToMethodName: "WriteTo",
writeLiteralToMethodName: "WriteLiteralTo",
templateTypeName: "HelperResult",
defineSectionMethodName: "DefineSection",
generatedTagHelperContext: new GeneratedTagHelperContext());
var engine = new RazorTemplateEngine(host);
var cshtmlContent = File.ReadAllText(cshtmlFilePath);
var generatorResults = engine.GenerateCode(
input: new StringReader(cshtmlContent),
className: fileNameNoExtension,
rootNamespace: Path.GetFileName(rootNamespace),
sourceFileName: fileName);
var generatedCode = generatorResults.GeneratedCode;
return(generatedCode);
}
public static ParsedTemplate parse(string sourceFilename, string cshtmlContent, string effectiveTemplateClassName, Type modelType)
{
var csCodeLanguage = new CSharpRazorCodeLanguage();
var templateHost = new RazorEngineHost(csCodeLanguage, () => new HtmlMarkupParser());
var concreteBaseClassType = getBaseClassTypeFromModel(modelType);
templateHost.DefaultBaseClass = concreteBaseClassType.FullName;
var templateEngine = new RazorTemplateEngine(templateHost);
var trimmedcshtmlContent = HeaderLines.trim(cshtmlContent);
GeneratorResults res;
using (var input = new StringReader(trimmedcshtmlContent))
{
res = templateEngine.GenerateCode(input, effectiveTemplateClassName, GeneratedTemplateNamespace, sourceFilename);
}
if (!res.Success)
{
throw new Exception("Failed to generate code");
}
var compileUnit = res.GeneratedCode;
var fullyQualifiedClassName = GeneratedTemplateNamespace + "." + effectiveTemplateClassName;
return(new ParsedTemplate(fullyQualifiedClassName, compileUnit));
}
public void CodeDomProviderTypeReturnsVBCodeProvider() {
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Assert
Assert.AreEqual(typeof(CSharpCodeProvider), service.CodeDomProviderType);
}
public PreprocessResult PreprocessRazorTemplate(string content, string className, string classNamespace)
{
var language = new CSharpRazorCodeLanguage();
var razorHost = new RazorEngineHost(language)
{
DefaultBaseClass = typeof(TemplateBase).FullName,
DefaultNamespace = classNamespace,
DefaultClassName = className,
GeneratedClassContext = new GeneratedClassContext(
nameof(TemplateBase.ExecuteAsync),
nameof(TemplateBase.Write),
nameof(TemplateBase.WriteLiteral),
new GeneratedTagHelperContext())
};
razorHost.NamespaceImports.Add(classNamespace);
var razorEngine = new RazorTemplateEngine(razorHost);
var generatorResults = razorEngine.GenerateCode(new StringReader(content));
if (!generatorResults.Success)
{
throw new Exception(string.Join(Environment.NewLine, generatorResults.ParserErrors.Select(x => x.Message)));
}
var preprocessResult = new PreprocessResult()
{
PreprocessedContent = generatorResults.GeneratedCode,
References = _host.StandardImports.ToList(),
};
return(preprocessResult);
}
private static object Compile(string code, string name)
{
var cacheKey = (name ?? DynamicallyGeneratedClassName) + GetHash(code);
var generatedClassName = name != null?name.Strip(c => !c.IsLetter() && !Char.IsDigit(c)) : DynamicallyGeneratedClassName;
Assembly assembly;
if (_cache.TryGetValue(cacheKey, out assembly))
{
return(assembly.CreateInstance(NamespaceForDynamicClasses + "." + generatedClassName));
}
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language)
{
DefaultBaseClass = "RazorTemplateBase<dynamic>",
DefaultClassName = generatedClassName,
DefaultNamespace = NamespaceForDynamicClasses
};
foreach (var n in DefaultNamespaces)
{
host.NamespaceImports.Add(n);
}
var engine = new RazorTemplateEngine(host);
var razorTemplate = engine.GenerateCode(new StringReader(code));
assembly = CreateCompiledAssemblyFor(razorTemplate.GeneratedCode, name);
_cache.TryAdd(cacheKey, assembly);
return(assembly.CreateInstance(NamespaceForDynamicClasses + "." + generatedClassName));
}
public void CodeTreeWithUsings()
{
var syntaxTreeNode = new Mock<Span>(new SpanBuilder());
var language = new CSharpRazorCodeLanguage();
var host = new CodeGenTestHost(language);
var codeBuilderContext = new CodeBuilderContext(
host,
"TestClass",
"TestNamespace",
"Foo.cs",
shouldGenerateLinePragmas: false,
errorSink: new ErrorSink());
codeBuilderContext.CodeTreeBuilder.AddUsingChunk("FakeNamespace1", syntaxTreeNode.Object);
codeBuilderContext.CodeTreeBuilder.AddUsingChunk("FakeNamespace2.SubNamespace", syntaxTreeNode.Object);
var codeBuilder = new CodeGenTestCodeBuilder(codeBuilderContext);
// Act
var result = codeBuilder.Build();
BaselineWriter.WriteBaseline(
@"test\Microsoft.AspNet.Razor.Test\TestFiles\CodeGenerator\CS\Output\CSharpCodeBuilder.cs",
result.Code);
var expectedOutput = TestFile.Create("TestFiles/CodeGenerator/CS/Output/CSharpCodeBuilder.cs").ReadAllText();
// Assert
Assert.Equal(expectedOutput, result.Code);
}
public void CodeTreeWithUsings()
{
var syntaxTreeNode = new Mock <Span>(new SpanBuilder());
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var codeBuilderContext = new CodeBuilderContext(
host,
"TestClass",
"TestNamespace",
"Foo.cs",
shouldGenerateLinePragmas: false);
codeBuilderContext.CodeTreeBuilder.AddUsingChunk("FakeNamespace1", syntaxTreeNode.Object);
codeBuilderContext.CodeTreeBuilder.AddUsingChunk("FakeNamespace2.SubNamespace", syntaxTreeNode.Object);
var codeBuilder = language.CreateCodeBuilder(codeBuilderContext);
// Act
var result = codeBuilder.Build();
BaselineWriter.WriteBaseline(
@"test\Microsoft.AspNet.Razor.Test\TestFiles\CodeGenerator\CS\Output\CSharpCodeBuilder.cs",
result.Code);
var expectedOutput = TestFile.Create("TestFiles/CodeGenerator/CS/Output/CSharpCodeBuilder.cs").ReadAllText();
// Assert
Assert.Equal(expectedOutput, result.Code);
}
private static GeneratorResults GenerateCode <TModel>(string classFullName, string template, IEnumerable <string> additionalNamespaceImports)
{
var lastIndexOf = classFullName.LastIndexOf('.');
string classNamespace = classFullName.Substring(0, lastIndexOf);
string className = classFullName.Substring(lastIndexOf + 1);
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language)
{
DefaultBaseClass = typeof(RazorGeneratorBase <TModel>).FullName,
DefaultClassName = className,
DefaultNamespace = classNamespace,
};
host.NamespaceImports.Add("System");
host.NamespaceImports.Add("System.Dynamic");
host.NamespaceImports.Add("System.Text");
host.NamespaceImports.Add("System.Linq");
host.NamespaceImports.Add(typeof(TModel).Namespace ?? throw new InvalidOperationException());
if (additionalNamespaceImports != null)
{
foreach (var additionalNamespaceImport in additionalNamespaceImports)
{
host.NamespaceImports.Add(additionalNamespaceImport);
}
}
var engine = new RazorTemplateEngine(host);
var tr = new StringReader(template); // here is where the string come in place
GeneratorResults razorTemplate = engine.GenerateCode(tr);
return(razorTemplate);
}
private Type GenerateTemplateTypes <T>(string templateName)
{
var source = ContentReader.ReadTemplate(templateName);
var className = templateName.Replace(".", "_");
// determine language, pass into generateAssembly
RazorCodeLanguage codeLanguage;
switch (templateName.Substring(templateName.LastIndexOf(".")))
{
case ".cshtml":
codeLanguage = new CSharpRazorCodeLanguage();
break;
case ".vbhtml":
codeLanguage = new VBRazorCodeLanguage();
break;
default:
throw new ApplicationException("Unsupported Template language. Either .cshtml or .vbhtml");
}
var razorEngine = CreateRazorEngine <T>(codeLanguage);
var assembly = GenerateAssembly <T>(razorEngine, className, source);
return(assembly.GetType(NamespaceName + "." + className, true, false));
}
public void CodeDomProviderTypeReturnsVBCodeProvider()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Assert
Assert.Equal(typeof(CSharpCodeProvider), service.CodeDomProviderType);
}
private static RazorTemplateEngine CreateRazorTemplateEngine()
{
var language = new CSharpRazorCodeLanguage();
var host = new SimpleRazorEngineHost(language);
var engine = new RazorTemplateEngine(host);
return(engine);
}
/// <summary>
/// Generates code for a razor template in the specified namespace.
/// </summary>
/// <param name="cshtmlFilePath">Full path to razor template.</param>
/// <param name="rootNamespace">Root namespace for razor-generated class.</param>
private void GenerateCodeFile(string cshtmlFilePath, string rootNamespace)
{
var basePath = Path.GetDirectoryName(cshtmlFilePath);
var fileName = Path.GetFileName(cshtmlFilePath);
var fileNameNoExtension = Path.GetFileNameWithoutExtension(fileName);
var codeLang = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(codeLang);
host.GeneratedClassContext = new GeneratedClassContext(
executeMethodName: GeneratedClassContext.DefaultExecuteMethodName,
writeMethodName: GeneratedClassContext.DefaultWriteMethodName,
writeLiteralMethodName: GeneratedClassContext.DefaultWriteLiteralMethodName,
writeToMethodName: "WriteTo",
writeLiteralToMethodName: "WriteLiteralTo",
templateTypeName: "HelperResult",
defineSectionMethodName: "DefineSection",
generatedTagHelperContext: new GeneratedTagHelperContext());
var engine = new RazorTemplateEngine(host);
using (var fileStream = File.OpenText(cshtmlFilePath))
{
var code = engine.GenerateCode(
input: fileStream,
className: fileNameNoExtension,
rootNamespace: rootNamespace,
sourceFileName: fileName);
var source = code.GeneratedCode;
source = CopyrightHeader + "\r\n\r\n" + source;
var startIndex = 0;
while (startIndex < source.Length)
{
var startMatch = @"<%$ include: ";
var endMatch = @" %>";
startIndex = source.IndexOf(startMatch, startIndex);
if (startIndex == -1)
{
break;
}
var endIndex = source.IndexOf(endMatch, startIndex);
if (endIndex == -1)
{
break;
}
var includeFileName = source.Substring(startIndex + startMatch.Length,
endIndex - (startIndex + startMatch.Length));
Console.WriteLine(" Inlining file {0}", includeFileName);
var replacement =
File.ReadAllText(Path.Combine(basePath, includeFileName))
.Replace("\"", "\\\"")
.Replace("\r\n", "\\r\\n");
source = source.Substring(0, startIndex) + replacement +
source.Substring(endIndex + endMatch.Length);
startIndex = startIndex + replacement.Length;
}
File.WriteAllText(Path.Combine(basePath, string.Format("{0}.cs", fileNameNoExtension)), source);
}
}
public void CreateCodeParserReturnsNewCSharpCodeParser() {
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
ParserBase parser = service.CreateCodeParser();
// Assert
Assert.IsNotNull(parser);
Assert.IsInstanceOfType(parser, typeof(CSharpCodeParser));
}
public void ConstructorWithCodeLanguageSetsPropertiesAppropriately() {
// Arrange
RazorCodeLanguage language = new CSharpRazorCodeLanguage();
// Act
RazorEngineHost host = new RazorEngineHost(language);
// Assert
VerifyCommonDefaults(host);
Assert.AreSame(language, host.CodeLanguage);
Assert.IsInstanceOfType(host.CreateMarkupParser(), typeof(HtmlMarkupParser));
}
public void CreateCodeParserReturnsNewCSharpCodeParser()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
ParserBase parser = service.CreateCodeParser();
// Assert
Assert.NotNull(parser);
Assert.IsType<CSharpCodeParser>(parser);
}
public void CreateCodeParserReturnsNewCSharpCodeParser()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
ParserBase parser = service.CreateCodeParser();
// Assert
Assert.IsNotNull(parser);
Assert.IsInstanceOfType(parser, typeof(CSharpCodeParser));
}
public void CreateCodeParserReturnsNewCSharpCodeParser()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
ParserBase parser = service.CreateCodeParser();
// Assert
Assert.NotNull(parser);
Assert.IsType <CSharpCodeParser>(parser);
}
public void ConstructorWithCodeLanguageSetsPropertiesAppropriately()
{
// Arrange
var language = new CSharpRazorCodeLanguage();
// Act
var host = new RazorEngineHost(language);
// Assert
VerifyCommonDefaults(host);
Assert.Same(language, host.CodeLanguage);
Assert.IsType <HtmlMarkupParser>(host.CreateMarkupParser());
}
public void ConstructorWithCodeLanguageSetsPropertiesAppropriately()
{
// Arrange
var language = new CSharpRazorCodeLanguage();
// Act
var host = new RazorEngineHost(language);
// Assert
VerifyCommonDefaults(host);
Assert.Same(language, host.CodeLanguage);
Assert.IsType<HtmlMarkupParser>(host.CreateMarkupParser());
}
public void ConstructorWithCodeLanguageSetsPropertiesAppropriately()
{
// Arrange
RazorCodeLanguage language = new CSharpRazorCodeLanguage();
// Act
RazorEngineHost host = new RazorEngineHost(language);
// Assert
VerifyCommonDefaults(host);
Assert.AreSame(language, host.CodeLanguage);
Assert.IsInstanceOfType(host.CreateMarkupParser(), typeof(HtmlMarkupParser));
}
public void ConstructorWithCodeLanguageAndMarkupParserSetsPropertiesAppropriately() {
// Arrange
RazorCodeLanguage language = new CSharpRazorCodeLanguage();
MarkupParser expected = new HtmlMarkupParser();
// Act
RazorEngineHost host = new RazorEngineHost(language, () => expected);
// Assert
VerifyCommonDefaults(host);
Assert.AreSame(language, host.CodeLanguage);
Assert.AreSame(expected, host.CreateMarkupParser());
}
public void ConstructorWithCodeLanguageAndMarkupParserSetsPropertiesAppropriately()
{
// Arrange
RazorCodeLanguage language = new CSharpRazorCodeLanguage();
ParserBase expected = new HtmlMarkupParser();
// Act
RazorEngineHost host = new RazorEngineHost(language, () => expected);
// Assert
VerifyCommonDefaults(host);
Assert.Same(language, host.CodeLanguage);
Assert.Same(expected, host.CreateMarkupParser());
}
static void Run()
{
// ホスト作成
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language)
{
DefaultBaseClass = nameof(Legacy) + "." + nameof(LegacyTemplateBase),
DefaultClassName = "Generated",
DefaultNamespace = "RazorTemplate",
// 生成されるメソッド名の指定（これはデフォルトと同じものを指定している）
GeneratedClassContext = new GeneratedClassContext(
nameof(LegacyTemplateBase.Execute),
nameof(LegacyTemplateBase.Write),
nameof(LegacyTemplateBase.WriteLiteral)
)
};
// デフォルトで挿入する名前空間を追加
host.NamespaceImports.Add(nameof(System));
var engine = new RazorTemplateEngine(host);
using (var reader = new StreamReader(File.OpenRead("../../../Page.cshtml")))
{
// コードDOM生成
var generatorResults = engine.GenerateCode(reader);
System.CodeDom.CodeCompileUnit unit = generatorResults.GeneratedCode;
var provider = new CSharpCodeProvider();
// 表示用
provider.GenerateCodeFromCompileUnit(unit, Console.Out, new CodeGeneratorOptions());
Console.WriteLine("------------------------------------------------------------------------");
// 使用アセンブリ参照
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add(typeof(LegacyTemplateBase).Assembly.Location);
// コンパイル
var compilerResults = provider.CompileAssemblyFromDom(parameters, unit);
// 実行
var typeName = host.DefaultNamespace + "." + host.DefaultClassName;
var instance = compilerResults.CompiledAssembly.CreateInstance(typeName) as LegacyTemplateBase;
var generatedString = instance.Generate();
// 結果表示
Console.Write(generatedString);
}
}
public void ChunkTreeWithUsings()
{
var syntaxTreeNode = new Mock <Span>(new SpanBuilder());
var language = new CSharpRazorCodeLanguage();
var host = new CodeGenTestHost(language);
var codeGeneratorContext = new CodeGeneratorContext(
host,
"TestClass",
"TestNamespace",
"Foo.cs",
shouldGenerateLinePragmas: false,
errorSink: new ErrorSink());
codeGeneratorContext.ChunkTreeBuilder.AddUsingChunk("FakeNamespace1", syntaxTreeNode.Object);
codeGeneratorContext.ChunkTreeBuilder.AddUsingChunk("FakeNamespace2.SubNamespace", syntaxTreeNode.Object);
var codeGenerator = new CodeGenTestCodeGenerator(codeGeneratorContext);
var testFile = TestFile.Create("TestFiles/CodeGenerator/Output/CSharpCodeGenerator.cs");
string expectedOutput;
#if GENERATE_BASELINES
if (testFile.Exists())
{
expectedOutput = testFile.ReadAllText();
}
else
{
expectedOutput = null;
}
#else
expectedOutput = testFile.ReadAllText();
#endif
// Act
var result = codeGenerator.Generate();
// Assert
#if GENERATE_BASELINES
// Update baseline files if files do not already match.
if (!string.Equals(expectedOutput, result.Code, StringComparison.Ordinal))
{
BaselineWriter.WriteBaseline(
@"test\Microsoft.AspNet.Razor.Test\TestFiles\CodeGenerator\Output\CSharpCodeGenerator.cs",
result.Code);
}
#else
Assert.Equal(expectedOutput, result.Code);
#endif
}
private static void GenerateCodeFile(string cshtmlFilePath, string targetPath, string rootNamespace, string defaultBaseClass)
{
var basePath = Path.GetDirectoryName(cshtmlFilePath);
var fileName = Path.GetFileName(cshtmlFilePath);
var cleanFileName = CleanFileName(Path.GetFileNameWithoutExtension(fileName));
var codeLang = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(codeLang);
host.GeneratedClassContext = new GeneratedClassContext(
executeMethodName: GeneratedClassContext.DefaultExecuteMethodName,
writeMethodName: GeneratedClassContext.DefaultWriteMethodName,
writeLiteralMethodName: GeneratedClassContext.DefaultWriteLiteralMethodName,
writeToMethodName: "WriteTo",
writeLiteralToMethodName: "WriteLiteralTo",
templateTypeName: "HelperResult",
generatedTagHelperContext: new GeneratedTagHelperContext());
var engine = new RazorTemplateEngine(host);
var source = File.ReadAllText(cshtmlFilePath);
var modelType = GetModelType(source);
if (!string.IsNullOrEmpty(modelType))
{
host.DefaultBaseClass = $"{defaultBaseClass}<{modelType}>"; // BaseClass<T>
}
else
{
host.DefaultBaseClass = defaultBaseClass;
}
source = RemoveAnnotations(source, rootNamespace);
source = RemoveExtraWhitespace(source);
using (var fileStream = File.OpenText(cshtmlFilePath))
{
var code = engine.GenerateCode(
input: new StringReader(source),
className: cleanFileName,
rootNamespace: rootNamespace,
sourceFileName: fileName);
var output = code.GeneratedCode;
output = InlineIncludedFiles(basePath, output);
File.WriteAllText(Path.Combine(targetPath, string.Format($"{cleanFileName}.cs")), output);
}
}
private object Compile(string code, string name, Type modelType, IDictionary <string, object> parameters)
{
var cacheKey = (name ?? DynamicallyGeneratedClassName) + GetHash(code);
var generatedClassName = name != null?name.Strip(c => !c.IsLetter() && !Char.IsDigit(c)) : DynamicallyGeneratedClassName;
var assembly = _cache.Get(cacheKey, ctx => {
_signals.When(ForceRecompile);
var modelTypeName = "dynamic";
var reader = new StringReader(code);
var builder = new StringBuilder();
// A hack to remove any @model directive as it's MVC-specific and compiler does not recognize it.
// We should use this information to compile a strongly-typed template in the future
string line;
while ((line = reader.ReadLine()) != null)
{
var trimmedLine = line.TrimStart(' ', '\t', '\n', '\r');
if (trimmedLine.StartsWith("@model "))
{
modelTypeName = trimmedLine.Substring("@model ".Length).Trim();
continue;
}
builder.AppendLine(line);
}
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language)
{
DefaultBaseClass = "RazorTemplateBase<" + modelTypeName + ">",
DefaultClassName = generatedClassName,
DefaultNamespace = NamespaceForDynamicClasses
};
foreach (var n in DefaultNamespaces)
{
host.NamespaceImports.Add(n);
}
var engine = new RazorTemplateEngine(host);
var razorTemplate = engine.GenerateCode(new StringReader(builder.ToString()));
var compiledAssembly = CreateCompiledAssemblyFor(razorTemplate.GeneratedCode, name);
return(compiledAssembly);
});
return(assembly.CreateInstance(NamespaceForDynamicClasses + "." + generatedClassName));
}
private GeneratorResults GenerateCode()
{
var codeLang = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(codeLang)
{
DefaultBaseClass = "Thriot.Framework.Mails.TemplatingEngine.BaseView",
DefaultClassName = "Template",
DefaultNamespace = "CompiledRazor",
NamespaceImports = { "System" }
};
var engine = new RazorTemplateEngine(host);
return(engine.GenerateCode(new StringReader(_template)));
}
public void CreateCodeGeneratorParserListenerReturnsNewCSharpCodeGeneratorParserListener() {
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
RazorEngineHost host = new RazorEngineHost(service);
RazorCodeGenerator generator = service.CreateCodeGenerator("Foo", "Bar", "Baz", host);
// Assert
Assert.IsNotNull(generator);
Assert.IsInstanceOfType(generator, typeof(CSharpRazorCodeGenerator));
Assert.AreEqual("Foo", generator.ClassName);
Assert.AreEqual("Bar", generator.RootNamespaceName);
Assert.AreEqual("Baz", generator.SourceFileName);
Assert.AreSame(host, generator.Host);
}
public LoveSyntaxTree Parse(TextReader source)
{
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language)
{
};
var parser = new RazorTemplateEngine(host);
var results = parser.ParseTemplate(source);
//var debugText = RazorDebugView.ToDebug(results);
var tree = VisitTree(results);
var treeText = tree.ToString();
return(tree);
}
public void ChunkTreeWithUsings()
{
var syntaxTreeNode = new Mock<Span>(new SpanBuilder());
var language = new CSharpRazorCodeLanguage();
var host = new CodeGenTestHost(language);
var codeGeneratorContext = new CodeGeneratorContext(
host,
"TestClass",
"TestNamespace",
"Foo.cs",
shouldGenerateLinePragmas: false,
errorSink: new ErrorSink());
codeGeneratorContext.ChunkTreeBuilder.AddUsingChunk("FakeNamespace1", syntaxTreeNode.Object);
codeGeneratorContext.ChunkTreeBuilder.AddUsingChunk("FakeNamespace2.SubNamespace", syntaxTreeNode.Object);
var codeGenerator = new CodeGenTestCodeGenerator(codeGeneratorContext);
var testFile = TestFile.Create("TestFiles/CodeGenerator/Output/CSharpCodeGenerator.cs");
string expectedOutput;
#if GENERATE_BASELINES
if (testFile.Exists())
{
expectedOutput = testFile.ReadAllText();
}
else
{
expectedOutput = null;
}
#else
expectedOutput = testFile.ReadAllText();
#endif
// Act
var result = codeGenerator.Generate();
// Assert
#if GENERATE_BASELINES
// Update baseline files if files do not already match.
if (!string.Equals(expectedOutput, result.Code, StringComparison.Ordinal))
{
BaselineWriter.WriteBaseline(
@"test\Microsoft.AspNet.Razor.Test\TestFiles\CodeGenerator\Output\CSharpCodeGenerator.cs",
result.Code);
}
#else
Assert.Equal(expectedOutput, result.Code);
#endif
}
public static RazorTemplateEngine CreateEngine()
{
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
host.DefaultBaseClass = typeof(RazorTemplate <Context>).FullName;
host.DefaultNamespace = "RazorOutput";
host.DefaultClassName = "Template";
host.NamespaceImports.Add("System");
host.NamespaceImports.Add("System.IO");
//host.NamespaceImports.Add("System.Linq");
// host.NamespaceImports.Add("System.Text.RegularExpressions");
var engine = new RazorTemplateEngine(host);
return(engine);
}
public void CreateCodeBuilder_ReturnsNewCSharpCodeBuilder()
{
// Arrange
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var context = CodeGeneratorContext.Create(host,
"myclass",
"myns",
string.Empty,
shouldGenerateLinePragmas: false);
// Act
var generator = language.CreateCodeBuilder(context);
// Assert
Assert.IsType<CSharpCodeBuilder>(generator);
}
public void CreateChunkGeneratorParserListenerReturnsNewCSharpChunkGeneratorParserListener()
{
// Arrange
var service = new CSharpRazorCodeLanguage();
// Act
var host = new RazorEngineHost(service);
var generator = service.CreateChunkGenerator("Foo", "Bar", "Baz", host);
// Assert
Assert.NotNull(generator);
Assert.IsType<RazorChunkGenerator>(generator);
Assert.Equal("Foo", generator.ClassName);
Assert.Equal("Bar", generator.RootNamespaceName);
Assert.Equal("Baz", generator.SourceFileName);
Assert.Same(host, generator.Host);
}
public void CreateCodeBuilder_ReturnsNewCSharpCodeBuilder()
{
// Arrange
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var context = CodeGeneratorContext.Create(host,
"myclass",
"myns",
string.Empty,
shouldGenerateLinePragmas: false);
// Act
var generator = language.CreateCodeBuilder(context);
// Assert
Assert.IsType <CSharpCodeBuilder>(generator);
}
public void CreateCodeGeneratorParserListenerReturnsNewCSharpCodeGeneratorParserListener()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
RazorEngineHost host = new RazorEngineHost(service);
RazorCodeGenerator generator = service.CreateCodeGenerator("Foo", "Bar", "Baz", host);
// Assert
Assert.NotNull(generator);
Assert.IsType <CSharpRazorCodeGenerator>(generator);
Assert.Equal("Foo", generator.ClassName);
Assert.Equal("Bar", generator.RootNamespaceName);
Assert.Equal("Baz", generator.SourceFileName);
Assert.Same(host, generator.Host);
}
public Assembly Compile(IEnumerable <TemplateMetadata> templates, Type baseClass)
{
var metadataReferences = typeof(ConsulTemplateBase).GetTypeInfo()
.Assembly
.GetReferencedAssemblies()
.Select(Assembly.Load)
.Concat(new[] { typeof(ConsulTemplateBase).GetTypeInfo().Assembly })
.Select(assembly => assembly.Location)
.Select(location => MetadataReference.CreateFromFile(location))
.Concat(new[]
{
MetadataReference.CreateFromFile(Path.Combine(
Path.GetDirectoryName(typeof(Enumerable).GetTypeInfo().Assembly.Location), "mscorlib.dll")),
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)
})
.ToArray();
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language)
{
DefaultBaseClass = baseClass.FullName,
DefaultNamespace = "ConsulRazor.CompiledRazorTemplates",
};
// Everyone needs the System namespace, right?
host.NamespaceImports.Add("System");
host.NamespaceImports.Add("System.Linq");
var engine = new RazorTemplateEngine(host);
var syntaxTrees = templates.Select(metadata =>
{
using (var templateStream = File.OpenRead(metadata.FullPath))
{
var generatorResults = engine.GenerateCode(new StreamReader(templateStream), metadata.ClassName,
metadata.Namespace, metadata.Filename);
return(CSharpSyntaxTree.ParseText(generatorResults.GeneratedCode));
}
})
.ToArray();
var compilation = CSharpCompilation.Create("ConsulRazor.CompiledRazorTemplates", syntaxTrees,
metadataReferences, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
return(CompileCompilation(compilation));
}
/// <summary>
/// 创建DLL文件 重复方法 则覆盖
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="razorTemplate">razor语法的Html模板</param>
/// <param name="model">实体一般Model</param>
/// <param name="keyName">dll名称不含后缀</param>
/// <param name="dllDir">dll生成目录</param>
public static void CreateDLL <T>(string razorTemplate, T model, string keyName, string dllDir = ".")
{
//1、创建一个C#的对象
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
var check = KuRazor.CheckModel(model);
Type modelType = check.Item2;
modelType = modelType ?? typeof(System.Dynamic.DynamicObject);
Type templateType = typeof(TemplateBase <>);
RazorCodeLanguage language = new CSharpRazorCodeLanguage();
RazorEngineHost host = new RazorEngineHost(language);
host.DefaultBaseClass = KuRazor.BuildTypeName(templateType, modelType);
host.DefaultClassName = keyName;
host.DefaultNamespace = "KuRazorCommon.Dynamic";
List <string> namespaceImports = new List <string>();
namespaceImports.Add("System");
namespaceImports.Add("System.Collections.Generic");
namespaceImports.Add("System.Linq");
foreach (string ns in namespaceImports)
{
host.NamespaceImports.Add(ns);
}
RazorTemplateEngine engine = new RazorTemplateEngine(host);
GeneratorResults razorResult;
using (var reader = new StringReader(razorTemplate))
razorResult = engine.GenerateCode(reader);
CodeCompileUnit razorCode = razorResult.GeneratedCode;
string generatedCode;
var builder = new StringBuilder();
using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture))
{
provider.GenerateCodeFromCompileUnit(razorCode, writer, new CodeGeneratorOptions());
generatedCode = builder.ToString();
}
string dllName = string.Format("{0}.dll", keyName);
CompilerResults results = CompileCode(provider, generatedCode, dllName, dllDir);
}
private static void GenerateCodeFile(string cshtmlFilePath)
{
var basePath = Path.GetDirectoryName(cshtmlFilePath);
var fileName = Path.GetFileName(cshtmlFilePath);
var fileNameNoExtension = Path.GetFileNameWithoutExtension(fileName);
var codeLang = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(codeLang);
host.DefaultBaseClass = "Microsoft.AspNet.Diagnostics.Views.BaseView";
var engine = new RazorTemplateEngine(host);
using (var fileStream = File.OpenText(cshtmlFilePath))
{
var code = engine.GenerateCode(
input: fileStream,
className: fileNameNoExtension,
rootNamespace: "Microsoft.AspNet.Diagnostics.Entity.Views",
sourceFileName: fileName);
var source = code.GeneratedCode;
var startIndex = 0;
while (startIndex < source.Length)
{
var startMatch = @"<%$ include: ";
var endMatch = @" %>";
startIndex = source.IndexOf(startMatch, startIndex);
if (startIndex == -1)
{
break;
}
var endIndex = source.IndexOf(endMatch, startIndex);
if (endIndex == -1)
{
break;
}
var includeFileName = source.Substring(startIndex + startMatch.Length, endIndex - (startIndex + startMatch.Length));
includeFileName = SanitizeFileName(includeFileName);
Console.WriteLine(" Inlining file {0}", includeFileName);
var replacement = File.ReadAllText(Path.Combine(basePath, includeFileName)).Replace("\"", "\\\"").Replace("\r\n", "\\r\\n");
source = source.Substring(0, startIndex) + replacement + source.Substring(endIndex + endMatch.Length);
startIndex = startIndex + replacement.Length;
}
File.WriteAllText(Path.Combine(basePath, string.Format("{0}.cs", fileNameNoExtension)), source);
}
}
private static RazorTemplateEngine CreateRazorTemplateEngine()
{
var language = new CSharpRazorCodeLanguage();
var host = new SimpleRazorEngineHost(language)
{
DefaultBaseClass = "SimpleTemplateBase",
DefaultClassName = "SimpleView",
DefaultNamespace = "SimpleRazor",
};
foreach (string nameSpace in DefaultNamespaceImports)
{
host.NamespaceImports.Add(nameSpace);
}
var engine = new RazorTemplateEngine(host);
return(engine);
}
public static CodeGeneratorContext CreateCodeGeneratorContext()
{
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var chunkGeneratorContext = new ChunkGeneratorContext
(
host,
_testClass,
_testNamespace,
_testFile,
shouldGenerateLinePragmas: false
);
var codeGeneratorContext = new CodeGeneratorContext(
chunkGeneratorContext,
errorSink: new ErrorSink());
return(codeGeneratorContext);
}
static void Main(string[] args)
{
const string rootNamespace = "RazorOnConsole";
var viewPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Views\Index.cshtml");
var basePath = Path.GetDirectoryName(viewPath);
var fileName = Path.GetFileName(viewPath);
var fileNameNoExtension = Path.GetFileNameWithoutExtension(fileName);
using (var file = File.Create(fileNameNoExtension + ".html")) { new Index {
Model = "foobarfoo"
}.ExecuteAsync(file).Wait(); }
var codeLang = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(codeLang)
{
DefaultBaseClass = "RazorOnConsole.Views.BaseView",
GeneratedClassContext = new GeneratedClassContext(
executeMethodName: GeneratedClassContext.DefaultExecuteMethodName,
writeMethodName: GeneratedClassContext.DefaultWriteMethodName,
writeLiteralMethodName: GeneratedClassContext.DefaultWriteLiteralMethodName,
writeToMethodName: "WriteTo",
writeLiteralToMethodName: "WriteLiteralTo",
templateTypeName: "HelperResult",
defineSectionMethodName: "DefineSection",
generatedTagHelperContext: new GeneratedTagHelperContext())
};
host.NamespaceImports.Add("System");
var engine = new RazorTemplateEngine(host);
using (var fileStream = File.OpenText(viewPath))
{
GeneratorResults code = engine.GenerateCode(
input: fileStream,
className: fileNameNoExtension,
rootNamespace: rootNamespace,
sourceFileName: fileName);
string source = code.GeneratedCode;
File.WriteAllText(Path.Combine(basePath, @"..\..\..\", "Views", string.Format("{0}.cs", fileNameNoExtension)), source);
}
}
