Switch from ICompilerOptions to more complete IProviderOptions.

Author: StephenMolloy

RoslynCodeProviderTest/CompilerSettingsHelper.cs

@@ -11,6 +11,7 @@ internal static class CompilerSettingsHelper {
 
         private const int DefaultCompilerServerTTL = 0; // set TTL to 0 to turn of keepalive switch
 
+        //smolloy debug degub todo - these two lines, and the next two properties are obsolete.
         private static ICompilerSettings _csc = new CompilerSettings(CompilerFullPath(@"csc.exe"), DefaultCompilerServerTTL);
         private static ICompilerSettings _vb = new CompilerSettings(CompilerFullPath(@"vbc.exe"), DefaultCompilerServerTTL);
 

src/DotNetCompilerPlatformTasks/CheckIfVBCSCompilerWillOverride.cs

@@ -0,0 +1,31 @@
+using System;
+using System.IO;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace DotNetCompilerPlatformTasks
+{
+    public class CheckIfVBCSCompilerWillOverride : Task
+    {
+        [Required]
+        public string Src { get; set; }
+        [Required]
+        public string Dest { get; set; }
+
+        [Output]
+        public bool WillOverride { get; set; }
+
+        public override bool Execute()
+        {
+            WillOverride = false;
+
+            try
+            {
+                WillOverride = File.Exists(Src) && File.Exists(Dest) && (File.GetLastWriteTime(Src) != File.GetLastWriteTime(Dest));
+            }
+            catch { return false; }
+
+            return true;
+        }
+    }
+}

src/DotNetCompilerPlatformTasks/Tasks.cs …tNetCompilerPlatformTasks/KillProcess.cssrc/DotNetCompilerPlatformTasks/Tasks.cs renamed to src/DotNetCompilerPlatformTasks/KillProcess.cs src/DotNetCompilerPlatformTasks/Tasks.cs renamed to src/DotNetCompilerPlatformTasks/KillProcess.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Diagnostics;
-using System.IO;
 using System.Linq;
 using System.Management;
 using Microsoft.Build.Framework;
@@ -52,28 +51,4 @@ public override bool Execute()
             return true;
         }
     }
-
-    public class CheckIfVBCSCompilerWillOverride : Task
-    {
-        [Required]
-        public string Src { get; set; }
-        [Required]
-        public string Dest { get; set; }
-
-        [Output]
-        public bool WillOverride { get; set; }
-
-        public override bool Execute()
-        {
-            WillOverride = false;
-
-            try
-            {
-                WillOverride = File.Exists(Src) && File.Exists(Dest) && (File.GetLastWriteTime(Src) != File.GetLastWriteTime(Dest));
-            }
-            catch { return false; }
-
-            return true;
-        }
-    }
 }

src/Microsoft.CodeDom.Providers.DotNetCompilerPlatform/AppSettings.cs

@@ -1,12 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Collections.Specialized;
 using System.Web.Configuration;
 
 namespace Microsoft.CodeDom.Providers.DotNetCompilerPlatform {
@@ -32,6 +27,8 @@ private static void EnsureSettingsLoaded() {
             lock (_lock) {
                 if (!_settingsInitialized) {
                     try {
+                        // I think it should be safe to straight up use regular ConfigurationManager here...
+                        // but if it ain't broke, don't fix it.
                         LoadSettings(WebConfigurationManager.AppSettings);
                     }
                     finally {

src/Microsoft.CodeDom.Providers.DotNetCompilerPlatform/CSharpCodeProvider.cs

@@ -11,22 +11,30 @@ namespace Microsoft.CodeDom.Providers.DotNetCompilerPlatform {
     /// </summary>
     [DesignerCategory("code")]
     public sealed class CSharpCodeProvider : Microsoft.CSharp.CSharpCodeProvider {
-        private ICompilerSettings _compilerSettings;
+        private IProviderOptions _providerOptions;
 
         /// <summary>
         /// Default Constructor
         /// </summary>
         public CSharpCodeProvider()
-            : this(null) {
+            : this((IProviderOptions)null) {
         }
 
-        
         /// <summary>
         /// Creates an instance using the given ICompilerSettings
         /// </summary>
         /// <param name="compilerSettings"></param>
+        [Obsolete("ICompilerSettings is obsolete. Please update code to use IProviderOptions instead.", false)]
         public CSharpCodeProvider(ICompilerSettings compilerSettings = null) {
-            _compilerSettings = compilerSettings == null ? CompilationSettingsHelper.CSC2 : compilerSettings;
+            _providerOptions = compilerSettings == null ? CompilationUtil.CSC2 : new ProviderOptions(compilerSettings);
+        }
+
+        /// <summary>
+        /// Creates an instance using the given IProviderOptions
+        /// </summary>
+        /// <param name="providerOptions"></param>
+        public CSharpCodeProvider(IProviderOptions providerOptions = null) {
+            _providerOptions = providerOptions == null ? CompilationUtil.CSC2 : providerOptions;
         }
 
         /// <summary>
@@ -35,7 +43,7 @@ public CSharpCodeProvider(ICompilerSettings compilerSettings = null) {
         /// <returns>An instance of the .NET Compiler Platform C# code compiler</returns>
         [Obsolete("Callers should not use the ICodeCompiler interface and should instead use the methods directly on the CodeDomProvider class.")]
         public override ICodeCompiler CreateCompiler() {
-            return new CSharpCompiler(this, _compilerSettings);
+            return new CSharpCompiler(this, _providerOptions);
         }
     }
 }

src/Microsoft.CodeDom.Providers.DotNetCompilerPlatform/CSharpCompiler.cs

@@ -14,8 +14,8 @@ internal class CSharpCompiler : Compiler {
         private static volatile Regex outputRegWithFileAndLine;
         private static volatile Regex outputRegSimple;
 
-        public CSharpCompiler(CodeDomProvider codeDomProvider, ICompilerSettings compilerSettings = null)
-            : base(codeDomProvider, compilerSettings) {
+        public CSharpCompiler(CodeDomProvider codeDomProvider, IProviderOptions providerOptions = null)
+            : base(codeDomProvider, providerOptions) {
         }
 
         protected override string FileExtension {

src/Microsoft.CodeDom.Providers.DotNetCompilerPlatform/Compiler.cs

@@ -16,14 +16,15 @@
 namespace Microsoft.CodeDom.Providers.DotNetCompilerPlatform {
     internal abstract class Compiler : ICodeCompiler {
         private readonly CodeDomProvider _codeDomProvider;
-        private readonly ICompilerSettings _compilerSettings;
+        private readonly IProviderOptions _providerOptions;
         private string _compilerFullPath = null;
         private const string CLR_PROFILING_SETTING = "COR_ENABLE_PROFILING";
         private const string DISABLE_PROFILING = "0";
 
-        public Compiler(CodeDomProvider codeDomProvider, ICompilerSettings compilerSettings) {
+        public Compiler(CodeDomProvider codeDomProvider, IProviderOptions providerOptions)
+        {
             this._codeDomProvider = codeDomProvider;
-            this._compilerSettings = compilerSettings;
+            this._providerOptions = providerOptions;
         }
 
         public CompilerResults CompileAssemblyFromDom(CompilerParameters options, CodeCompileUnit compilationUnit) {
@@ -132,7 +133,7 @@ protected abstract string FileExtension {
         protected virtual string CompilerName {
             get {
                 if (null == _compilerFullPath) {
-                    _compilerFullPath = _compilerSettings.CompilerFullPath;
+                    _compilerFullPath = _providerOptions.CompilerFullPath;
 
                     // Try opening the file to make sure the compiler exist.  This will throw an exception
                     // if it doesn't
@@ -277,8 +278,8 @@ private CompilerResults FromFileBatch(CompilerParameters options, string[] fileN
             }
 
             // Appending TTL to the command line arguments.
-            if (_compilerSettings.CompilerServerTimeToLive > 0) {
-                args = string.Format("/shared /keepalive:\"{0}\" {1}", _compilerSettings.CompilerServerTimeToLive, args);
+            if (_providerOptions.CompilerServerTimeToLive > 0) {
+                args = string.Format("/shared /keepalive:\"{0}\" {1}", _providerOptions.CompilerServerTimeToLive, args);
             }
 
             Compile(options,

src/Microsoft.CodeDom.Providers.DotNetCompilerPlatform/Microsoft.CodeDom.Providers.DotNetCompilerPlatform.csproj

@@ -57,7 +57,8 @@
     <Compile Include="CSharpCompiler.cs" />
     <Compile Include="CSharpCodeProvider.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Util\CompilationSettings.cs" />
+    <Compile Include="Util\IProviderOptions.cs" />
+    <Compile Include="Util\ProviderOptions.cs" />
     <Compile Include="Util\CompilationUtil.cs" />
     <Compile Include="Util\ICompilerSettings.cs" />
     <Compile Include="VBCodeProvider.cs" />