Added interfaces IRazorEngine, IRazorEngineCompilationOptionsBuilder, IRazorEngineCompiledTemplate, IRazorEngineCompiledTemplate<>, these are crucial for Unit Testing using mocking frameworks, i.e. Moq.

William David Cossey · William David Cossey · commit 5748e5f5a186 · 2020-06-03T20:11:33.000+01:00
diff --git a/ExampleApp/Program.cs b/ExampleApp/Program.cs
@@ -42,7 +42,7 @@ void RecursionTest(int level){
         static void Main(string[] args)
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = razorEngine.Compile(Content);
+            IRazorEngineCompiledTemplate template = razorEngine.Compile(Content);
 
             string result = template.Run(new
             {
diff --git a/RazorEngineCore.Tests/TestCompileAndRun.cs b/RazorEngineCore.Tests/TestCompileAndRun.cs
@@ -25,7 +25,7 @@ public Task TestCompileAsync()
         public void TestCompileAndRun_HtmlLiteral()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = razorEngine.Compile("<h1>Hello @Model.Name</h1>");
+            IRazorEngineCompiledTemplate template = razorEngine.Compile("<h1>Hello @Model.Name</h1>");
 
             string actual = template.Run(new
             {
@@ -39,7 +39,7 @@ public void TestCompileAndRun_HtmlLiteral()
         public async Task TestCompileAndRun_HtmlLiteralAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<h1>Hello @Model.Name</h1>");
+            IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<h1>Hello @Model.Name</h1>");
 
             string actual = await template.RunAsync(new
             {
@@ -53,7 +53,7 @@ public async Task TestCompileAndRun_HtmlLiteralAsync()
         public void TestCompileAndRun_InAttributeVariables()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = razorEngine.Compile("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%,   80%,1);\">");
+            IRazorEngineCompiledTemplate template = razorEngine.Compile("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%,   80%,1);\">");
 
             string actual = template.Run(new
             {
@@ -67,7 +67,7 @@ public void TestCompileAndRun_InAttributeVariables()
         public async Task TestCompileAndRun_InAttributeVariablesAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%,   80%,1);\">");
+            IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%,   80%,1);\">");
 
             string actual = await template.RunAsync(new
             {
@@ -81,7 +81,7 @@ public async Task TestCompileAndRun_InAttributeVariablesAsync()
         public void TestCompileAndRun_HtmlAttribute()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = razorEngine.Compile("<div title=\"@Model.Name\">Hello</div>");
+            IRazorEngineCompiledTemplate template = razorEngine.Compile("<div title=\"@Model.Name\">Hello</div>");
 
             string actual = template.Run(new
             {
@@ -95,7 +95,7 @@ public void TestCompileAndRun_HtmlAttribute()
         public async Task TestCompileAndRun_HtmlAttributeAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div title=\"@Model.Name\">Hello</div>");
+            IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div title=\"@Model.Name\">Hello</div>");
 
             string actual = await template.RunAsync(new
             {
@@ -109,7 +109,7 @@ public async Task TestCompileAndRun_HtmlAttributeAsync()
         public void TestCompileAndRun_DynamicModel_Plain()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name");
+            IRazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name");
 
             string actual = template.Run(new
             {
@@ -123,7 +123,7 @@ public void TestCompileAndRun_DynamicModel_Plain()
         public async Task TestCompileAndRun_DynamicModel_PlainAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("Hello @Model.Name");
+            IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("Hello @Model.Name");
 
             string actual = await template.RunAsync(new
             {
@@ -339,7 +339,7 @@ void RecursionTest(int level)
         public void TestCompileAndRun_TypedModel1()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate<TestModel1> template = razorEngine.Compile<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");
+            IRazorEngineCompiledTemplate<TestModel1> template = razorEngine.Compile<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");
 
             string actual = template.Run(instance =>
             {
@@ -355,7 +355,7 @@ public void TestCompileAndRun_TypedModel1()
         public async Task TestCompileAndRun_TypedModel1Async()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate<TestModel1> template = await razorEngine.CompileAsync<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");
+            IRazorEngineCompiledTemplate<TestModel1> template = await razorEngine.CompileAsync<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");
 
             string actual = await template.RunAsync(instance =>
             {
@@ -371,7 +371,7 @@ public async Task TestCompileAndRun_TypedModel1Async()
         public void TestCompileAndRun_TypedModel2()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>("Hello @Model.Decorator(Model.C)");
+            IRazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>("Hello @Model.Decorator(Model.C)");
 
             string actual = template.Run(instance =>
             {
@@ -388,7 +388,7 @@ public void TestCompileAndRun_TypedModel2()
         public async Task TestCompileAndRun_TypedModel2Async()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>("Hello @Model.Decorator(Model.C)");
+            IRazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>("Hello @Model.Decorator(Model.C)");
 
             string actual = await template.RunAsync(instance =>
             {
@@ -405,7 +405,7 @@ public async Task TestCompileAndRun_TypedModel2Async()
         public void TestCompileAndRun_Linq()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>(
+            IRazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>(
 @"
 @foreach (var item in Model.Numbers.OrderByDescending(x => x))
 {
@@ -432,7 +432,7 @@ public void TestCompileAndRun_Linq()
         public async Task TestCompileAndRun_LinqAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>(
+            IRazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>(
 @"
 @foreach (var item in Model.Numbers.OrderByDescending(x => x))
 {
diff --git a/RazorEngineCore.Tests/TestSaveLoad.cs b/RazorEngineCore.Tests/TestSaveLoad.cs
@@ -11,13 +11,13 @@ public class TestSaveLoad
         public void TestSaveToStream()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate initialTemplate = razorEngine.Compile("Hello @Model.Name");
+            IRazorEngineCompiledTemplate initialTemplate = razorEngine.Compile("Hello @Model.Name");
             
             MemoryStream memoryStream = new MemoryStream();
             initialTemplate.SaveToStream(memoryStream);
             memoryStream.Position = 0;
 
-            RazorEngineCompiledTemplate loadedTemplate = RazorEngineCompiledTemplate.LoadFromStream(memoryStream);
+            IRazorEngineCompiledTemplate loadedTemplate = RazorEngineCompiledTemplate.LoadFromStream(memoryStream);
 
             string initialTemplateResult = initialTemplate.Run(new { Name = "Alex" });
             string loadedTemplateResult = loadedTemplate.Run(new { Name = "Alex" });
@@ -29,13 +29,13 @@ public void TestSaveToStream()
         public async Task TestSaveToStreamAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate initialTemplate = await razorEngine.CompileAsync("Hello @Model.Name");
+            IRazorEngineCompiledTemplate initialTemplate = await razorEngine.CompileAsync("Hello @Model.Name");
             
             MemoryStream memoryStream = new MemoryStream();
             await initialTemplate.SaveToStreamAsync(memoryStream);
             memoryStream.Position = 0;
 
-            RazorEngineCompiledTemplate loadedTemplate = await RazorEngineCompiledTemplate.LoadFromStreamAsync(memoryStream);
+            IRazorEngineCompiledTemplate loadedTemplate = await RazorEngineCompiledTemplate.LoadFromStreamAsync(memoryStream);
 
             string initialTemplateResult = await initialTemplate.RunAsync(new { Name = "Alex" });
             string loadedTemplateResult = await loadedTemplate.RunAsync(new { Name = "Alex" });
@@ -47,11 +47,11 @@ public async Task TestSaveToStreamAsync()
         public void TestSaveToFile()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate initialTemplate = razorEngine.Compile("Hello @Model.Name");
+            IRazorEngineCompiledTemplate initialTemplate = razorEngine.Compile("Hello @Model.Name");
             
             initialTemplate.SaveToFile("testTemplate.dll");
 
-            RazorEngineCompiledTemplate loadedTemplate = RazorEngineCompiledTemplate.LoadFromFile("testTemplate.dll");
+            IRazorEngineCompiledTemplate loadedTemplate = RazorEngineCompiledTemplate.LoadFromFile("testTemplate.dll");
 
             string initialTemplateResult = initialTemplate.Run(new { Name = "Alex" });
             string loadedTemplateResult = loadedTemplate.Run(new { Name = "Alex" });
@@ -63,11 +63,11 @@ public void TestSaveToFile()
         public async Task TestSaveToFileAsync()
         {
             RazorEngine razorEngine = new RazorEngine();
-            RazorEngineCompiledTemplate initialTemplate = await razorEngine.CompileAsync("Hello @Model.Name");
+            IRazorEngineCompiledTemplate initialTemplate = await razorEngine.CompileAsync("Hello @Model.Name");
             
             await initialTemplate.SaveToFileAsync("testTemplate.dll");
 
-            RazorEngineCompiledTemplate loadedTemplate = await RazorEngineCompiledTemplate.LoadFromFileAsync("testTemplate.dll");
+            IRazorEngineCompiledTemplate loadedTemplate = await RazorEngineCompiledTemplate.LoadFromFileAsync("testTemplate.dll");
 
             string initialTemplateResult = await initialTemplate.RunAsync(new { Name = "Alex" });
             string loadedTemplateResult = await loadedTemplate.RunAsync(new { Name = "Alex" });
diff --git a/RazorEngineCore/IRazorEngine.cs b/RazorEngineCore/IRazorEngine.cs
@@ -0,0 +1,18 @@
+﻿using System;
+using System.Threading.Tasks;
+
+namespace RazorEngineCore
+{
+    public interface IRazorEngine
+    {
+        IRazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) 
+            where T : IRazorEngineTemplate;
+        
+        Task<IRazorEngineCompiledTemplate<T>> CompileAsync<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) 
+            where T : IRazorEngineTemplate;
+        
+        IRazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null);
+        
+        Task<IRazorEngineCompiledTemplate> CompileAsync(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null);
+    }
+}
diff --git a/RazorEngineCore/IRazorEngineCompilationOptionsBuilder.cs b/RazorEngineCore/IRazorEngineCompilationOptionsBuilder.cs
@@ -0,0 +1,20 @@
+﻿using System;
+using System.Reflection;
+
+namespace RazorEngineCore
+{
+    public interface IRazorEngineCompilationOptionsBuilder
+    {
+        RazorEngineCompilationOptions Options { get; set; }
+        
+        void AddAssemblyReferenceByName(string assemblyName);
+        
+        void AddAssemblyReference(Assembly assembly);
+        
+        void AddAssemblyReference(Type type);
+        
+        void AddUsing(string namespaceName);
+        
+        void Inherits(Type type);
+    }
+}
diff --git a/RazorEngineCore/IRazorEngineCompiledTemplate.cs b/RazorEngineCore/IRazorEngineCompiledTemplate.cs
@@ -0,0 +1,20 @@
+﻿using System.IO;
+using System.Threading.Tasks;
+
+namespace RazorEngineCore
+{
+    public interface IRazorEngineCompiledTemplate
+    {
+        void SaveToStream(Stream stream);
+        
+        Task SaveToStreamAsync(Stream stream);
+        
+        void SaveToFile(string fileName);
+        
+        Task SaveToFileAsync(string fileName);
+        
+        string Run(object model = null);
+        
+        Task<string> RunAsync(object model = null);
+    }
+}
diff --git a/RazorEngineCore/IRazorEngineCompiledTemplateT.cs b/RazorEngineCore/IRazorEngineCompiledTemplateT.cs
@@ -0,0 +1,22 @@
+﻿using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace RazorEngineCore
+{
+    public interface IRazorEngineCompiledTemplate<out T> 
+        where T : IRazorEngineTemplate
+    {
+        void SaveToStream(Stream stream);
+        
+        Task SaveToStreamAsync(Stream stream);
+        
+        void SaveToFile(string fileName);
+        
+        Task SaveToFileAsync(string fileName);
+        
+        string Run(Action<T> initializer);
+        
+        Task<string> RunAsync(Action<T> initializer);
+    }
+}
diff --git a/RazorEngineCore/RazorEngine.cs b/RazorEngineCore/RazorEngine.cs
@@ -11,9 +11,9 @@
 
 namespace RazorEngineCore
 {
-    public class RazorEngine
+    public class RazorEngine : IRazorEngine
     {
-        public RazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate
+        public IRazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate
         {
             RazorEngineCompilationOptionsBuilder compilationOptionsBuilder = new RazorEngineCompilationOptionsBuilder();
             
@@ -27,12 +27,12 @@ public RazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEng
             return new RazorEngineCompiledTemplate<T>(memoryStream);
         }
 
-        public Task<RazorEngineCompiledTemplate<T>> CompileAsync<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate
+        public Task<IRazorEngineCompiledTemplate<T>> CompileAsync<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate
         {
             return Task.Factory.StartNew(() => this.Compile<T>(content: content, builderAction: builderAction));
         }
 
-        public RazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)
+        public IRazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)
         {
             RazorEngineCompilationOptionsBuilder compilationOptionsBuilder = new RazorEngineCompilationOptionsBuilder();
             compilationOptionsBuilder.Inherits(typeof(RazorEngineTemplateBase));
@@ -44,7 +44,7 @@ public RazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCom
             return new RazorEngineCompiledTemplate(memoryStream);
         }
 
-        public Task<RazorEngineCompiledTemplate> CompileAsync(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)
+        public Task<IRazorEngineCompiledTemplate> CompileAsync(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)
         {
             return Task.Factory.StartNew(() => this.Compile(content: content, builderAction: builderAction));
         }
diff --git a/RazorEngineCore/RazorEngineCompilationOptionsBuilder.cs b/RazorEngineCore/RazorEngineCompilationOptionsBuilder.cs
@@ -4,7 +4,7 @@
 
 namespace RazorEngineCore
 {
-    public class RazorEngineCompilationOptionsBuilder
+    public class RazorEngineCompilationOptionsBuilder : IRazorEngineCompilationOptionsBuilder
     {
         public RazorEngineCompilationOptions Options { get; set; }
 
diff --git a/RazorEngineCore/RazorEngineCompiledTemplate.cs b/RazorEngineCore/RazorEngineCompiledTemplate.cs
@@ -5,7 +5,7 @@
 
 namespace RazorEngineCore
 {
-    public class RazorEngineCompiledTemplate
+    public class RazorEngineCompiledTemplate : IRazorEngineCompiledTemplate
     {
         private readonly MemoryStream assemblyByteCode;
         private readonly Type templateType;
@@ -18,12 +18,12 @@ internal RazorEngineCompiledTemplate(MemoryStream assemblyByteCode)
             this.templateType = assembly.GetType("TemplateNamespace.Template");
         }
 
-        public static RazorEngineCompiledTemplate LoadFromFile(string fileName)
+        public static IRazorEngineCompiledTemplate LoadFromFile(string fileName)
         {
             return LoadFromFileAsync(fileName: fileName).GetAwaiter().GetResult();
         }
 
-        public static async Task<RazorEngineCompiledTemplate> LoadFromFileAsync(string fileName)
+        public static async Task<IRazorEngineCompiledTemplate> LoadFromFileAsync(string fileName)
         {
             MemoryStream memoryStream = new MemoryStream();
             
@@ -41,12 +41,12 @@ public static async Task<RazorEngineCompiledTemplate> LoadFromFileAsync(string f
             return new RazorEngineCompiledTemplate(memoryStream);
         }
         
-        public static RazorEngineCompiledTemplate LoadFromStream(Stream stream)
+        public static IRazorEngineCompiledTemplate LoadFromStream(Stream stream)
         {
             return LoadFromStreamAsync(stream).GetAwaiter().GetResult();
         }
         
-        public static async Task<RazorEngineCompiledTemplate> LoadFromStreamAsync(Stream stream)
+        public static async Task<IRazorEngineCompiledTemplate> LoadFromStreamAsync(Stream stream)
         {
             MemoryStream memoryStream = new MemoryStream();
             await stream.CopyToAsync(memoryStream);
diff --git a/RazorEngineCore/RazorEngineCompiledTemplateT.cs b/RazorEngineCore/RazorEngineCompiledTemplateT.cs

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ void RecursionTest(int level){`
`42`	`42`	`static void Main(string[] args)`
`43`	`43`	`{`
`44`	`44`	`RazorEngine razorEngine = new RazorEngine();`
`45`		`- RazorEngineCompiledTemplate template = razorEngine.Compile(Content);`
	`45`	`+ IRazorEngineCompiledTemplate template = razorEngine.Compile(Content);`
`46`	`46`
`47`	`47`	`string result = template.Run(new`
`48`	`48`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public Task TestCompileAsync()`
`25`	`25`	`public void TestCompileAndRun_HtmlLiteral()`
`26`	`26`	`{`
`27`	`27`	`RazorEngine razorEngine = new RazorEngine();`
`28`		`- RazorEngineCompiledTemplate template = razorEngine.Compile("<h1>Hello @Model.Name</h1>");`
	`28`	`+ IRazorEngineCompiledTemplate template = razorEngine.Compile("<h1>Hello @Model.Name</h1>");`
`29`	`29`
`30`	`30`	`string actual = template.Run(new`
`31`	`31`	`{`
`@@ -39,7 +39,7 @@ public void TestCompileAndRun_HtmlLiteral()`
`39`	`39`	`public async Task TestCompileAndRun_HtmlLiteralAsync()`
`40`	`40`	`{`
`41`	`41`	`RazorEngine razorEngine = new RazorEngine();`
`42`		`- RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<h1>Hello @Model.Name</h1>");`
	`42`	`+ IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<h1>Hello @Model.Name</h1>");`
`43`	`43`
`44`	`44`	`string actual = await template.RunAsync(new`
`45`	`45`	`{`
`@@ -53,7 +53,7 @@ public async Task TestCompileAndRun_HtmlLiteralAsync()`
`53`	`53`	`public void TestCompileAndRun_InAttributeVariables()`
`54`	`54`	`{`
`55`	`55`	`RazorEngine razorEngine = new RazorEngine();`
`56`		`- RazorEngineCompiledTemplate template = razorEngine.Compile("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%, 80%,1);\">");`
	`56`	`+ IRazorEngineCompiledTemplate template = razorEngine.Compile("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%, 80%,1);\">");`
`57`	`57`
`58`	`58`	`string actual = template.Run(new`
`59`	`59`	`{`
`@@ -67,7 +67,7 @@ public void TestCompileAndRun_InAttributeVariables()`
`67`	`67`	`public async Task TestCompileAndRun_InAttributeVariablesAsync()`
`68`	`68`	`{`
`69`	`69`	`RazorEngine razorEngine = new RazorEngine();`
`70`		`- RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%, 80%,1);\">");`
	`70`	`+ IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div class=\"circle\" style=\"background-color: hsla(@Model.Colour, 70%, 80%,1);\">");`
`71`	`71`
`72`	`72`	`string actual = await template.RunAsync(new`
`73`	`73`	`{`
`@@ -81,7 +81,7 @@ public async Task TestCompileAndRun_InAttributeVariablesAsync()`
`81`	`81`	`public void TestCompileAndRun_HtmlAttribute()`
`82`	`82`	`{`
`83`	`83`	`RazorEngine razorEngine = new RazorEngine();`
`84`		`- RazorEngineCompiledTemplate template = razorEngine.Compile("<div title=\"@Model.Name\">Hello</div>");`
	`84`	`+ IRazorEngineCompiledTemplate template = razorEngine.Compile("<div title=\"@Model.Name\">Hello</div>");`
`85`	`85`
`86`	`86`	`string actual = template.Run(new`
`87`	`87`	`{`
`@@ -95,7 +95,7 @@ public void TestCompileAndRun_HtmlAttribute()`
`95`	`95`	`public async Task TestCompileAndRun_HtmlAttributeAsync()`
`96`	`96`	`{`
`97`	`97`	`RazorEngine razorEngine = new RazorEngine();`
`98`		`- RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div title=\"@Model.Name\">Hello</div>");`
	`98`	`+ IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("<div title=\"@Model.Name\">Hello</div>");`
`99`	`99`
`100`	`100`	`string actual = await template.RunAsync(new`
`101`	`101`	`{`
`@@ -109,7 +109,7 @@ public async Task TestCompileAndRun_HtmlAttributeAsync()`
`109`	`109`	`public void TestCompileAndRun_DynamicModel_Plain()`
`110`	`110`	`{`
`111`	`111`	`RazorEngine razorEngine = new RazorEngine();`
`112`		`- RazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name");`
	`112`	`+ IRazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name");`
`113`	`113`
`114`	`114`	`string actual = template.Run(new`
`115`	`115`	`{`
`@@ -123,7 +123,7 @@ public void TestCompileAndRun_DynamicModel_Plain()`
`123`	`123`	`public async Task TestCompileAndRun_DynamicModel_PlainAsync()`
`124`	`124`	`{`
`125`	`125`	`RazorEngine razorEngine = new RazorEngine();`
`126`		`- RazorEngineCompiledTemplate template = await razorEngine.CompileAsync("Hello @Model.Name");`
	`126`	`+ IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("Hello @Model.Name");`
`127`	`127`
`128`	`128`	`string actual = await template.RunAsync(new`
`129`	`129`	`{`
`@@ -339,7 +339,7 @@ void RecursionTest(int level)`
`339`	`339`	`public void TestCompileAndRun_TypedModel1()`
`340`	`340`	`{`
`341`	`341`	`RazorEngine razorEngine = new RazorEngine();`
`342`		`- RazorEngineCompiledTemplate<TestModel1> template = razorEngine.Compile<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");`
	`342`	`+ IRazorEngineCompiledTemplate<TestModel1> template = razorEngine.Compile<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");`
`343`	`343`
`344`	`344`	`string actual = template.Run(instance =>`
`345`	`345`	`{`
`@@ -355,7 +355,7 @@ public void TestCompileAndRun_TypedModel1()`
`355`	`355`	`public async Task TestCompileAndRun_TypedModel1Async()`
`356`	`356`	`{`
`357`	`357`	`RazorEngine razorEngine = new RazorEngine();`
`358`		`- RazorEngineCompiledTemplate<TestModel1> template = await razorEngine.CompileAsync<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");`
	`358`	`+ IRazorEngineCompiledTemplate<TestModel1> template = await razorEngine.CompileAsync<TestModel1>("Hello @A @B @(A + B) @C @Decorator(\"777\")");`
`359`	`359`
`360`	`360`	`string actual = await template.RunAsync(instance =>`
`361`	`361`	`{`
`@@ -371,7 +371,7 @@ public async Task TestCompileAndRun_TypedModel1Async()`
`371`	`371`	`public void TestCompileAndRun_TypedModel2()`
`372`	`372`	`{`
`373`	`373`	`RazorEngine razorEngine = new RazorEngine();`
`374`		`- RazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>("Hello @Model.Decorator(Model.C)");`
	`374`	`+ IRazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>("Hello @Model.Decorator(Model.C)");`
`375`	`375`
`376`	`376`	`string actual = template.Run(instance =>`
`377`	`377`	`{`
`@@ -388,7 +388,7 @@ public void TestCompileAndRun_TypedModel2()`
`388`	`388`	`public async Task TestCompileAndRun_TypedModel2Async()`
`389`	`389`	`{`
`390`	`390`	`RazorEngine razorEngine = new RazorEngine();`
`391`		`- RazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>("Hello @Model.Decorator(Model.C)");`
	`391`	`+ IRazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>("Hello @Model.Decorator(Model.C)");`
`392`	`392`
`393`	`393`	`string actual = await template.RunAsync(instance =>`
`394`	`394`	`{`
`@@ -405,7 +405,7 @@ public async Task TestCompileAndRun_TypedModel2Async()`
`405`	`405`	`public void TestCompileAndRun_Linq()`
`406`	`406`	`{`
`407`	`407`	`RazorEngine razorEngine = new RazorEngine();`
`408`		`- RazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>(`
	`408`	`+ IRazorEngineCompiledTemplate<TestModel2> template = razorEngine.Compile<TestModel2>(`
`409`	`409`	`@"`
`410`	`410`	`@foreach (var item in Model.Numbers.OrderByDescending(x => x))`
`411`	`411`	`{`
`@@ -432,7 +432,7 @@ public void TestCompileAndRun_Linq()`
`432`	`432`	`public async Task TestCompileAndRun_LinqAsync()`
`433`	`433`	`{`
`434`	`434`	`RazorEngine razorEngine = new RazorEngine();`
`435`		`- RazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>(`
	`435`	`+ IRazorEngineCompiledTemplate<TestModel2> template = await razorEngine.CompileAsync<TestModel2>(`
`436`	`436`	`@"`
`437`	`437`	`@foreach (var item in Model.Numbers.OrderByDescending(x => x))`
`438`	`438`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,9 @@`
`11`	`11`
`12`	`12`	`namespace RazorEngineCore`
`13`	`13`	`{`
`14`		`- public class RazorEngine`
	`14`	`+ public class RazorEngine : IRazorEngine`
`15`	`15`	`{`
`16`		`- public RazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate`
	`16`	`+ public IRazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate`
`17`	`17`	`{`
`18`	`18`	`RazorEngineCompilationOptionsBuilder compilationOptionsBuilder = new RazorEngineCompilationOptionsBuilder();`
`19`	`19`
`@@ -27,12 +27,12 @@ public RazorEngineCompiledTemplate<T> Compile<T>(string content, Action<RazorEng`
`27`	`27`	`return new RazorEngineCompiledTemplate<T>(memoryStream);`
`28`	`28`	`}`
`29`	`29`
`30`		`- public Task<RazorEngineCompiledTemplate<T>> CompileAsync<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate`
	`30`	`+ public Task<IRazorEngineCompiledTemplate<T>> CompileAsync<T>(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null) where T : IRazorEngineTemplate`
`31`	`31`	`{`
`32`	`32`	`return Task.Factory.StartNew(() => this.Compile<T>(content: content, builderAction: builderAction));`
`33`	`33`	`}`
`34`	`34`
`35`		`- public RazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)`
	`35`	`+ public IRazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)`
`36`	`36`	`{`
`37`	`37`	`RazorEngineCompilationOptionsBuilder compilationOptionsBuilder = new RazorEngineCompilationOptionsBuilder();`
`38`	`38`	`compilationOptionsBuilder.Inherits(typeof(RazorEngineTemplateBase));`
`@@ -44,7 +44,7 @@ public RazorEngineCompiledTemplate Compile(string content, Action<RazorEngineCom`
`44`	`44`	`return new RazorEngineCompiledTemplate(memoryStream);`
`45`	`45`	`}`
`46`	`46`
`47`		`- public Task<RazorEngineCompiledTemplate> CompileAsync(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)`
	`47`	`+ public Task<IRazorEngineCompiledTemplate> CompileAsync(string content, Action<RazorEngineCompilationOptionsBuilder> builderAction = null)`
`48`	`48`	`{`
`49`	`49`	`return Task.Factory.StartNew(() => this.Compile(content: content, builderAction: builderAction));`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace RazorEngineCore`
`6`	`6`	`{`
`7`		`- public class RazorEngineCompilationOptionsBuilder`
	`7`	`+ public class RazorEngineCompilationOptionsBuilder : IRazorEngineCompilationOptionsBuilder`
`8`	`8`	`{`
`9`	`9`	`public RazorEngineCompilationOptions Options { get; set; }`
`10`	`10`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace RazorEngineCore`
`7`	`7`	`{`
`8`		`- public class RazorEngineCompiledTemplate`
	`8`	`+ public class RazorEngineCompiledTemplate : IRazorEngineCompiledTemplate`
`9`	`9`	`{`
`10`	`10`	`private readonly MemoryStream assemblyByteCode;`
`11`	`11`	`private readonly Type templateType;`
`@@ -18,12 +18,12 @@ internal RazorEngineCompiledTemplate(MemoryStream assemblyByteCode)`
`18`	`18`	`this.templateType = assembly.GetType("TemplateNamespace.Template");`
`19`	`19`	`}`
`20`	`20`
`21`		`- public static RazorEngineCompiledTemplate LoadFromFile(string fileName)`
	`21`	`+ public static IRazorEngineCompiledTemplate LoadFromFile(string fileName)`
`22`	`22`	`{`
`23`	`23`	`return LoadFromFileAsync(fileName: fileName).GetAwaiter().GetResult();`
`24`	`24`	`}`
`25`	`25`
`26`		`- public static async Task<RazorEngineCompiledTemplate> LoadFromFileAsync(string fileName)`
	`26`	`+ public static async Task<IRazorEngineCompiledTemplate> LoadFromFileAsync(string fileName)`
`27`	`27`	`{`
`28`	`28`	`MemoryStream memoryStream = new MemoryStream();`
`29`	`29`
`@@ -41,12 +41,12 @@ public static async Task<RazorEngineCompiledTemplate> LoadFromFileAsync(string f`
`41`	`41`	`return new RazorEngineCompiledTemplate(memoryStream);`
`42`	`42`	`}`
`43`	`43`
`44`		`- public static RazorEngineCompiledTemplate LoadFromStream(Stream stream)`
	`44`	`+ public static IRazorEngineCompiledTemplate LoadFromStream(Stream stream)`
`45`	`45`	`{`
`46`	`46`	`return LoadFromStreamAsync(stream).GetAwaiter().GetResult();`
`47`	`47`	`}`
`48`	`48`
`49`		`- public static async Task<RazorEngineCompiledTemplate> LoadFromStreamAsync(Stream stream)`
	`49`	`+ public static async Task<IRazorEngineCompiledTemplate> LoadFromStreamAsync(Stream stream)`
`50`	`50`	`{`
`51`	`51`	`MemoryStream memoryStream = new MemoryStream();`
`52`	`52`	`await stream.CopyToAsync(memoryStream);`