Create a pre compilation module and apis to allow meta programming

to precompile razor pages.

This is limited to sites where the .cshtml are still deployed. It's
current purpose is to speed up startup. Deploying without the razor
files is a separate feature.

Author: YishaiGalatzer

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,102 @@
 
 using System;
 using System.Collections.Concurrent;
-using Microsoft.AspNet.FileSystems;
+using System.Linq;
+using System.Reflection;
 
 namespace Microsoft.AspNet.Mvc.Razor
 {
     public class CompilerCache
     {
-        private readonly ConcurrentDictionary<string, Type> _cache;
+        public static bool DebugBreak { get; set; }
+        private readonly ConcurrentDictionary<string, CompilerCacheEntry> _cache;
+        private static readonly Type[] EmptyType = new Type[0];
 
-        public CompilerCache()
+        internal CompilerCache()
         {
-            _cache = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
+            _cache = new ConcurrentDictionary<string, CompilerCacheEntry>(StringComparer.OrdinalIgnoreCase);
         }
 
-        public CompilationResult GetOrAdd(IFileInfo file, Func<CompilationResult> compile)
+        public CompilerCache([NotNull] IControllerAssemblyProvider _controllerAssemblyProvider)
+            : this()
         {
-            // Generate a content id
-            var contentId = file.PhysicalPath + '|' + file.LastModified.Ticks;
+            var assemblies = _controllerAssemblyProvider.CandidateAssemblies;
+            var types = assemblies.SelectMany(a => a.ExportedTypes);
+            var preCompiledCollections =
+                types
+                .Where(Match);
 
-            Type compiledType;
-            if (!_cache.TryGetValue(contentId, out compiledType))
+            foreach (var collectionType in preCompiledCollections)
             {
-                var result = compile();
-                _cache.TryAdd(contentId, result.CompiledType);
+                var preCompiledCollection = Activator.CreateInstance(collectionType)
+                                                    as ViewDescriptorCollection;
 
-                return result;
+                foreach (var fileInfo in preCompiledCollection.FileInfos)
+                {
+                    var containingAssembly = collectionType.GetTypeInfo().Assembly;
+                    var viewType = containingAssembly.GetType(fileInfo.FullTypeName);
+                    var cacheEntry = new CompilerCacheEntry(fileInfo, viewType);
+
+                    _cache.AddOrUpdate(fileInfo.RelativePath, cacheEntry, (a, b) => cacheEntry);
+                }
             }
+        }
+
+        private static bool Match(Type t)
+        {
+            var b = t.GetConstructor(EmptyType) != null;
+
+            var inAssemblyType = typeof(ViewDescriptorCollection);
+            var c = inAssemblyType.IsAssignableFrom(t);
+
+            return b && c
+                && !t.GetTypeInfo().IsAbstract
+                && !t.GetTypeInfo().ContainsGenericParameters;
+        }
+
+        public CompilationResult GetOrAdd(RelativeFileInfo fileInfo, Func<CompilationResult> compile)
+        {
+            CompilerCacheEntry cacheEntry;
+
+            if (!_cache.TryGetValue(fileInfo.RelativePath, out cacheEntry))
+            {
+                return OnCacheMiss(fileInfo, compile);
+            }
+            else
+            {
+                if (cacheEntry.Length != fileInfo.FileInfo.Length)
+                {
+                    // it's not a match, recompile
+                    return OnCacheMiss(fileInfo, compile);
+                }
+
+                if (cacheEntry.RuntimeTimeStamp == fileInfo.FileInfo.LastModified)
+                {
+                    // Match, not update needed
+                    return CompilationResult.Successful(cacheEntry.ViewType);
+                }
+
+                if (cacheEntry.CompiledTimeStamp == fileInfo.FileInfo.LastModified ||
+                    // Date doesn't match but it might be because of deployment, compare the hash
+                    cacheEntry.Hash == RazorFileHash.GetHash(fileInfo.FileInfo))
+                {
+                    // 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, null);
+            _cache.AddOrUpdate(file.RelativePath, cacheEntry, (a, b) => cacheEntry);
 
-            return CompilationResult.Successful(compiledType);
+            return result;
         }
     }
 }

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

@@ -0,0 +1,36 @@
+// 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;
+            CompiledTimeStamp = info.LastModified;
+            Hash = info.Hash;
+        }
+
+        public CompilerCacheEntry([NotNull] RelativeFileInfo info, [NotNull] Type viewType, string hash)
+        {
+            ViewType = viewType;
+            RelativePath = info.RelativePath;
+            Length = info.FileInfo.Length;
+            CompiledTimeStamp = info.FileInfo.LastModified;
+            RuntimeTimeStamp = info.FileInfo.LastModified;
+            Hash = hash;
+        }
+
+        public Type ViewType { get; set; }
+        public string RelativePath { get; set; }
+        public long Length { get; set; }
+        public DateTime CompiledTimeStamp { get; set; }
+        public DateTime? RuntimeTimeStamp { get; set; }
+        public string Hash { get; set; }
+    }
+}

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

@@ -31,27 +31,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) };
 
             var references = _applicationReferences.Value;
 
@@ -103,9 +107,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,59 @@
+// 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.AspNet.FileSystems;
+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] IFileInfo fileInfo)
+        {
+            return GenerateCore(text, fileInfo.PhysicalPath, DefaultOptions);
+        }
+
+        public static SyntaxTree Generate([NotNull] string text,
+                                          [NotNull] IFileInfo fileInfo,
+                                          [NotNull] CSharpParseOptions options)
+        {
+            return GenerateCore(text, fileInfo.PhysicalPath, options);
+        }
+
+        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;
+        }
+    }
+}

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/Razor/PreCompileViews/ParseOptions.cs

@@ -0,0 +1,16 @@
+// 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.CodeAnalysis.CSharp;
+
+namespace Microsoft.AspNet.Mvc.Razor
+{
+    internal static class ParseOptions
+    {
+	    public static CSharpParseOptions GetParseOptions(CSharpCompilation compilation)
+	    {
+            return CSharpParseOptions.Default
+                              .WithLanguageVersion(compilation.LanguageVersion);
+        }
+    }
+}

src/Microsoft.AspNet.Mvc.Razor/Razor/PreCompileViews/RazorFileInfo.cs

@@ -0,0 +1,35 @@
+// 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 RazorFileInfo
+    {
+        /// <summary>
+        /// Type name including namespace.
+        /// </summary>
+        public string FullTypeName { get; set; }
+
+        /// <summary>
+        /// Last modified at compilation time.
+        /// </summary>
+        public DateTime LastModified { get; set; }
+
+        /// <summary>
+        /// The length of the file in bytes.
+        /// </summary>
+        public long Length { get; set; }
+
+        /// <summary>
+        /// Path to to the file relative to the application base.
+        /// </summary>
+        public string RelativePath { get; set; }
+
+        /// <summary>
+        /// A hash of the file content.
+        /// </summary>
+        public string Hash { get; set; }
+    }
+}