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); }
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 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 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; } }
private static string GenerateCodeFromRazorString(WebPageRazorHost host, string razorString, string virtualPath) { // Create Razor engine and use it to generate a CodeCompileUnit var engine = new RazorTemplateEngine(host); GeneratorResults results = null; using (StringReader reader = new StringReader(razorString)) { 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 using (var codeDomProvider = new CSharpCodeProvider()) { using (var srcFileWriter = new StringWriter()) { codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, srcFileWriter, new CodeGeneratorOptions()); return srcFileWriter.ToString(); } } }
void ReadHtmlSpans(string html) { RazorEngineHost razorEngineHost = new RazorEngineHost(codeLanguage); RazorTemplateEngine engine = new RazorTemplateEngine(razorEngineHost); ParserResults results = engine.ParseTemplate(new StringReader(html)); spans = new List<Span>(results.Document.Flatten()); spans.RemoveAll(span => span.Kind != SpanKind.Markup); }
void ReadBlockSpans(string markup) { var razorEngineHost = new RazorEngineHost(codeLanguage); var engine = new RazorTemplateEngine(razorEngineHost); var results = engine.ParseTemplate(new StringReader(markup)); spans = new List<Span>(results.Document.Flatten()); spans.RemoveAll(span => !span.IsBlock); }
private static RazorTemplateEngine CreateRazorTemplateEngine() { var language = new CSharpRazorCodeLanguage(); var host = new SimpleRazorEngineHost(language); var engine = new RazorTemplateEngine(host); return engine; }
public TemplateFactory(RazorContext razorContext) { if (razorContext == null) throw new ArgumentNullException("razorContext"); _razorContext = razorContext; _razorEngine = new RazorTemplateEngine(new XiptonEngineHost(razorContext.Config)); ContentManager = new ContentManager(razorContext.Config); ContentManager.ContentProvider.ContentModified += OnContentModified; ContentManager.SharedContentModified += OnSharedContentModified; }
} public interface IViewParser { IEnumerable<Span> Parse(string viewFile); } }
internal void Parse(TextReader razorTemplate, TextWriter output) { RazorEngineHost host = new RazorEngineHost(new CSharpRazorCodeLanguage()); RazorTemplateEngine engine = new RazorTemplateEngine(host); ParserResults result = engine.ParseTemplate(razorTemplate); if (!result.Success) { ThrowParserError(result); } WriteTemplateFunction(result.Document, output); }
public virtual void RenderClientTemplate(TextReader razorTemplate, TextWriter output) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); var engine = new RazorTemplateEngine(host); var parserResults = engine.ParseTemplate(razorTemplate); if(parserResults.Success == false) // TODO: Less suck throw new RazorClientTemplateException("Template parse exception"); RenderClientTemplate(parserResults.Document, output); }
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); } } }
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; }
// Returns an instance of the razor template, compiled from the file stored as an embedded resource. // The first time this method is executed, the Razor template is compiled and stored. // This method will throw an InvalidDataException if the template contains syntax errors. public TemplateBase CreateRazorTemplateInstance() { if (templateType == null) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = typeof(TemplateBase).FullName; host.DefaultNamespace = "RazorOutput"; host.DefaultClassName = "Template"; host.NamespaceImports.Add("System"); GeneratorResults razorResult = null; var templateStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Curtsy.Resources.curtsy.cshtml"); if (templateStream == null) throw new FileNotFoundException("Could not find embedded resource 'Curtsy.Resources.curtsy.cshtml'"); using (var reader = new StreamReader(templateStream)) { razorResult = new RazorTemplateEngine(host).GenerateCode(reader); } var compilerParams = new CompilerParameters { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/target:library /optimize" }; compilerParams.ReferencedAssemblies.Add(typeof(Program).Assembly.CodeBase.Replace("file:///", "").Replace('/', Path.DirectorySeparatorChar)); var codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); var results = codeProvider.CompileAssemblyFromDom(compilerParams, razorResult.GeneratedCode); if (results.Errors.HasErrors) { StringBuilder errors = new StringBuilder(); foreach (var err in results.Errors.OfType<CompilerError>().Where(ce => !ce.IsWarning)) errors.AppendFormat("Error compiling template: ({0}, {1}) {2}", err.Line, err.Column, err.ErrorText); throw new InvalidDataException(errors.ToString()); } templateType = results.CompiledAssembly.GetType("RazorOutput.Template"); } return (TemplateBase)Activator.CreateInstance(templateType); }
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); }
private static GeneratorResults GenerateCode(RazorTemplateEntry entry) { var host = new NodeRazorHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = string.Format("Http.Renderer.Razor.Integration.RazorTemplateBase<{0}>", TypeToString(entry.ModelType)); host.DefaultNamespace = "Http.Renderer.Razor.Integration"; host.DefaultClassName = entry.TemplateName + "Template"; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("System.Dynamic"); GeneratorResults razorResult = null; using (TextReader reader = new StringReader(entry.TemplateString)) { razorResult = new RazorTemplateEngine(host).GenerateCode(reader); } return razorResult; }
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 RazorTemplatesCompiler(string templatesNamespaceName, Type defaultTemplatesBaseClass) { _templatesNamespaceName = templatesNamespaceName; var razorHost = new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultBaseClass = defaultTemplatesBaseClass.Name, GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", null, "DefineSection") }; string[] namespaces = new[] { "System", "System.Collections.Generic", "System.Linq", "System.Text" }; foreach (var ns in namespaces) { razorHost.NamespaceImports.Add(ns); } _razorEngine = new RazorTemplateEngine(razorHost); string[] references = new[] { "System.Core.dll", "Microsoft.CSharp.dll" }; var assemblies = AppDomain.CurrentDomain.GetAssemblies(); _compilerParameters = new CompilerParameters(assemblies .Where(x => !x.IsDynamic) .Where(a => !references.Contains(a.ManifestModule.Name)) .Select(a => new Uri(a.CodeBase).LocalPath) .Distinct() .ToArray()) { GenerateInMemory = true }; _compilerParameters.ReferencedAssemblies.AddRange(references); }
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)); }
// Setup the Razor templating engine so that we can quickly pass the data in // and generate HTML. // // The file `Resources\Nocco.cshtml` is read and compiled into a new dll // with a type that extends the `TemplateBase` class. This new assembly is // loaded so that we can create an instance and pass data into it // and generate the HTML. private static Type SetupRazorTemplate() { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultBaseClass = typeof(TemplateBase).FullName, DefaultNamespace = "RazorOutput", DefaultClassName = "Template" }; host.NamespaceImports.Add("System"); var executingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); GeneratorResults razorResult; using (var reader = new StreamReader(Path.Combine(executingDirectory, "Resources", "Nocco.cshtml"))) { razorResult = new RazorTemplateEngine(host).GenerateCode(reader); } var compilerParams = new CompilerParameters { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/target:library /optimize" }; compilerParams.ReferencedAssemblies.Add(typeof(Nocco).Assembly.CodeBase.Replace("file:///", "").Replace("/", "\\")); var codeProvider = new CSharpCodeProvider(); var results = codeProvider.CompileAssemblyFromDom(compilerParams, razorResult.GeneratedCode); // Check for errors that may have occurred during template generation if (results.Errors.HasErrors) { foreach (var err in results.Errors.OfType<CompilerError>().Where(ce => !ce.IsWarning)) Console.WriteLine("Error Compiling Template: ({0}, {1}) {2}", err.Line, err.Column, err.ErrorText); } return results.CompiledAssembly.GetType("RazorOutput.Template"); }
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; }
private Assembly CompileAssembly(string templateContent) { var host = new RazorEngineHost(RazorCodeLanguage.GetLanguageByExtension("cshtml")); host.DefaultBaseClass = typeof(MacroView).FullName; host.NamespaceImports.Add("System.Web.Mvc"); host.NamespaceImports.Add("System.Web.Mvc.Ajax"); host.NamespaceImports.Add("System.Web.Mvc.Html"); host.NamespaceImports.Add("System.Net"); host.NamespaceImports.Add("System"); host.NamespaceImports.Add("System.Web.Routing"); host.NamespaceImports.Add("FunnelWeb.Model"); host.NamespaceImports.Add("FunnelWeb.Web.Application.Extensions"); host.NamespaceImports.Add("FunnelWeb.Web.Application.Mvc"); var eng = new RazorTemplateEngine(host); var res = eng.GenerateCode(new StringReader(templateContent), "TemplateInstance", "Generated", "TemplateInstance.cs"); var compiler = new CSharpCodeProvider(); var param = new CompilerParameters(); param.GenerateInMemory = true; param.ReferencedAssemblies.Add(typeof(MacroView).Assembly.Location); param.ReferencedAssemblies.Add(typeof(Microsoft.CSharp.RuntimeBinder.Binder).Assembly.Location); param.ReferencedAssemblies.Add(typeof(System.Runtime.CompilerServices.CallSite).Assembly.Location); foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { try { param.ReferencedAssemblies.Add(assembly.Location); } catch (NotSupportedException) { } } var results = compiler.CompileAssemblyFromDom(param, res.GeneratedCode); if (results.Errors.HasErrors) { throw new Exception("Error compiling template: " + results.Errors[0].ErrorText); } return results.CompiledAssembly; }
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 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 IEnumerable<Span> Parse(string viewFile) { RazorCodeLanguage language; switch (viewFile.FileExtension()) { case ".cshtml": language = new CSharpRazorCodeLanguage(true); break; case ".vbhtml": language = new VBRazorCodeLanguage(true); break; default: throw new ArgumentException("Invalid extension for Razor engine."); } using (var fileStream = new FileStream(viewFile, FileMode.Open, FileAccess.Read)) using (var reader = new StreamReader(fileStream)) { var engine = new RazorTemplateEngine(new RazorEngine.Compilation.RazorEngineHost(language, () => new HtmlMarkupParser())); var parseResults = engine.ParseTemplate(reader); return parseResults.Document.Flatten(); } }
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; } }