private CodeCompileUnit GetGeneratedCode() { try { if (this.generatedCode == null) { var engine = new RazorTemplateEngine(this.host); GeneratorResults results; using (var reader = this.OpenReader()) { results = engine.GenerateCode(reader); } if (!results.Success) { throw new InvalidOperationException(results.ToString()); } this.generatedCode = results.GeneratedCode; } return this.generatedCode; } catch (Exception ex) { Log.Error("GetGeneratedCode(): ", ex); return null; } }
public override TemplateParseResult ParseTemplate(string template) { string templateNamespace = GetCompiledTemplateNamespace(); string templateClass = GetCompiledTemplateClass(); string templateMethodName = GetCompiledTemplateMethodName(); var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = typeof(TemplateBase).FullName; host.DefaultNamespace = templateNamespace; host.DefaultClassName = templateClass; host.NamespaceImports.Add("System"); host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral") { WriteAttributeMethodName = "WriteAttribute" }; GeneratorResults generatorResults; var engine = new System.Web.Razor.RazorTemplateEngine(host); using (var reader = new StringReader(template)) { generatorResults = engine.GenerateCode(reader); } return(new TemplateParseResult { CodeCompileUnit = generatorResults.GeneratedCode, Namespace = templateNamespace, Class = templateClass }); }
private static string GenerateCodeFromRazorTemplate(WebPageRazorHost host, string virtualPath) { // Create Razor engine and use it to generate a CodeCompileUnit var engine = new RazorTemplateEngine(host); GeneratorResults results = null; VirtualFile file = HostingEnvironment.VirtualPathProvider.GetFile(virtualPath); using (var stream = file.Open()) { using (TextReader reader = new StreamReader(stream)) { results = engine.GenerateCode(reader, className: null, rootNamespace: null, sourceFileName: host.PhysicalPath); } } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), virtualPath); } // Use CodeDom to generate source code from the CodeCompileUnit var codeDomProvider = new CSharpCodeProvider(); var srcFileWriter = new StringWriter(); codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, srcFileWriter, new CodeGeneratorOptions()); return srcFileWriter.ToString(); }
public override SyntaxTree GetSyntaxTree(string sourcePath, Stream sourceStream) { try { var viewFullPath = sourcePath; var viewVirtualPath = GetRelativeUri(sourcePath, Compilation.CurrentDirectory.FullName); var viewConfig = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath); var razorConfig = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup; var host = razorConfig == null ? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath) : WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath); using (var rdr = new StreamReader(sourceStream, Compilation.Encoding, detectEncodingFromByteOrderMarks: true)) using (var provider = CodeDomProvider.CreateProvider("csharp")) using (var generatedStream = new MemoryStream()) using (var generatedWriter = new StreamWriter(generatedStream, Compilation.Encoding)) { var engine = new RazorTemplateEngine(host); var razorOut = engine.GenerateCode(rdr, null, null, viewFullPath); var codeGenOptions = new CodeGeneratorOptions { VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false }; provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions); // rewind generatedWriter.Flush(); generatedStream.Position = 0; return base.GetSyntaxTree(sourcePath, generatedStream); } } catch (Exception ex) { Compilation.Diagnostics.Add(Diagnostic.Create(Compilation.ViewGenerationFailed, Compilation.AsLocation(sourcePath), ex.ToString())); return null; } }
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 GeneratorResults ParseToCode(string TemplateCode, string defaultnamespace, string defaultclassname, string baseClassFullName) { GeneratorResults razorResults; var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = baseClassFullName;//typeof(BulaqTemplateForRazorBase).FullName; host.DefaultNamespace = defaultnamespace; host.DefaultClassName = defaultclassname; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("BulaqCMS.Models"); host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral"); var engine = new RazorTemplateEngine(host); using (var reader = new StringReader(TemplateCode)) { razorResults = engine.GenerateCode(reader); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; using (StringWriter writer = new StringWriter()) { IndentedTextWriter indentwriter = new IndentedTextWriter(writer, " "); codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, indentwriter, options); indentwriter.Flush(); indentwriter.Close(); LastGeneratedCode = writer.GetStringBuilder().ToString(); string codePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\code.cs"; File.WriteAllText(codePath, LastGeneratedCode, Encoding.UTF8); } } return razorResults; }
private async Task<CompilationResult> CompileCore(IFileInfo file) { var host = new MvcRazorHost(); var engine = new RazorTemplateEngine(host); GeneratorResults results; using (TextReader rdr = new StreamReader(file.CreateReadStream())) { results = engine.GenerateCode(rdr, '_' + Path.GetFileNameWithoutExtension(file.Name), "Asp", file.PhysicalPath ?? file.Name); } string generatedCode; using (var writer = new StringWriter()) using (var codeProvider = new CSharpCodeProvider()) { codeProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions()); generatedCode = writer.ToString(); } if (!results.Success) { return CompilationResult.Failed(generatedCode, results.ParserErrors.Select(e => new CompilationMessage(e.Message))); } Directory.CreateDirectory(_tempPath); string tempFile = Path.Combine(_tempPath, Path.GetRandomFileName() + ".cs"); File.WriteAllText(tempFile, generatedCode); _tempFileSystem.TryGetFileInfo(tempFile, out file); return await _baseCompilationService.Compile(file); }
protected internal virtual void ProcessChange(CancellationToken cancelToken, TextChange change, Block parseTree) { try { if (!cancelToken.IsCancellationRequested) { GeneratorResults results = null; RazorTemplateEngine engine = new RazorTemplateEngine(_host); // Seek the buffer to the beginning change.NewBuffer.Position = 0; try { results = engine.GenerateCode(change.NewBuffer, className: null, rootNamespace: null, sourceFileName: _sourceFileName, cancelToken: cancelToken); } catch (OperationCanceledException) { // We've been cancelled, so just return. return; } // Parsing complete! Check if we're still active: bool lockTaken = false; _syncLock.Enter(ref lockTaken); if (lockTaken && !cancelToken.IsCancellationRequested) { // We're still active, check for tree changes, then update the parse tree bool treeStructureChanged = parseTree == null || TreesAreDifferent(parseTree, results.Document, change); Interlocked.Exchange(ref _currentParseTree, results.Document); Interlocked.Exchange(ref _lastChangeOwner, null); #if DEBUG Interlocked.Exchange(ref _currentCodeCompileUnit, results.GeneratedCode); #endif _parseUnderway = false; // Done, now exit the lock and fire the event _syncLock.Exit(); OnDocumentParseComplete(new DocumentParseCompleteEventArgs() { GeneratorResults = results, SourceChange = change, TreeStructureChanged = treeStructureChanged }); } } } finally { // Make sure we release the lock if we're holding it if (_syncLock.IsHeldByCurrentThread) { _syncLock.Exit(); } } }
public GeneratorResults GenerateCode() { // Create the engine RazorTemplateEngine engine = new RazorTemplateEngine(this); // Generate code using (Stream stream = File.OpenRead(_fullPath)) { using (StreamReader reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true)) { return engine.GenerateCode(reader); } } }
private CodeCompileUnit GenerateCode() { var engine = new RazorTemplateEngine(this._host); GeneratorResults results; using (TextReader reader = OpenReader()) { results = engine.GenerateCode(reader); //, className: null, rootNamespace: null, sourceFileName: Host.PhysicalPath); } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), VirtualPath); } return results.GeneratedCode; }
public GeneratorResults GenerateCode(RazorTemplate descriptor, string className, RazorEngineHost host) { var engine = new RazorTemplateEngine(host); GeneratorResults results; using (var fileStream = new FileStream(descriptor.FilePath, FileMode.Open, FileAccess.Read)) using (var reader = new StreamReader(fileStream)) { results = engine.GenerateCode(reader, className, host.DefaultNamespace, descriptor.ViewPath); } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), descriptor.Name()); } return results; }
private CompilationData GenerateCode(string path) { var viewDefinition = _viewProvider.GetViewDefinition(path); var host = OpenRastaRazorHostFactory.CreateHost(DetermineCodeLanguage(viewDefinition.FileName)); var engine = new RazorTemplateEngine(host); GeneratorResults results; using (TextReader reader = viewDefinition.Contents) { results = engine.GenerateCode(reader, GetClassName(viewDefinition.FileName), host.DefaultNamespace, viewDefinition.FileName); } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), path); } return new CompilationData(GetReferencedAssemblies(viewDefinition), results.GeneratedCode); }
public Task<CompilationResult> Compile(IFileInfo file) { string className = MakeClassName(file.Name); var engine = new RazorTemplateEngine(new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultBaseClass = "Microsoft.AspNet.Razor.Owin.PageBase", GeneratedClassContext = new GeneratedClassContext( executeMethodName: "Execute", writeMethodName: "Write", writeLiteralMethodName: "WriteLiteral", writeToMethodName: "WriteTo", writeLiteralToMethodName: "WriteLiteralTo", templateTypeName: "Template", defineSectionMethodName: "DefineSection") { ResolveUrlMethodName = "Href" } }); engine.Host.NamespaceImports.Add("System"); engine.Host.NamespaceImports.Add("System.Linq"); engine.Host.NamespaceImports.Add("System.Collections.Generic"); GeneratorResults results; using (TextReader rdr = new StreamReader(file.CreateReadStream())) { results = engine.GenerateCode(rdr, className, "RazorCompiled", file.PhysicalPath ?? file.Name); } var messages = new List<CompilationMessage>(); if (!results.Success) { foreach (var error in results.ParserErrors) { messages.Add(new CompilationMessage( MessageLevel.Error, error.Message, new FileLocation(file.PhysicalPath ?? file.Name, error.Location.LineIndex, error.Location.CharacterIndex))); } } // Regardless of success or failure, we're going to try and compile return Task.FromResult(CompileCSharp("RazorCompiled." + className, file, results.Success, messages, results.GeneratedCode)); }
public static Assembly GenerateAssemblyFromTemplate(string template) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultNamespace = "Federation.MailService", DefaultBaseClass = typeof(MailMessageTemplate).FullName }; var engine = new RazorTemplateEngine(host); var generatedCode = engine.GenerateCode(new StringReader(template), "MailMessageRazorTemplate", "Federation.MailService", "MailMessageTemplate.cs"); var currentAssemblyLocation = typeof(MailMessageTemplate).Assembly.CodeBase.Replace("file:///", string.Empty).Replace("/", "\\"); var modelsAssemblyLocation = typeof(MailRecord).Assembly.CodeBase.Replace("file:///", string.Empty).Replace("/", "\\"); List<string> refer = new List<string> { "mscorlib.dll", "system.dll", "system.core.dll", "microsoft.csharp.dll", "system.configuration.dll", "system.data.linq.dll", "system.data.dll", currentAssemblyLocation, modelsAssemblyLocation }; var codeProvider = new CSharpCodeProvider(); var compilerParameters = new CompilerParameters(refer.ToArray()) { GenerateInMemory = true, CompilerOptions = "/optimize" }; var compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, generatedCode.GeneratedCode); if (compilerResults.Errors.HasErrors) { var compileExceptionMessage = string.Join("\n", compilerResults.Errors.OfType<CompilerError>().Where(ce => !ce.IsWarning).Select(e => "ERROR in " + e.Line + ": " + e.ErrorText).ToArray()); throw new InvalidOperationException(compileExceptionMessage); } return compilerResults.CompiledAssembly; }
public static string GenerateCodeWithAspNetRazorViewEngine(string razorTemplatePath) { //-- Configure the code-generator var host = new MvcWebPageRazorHost("/", razorTemplatePath); //-- Parse the template into a CodeDOM graph (see http://msdn.microsoft.com/en-us/library/y2k85ax6(v=vs.110).aspx for an overview of what CodeDOM is) var engine = new RazorTemplateEngine(host); GeneratorResults results; using (var reader = new StringReader(File.ReadAllText(razorTemplatePath))) { results = engine.GenerateCode(reader); } //-- Generate C# code from the CodeDOM graph var builder = new StringBuilder(); using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) { new CSharpCodeProvider().GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions()); return builder.ToString(); } }
public CompilationResults Compile(string template) { Host.DefaultClassName = "Template"; Host.DefaultNamespace = "__CompiledTemplates"; RazorTemplateEngine engine = new RazorTemplateEngine(Host); GeneratorResults generatorResults; using (TextReader reader = new StringReader(template)) { generatorResults = engine.GenerateCode(reader); } if (!generatorResults.Success) { return new CompilationResults(generatorResults, new List<CompilerError>()); } // Compile the code to a temporary assembly CodeDomProvider provider = Activator.CreateInstance(_language.CodeDomProviderType) as CodeDomProvider; if (provider == null) { throw new InvalidCastException(String.Format("Unable to convert '{0}' to a CodeDomProvider", _language.CodeDomProviderType.FullName)); } var compilerResults = provider.CompileAssemblyFromDom(new CompilerParameters(new [] { typeof(TemplateBase).Assembly.Location }), generatorResults.GeneratedCode); if (compilerResults.Errors.HasErrors) { return new CompilationResults(generatorResults, compilerResults.Errors.Cast<CompilerError>().ToList()); } var type = compilerResults.CompiledAssembly.GetType("__CompiledTemplates.Template"); if (type == null) { throw new MissingMemberException("Unable to find compiled template in assembly"); } TemplateBase compiled = Activator.CreateInstance(type) as TemplateBase; if (compiled == null) { throw new InvalidCastException("Unable to convert template to TemplateBase"); } return new CompilationResults(generatorResults, compiled); }
public GeneratorResults Generate() { lock (this) { _codeTransformer.Initialize(this, _directives); // Create the engine var engine = new RazorTemplateEngine(this); // Generate code GeneratorResults results = null; try { using (var stream = File.OpenRead()) { var reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true); results = engine.GenerateCode(reader, className: DefaultClassName, rootNamespace: DefaultNamespace, sourceFileName: this.File.RealPath); } } catch (Exception e) { throw new HttpParseException(e.Message, e, this.File.VirtualPath, null, 1); } //Throw the first parser message to generate the YSOD //TODO: Is there a way to output all errors at once? if (results.ParserErrors.Count > 0) { var error = results.ParserErrors[0]; throw new HttpParseException(error.Message, null, this.File.VirtualPath, null, error.Location.LineIndex + 1); } return results; } }
private Func<INancyRazorView> GetCompiledViewFactory(TextReader reader, Type passedModelType, ViewLocationResult viewLocationResult) { var engine = new RazorTemplateEngine(this.viewRenderer.Host); var razorResult = engine.GenerateCode(reader, null, null, "roo"); var viewFactory = this.GenerateRazorViewFactory(this.viewRenderer, razorResult, passedModelType, viewLocationResult); return viewFactory; }
public Type PrepareView(TextReader viewText, string viewFileName) { var currrentCount = Interlocked.Increment(ref _count); var className = "_view" + currrentCount.ToString(CultureInfo.InvariantCulture); RazorTemplateEngine razor = new RazorTemplateEngine(_host); var parseResult = razor.GenerateCode(viewText, className, "MiniMVC._generated", viewFileName); if (!parseResult.Success) { throw new ViewCompilerException(parseResult.ParserErrors, viewFileName); } var codeProvider = new CSharpCodeProvider(); var compilerParams = new CompilerParameters(new string[] { System.Reflection.Assembly.GetExecutingAssembly().Location, typeof(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException).Assembly.Location, typeof(System.Runtime.CompilerServices.CallSite).Assembly.Location, }); compilerParams.GenerateInMemory = true; var code = new StringWriter(); codeProvider.GenerateCodeFromCompileUnit(parseResult.GeneratedCode, code, new CodeGeneratorOptions()); System.Diagnostics.Debug.Write(code.ToString()); var compileResult = codeProvider.CompileAssemblyFromDom(compilerParams, parseResult.GeneratedCode); if (compileResult.Errors.HasErrors) { throw new ViewCompilerException(compileResult.Errors, viewFileName); } return compileResult.CompiledAssembly.GetType("MiniMVC._generated." + className); }
private static string GenerateCodeFromRazorTemplate(WebPageRazorHost host, string virtualPath) { // create Razor engine and use it to generate a CodeCompileUnit var engine = new RazorTemplateEngine(host); var file = HostingEnvironment.VirtualPathProvider.GetFile(virtualPath); // load the source (eg cshtml) code string code; using (var stream = file.Open()) using (TextReader reader = new StreamReader(stream)) code = reader.ReadToEnd(); // generate the target (C#) code ITextBuffer textBuffer = new SeekableTextReader(code); var results = engine.GenerateCode(textBuffer, null, null, virtualPath); if (!results.Success) ThrowExceptionFromParserError(virtualPath, code, results.ParserErrors.Last()); // use CodeDom to generate source code from the CodeCompileUnit var codeDomProvider = new CSharpCodeProvider(); var srcFileWriter = new StringWriter(); codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, srcFileWriter, new CodeGeneratorOptions()); return srcFileWriter.ToString(); }
/// <summary> /// Gets the generator result. /// </summary> /// <param name="host">The razor engine host.</param> /// <param name="template">The template.</param> /// <returns>The generator result.</returns> private static GeneratorResults GetGeneratorResult(RazorEngineHost host, string template) { var engine = new RazorTemplateEngine(host); GeneratorResults result; using (var reader = new StringReader(template)) //for VB, GenerateCode output "#ExternalSource(XX,XX)" //http://msdn.microsoft.com/en-us/library/szc67b5s(v=vs.120).aspx result = engine.GenerateCode(reader, null, null, host.DefaultClassName + "." + host.CodeLanguage.LanguageName); return result; }
static void Main(string[] args) { string templatebasename = "RazorEngine.Templating.TemplateBase"; var namespaces = new List<string>(); if (args.Length > 0) { templatebasename = args[0]; } for (int i = 1; i < args.Length; i++ ) { namespaces.Add(args[i]); } var filecount = 0; // for each .cshtml file under the working directory, generate a .cs file if it has changed. foreach (var templatepath in Directory.EnumerateFiles(Environment.CurrentDirectory, "*.cshtml", SearchOption.AllDirectories)) { FileInfo fitemplate = new FileInfo(templatepath); FileInfo ficode = new FileInfo(templatepath + ".cs"); if (!ficode.Exists || ficode.LastWriteTimeUtc < fitemplate.LastWriteTimeUtc) { // get classname from path var cn = fitemplate.Name.Substring(0, fitemplate.Name.IndexOf('.')); var pt = fitemplate.DirectoryName.Split(new char[] { Path.DirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries); var ns = pt[pt.Length - 1]; for (var i = pt.Length - 2; i > 0; i--) { ns = pt[i] + "." + ns; if (pt[i + 1] == "Views") break; } var prp = fitemplate.FullName.Substring(fitemplate.FullName.IndexOf(@"\Views\")).Replace('\\', '/'); string template = File.ReadAllText(fitemplate.FullName); var host = new WebPageRazorHost("~" + prp, fitemplate.FullName); //new RazorEngineHost(new CSharpRazorCodeLanguage()); //new WebCodeRazorHost("~"+prp, fitemplate.FullName); var rte = new RazorTemplateEngine(host); //Razor.SetTemplateBaseType(typeof(TemplateBase<>)); string baseTypeName = templatebasename; if (template.StartsWith("@model")) { var l1 = template.IndexOf("\n"); var modelTypeName = template.Substring(6, l1 - 6).Trim(); template = template.Substring(l1).Trim(); baseTypeName = templatebasename + "<" + modelTypeName + ">"; } //else if (cn == "_ViewStart") //{ // baseTypeName = "System.Web.WebPages.StartPage"; //} else { baseTypeName = templatebasename + "<dynamic>"; } //host.DefaultNamespace = ""; host.DefaultPageBaseClass = baseTypeName; host.NamespaceImports.Add("System.Web.Mvc"); host.NamespaceImports.Add("System.Web.Mvc.Html"); //string result = //Razor.ParseToCode(template, null, cn, baseTypeName, ns); GeneratorResults results = null; using (var reader = new StringReader(template)) { results = rte.GenerateCode(reader, cn, ns, null); } StringBuilder builder = new StringBuilder(); builder.AppendLine("using System.Web.Mvc;"); builder.AppendLine("using System.Web.Mvc.Html;"); builder.AppendLine("using System.Web.Mvc.Ajax;"); foreach (var v in namespaces) { builder.AppendLine("using "+v+";"); } using (var writer = new StringWriter(builder)) { new CSharpCodeProvider().GenerateCodeFromCompileUnit(results.GeneratedCode, writer, null); } builder.Replace("#line hidden", "#line 1 \"" + fitemplate.Name + "\""); File.WriteAllText(ficode.FullName, builder.ToString()); Console.WriteLine("Updated {0}.{1}", ns, cn); filecount++; } } Console.WriteLine("Done - updated {0} files", filecount); Console.ReadLine(); }
public static string GenerateCodeWithRazorEngine(string razorTemplatePath, Type modelType) { //-- Configure the code-generator var host = new RazorEngineHost(new RazorEngine.Compilation.CSharp.CSharpRazorCodeLanguage(true), () => new HtmlMarkupParser()) { DefaultBaseTemplateType = typeof(TemplateBase<>), DefaultModelType = modelType, DefaultBaseClass = typeof(TemplateBase<>).FullName, DefaultClassName = "RazorViewGeneratedByRazorEngine", DefaultNamespace = "CompiledRazorTemplates.Dynamic", GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", "RazorEngine.Templating.TemplateWriter", "DefineSection") { ResolveUrlMethodName = "ResolveUrl" } }; //-- Parse the template into a CodeDOM graph (see http://msdn.microsoft.com/en-us/library/y2k85ax6(v=vs.110).aspx for an overview of what CodeDOM is) var engine = new RazorTemplateEngine(host); GeneratorResults result; using (var reader = new StringReader(File.ReadAllText(razorTemplatePath))) { result = engine.GenerateCode(reader); } //-- Generate C# code from the CodeDOM graph var builder = new StringBuilder(); using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) { new CSharpCodeProvider().GenerateCodeFromCompileUnit(result.GeneratedCode, writer, new CodeGeneratorOptions()); return builder.ToString(); } }
private GeneratorResults ParseChange(ITextBuffer buffer, CancellationToken token) { EnsureOnThread(); // Create a template engine RazorTemplateEngine engine = new RazorTemplateEngine(_host); // Seek the buffer to the beginning buffer.Position = 0; try { return engine.GenerateCode( input: buffer, className: null, rootNamespace: null, sourceFileName: _fileName, cancelToken: token); } catch (OperationCanceledException) { return null; } }
private void EnsureGeneratedCode() { if (_generatedCode == null) { RazorTemplateEngine engine = new RazorTemplateEngine(Host); GeneratorResults results = null; using (TextReader reader = InternalOpenReader()) { results = engine.GenerateCode(reader, className: null, rootNamespace: null, sourceFileName: Host.PhysicalPath); } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), VirtualPath); } _generatedCode = results.GeneratedCode; // Run the code gen complete event OnCodeGenerationCompleted(_generatedCode); } }
private static GeneratorResults GenerateCode(RazorTemplateEntry entry, Type baseType) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = baseType.FullName; host.DefaultNamespace = "TeamConfig.Razor.Template"; host.DefaultClassName = entry.TemplateName + "Template"; host.NamespaceImports.Add("System"); //filter out page directives and add them as namespace string templateString = entry.TemplateString; foreach (Match match in PageDirectivePattern.Matches(templateString)) { string usedNamespace = match.Groups["Namespace"].Value; templateString = templateString.Replace(match.Value, string.Empty); if (usedNamespace.StartsWith("using")) { host.NamespaceImports.Add(usedNamespace); } } GeneratorResults razorResult = null; using (TextReader reader = new StringReader(templateString)) { var templateEngine = new RazorTemplateEngine(host); razorResult = templateEngine.GenerateCode(reader); } return razorResult; }
private Func<INancyRazorView> GetCompiledViewFactory(string extension, TextReader reader, Assembly referencingAssembly, Type passedModelType, ViewLocationResult viewLocationResult) { var renderer = this.viewRenderers.First(x => x.Extension.Equals(extension, StringComparison.OrdinalIgnoreCase)); var engine = new RazorTemplateEngine(renderer.Host); var razorResult = engine.GenerateCode(reader, null, null, "roo"); var viewFactory = this.GenerateRazorViewFactory(renderer, razorResult, referencingAssembly, passedModelType, viewLocationResult); return viewFactory; }
/// <summary> /// Gets the generator result. /// </summary> /// <param name="host">The razor engine host.</param> /// <param name="template">The template.</param> /// <returns>The generator result.</returns> private static GeneratorResults GetGeneratorResult(RazorEngineHost host, string template) { var engine = new RazorTemplateEngine(host); GeneratorResults result; using (var reader = new StringReader(template)) result = engine.GenerateCode(reader); return result; }
private IEnumerable<CodeCompileUnit> GenerateCode(IEnumerable<string> resourceNames) { Log.Debug(() => string.Format("Generating code for resources: {0}", string.Join("; ", resourceNames.ToArray()))); var codeCompileUnits = new List<CodeCompileUnit>(); foreach (var resourceName in resourceNames) { var host = new EmbeddedTemplateHost(Assembly, resourceName); var engine = new RazorTemplateEngine(host); var generatorResults = engine.GenerateCode(host.GetEmbeddedResource()); codeCompileUnits.Add(generatorResults.GeneratedCode); } return codeCompileUnits; }
private GeneratorResults RunRazorGenerator(string virtualPath, WebPageRazorHost host) { var file = HostingEnvironment.VirtualPathProvider.GetFile(virtualPath); var engine = new RazorTemplateEngine(host); using (var viewStream = file.Open()) using (var viewReader = new StreamReader(viewStream)) { var razorResult = engine.GenerateCode(viewReader, className: null, rootNamespace: null, sourceFileName: host.PhysicalPath); if (!razorResult.Success) { throw CreateExceptionFromParserError(razorResult.ParserErrors.Last(), virtualPath); } OnCodeGenerationCompleted(razorResult.GeneratedCode, host); return razorResult; } }
public string GenerateCode (out CompilerErrorCollection errors) { errors = new CompilerErrorCollection (); // Create the engine RazorTemplateEngine engine = new RazorTemplateEngine(this); // Generate code GeneratorResults results = null; try { Stream stream = File.OpenRead(_fullPath); using (var reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true)) { results = engine.GenerateCode(reader, className: DefaultClassName, rootNamespace: DefaultNamespace, sourceFileName: _fullPath); } } catch (Exception e) { errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ())); //Returning null signifies that generation has failed return null; } // Output errors foreach (RazorError error in results.ParserErrors) { errors.Add (new CompilerError (FullPath, error.Location.LineIndex + 1, error.Location.CharacterIndex + 1, null, error.Message)); } try { using (StringWriter writer = new StringWriter()) { //Generate the code writer.WriteLine("#pragma warning disable 1591"); _codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, _codeGeneratorOptions); writer.WriteLine("#pragma warning restore 1591"); return writer.ToString(); } } catch (Exception e) { errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ())); //Returning null signifies that generation has failed return null; } }
/// <summary> /// Function that builds the contents of the generated file based on the contents of the input file /// </summary> /// <param name="inputFileContent">Content of the input file</param> /// <returns>Generated file as a byte array</returns> protected override byte[] GenerateCode(string inputFileContent) { var references = GetVSProject().References; // Add reference to our buildprovider and virtualpathprovider /* var buildprovAssembly = typeof(CompiledVirtualPathProvider).Assembly; if (references.Find(buildprovAssembly.GetName().Name) == null) { references.Add(buildprovAssembly.Location); } */ // Get the root folder of the project var appRoot = Path.GetDirectoryName(GetProject().FullName); // Determine the project-relative path string projectRelativePath = InputFilePath.Substring(appRoot.Length); // Turn it into a virtual path by prepending ~ and fixing it up string virtualPath = VirtualPathUtility.ToAppRelative("~" + projectRelativePath); var vdm = new VirtualDirectoryMapping(appRoot, true); var wcfm = new WebConfigurationFileMap(); wcfm.VirtualDirectories.Add("/", vdm); var config = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, projectRelativePath); var sectGroup = new RazorWebSectionGroup { Host = (HostSection) config.GetSection(HostSection.SectionName) ?? new HostSection {FactoryType = typeof (MvcWebRazorHostFactory).AssemblyQualifiedName}, Pages = (RazorPagesSection) config.GetSection(RazorPagesSection.SectionName) }; // Create the same type of Razor host that's used to process Razor files in App_Code var host = IsHelper ? new WebCodeRazorHost(virtualPath, InputFilePath) : WebRazorHostFactory.CreateHostFromConfig(sectGroup, virtualPath, InputFilePath); // Set the namespace to be the same as what's used by default for regular .cs files host.DefaultNamespace = FileNameSpace; host.NamespaceImports.Remove("WebMatrix.Data"); host.NamespaceImports.Remove("WebMatrix.WebData"); var systemWebPages = config.GetSection("system.web/pages") as PagesSection; if (systemWebPages != null) { foreach (NamespaceInfo ns in systemWebPages.Namespaces) { if (!host.NamespaceImports.Contains(ns.Namespace)) { host.NamespaceImports.Add(ns.Namespace); } } } var compilationSection = config.GetSection("system.web/compilation") as CompilationSection; if (compilationSection != null) { foreach (AssemblyInfo assembly in compilationSection.Assemblies) { if (assembly.Assembly != "*" && references.Find(assembly.Assembly) == null) { references.Add(assembly.Assembly); } } } // Create a Razor engine and pass it our host var engine = new RazorTemplateEngine(host); // Generate code GeneratorResults results; try { using (TextReader reader = new StringReader(inputFileContent)) { results = engine.GenerateCode(reader,null,null,InputFilePath); } } catch (Exception e) { GeneratorError(4, e.ToString(), 1, 1); return RazorError; } // Output errors foreach (RazorError error in results.ParserErrors) { GeneratorError(4, error.Message, (uint)error.Location.LineIndex + 1, (uint)error.Location.CharacterIndex + 1); } CodeDomProvider provider = GetCodeProvider(); try { if (CodeGeneratorProgress != null) { // Report that we are 1/2 done CodeGeneratorProgress.Progress(50, 100); } using (StringWriter writer = new StringWriter(new StringBuilder())) { CodeGeneratorOptions options = new CodeGeneratorOptions { BlankLinesBetweenMembers = false, BracingStyle = "C" }; // Add a GeneratedCode attribute to the generated class CodeCompileUnit generatedCode = results.GeneratedCode; var ns = generatedCode.Namespaces[0]; CodeTypeDeclaration generatedType = ns.Types[0]; generatedType.CustomAttributes.Add( new CodeAttributeDeclaration( new CodeTypeReference(typeof(GeneratedCodeAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression("RazorViewCompiler")), new CodeAttributeArgument(new CodePrimitiveExpression("1.0")))); if(!IsHelper) { generatedType.CustomAttributes.Add( new CodeAttributeDeclaration( new CodeTypeReference(typeof(PageVirtualPathAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(virtualPath)))); } // Generate the code provider.GenerateCodeFromCompileUnit(generatedCode, writer, options); if (CodeGeneratorProgress != null) { //Report that we are done CodeGeneratorProgress.Progress(100, 100); } writer.Flush(); // Save as UTF8 Encoding enc = Encoding.UTF8; // Get the preamble (byte-order mark) for our encoding byte[] preamble = enc.GetPreamble(); int preambleLength = preamble.Length; // Convert the writer contents to a byte array byte[] body = enc.GetBytes(writer.ToString()); // Prepend the preamble to body (store result in resized preamble array) Array.Resize<byte>(ref preamble, preambleLength + body.Length); Array.Copy(body, 0, preamble, preambleLength, body.Length); // Return the combined byte array return preamble; } } catch (Exception e) { GeneratorError(4, e.ToString(), 1, 1); return RazorError; } }