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