Precompile razor views

src/Microsoft.AspNet.Mvc.Razor.Host/IMvcRazorHost.cs

@@ -9,5 +9,15 @@ namespace Microsoft.AspNet.Mvc.Razor
     public interface IMvcRazorHost
     {
         GeneratorResults GenerateCode(string rootRelativePath, Stream inputStream);
+
+        /// <summary>
+        /// Represent the prefix off the main entry class in the view.
+        /// </summary>
+        string MainClassNamePrefix { get; }
+
+        /// <summary>
+        /// Represent the namespace the main entry class in the view.
+        /// </summary>
+        string DefaultNamespace { get; }
     }
 }

src/Microsoft.AspNet.Mvc.Razor.Host/MvcRazorHost.cs

@@ -58,7 +58,6 @@ public MvcRazorHost(IApplicationEnvironment appEnvironment)
         public MvcRazorHost(string root) :
             this(new PhysicalFileSystem(root))
         {
-
         }
 #endif
 
@@ -101,6 +100,12 @@ public virtual string DefaultModel
             get { return "dynamic"; }
         }
 
+        /// <inheritdoc />
+        public string MainClassNamePrefix
+        {
+            get { return "ASPV_"; }
+        }
+
         /// <summary>
         /// Gets the list of chunks that are injected by default by this host.
         /// </summary>
@@ -121,7 +126,8 @@ public virtual string ActivateAttribute
         /// <inheritdoc />
         public GeneratorResults GenerateCode(string rootRelativePath, Stream inputStream)
         {
-            var className = ParserHelpers.SanitizeClassName(rootRelativePath);
+            // Adding a prefix so that the main view class can be easily identified.
+            var className = MainClassNamePrefix + ParserHelpers.SanitizeClassName(rootRelativePath);
             using (var reader = new StreamReader(inputStream))
             {
                 var engine = new RazorTemplateEngine(this);

src/Microsoft.AspNet.Mvc.Razor/Compilation/CompilationResult.cs

@@ -120,7 +120,7 @@ private static string ReadContent(IFileInfo file)
                     }
                 }
             }
-            catch (IOException)
+            catch (Exception)
             {
                 // Don't throw if reading the file fails.
                 return string.Empty;

src/Microsoft.AspNet.Mvc.Razor/Compilation/CompilerCache.cs

@@ -3,34 +3,110 @@
 
 using System;
 using System.Collections.Concurrent;
-using Microsoft.AspNet.FileSystems;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 
 namespace Microsoft.AspNet.Mvc.Razor
 {
     public class CompilerCache
     {
-        private readonly ConcurrentDictionary<string, Type> _cache;
+        private readonly ConcurrentDictionary<string, CompilerCacheEntry> _cache;
+        private static readonly Type[] EmptyType = new Type[0];
 
-        public CompilerCache()
+        public CompilerCache([NotNull] IEnumerable<Assembly> assemblies)
+            : this(GetFileInfos(assemblies))
         {
-            _cache = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
         }
 
-        public CompilationResult GetOrAdd(IFileInfo file, Func<CompilationResult> compile)
+        internal CompilerCache(IEnumerable<RazorFileInfoCollection> viewCollections) : this()
         {
-            // Generate a content id
-            var contentId = file.PhysicalPath + '|' + file.LastModified.Ticks;
+            foreach (var viewCollection in viewCollections)
+            {
+                foreach (var fileInfo in viewCollection.FileInfos)
+                {
+                    var containingAssembly = viewCollection.GetType().GetTypeInfo().Assembly;
+                    var viewType = containingAssembly.GetType(fileInfo.FullTypeName);
+                    var cacheEntry = new CompilerCacheEntry(fileInfo, viewType);
+
+                    // There shouldn't be any duplicates and if there are any the first will win.
+                    // If the result doesn't match the one on disk its going to recompile anyways.
+                    _cache.TryAdd(fileInfo.RelativePath, cacheEntry);
+                }
+            }
+        }
+
+        internal CompilerCache()
+        {
+            _cache = new ConcurrentDictionary<string, CompilerCacheEntry>(StringComparer.OrdinalIgnoreCase);
+        }
 
-            Type compiledType;
-            if (!_cache.TryGetValue(contentId, out compiledType))
+        internal static IEnumerable<RazorFileInfoCollection>
+                            GetFileInfos(IEnumerable<Assembly> assemblies)
+        {
+            return assemblies.SelectMany(a => a.ExportedTypes)
+                    .Where(Match)
+                    .Select(c => (RazorFileInfoCollection)Activator.CreateInstance(c));
+        }
+
+        private static bool Match(Type t)
+        {
+            var inAssemblyType = typeof(RazorFileInfoCollection);
+            if (inAssemblyType.IsAssignableFrom(t))
             {
-                var result = compile();
-                _cache.TryAdd(contentId, result.CompiledType);
+                var hasParameterlessConstructor = t.GetConstructor(EmptyType) != null;
 
-                return result;
+                return hasParameterlessConstructor
+                    && !t.GetTypeInfo().IsAbstract
+                    && !t.GetTypeInfo().ContainsGenericParameters;
             }
 
-            return CompilationResult.Successful(compiledType);
+            return false;
+        }
+
+        public CompilationResult GetOrAdd(RelativeFileInfo fileInfo, Func<CompilationResult> compile)
+        {
+            if (!_cache.TryGetValue(fileInfo.RelativePath, out var cacheEntry))
+            {
+                return OnCacheMiss(fileInfo, compile);
+            }
+            else
+            {
+                if (cacheEntry.Length != fileInfo.FileInfo.Length)
+                {
+                    // it's not a match, recompile
+                    return OnCacheMiss(fileInfo, compile);
+                }
+
+                if (cacheEntry.LastModified == fileInfo.FileInfo.LastModified)
+                {
+                    // Match, not update needed
+                    return CompilationResult.Successful(cacheEntry.ViewType);
+                }
+
+                var hash = RazorFileHash.GetHash(fileInfo.FileInfo);
+
+                // Timestamp doesn't match but it might be because of deployment, compare the hash.
+                if (cacheEntry.IsPreCompiled &&
+                    string.Equals(cacheEntry.Hash, hash, StringComparison.Ordinal))
+                {
+                    // Cache hit, but we need to update the entry
+                    return OnCacheMiss(fileInfo, () => CompilationResult.Successful(cacheEntry.ViewType));
+                }
+
+                // it's not a match, recompile
+                return OnCacheMiss(fileInfo, compile);
+            }
+        }
+
+        private CompilationResult OnCacheMiss(RelativeFileInfo file, Func<CompilationResult> compile)
+        {
+            var result = compile();
+
+            var cacheEntry = new CompilerCacheEntry(file, result.CompiledType);
+            _cache.AddOrUpdate(file.RelativePath, cacheEntry, (a, b) => cacheEntry);
+
+            return result;
         }
     }
 }

src/Microsoft.AspNet.Mvc.Razor/Compilation/CompilerCacheEntry.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNet.Mvc.Razor
+{
+    public class CompilerCacheEntry
+    {
+        public CompilerCacheEntry([NotNull] RazorFileInfo info, [NotNull] Type viewType)
+        {
+            ViewType = viewType;
+            RelativePath = info.RelativePath;
+            Length = info.Length;
+            LastModified = info.LastModified;
+            Hash = info.Hash;
+        }
+
+        public CompilerCacheEntry([NotNull] RelativeFileInfo info, [NotNull] Type viewType)
+        {
+            ViewType = viewType;
+            RelativePath = info.RelativePath;
+            Length = info.FileInfo.Length;
+            LastModified = info.FileInfo.LastModified;
+        }
+
+        public Type ViewType { get; set; }
+        public string RelativePath { get; set; }
+        public long Length { get; set; }
+        public DateTime LastModified { get; set; }
+
+        /// <summary>
+        /// The file hash, should only be available for pre compiled files.
+        /// </summary>
+        public string Hash { get; set; }
+
+        public bool IsPreCompiled {  get { return Hash != null; } }
+    }
+}

src/Microsoft.AspNet.Mvc.Razor/Compilation/RoslynCompilationService.cs

@@ -7,12 +7,10 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using System.Text;
 using Microsoft.AspNet.FileSystems;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Emit;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.Framework.Runtime;
 
 namespace Microsoft.AspNet.Mvc.Razor.Compilation
@@ -31,27 +29,31 @@ public class RoslynCompilationService : ICompilationService
 
         private readonly Lazy<List<MetadataReference>> _applicationReferences;
 
+        private readonly string _classPrefix;
+
         /// <summary>
         /// Initalizes a new instance of the <see cref="RoslynCompilationService"/> class.
         /// </summary>
         /// <param name="environment">The environment for the executing application.</param>
         /// <param name="loaderEngine">The loader used to load compiled assemblies.</param>
         /// <param name="libraryManager">The library manager that provides export and reference information.</param>
+        /// <param name="host">The <see cref="IMvcRazorHost"/> that was used to generate the code.</param>
         public RoslynCompilationService(IApplicationEnvironment environment,
                                         IAssemblyLoaderEngine loaderEngine,
-                                        ILibraryManager libraryManager)
+                                        ILibraryManager libraryManager,
+                                        IMvcRazorHost host)
         {
             _environment = environment;
             _loader = loaderEngine;
             _libraryManager = libraryManager;
             _applicationReferences = new Lazy<List<MetadataReference>>(GetApplicationReferences);
+            _classPrefix = host.MainClassNamePrefix;
         }
 
         /// <inheritdoc />
         public CompilationResult Compile(IFileInfo fileInfo, string compilationContent)
         {
-            var sourceText = SourceText.From(compilationContent, Encoding.UTF8);
-            var syntaxTrees = new[] { CSharpSyntaxTree.ParseText(sourceText, path: fileInfo.PhysicalPath) };
+            var syntaxTrees = new[] { SyntaxTreeGenerator.Generate(compilationContent, fileInfo.PhysicalPath) };
 
             var references = _applicationReferences.Value;
 
@@ -103,9 +105,10 @@ public CompilationResult Compile(IFileInfo fileInfo, string compilationContent)
                     }
 
                     var type = assembly.GetExportedTypes()
-                                       .First();
+                                       .First(t => t.Name.
+                                          StartsWith(_classPrefix, StringComparison.Ordinal));
 
-                    return UncachedCompilationResult.Successful(type, compilationContent);
+                    return UncachedCompilationResult.Successful(type);
                 }
             }
         }

src/Microsoft.AspNet.Mvc.Razor/Compilation/SyntaxTreeGenerator.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.AspNet.Mvc.Razor
+{
+    public static class SyntaxTreeGenerator
+    {
+        private static CSharpParseOptions DefaultOptions
+        {
+            get
+            {
+                return CSharpParseOptions.Default
+                        .WithLanguageVersion(LanguageVersion.CSharp6);
+            }
+        }
+
+        public static SyntaxTree Generate([NotNull] string text, [NotNull] string path)
+        {
+            return GenerateCore(text, path, DefaultOptions);
+        }
+
+        public static SyntaxTree Generate([NotNull] string text,
+                                          [NotNull] string path,
+                                          [NotNull] CSharpParseOptions options)
+        {
+            return GenerateCore(text, path, options);
+        }
+
+        public static SyntaxTree GenerateCore([NotNull] string text,
+                                              [NotNull] string path,
+                                              [NotNull] CSharpParseOptions options)
+        {
+            var sourceText = SourceText.From(text, Encoding.UTF8);
+            var syntaxTree = CSharpSyntaxTree.ParseText(sourceText,
+                path: path,
+                options: options);
+
+            return syntaxTree;
+        }
+
+        public static CSharpParseOptions GetParseOptions(CSharpCompilation compilation)
+        {
+            return CSharpParseOptions.Default
+                              .WithLanguageVersion(compilation.LanguageVersion);
+        }
+    }
+}

src/Microsoft.AspNet.Mvc.Razor/Compilation/UncachedCompilationResult.cs

@@ -14,6 +14,8 @@ private UncachedCompilationResult()
         {
         }
 
+        public string RazorFileContent { get; private set; }
+
         /// <summary>
         /// Creates a <see cref="UncachedCompilationResult"/> that represents a success in compilation.
         /// </summary>

src/Microsoft.AspNet.Mvc.Razor/IRazorPageFactory.cs

@@ -11,8 +11,8 @@ public interface IRazorPageFactory
         /// <summary>
         /// Creates a <see cref="IRazorPage"/> for the specified path.
         /// </summary>
-        /// <param name="path">The path to locate the page.</param>
+        /// <param name="relativePath">The path to locate the page.</param>
         /// <returns>The IRazorPage instance if it exists, null otherwise.</returns>
-        IRazorPage CreateInstance(string path);
+        IRazorPage CreateInstance(string relativePath);
     }
 }

src/Microsoft.AspNet.Mvc.Razor/Razor/IRazorCompilationService.cs

@@ -1,12 +1,10 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using Microsoft.AspNet.FileSystems;
-
 namespace Microsoft.AspNet.Mvc.Razor
 {
     public interface IRazorCompilationService
     {
-        CompilationResult Compile(IFileInfo fileInfo);
+        CompilationResult Compile(RelativeFileInfo fileInfo);
     }
 }