public static IControlScriptFactory Compile(string scriptCode)
{
var translatedCode = GetTranslatedCode(scriptCode);
var provider = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add(typeof(ControlScriptCompiler).Assembly.Location);
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add(typeof(ControlScriptLibrary.ControlScriptLibrary).Assembly.Location);
parameters.GenerateInMemory = true;
parameters.CompilerOptions = "/optimize";
CompilerResults results = provider.CompileAssemblyFromSource(parameters, translatedCode);
if (results.Errors.HasErrors)
{
throw new TranslatedCodeCompilationException()
{
Errors = results.Errors.Cast <CompilerError>().Select(x => x.ErrorText),
}
}
;
var cls = results.CompiledAssembly.GetType("ControlScript");
return(new ControlScriptFactory(() => (IControlScript)cls.GetConstructors()[0].Invoke(null)));
}
private Assembly GenerateAssembly(string sourceCode)
{
Environment.SetEnvironmentVariable("ROSLYN_COMPILER_LOCATION", @"C:\Code\ElasticSearchTalk\packages\Microsoft.Net.Compilers.2.9.0\tools", EnvironmentVariableTarget.Process);
var _codeDomProvider = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
var _compilerParameters = new CompilerParameters();
_compilerParameters.ReferencedAssemblies.Add("system.dll");
_compilerParameters.ReferencedAssemblies.Add("system.xml.dll");
_compilerParameters.ReferencedAssemblies.Add("system.core.dll");
_compilerParameters.ReferencedAssemblies.Add("system.linq.dll");
_compilerParameters.ReferencedAssemblies.Add(@"C:\Code\ElasticSearchTalk\packages\NEST.6.1.0\lib\net46\Nest.dll");
_compilerParameters.ReferencedAssemblies.Add(@"C:\Code\ElasticSearchTalk\NESTClient\bin\Debug\NESTClient.exe");
_compilerParameters.GenerateExecutable = false;
_compilerParameters.GenerateInMemory = true;
_compilerParameters.IncludeDebugInformation = true;
var _compilerResults = _codeDomProvider.CompileAssemblyFromSource(_compilerParameters, sourceCode);
if (_compilerResults.Errors.HasErrors)
{
foreach (CompilerError err in _compilerResults.Errors)
{
throw new InvalidScriptException(err.Line, err.Column, err.ErrorText, err.ErrorNumber);
}
throw new Exception("Compilation failed.");
}
return(_compilerResults.CompiledAssembly);
}
private Assembly CompileCode(String Source, String ErrorPath, Func <int, String> TranslateBulkFilenames = null)
{
//CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("CSharp");
CodeDomProvider codeProvider = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
var parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("System.Data.Linq.dll");
parameters.ReferencedAssemblies.Add("core.dll");
CompilerResults compilationResults = codeProvider.CompileAssemblyFromSource(parameters, Source);
bool realError = false;
if (compilationResults.Errors.Count > 0)
{
var errorString = new StringBuilder();
errorString.AppendLine(String.Format("{0} errors in {1}", compilationResults.Errors.Count, ErrorPath));
foreach (var error in compilationResults.Errors)
{
var cError = error as System.CodeDom.Compiler.CompilerError;
if (!cError.IsWarning)
{
realError = true;
}
var filename = cError.FileName;
if (TranslateBulkFilenames != null)
{
filename = TranslateBulkFilenames(cError.Line);
}
errorString.Append(filename + " : " + error.ToString());
errorString.AppendLine();
}
Core.LogError(errorString.ToString());
}
if (realError)
{
return(null);
}
return(compilationResults.CompiledAssembly);
}
private static Assembly BuildAssembly(string code)
{
using (var compiler = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider())
{
//Clean up
Environment.SetEnvironmentVariable("ROSLYN_COMPILER_LOCATION", null, EnvironmentVariableTarget.Process);
var compilerparams = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
CompilerOptions = "/unsafe /optimize /langversion:8.0"
};
var assemblies = AppDomain.CurrentDomain
.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => a.Location);
var asmList = assemblies.ToList();
asmList.RemoveAll(x => x.Contains(".winmd"));
compilerparams.ReferencedAssemblies.AddRange(asmList.ToArray());
CompilerResults results = compiler.CompileAssemblyFromSource(compilerparams, code);
if (results.Errors.HasErrors)
{
StringBuilder errors = new StringBuilder("Compiler Errors :\r\n");
foreach (CompilerError error in results.Errors)
{
errors.Append($"Line {error.Line},{error.Column}\t: {error.ErrorText}\n");
}
compiler.Dispose();
throw new Exception(errors.ToString());
}
else
{
return(results.CompiledAssembly);
}
}
}
//https://stackoverflow.com/questions/31639602/using-c-sharp-6-features-with-codedomprovider-rosyln
public void CompileCodeProgrammaticallyTest1_AfterCSharp6()
{
CompilerParameters parameters = new CompilerParameters();
//parameters.GenerateExecutable = true;
parameters.OutputAssembly = @"c:\tmp\helloWorld-compiled-programmatically.exe";
parameters.GenerateExecutable = true;
//parameters.CompilerOptions = "-langversion:6";
parameters.IncludeDebugInformation = true;
parameters.GenerateInMemory = false;
parameters.TreatWarningsAsErrors = false;
parameters.WarningLevel = 3;
parameters.ReferencedAssemblies.Add("System.Runtime.dll");
//V1 : après c#6 roslyn : v1
//CodeDomProvider compiler = CodeProvider.Value;
//V2 : après c#6 V2 : C:\Program Files (x86)\MSBuild\14.0\Bin\csc.exe
//Set hardcoded environment variable to set the path to the library
Environment.SetEnvironmentVariable("ROSLYN_COMPILER_LOCATION", @"C:\Program Files (x86)\MSBuild\14.0\Bin", EnvironmentVariableTarget.Process);
//Create compiler object
CSharpCodeProvider compiler = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
//Clean up
Environment.SetEnvironmentVariable("ROSLYN_COMPILER_LOCATION", null, EnvironmentVariableTarget.Process);
CompilerResults results = compiler.CompileAssemblyFromSource(parameters, SOURCE_STRING_C_SHARP_6);
foreach (CompilerError error in results.Errors)
{
Console.WriteLine(error);
}
Check.That(results.PathToAssembly).IsEqualTo(@"c:\tmp\helloWorld-compiled-programmatically.exe");
Check.That(results.Errors).CountIs(0);
Check.That(results.Errors.HasErrors).IsFalse();
Check.That(results.Errors.HasWarnings).IsFalse();
Check.That(results.NativeCompilerReturnValue).IsEqualTo(0);
}
public static CompilationResult Compile(IEnumerable <string> assemblies, string code)
{
return(resultCache.GetOrAdd(code, _ =>
{
using (HeavyProfiler.Log("COMPILE", () => code))
{
try
{
CodeDomProvider supplier = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
foreach (var ass in assemblies)
{
parameters.ReferencedAssemblies.Add(ass);
}
parameters.GenerateInMemory = true;
CompilerResults compiled = supplier.CompileAssemblyFromSource(parameters, code);
if (compiled.Errors.HasErrors)
{
var lines = code.Split('\n');
var errors = compiled.Errors.Cast <CompilerError>();
return new CompilationResult
{
CompilationErrors = errors.Count() + " Errors:\r\n" + errors.ToString(e => "Line {0}: {1}".FormatWith(e.Line, e.ErrorText) + "\r\n" + lines[e.Line - 1], "\r\n\r\n")
};
}
if (DynamicCode.GetCustomErrors != null)
{
var allCustomErrors = DynamicCode.GetCustomErrors.GetInvocationListTyped().SelectMany(a => a(code) ?? new List <CompilerError>()).ToList();
if (allCustomErrors.Any())
{
var lines = code.Split('\n');
return new CompilationResult
{
CompilationErrors = allCustomErrors.Count() + " Errors:\r\n" + allCustomErrors.ToString(e => "Line {0}: {1}".FormatWith(e.Line, e.ErrorText) + "\r\n" + lines[e.Line - 1], "\r\n\r\n")
};
}
}
Assembly assembly = compiled.CompiledAssembly;
Type type = assembly.GetTypes().Where(a => typeof(T).IsAssignableFrom(a)).SingleEx();
T algorithm = (T)assembly.CreateInstance(type.FullName);
return new CompilationResult {
Algorithm = algorithm
};
}
catch (Exception e)
{
return new CompilationResult {
CompilationErrors = e.Message
};
}
}
}));
}
public async Task <PluginMetadata> LoadPlugin(string path, bool shouldAwait = true)
{
var pluginMetadata = new PluginMetadata
{
FileName = Path.GetFileName(path)
};
var options = new CompilerParameters();
options.ReferencedAssemblies.Add(Assembly.GetEntryAssembly().Location);
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("System.Data.dll");
options.ReferencedAssemblies.Add(ServerPath.GetBin("Newtonsoft.Json.dll"));
options.GenerateInMemory = true;
var c = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
var cr = shouldAwait ? await Task.Run(() => c.CompileAssemblyFromSource(options, File.ReadAllText(path))) : c.CompileAssemblyFromSource(options, File.ReadAllText(path));
if (cr.Errors.HasErrors)
{
var sb = new StringBuilder();
foreach (CompilerError err in cr.Errors)
{
sb.Append($"{err.ErrorText}\nLine: {err.Line} - Column: {err.Column}\n\n");
}
pluginMetadata.Error = sb.ToString();
Console.WriteLine(pluginMetadata.Error);
return(pluginMetadata);
}
try
{
pluginMetadata.Type = shouldAwait ? await Task.Run(() => cr.CompiledAssembly.GetType($"WindowsGSM.Plugins.{Path.GetFileNameWithoutExtension(path)}")) : cr.CompiledAssembly.GetType($"WindowsGSM.Plugins.{Path.GetFileNameWithoutExtension(path)}");
var plugin = GetPluginClass(pluginMetadata);
pluginMetadata.FullName = $"{plugin.FullName} [{pluginMetadata.FileName}]";
pluginMetadata.Plugin = plugin.Plugin;
try
{
string gameImage = ServerPath.GetPlugins(pluginMetadata.FileName, $"{Path.GetFileNameWithoutExtension(pluginMetadata.FileName)}.png");
ImageSource image = new BitmapImage(new Uri(gameImage));
pluginMetadata.GameImage = gameImage;
}
catch
{
pluginMetadata.GameImage = DefaultPluginImage;
}
try
{
string authorImage = ServerPath.GetPlugins(pluginMetadata.FileName, "author.png");
ImageSource image = new BitmapImage(new Uri(authorImage));
pluginMetadata.AuthorImage = authorImage;
}
catch
{
pluginMetadata.AuthorImage = DefaultUserImage;
}
pluginMetadata.IsLoaded = true;
}
catch (Exception e)
{
pluginMetadata.Error = e.Message;
Console.WriteLine(pluginMetadata.Error);
pluginMetadata.IsLoaded = false;
}
return(pluginMetadata);
}
public virtual void Compile(CompileOption compileOption, string path)
{
CompilerResults results;
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.AddRange(compileOption.LibraryRefrences);
parameters.CompilerOptions = "/appconfig:\"" + (_fileSystemManager.RelativeToAbsolutePath("~/") + "web.config\"")
.Replace("//", "/");
parameters.GenerateInMemory = false;
parameters.GenerateExecutable = compileOption.GenerateExecutable;
parameters.TreatWarningsAsErrors = false;
parameters.OutputAssembly = path;
//parameters.CoreAssemblyFileName = "System.dll";
parameters.IncludeDebugInformation = compileOption.IncludeDebugInformation;
parameters.TempFiles = HttpContext.Current.Request.IsLocal ?
new TempFileCollection(Environment.GetEnvironmentVariable(Temp), true)
: new TempFileCollection(Environment.GetEnvironmentVariable(Temp), false);
if (compileOption.CodeProvider == SourceType.Csharp)
{
if (Convert.ToBoolean(WebConfigManager.GetSettingByOption(RoslynCompiler).Value))
{
//roslyn compiler
var cSharpCodeProvider = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
results = cSharpCodeProvider.CompileAssemblyFromSource(parameters, compileOption.Code);
}
else
{
//old compiler
var cSharpCodeProvider = CodeDomProvider.CreateProvider(CSharp);
results = cSharpCodeProvider.CompileAssemblyFromSource(parameters, compileOption.Code);
}
}
else
{
if (Convert.ToBoolean(WebConfigManager.GetSettingByOption(RoslynCompiler).Value))
{
//roslyn compiler
var vBCodeProvider = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider();
results = vBCodeProvider.CompileAssemblyFromSource(parameters, compileOption.Code);
}
else
{
//old compiler
var vBCodeProvider = CodeDomProvider.CreateProvider(VisualBasic);
results = vBCodeProvider.CompileAssemblyFromSource(parameters, compileOption.Code);
}
}
if (results.Errors.HasErrors)
{
var warnings = new StringBuilder();
var errors = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
if (error.IsWarning)
{
warnings.AppendLine($"Warning ({error.ErrorNumber}): {error.ErrorText} , Line : {error.Line} , Column : {error.Column} . <br>");
}
else
{
errors.AppendLine($"Error ({error.ErrorNumber}): {error.ErrorText} , Line : {error.Line} , Column : {error.Column} . <br>");
}
}
throw new KhodkarInvalidException(errors.ToString() + warnings);
}
}
public static object CreaOggettoSerializzato(XDocument documentoCaricato, string nomeClasseAttuale, string classeSerializzataString, string nameSpaceScelto)
{
// Parametri Compilatore
var compilerParams = new CompilerParameters
{
// Voglio la libreria dll, non l'exe
GenerateExecutable = false
};
// Riferimenti
compilerParams.ReferencedAssemblies.Add(@"System.dll");
compilerParams.ReferencedAssemblies.Add(@"mscorlib.dll");
compilerParams.ReferencedAssemblies.Add(@"sysglobl.dll");
compilerParams.ReferencedAssemblies.Add(@"System.Net.dll");
compilerParams.ReferencedAssemblies.Add(@"System.Core.dll");
compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.Xml.dll");
compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.Xml.Linq.dll");
compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.Data.dll");
compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.Data.DataSetExtensions.dll");
// N.B. Scommentare se servono le info per il debug
// compilerParams.IncludeDebugInformation = true;
// Compilatore
CodeDomProvider cdp = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
/* Gestione salvataggio dll, per ora non serve
* // Chiedo all'utilizzatore se vuole che venga creata la dll. Se è così gli chiedo di
* // specificare il path dove vuole che venga creata
* string dllPath;
* Console.WriteLine("Specify the complete path of the new dll if you want to create it or just press Enter to skip: ");
* dllPath = Console.ReadLine();
*
* // Se serve salvo la DLL, e poi chiedo di includerla
* if (!String.IsNullOrWhiteSpace(dllPath))
* {
* // Voglio Che salvi l'assembly, non che lo tenga in memoria
* compilerParams.GenerateInMemory = false;
*
* // Dico dove salvare e quale nome debba avere la dll
* compilerParams.CompilerOptions = " -out:" + dllPath;
*
* // Compila per salvare la dll, non ho trovato un modo migliore per salvarla
* var risultatoCompilazioneSalvataggio = cdp.CompileAssemblyFromSource(compilerParams, classeSerializzataString);
*
* // Setta di nuovo le opzioni a null
* compilerParams.CompilerOptions = null;
* }
*/
// Arrivato qui Voglio che non venga salvato l'assembly ma solo creato un temporaneo
compilerParams.GenerateInMemory = true;
// Prova a compilare il file creato
CompilerResults compilerResults = cdp.CompileAssemblyFromSource(compilerParams, classeSerializzataString);
// Prende finalmente l'assembly
Assembly assembly = compilerResults.CompiledAssembly;
// Crea un istanza dell'oggetto, chiaramente aggiungo il NameSpace che so già
var oggettoSerializzato = assembly.CreateInstance($"BELHXmlTool.{nameSpaceScelto}.{nomeClasseAttuale}");
// Inizializza il serializer con il tipo dell'oggetto caricato
var serializer = new XmlSerializer(oggettoSerializzato.GetType());
// Carico il loadedDocument in un memoryStream che può essere deserializzato e ne resetto
// la posizione per poterlo leggere
var ms = new MemoryStream();
documentoCaricato.Save(ms);
ms.Position = 0;
oggettoSerializzato = serializer.Deserialize(ms);
return(oggettoSerializzato);
}
