public IEnumerable<CompilerReference> GetReferences(TypeContext context, IEnumerable<CompilerReference> includeAssemblies) { #region 加载依赖程序集 此处是加载所有程序集,效率需要改进 return compilerReference; #endregion }
/// <summary> /// Compiles the type defined in the specified type context. /// </summary> /// <param name="context">The type context which defines the type to compile.</param> /// <returns>The compiled type.</returns> public override Type CompileType(TypeContext context) { var results = Compile(context); if (results.Errors != null && results.Errors.Count > 0) throw new TemplateCompilationException(results.Errors); return results.CompiledAssembly.GetType("CompiledRazorTemplates.Dynamic." + context.ClassName); }
/// <summary> /// Inspects the GeneratorResults and returns the source code. /// </summary> /// <param name="results"></param> /// <param name="context"></param> /// <returns></returns> public override string InspectSource(GeneratorResults results, TypeContext context) { string generatedCode; var builder = new StringBuilder(); using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) { _codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions()); generatedCode = builder.ToString(); } return generatedCode; }
public IEnumerable<CompilerReference> GetReferences(TypeContext context, IEnumerable<CompilerReference> includeAssemblies = null) { var setupAssemblies = new List<CompilerReference>(); var binPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var needAssemblies = Load().Select(_ => Assembly.LoadFile(Path.Combine(binPath, _.Name))).Select(_ => CompilerReference.From(_.Location)).ToArray(); setupAssemblies.AddRange(needAssemblies); var loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()).GetReferences(context, includeAssemblies); setupAssemblies.AddRange(loadedAssemblies); return setupAssemblies.Distinct(); }
public override string CompileTypeAndReturnSource(TypeContext context) { if (context == null) throw new ArgumentNullException("context"); var result = Compile(context); var compileResult = result.Item1; if (compileResult.Errors != null && compileResult.Errors.Count > 0) throw new TemplateCompilationException(compileResult.Errors, result.Item2, context.TemplateContent); return result.Item2; }
public override Tuple<Type, Assembly> CompileType(TypeContext context) { if (context == null) throw new ArgumentNullException("context"); var results = Compile(context); if (results.Errors != null && results.Errors.Count > 0) throw new TemplateCompilationException(results.Errors); return Tuple.Create( results.CompiledAssembly.GetType("CompiledRazorTemplates.Dynamic." + context.ClassName), results.CompiledAssembly); }
public IEnumerable<CompilerReference> GetReferences(TypeContext context, IEnumerable<CompilerReference> includeAssemblies) { // TypeContext gives you some context for the compilation (which templates, which namespaces and types) // My templates need some special reference to compile. return new[] { //CompilerReference.From("Path-to-my-custom-assembly"), // file path (string) CompilerReference.From(typeof (SystemConfig).Assembly), CompilerReference.From(typeof (Config).Assembly), CompilerReference.From(typeof (MongoConnectionConfig).Assembly) // Assembly //CompilerReference.From(assemblyInByteArray), // byte array (roslyn only) //CompilerReference.From(File.OpenRead(assembly)), // stream (roslyn only) }; }
public override Tuple<Type, CompilationData> CompileType(TypeContext context) { if (context == null) throw new ArgumentNullException("context"); (new PermissionSet(PermissionState.Unrestricted)).Assert(); var isMono = Type.GetType("Mono.Runtime") != null; if (!isMono) { return CompileType_Windows(context); } else { return CompileTypeImpl(context); } }
private Tuple<CompilerResults, string> Compile(TypeContext context) { if (_disposed) throw new ObjectDisposedException(GetType().Name); var compileUnit = GetCodeCompileUnit(context.ClassName, context.TemplateContent, context.Namespaces, context.TemplateType, context.ModelType); var @params = new CompilerParameters { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/target:library /optimize" }; var assemblies = CompilerServicesUtility .GetLoadedAssemblies() .Where(a => !a.IsDynamic && File.Exists(a.Location)) .GroupBy(a => a.GetName().Name).Select(grp => grp.First(y => y.GetName().Version == grp.Max(x => x.GetName().Version))) // only select distinct assemblies based on FullName to avoid loading duplicate assemblies .Select(a => a.Location); var includeAssemblies = (IncludeAssemblies() ?? Enumerable.Empty<string>()); assemblies = assemblies.Concat(includeAssemblies) .Where(a => !string.IsNullOrWhiteSpace(a)) .Distinct(StringComparer.InvariantCultureIgnoreCase); @params.ReferencedAssemblies.AddRange(assemblies.ToArray()); string sourceCode = null; if (Debug) { var builder = new StringBuilder(); using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) { _codeDomProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions()); sourceCode = builder.ToString(); } } return Tuple.Create(_codeDomProvider.CompileAssemblyFromDom(@params, compileUnit), sourceCode); }
public override Tuple<Type, CompilationData> CompileType(TypeContext context) { if (context == null) throw new ArgumentNullException("context"); (new PermissionSet(PermissionState.Unrestricted)).Assert(); var result = Compile(context); var compileResult = result.Item1; CompilationData tmpDir; if (compileResult.TempFiles != null) { tmpDir = new CompilationData(result.Item2, compileResult.TempFiles.TempDir); } else { tmpDir = new CompilationData(result.Item2, null); } if (compileResult.Errors != null && compileResult.Errors.HasErrors) { throw new TemplateCompilationException( compileResult.Errors .Cast<CompilerError>() .Select(error => new RazorEngineCompilerError( error.ErrorText, error.FileName, error.Line, error.Column, error.ErrorNumber, error.IsWarning)), tmpDir, context.TemplateContent); } // Make sure we load the assembly from a file and not with // Load(byte[]) (or it will be fully trusted!) var assemblyPath = compileResult.PathToAssembly; compileResult.CompiledAssembly = Assembly.LoadFile(assemblyPath); var type = compileResult.CompiledAssembly.GetType(DynamicTemplateNamespace + "." + context.ClassName); return Tuple.Create(type, tmpDir); }
/// <summary> /// Creates the compile results for the specified <see cref="TypeContext"/>. /// </summary> /// <param name="context">The type context.</param> /// <returns>The compiler results.</returns> private CompilerResults Compile(TypeContext context) { var compileUnit = GetCodeCompileUnit(context.ClassName, context.TemplateContent, context.Namespaces, context.TemplateType, context.ModelType); var @params = new CompilerParameters { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/target:library /optimize" }; var assemblies = CompilerServices .GetLoadedAssemblies() .Where(a => !a.IsDynamic) .Select(a => a.Location) .ToArray(); @params.ReferencedAssemblies.AddRange(assemblies); return CodeDomProvider.CompileAssemblyFromDom(@params, compileUnit); }
public IEnumerable<CompilerReference> GetReferences(TypeContext context, IEnumerable<CompilerReference> includeAssemblies) { // TypeContext gives you some context for the compilation (which templates, which namespaces and types) // You must make sure to include all libraries that are required! // Mono compiler does add more standard references than csc! // If you want mono compatibility include ALL references here, including mscorlib! // If you include mscorlib here the compiler is called with /nostdlib. IEnumerable<string> loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()) .GetReferences(context, includeAssemblies) .Select(r => r.GetFile()) .ToArray(); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "mscorlib.dll")); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "System.dll")); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "System.Core.dll")); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "System.Web.Razor.dll")); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "Microsoft.CSharp.dll")); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "RazorEngine.dll")); yield return CompilerReference.From(FindLoaded(loadedAssemblies, "RazorTransformLibary.dll")); yield return CompilerReference.From(typeof(MyIReferenceResolver).Assembly); // Assembly if (Directory.Exists(DllFolder)) { var fileDllList = Directory.GetFiles(DllFolder, "*.dll"); foreach (var dllPath in fileDllList) { var file = Path.GetFullPath(dllPath); yield return CompilerReference.From(file); } } // There are several ways to load an assembly: //yield return CompilerReference.From("Path-to-my-custom-assembly"); // file path (string) //byte[] assemblyInByteArray = --- Load your assembly ---; //yield return CompilerReference.From(assemblyInByteArray); // byte array (roslyn only) //string assemblyFile = --- Get the path to the assembly ---; //yield return CompilerReference.From(File.OpenRead(assemblyFile)); // stream (roslyn only) }
public string GetCodeCompileUnit(string className, ITemplateSource template, ISet<string> namespaceImports, Type templateType, Type modelType) { var typeContext = new TypeContext(className, namespaceImports) { TemplateContent = template, TemplateType = templateType, ModelType = modelType }; return GetCodeCompileUnit(typeContext); }
public abstract Tuple<Type, CompilationData> CompileType(TypeContext context);
/// <summary> /// Compiles the type defined in the specified type context. /// </summary> /// <param name="context">The type context which defines the type to compile.</param> /// <returns>The compiled type.</returns> public abstract Type CompileType(TypeContext context);
public abstract string CompileTypeAndReturnSource(TypeContext context);
private Tuple<CompilerResults, string> Compile(TypeContext context) { if (_disposed) throw new ObjectDisposedException(GetType().Name); var compileUnit = GetCodeCompileUnit(context.ClassName, context.TemplateContent, context.Namespaces, context.TemplateType, context.ModelType); Inspect(compileUnit); var @params = new CompilerParameters { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/target:library /optimize" }; var assemblies = CompilerServicesUtility .GetLoadedAssemblies() .Where(a => !a.IsDynamic) .Select(a => a.Location); var includeAssemblies = (IncludeAssemblies() ?? Enumerable.Empty<string>()); assemblies = assemblies.Concat(includeAssemblies) .Select(a => a.ToUpperInvariant()) .Where(a => !string.IsNullOrWhiteSpace(a)) .Distinct(); @params.ReferencedAssemblies.AddRange(assemblies.ToArray()); string sourceCode = null; if (Debug) { var builder = new StringBuilder(); using (var writer = new StringWriter(builder)) { _codeDomProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions()); sourceCode = builder.ToString(); } } return Tuple.Create(_codeDomProvider.CompileAssemblyFromDom(@params, compileUnit), sourceCode); }
public virtual string InspectSource(GeneratorResults results, TypeContext context) { return results.GeneratedCode; }
/// <summary> /// Helper method to generate the prefered assembly name. /// </summary> /// <param name="context">the context of the current compilation.</param> /// <returns></returns> protected string GetAssemblyName(TypeContext context) { return String.Format("{0}.{1}", DynamicTemplateNamespace, context.ClassName); }
/// <summary> /// Creates a CSharpCompilationOptions instance. /// </summary> /// <param name="context"></param> /// <returns></returns> public override CompilationOptions CreateOptions(TypeContext context) { return new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithUsings(context.Namespaces); }
/// <summary> /// Helper method to generate the prefered assembly name. /// </summary> /// <param name="context">the context of the current compilation.</param> /// <returns></returns> protected string GetAssemblyName(TypeContext context) { return(String.Format("{0}.{1}", DynamicTemplateNamespace, context.ClassName)); }
public virtual string InspectSource(GeneratorResults results, TypeContext context) { return(results.GeneratedCode); }
public abstract string InspectSource(GeneratorResults results, TypeContext context);
public string GetCodeCompileUnit(TypeContext context) { string className = context.ClassName; ITemplateSource template = context.TemplateContent; ISet<string> namespaceImports = context.Namespaces; Type templateType = context.TemplateType; Type modelType = context.ModelType; if (string.IsNullOrEmpty(className)) throw new ArgumentException("Class name is required."); if (template == null) throw new ArgumentException("Template is required."); namespaceImports = namespaceImports ?? new HashSet<string>(); templateType = templateType ?? ((modelType == null) ? typeof(TemplateBase) : typeof(TemplateBase<>)); // Create the RazorEngineHost var host = CreateHost(templateType, modelType, className); // Add any required namespace imports foreach (string ns in GetNamespaces(templateType, namespaceImports)) host.NamespaceImports.Add(ns); // Gets the generator result. return GetGeneratorResult(host, context); }
public abstract Tuple <Type, CompilationData> CompileType(TypeContext context);
/// <summary> /// Helper method to get all references for the given compilation. /// </summary> /// <param name="context"></param> /// <returns></returns> protected IEnumerable<CompilerReference> GetAllReferences(TypeContext context) { #pragma warning disable 0618 // Backwards Compat. var references = ReferenceResolver.GetReferences( context, IncludeAssemblies() .Select(RazorEngine.Compilation.ReferenceResolver.CompilerReference.From) .Concat(IncludeReferences())) #pragma warning restore 0618 // Backwards Compat. .ToList(); context.AddReferences(references); return references; }
private Tuple<CompilerResults, string> Compile(TypeContext context) { if (_disposed) throw new ObjectDisposedException(GetType().Name); var sourceCode = GetCodeCompileUnit(context); var assemblies = GetAllReferences(context); var fileAssemblies = assemblies .Select(a => a.GetFile( msg => new ArgumentException( string.Format( "Unsupported CompilerReference given to CodeDom compiler (only references which can be resolved to files are supported: {0})!", msg)))) .Where(a => !string.IsNullOrWhiteSpace(a)) .Distinct(StringComparer.InvariantCultureIgnoreCase) .ToArray(); var haveMscorlib = fileAssemblies.Any(a => a.Contains("mscorlib.dll")); var @params = new CompilerParameters { GenerateInMemory = false, GenerateExecutable = false, IncludeDebugInformation = Debug, TreatWarningsAsErrors = false, TempFiles = new TempFileCollection(GetTemporaryDirectory(), true), CompilerOptions = string.Format("/target:library /optimize /define:RAZORENGINE {0}", haveMscorlib ? "/nostdlib" : "") }; @params.ReferencedAssemblies.AddRange(fileAssemblies); var tempDir = @params.TempFiles.TempDir; var assemblyName = Path.Combine(tempDir, String.Format("{0}.dll", GetAssemblyName(context))); @params.TempFiles.AddFile(assemblyName, true); @params.OutputAssembly = assemblyName; var results = _codeDomProvider.CompileAssemblyFromSource(@params, new [] { sourceCode }); if (Debug) { bool written = false; var targetFile = Path.Combine(results.TempFiles.TempDir, "generated_template." + SourceFileExtension); if (!written && !File.Exists(targetFile)) { File.WriteAllText(targetFile, sourceCode); written = true; } if (!written) { foreach (string item in results.TempFiles) { if (item.EndsWith("." + this.SourceFileExtension)) { File.Copy(item, targetFile, true); written = true; break; } } } } return Tuple.Create(results, sourceCode); }
private string GetGeneratorResult(RazorEngineHost host, TypeContext context) { var engine = new RazorTemplateEngine(host); GeneratorResults result; using (var reader = context.TemplateContent.GetTemplateReader()) result = engine.GenerateCode(reader, null, null, context.TemplateContent.TemplateFile); return InspectSource(result, context); }
private Tuple<Type, CompilationData> CompileTypeImpl(TypeContext context) { var result = Compile(context); var compileResult = result.Item1; CompilationData tmpDir; if (compileResult.TempFiles != null) { tmpDir = new CompilationData(result.Item2, compileResult.TempFiles.TempDir); } else { tmpDir = new CompilationData(result.Item2, null); } if (compileResult.Errors != null && compileResult.Errors.HasErrors) { throw new TemplateCompilationException( compileResult.Errors .Cast<CompilerError>() .Select(error => new RazorEngineCompilerError( error.ErrorText, error.FileName, error.Line, error.Column, error.ErrorNumber, error.IsWarning)), tmpDir, context.TemplateContent); } // Make sure we load the assembly from a file and not with // Load(byte[]) (or it will be fully trusted!) var assemblyPath = compileResult.PathToAssembly; if (DisableTempFileLocking) { compileResult.CompiledAssembly = Assembly.Load(File.ReadAllBytes(assemblyPath)); } else { compileResult.CompiledAssembly = Assembly.LoadFile(assemblyPath); } var type = compileResult.CompiledAssembly.GetType(DynamicTemplateNamespace + "." + context.ClassName); if (type == null) { try { compileResult.CompiledAssembly.GetTypes(); } catch (Exception e) { throw new TemplateLoadingException("Unable to load types of the laded assembly", e); } // if we are here we just throw throw new TemplateLoadingException("We could not find the type in the compiled assembly!"); } return Tuple.Create(type, tmpDir); }
private Tuple<Type, CompilationData> CompileType_Windows(TypeContext context) { // NOTE: The static constructor of WindowsImpersonationContext can fail, // that's why we need to do that in a seperate method // -> Static constructor will not run /* Exception details: (2015-01-23: https://travis-ci.org/Antaris/RazorEngine/builds/47985319) System.Security.SecurityException : Couldn't impersonate token. at System.Security.Principal.WindowsImpersonationContext..ctor (IntPtr token) [0x00000] in <filename unknown>:0 at System.Security.Principal.WindowsIdentity.Impersonate (IntPtr userToken) [0x00000] in <filename unknown>:0 at RazorEngine.Compilation.DirectCompilerServiceBase.CompileType (RazorEngine.Compilation.TypeContext context) [0x00033] in /home/travis/build/Antaris/RazorEngine/src/source/RazorEngine.Core/Compilation/DirectCompilerServiceBase.cs:276 */ WindowsImpersonationContext wic = WindowsIdentity.Impersonate(IntPtr.Zero); try { return CompileTypeImpl(context); } finally { wic.Undo(); } }
/// <summary> /// Compiles the type defined in the specified type context. /// </summary> /// <param name="context">The type context which defines the type to compile.</param> /// <returns>The compiled type.</returns> public abstract Tuple<Type, Assembly> CompileType(TypeContext context);
/// <summary> /// Compiles the type defined in the specified type context. /// </summary> /// <param name="context">The type context which defines the type to compile.</param> /// <returns>The compiled type.</returns> public abstract Tuple <Type, Assembly> CompileType(TypeContext context);
public IEnumerable<CompilerReference> GetReferences( TypeContext context, IEnumerable<CompilerReference> includeAssemblies = null ) { // We need to return this standard set or even simple views blow up on // a missing reference to System.Linq. var loadedAssemblies = (new UseCurrentAssembliesReferenceResolver()).GetReferences(null); foreach (var reference in loadedAssemblies) yield return reference; yield return CompilerReference.From("test/TestHelper.dll"); }
private Tuple <CompilerResults, string> Compile(TypeContext context) { if (_disposed) { throw new ObjectDisposedException(GetType().Name); } var sourceCode = GetCodeCompileUnit(context); var assemblies = GetAllReferences(context); var fileAssemblies = assemblies .Select(a => a.GetFile( msg => new ArgumentException( string.Format( "Unsupported CompilerReference given to CodeDom compiler (only references which can be resolved to files are supported: {0})!", msg)))) .Where(a => !string.IsNullOrWhiteSpace(a)) .Distinct(StringComparer.InvariantCultureIgnoreCase) .ToArray(); var haveMscorlib = fileAssemblies.Any(a => a.Contains("mscorlib.dll")); var @params = new CompilerParameters { GenerateInMemory = false, GenerateExecutable = false, IncludeDebugInformation = Debug, TreatWarningsAsErrors = false, TempFiles = new TempFileCollection(GetTemporaryDirectory(), true), CompilerOptions = string.Format("/target:library /optimize /define:RAZORENGINE {0}", haveMscorlib ? "/nostdlib" : "") }; @params.ReferencedAssemblies.AddRange(fileAssemblies); var tempDir = @params.TempFiles.TempDir; var assemblyName = Path.Combine(tempDir, String.Format("{0}.dll", GetAssemblyName(context))); @params.TempFiles.AddFile(assemblyName, true); @params.OutputAssembly = assemblyName; var results = _codeDomProvider.CompileAssemblyFromSource(@params, new [] { sourceCode }); if (Debug) { bool written = false; var targetFile = Path.Combine(results.TempFiles.TempDir, "generated_template." + SourceFileExtension); if (!written && !File.Exists(targetFile)) { File.WriteAllText(targetFile, sourceCode); written = true; } if (!written) { foreach (string item in results.TempFiles) { if (item.EndsWith("." + this.SourceFileExtension)) { File.Copy(item, targetFile, true); written = true; break; } } } } return(Tuple.Create(results, sourceCode)); }
public override string InspectSource(GeneratorResults results, TypeContext context) { #if RAZOR4 string generatedCode = results.GeneratedCode; if (context.TemplateContent.TemplateFile == null) { generatedCode = generatedCode.Replace("#line hidden", ""); } // TODO: add attributes and constructor to the source code. return generatedCode; #else if (context.TemplateContent.TemplateFile == null) { // Allow to step into the template code by removing the "#line hidden" pragmas foreach (CodeNamespace @namespace in results.GeneratedCode.Namespaces.Cast<CodeNamespace>().ToList()) { foreach (CodeTypeDeclaration @type in @namespace.Types.Cast<CodeTypeDeclaration>().ToList()) { foreach (CodeTypeMember member in @type.Members.Cast<CodeTypeMember>().ToList()) { var snippet = member as CodeSnippetTypeMember; if (snippet != null && snippet.Text.Contains("#line hidden")) { snippet.Text = snippet.Text.Replace("#line hidden", ""); } } } } } // Add the dynamic model attribute if the type is an anonymous type. var generatedType = results.GeneratedCode.Namespaces[0].Types[0]; if (context.ModelType != null && CompilerServicesUtility.IsDynamicType(context.ModelType)) generatedType.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(HasDynamicModelAttribute)))); // Generate any constructors required by the base template type. GenerateConstructors(CompilerServicesUtility.GetConstructors(context.TemplateType), generatedType); #pragma warning disable 0618 // Backwards Compat. // Despatch any inspectors Inspect(results.GeneratedCode); #pragma warning restore 0618 // Backwards Compat. string generatedCode; var builder = new StringBuilder(); using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) { CodeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions()); generatedCode = builder.ToString(); } return generatedCode; #endif }
private string GetGeneratorResult(IEnumerable <string> namespaces, TypeContext context) { #pragma warning disable 612, 618 // HERE is where we create our razor engine var razorEngine = RazorEngine.Create(builder => { builder .SetNamespace(DynamicTemplateNamespace) //.SetBaseType("Microsoft.Extensions.RazorViews.BaseView") .SetBaseType(BuildTypeName(context.TemplateType, context.ModelType)) .ConfigureClass((document, @class) => { @class.ClassName = context.ClassName; //if (!str ing.IsNullOrWhiteSpace(document.Source.FilePath)) //{ // @class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath); //} @class.Modifiers.Clear(); @class.Modifiers.Add("internal"); }); SectionDirective.Register(builder); builder.Features.Add(new SuppressChecksumOptionsFeature()); }); string importString = @" @using System @using System.Threading.Tasks "; importString += String.Join("\r\n", namespaces.Select(n => "@using " + n.Trim())) + "\r\n"; using (var reader = context.TemplateContent.GetTemplateReader()) { string path = null; if (string.IsNullOrWhiteSpace(context.TemplateContent.TemplateFile)) { path = Directory.GetCurrentDirectory(); } else { path = Path.GetDirectoryName(context.TemplateContent.TemplateFile); } var razorProject = RazorProjectFileSystem.Create(path); var templateEngine = new RazorTemplateEngine(razorEngine, razorProject); templateEngine.Options.DefaultImports = RazorSourceDocument.Create(importString, fileName: null); RazorPageGeneratorResult result; if (string.IsNullOrWhiteSpace(context.TemplateContent.TemplateFile)) { var item = RazorSourceDocument.Create(context.TemplateContent.Template, string.Empty); var imports = new List <RazorSourceDocument>(); imports.Add(templateEngine.Options.DefaultImports); var doc = RazorCodeDocument.Create(item, imports); result = GenerateCodeFile(templateEngine, doc); } else { var item = razorProject.GetItem(context.TemplateContent.TemplateFile); result = GenerateCodeFile(templateEngine, item); } return(InspectSource(result, context)); } }