Usando CSharpCodeProvider con .net 4.5 beta

Question

Instalé recientemente el Visual Studio 11 Beta, y estoy tratando de actualizar un proyecto 4.0 existente para usar 4.5. En el programa, compila código generado dinámicamente usando CSharpCodeProvider.

/// <summary> 
/// Compile and return a reference to the compiled assembly 
/// </summary> 
private Assembly Compile() 
{ 
    var referencedDlls = new List<string> 
    { 
     "mscorlib.dll", 
     "System.dll", 
     "System.Core.dll", 
    }; 
    referencedDlls.AddRange(RequiredReferences); 

    var parameters = new CompilerParameters(
     assemblyNames: referencedDlls.ToArray(), 
     outputName: GeneratedDllFileName, 
     // only include debug information if we are currently debugging 
     includeDebugInformation: Debugger.IsAttached); 
    parameters.TreatWarningsAsErrors = false; 
    parameters.WarningLevel = 0; 
    parameters.GenerateExecutable = false; 
    parameters.GenerateInMemory = false; 
    parameters.CompilerOptions = "/optimize+ /platform:x64"; 

    string[] files = Directory.GetFiles(GenerationDirectory, "*.cs"); 

    var compiler = new CSharpCodeProvider(
     new Dictionary<string, string> { { "CompilerVersion", "v4.5" } }); 
    var results = compiler.CompileAssemblyFromFile(parameters, files); 

    if (results.Errors.HasErrors) 
    { 
     string firstError = 
      string.Format("Compile error: {0}", results.Errors[0].ToString()); 
     throw new ApplicationException(firstError); 
    } 
    else 
    { 
     return results.CompiledAssembly; 
    } 
} 

El problema viene cuando he cambiado el CompilerVersion{ "CompilerVersion", "v4.0" }-{ "CompilerVersion", "v4.5" }

Ahora recibe una excepción

Compilador csc.exe archivo ejecutable no se puede encontrar.

¿Está especificando CompilerVersion la forma incorrecta de indicarle que use 4.5? ¿Compilarlo como v4.5 incluso marcará la diferencia ya que el código no usará ninguna nueva característica específica de 4.5?

Answer 1

Hubiera sido útil si nos hubiera dado un programa breve pero completo para demostrar el problema, pero puedo verificar que con "v4.0" funcionará y compilará métodos asíncronos, suponiendo que se está ejecutando en un máquina con el VS11 beta instalado.

Demostración:

using System; 
using System.Collections; 
using System.Reflection; 
using System.Collections.Generic; 
using System.Diagnostics; 
using Microsoft.CSharp; 
using System.CodeDom.Compiler; 

namespace Foo {} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var referencedDll = new List<string> 
     { 
      "mscorlib.dll", 
      "System.dll", 
      "System.Core.dll", 
     }; 

     var parameters = new CompilerParameters(
      assemblyNames: referencedDll.ToArray(), 
      outputName: "foo.dll", 
      includeDebugInformation: false) 
     { 
      TreatWarningsAsErrors = true, 
      // We don't want to be warned that we have no await! 
      WarningLevel = 0, 
      GenerateExecutable = false, 
      GenerateInMemory = true 
     }; 

     var source = new[] { "class Test { static async void Foo() {}}" }; 

     var options = new Dictionary<string, string> { 
      { "CompilerVersion", "v4.0" } 
     }; 
     var compiler = new CSharpCodeProvider(options); 
     var results = compiler.CompileAssemblyFromSource(parameters, source); 

     Console.WriteLine("Success? {0}", !results.Errors.HasErrors); 
    } 
}