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;
}
}
