public static string compilerte(string outputname, string sourcecode)
{
var codeProvider = new CSharpCodeProvider();
var provider = CodeDomProvider.CreateProvider("CSharp");
var exeName = outputname;
var cp = new CompilerParameters
{
GenerateExecutable = true,
OutputAssembly = exeName,
GenerateInMemory = false,
TreatWarningsAsErrors = false
};
var cr = provider.CompileAssemblyFromSource(cp, translatetocsharp(sourcecode));
if (cr.Errors.Count > 0)
{
var builder = new StringBuilder();
builder.Append("Cehape broke our codes that were supposed to be compiled here: " + cr.PathToAssembly);
foreach (CompilerError ce in cr.Errors)
{
builder.Append(Environment.NewLine + ce.ToString());
}
codeProvider.Dispose();
return builder.ToString();
}
else
{
codeProvider.Dispose();
return ("We were able to compile {0} successfully without cehape messing with it.".Replace("{0}", cr.PathToAssembly));
}
}
private CompilerResults Compile(string code, CompilerParameters compilerParameters)
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider(new Dictionary<String, String> { { "CompilerVersion", "v4.0" } });
CompilerResults results = codeProvider.CompileAssemblyFromSource(compilerParameters, new string[] { code });
codeProvider.Dispose();
return results;
}
internal static async Task<LiveCodeCompilationResult> Compile(IEnumerable<string> sourceFilesPaths, string projectName, IEnumerable<string> references, bool createAssemblyFiles = false)
{
string[] filesPaths = sourceFilesPaths as string[] ?? sourceFilesPaths.ToArray();
string[] sourceFiles = filesPaths.ToArray();
string location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string assemblyName = GetNewAssemblyName(projectName, location);
// clean up previous assemblies
DeletePreviousAssemblies(projectName, location);
// setup compilation parameters
var options = SetupCompilationParameters(createAssemblyFiles, assemblyName, sourceFiles, location, references);
// compile
var cSharpCodeProvider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
CompilerResults results = await cSharpCodeProvider.CompileAsync(options, sourceFiles);
cSharpCodeProvider.Dispose();
var errorMessage = new StringBuilder();
if (results.Errors.HasErrors)
{
errorMessage.Append(string.Format("Compilation errors for {0}", projectName));
foreach (CompilerError error in results.Errors)
{
errorMessage.Append(string.Format("{0}({1},{2}): {3}", error.FileName, error.Line, error.Column, error.ErrorText));
}
return new LiveCodeCompilationResult{ ErrorMessage = errorMessage.ToString() };
}
// load compiled assembly
if (createAssemblyFiles)
{
// load from disk
return await LoadAssemblyFromDisk(assemblyName);
}
// load from memory
return new LiveCodeCompilationResult { Assembly = results.CompiledAssembly, HasSucceed = true };
}
/* From http://www.codeproject.com/Articles/9019/Compiling-and-Executing-Code-at-Runtime */
public Assembly BuildAssembly(string[] Code, string[] ReferencedAssemblies)
{
Microsoft.CSharp.CSharpCodeProvider Compiler = new CSharpCodeProvider();
CompilerParameters CompilerParams = new CompilerParameters();
CompilerParams.GenerateExecutable = false;
CompilerParams.GenerateInMemory = true;
CompilerParams.IncludeDebugInformation = false;
CompilerParams.ReferencedAssemblies.AddRange(ReferencedAssemblies);
CompilerResults Results = Compiler.CompileAssemblyFromSource(CompilerParams, Code);
Compiler.Dispose();
if (Results.Errors.HasErrors)
{
StringBuilder Errors = new StringBuilder("Compiler Errors :\r\n");
foreach (CompilerError Error in Results.Errors)
{
Errors.AppendFormat("Line {0},{1}\t: {2}\n", Error.Line, Error.Column, Error.ErrorText);
}
throw new Exception(Errors.ToString());
}
else
{
return Results.CompiledAssembly;
}
}
public DynamicAssembly(string nameWithoutExtension, DynamicAssembly[] references = null, Version version = null, bool fakeIdentity = false)
{
if (version == null)
{
version = new Version(1, 0, 0, 0);
}
if (references == null)
{
references = new DynamicAssembly[0];
}
Name = nameWithoutExtension;
Namespace = nameWithoutExtension;
FileName = $"{Namespace}{Path.GetFileNameWithoutExtension(Path.GetRandomFileName())}{Interlocked.Increment(ref dynamicAssemblyId)}.dll";
DynamicName = Path.GetFileNameWithoutExtension(FileName);
var builder = new StringBuilder();
builder.AppendLine("using System.Reflection;");
builder.AppendLine($"[assembly: AssemblyVersion(\"{version}\")]");
builder.AppendLine($"[assembly: AssemblyFileVersion(\"{version}\")]");
builder.AppendFormat("namespace {0} {{ ", Namespace);
var provider = new CSharpCodeProvider();
var param = new CompilerParameters(new string[]
{
}, FileName);
param.GenerateExecutable = false;
param.GenerateInMemory = false;
param.OutputAssembly = FilePath = Path.Combine(TestAssemblyDirectory, FileName);
param.TempFiles = new TempFileCollection(TestAssemblyDirectory, false);
foreach (var reference in references)
{
builder.AppendLine($"using {reference.Namespace};");
param.ReferencedAssemblies.Add(reference.FilePath);
}
builder.AppendLine("public class Foo { public Foo() {");
foreach (var reference in references)
{
builder.AppendLine($"new {reference.Namespace}.Foo();");
}
builder.AppendLine("} } }");
var result = provider.CompileAssemblyFromSource(param, builder.ToString());
ThrowIfCompilationWasNotSuccessful(result);
provider.Dispose();
if (fakeIdentity)
{
var reader = AssemblyDefinition.ReadAssembly(FilePath);
reader.Name.Name = nameWithoutExtension;
reader.MainModule.Name = nameWithoutExtension;
reader.Write(FilePath);
}
Assembly = result.CompiledAssembly;
}
public void CompilePlugins(PermissionSet pluginSandboxPermissions, List<String> ignoredPluginClassNames = null) {
try {
if (File.Exists(Path.Combine(this.PluginBaseDirectory, "PluginCache.xml")) == true) {
WritePluginConsole("Loading plugin cache..");
try {
this.PluginCache = XDocument.Load(Path.Combine(this.PluginBaseDirectory, "PluginCache.xml")).Root.FromXElement<PluginCache>();
}
catch (Exception e) {
WritePluginConsole("Error loading plugin cache: {0}", e.Message);
}
}
// Recover from exceptions or logic errors if the document parsed correctly, but didn't deserialize correctly.
if (this.PluginCache == null) {
this.PluginCache = new PluginCache();
}
// Make sure we ignore any plugins passed in. These won't even be loaded again.
if (ignoredPluginClassNames != null) {
IgnoredPluginClassNames = ignoredPluginClassNames;
}
// Clear out all invocations if this is a reload.
Invocations.Clear();
WritePluginConsole("Preparing plugins directory..");
PreparePluginsDirectory();
WritePluginConsole("Moving legacy plugins..");
MoveLegacyPlugins();
WritePluginConsole("Creating compiler..");
// CodeDomProvider pluginsCodeDomProvider = CodeDomProvider.CreateProvider("CSharp");
var providerOptions = new Dictionary<String, String>();
providerOptions.Add("CompilerVersion", "v3.5");
CodeDomProvider pluginsCodeDomProvider = new CSharpCodeProvider(providerOptions);
WritePluginConsole("Configuring compiler..");
CompilerParameters parameters = GenerateCompilerParameters();
// AppDomainSetup domainSetup = new AppDomainSetup() { ApplicationBase = this.PluginBaseDirectory };
// Start of XpKillers mono workaround
AppDomainSetup domainSetup = null;
Type t = Type.GetType("Mono.Runtime");
if (t != null) {
//Console.WriteLine("You are running with the Mono VM");
WritePluginConsole("Running with Mono VM..");
//AppDomain.CurrentDomain.BaseDirectory
domainSetup = new AppDomainSetup() {
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
};
domainSetup.PrivateBinPath = PluginBaseDirectory;
}
else {
// Console.WriteLine("You are running something else (native .Net)");
WritePluginConsole("Running with native .Net..");
domainSetup = new AppDomainSetup() {
ApplicationBase = PluginBaseDirectory
};
}
// Workaround end
WritePluginConsole("Building sandbox..");
var hostEvidence = new Evidence();
hostEvidence.AddHost(new Zone(SecurityZone.MyComputer));
AppDomainSandbox = AppDomain.CreateDomain(ProconClient.HostName + ProconClient.Port + "Engine", hostEvidence, domainSetup, pluginSandboxPermissions);
WritePluginConsole("Configuring sandbox..");
// create the factory class in the secondary app-domain
PluginFactory = (CPRoConPluginLoaderFactory) AppDomainSandbox.CreateInstance("PRoCon.Core", "PRoCon.Core.Plugin.CPRoConPluginLoaderFactory").Unwrap();
PluginCallbacks = new CPRoConPluginCallbacks(ProconClient.ExecuteCommand, ProconClient.GetAccountPrivileges, ProconClient.GetVariable, ProconClient.GetSvVariable, ProconClient.GetMapDefines, ProconClient.TryGetLocalized, RegisterCommand, UnregisterCommand, GetRegisteredCommands, ProconClient.GetWeaponDefines, ProconClient.GetSpecializationDefines, ProconClient.Layer.GetLoggedInAccounts, RegisterPluginEvents);
WritePluginConsole("Compiling and loading plugins..");
var pluginsDirectoryInfo = new DirectoryInfo(PluginBaseDirectory);
foreach (FileInfo pluginFile in pluginsDirectoryInfo.GetFiles("*.cs")) {
string className = Regex.Replace(pluginFile.Name, "\\.cs$", "");
if (IgnoredPluginClassNames.Contains(className) == false) {
CompilePlugin(pluginFile, className, pluginsCodeDomProvider, parameters);
LoadPlugin(className, PluginFactory, pluginSandboxPermissions.IsUnrestricted());
}
else {
WritePluginConsole("Compiling {0}... ^1^bIgnored", className);
}
}
XDocument pluginCacheDocument = new XDocument(this.PluginCache.ToXElement());
pluginCacheDocument.Save(Path.Combine(this.PluginBaseDirectory, "PluginCache.xml"));
pluginsCodeDomProvider.Dispose();
}
catch (Exception e) {
WritePluginConsole(e.Message);
}
}
public void CompilePlugins(PermissionSet pluginSandboxPermissions, List<String> ignoredPluginClassNames = null) {
try {
// Make sure we ignore any plugins passed in. These won't even be loaded again.
if (ignoredPluginClassNames != null) {
this.IgnoredPluginClassNames = ignoredPluginClassNames;
}
// Clear out all invocations if this is a reload.
this.Invocations.Clear();
this.WritePluginConsole("Preparing plugins directory..");
this.PreparePluginsDirectory();
this.CleanPlugins();
this.WritePluginConsole("Moving legacy plugins..");
this.MoveLegacyPlugins();
this.WritePluginConsole("Creating compiler..");
// CodeDomProvider pluginsCodeDomProvider = CodeDomProvider.CreateProvider("CSharp");
Dictionary<String, String> providerOptions = new Dictionary<String, String>();
providerOptions.Add("CompilerVersion", "v3.5");
CodeDomProvider pluginsCodeDomProvider = new CSharpCodeProvider(providerOptions);
this.WritePluginConsole("Configuring compiler..");
CompilerParameters parameters = GenerateCompilerParameters();
// AppDomainSetup domainSetup = new AppDomainSetup() { ApplicationBase = this.PluginBaseDirectory };
// Start of XpKillers mono workaround
AppDomainSetup domainSetup = null;
Type t = Type.GetType("Mono.Runtime");
if (t != null)
{
//Console.WriteLine("You are running with the Mono VM");
this.WritePluginConsole("Running with Mono VM..");
//AppDomain.CurrentDomain.BaseDirectory
domainSetup = new AppDomainSetup() { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory };
domainSetup.PrivateBinPath = this.PluginBaseDirectory;
}
else
{
// Console.WriteLine("You are running something else (native .Net)");
this.WritePluginConsole("Running with native .Net..");
domainSetup = new AppDomainSetup() { ApplicationBase = this.PluginBaseDirectory };
}
// Workaround end
this.WritePluginConsole("Building sandbox..");
Evidence hostEvidence = new Evidence();
hostEvidence.AddHost(new Zone(SecurityZone.MyComputer));
this.m_appDomainSandbox = AppDomain.CreateDomain(this.m_client.HostName + this.m_client.Port + "Engine", hostEvidence, domainSetup, pluginSandboxPermissions);
this.WritePluginConsole("Configuring sandbox..");
// create the factory class in the secondary app-domain
CPRoConPluginLoaderFactory pluginFactory = (CPRoConPluginLoaderFactory)this.m_appDomainSandbox.CreateInstance("PRoCon.Core", "PRoCon.Core.Plugin.CPRoConPluginLoaderFactory").Unwrap();
this.m_cpPluginCallbacks = new CPRoConPluginCallbacks(this.m_client.ExecuteCommand, this.m_client.GetAccountPrivileges, this.m_client.GetVariable, this.m_client.GetSvVariable, this.m_client.GetMapDefines, this.m_client.TryGetLocalized, this.RegisterCommand, this.UnregisterCommand, this.GetRegisteredCommands, this.m_client.GetWeaponDefines, this.m_client.GetSpecializationDefines, this.m_client.Layer.GetLoggedInAccounts, this.RegisterPluginEvents);
this.WritePluginConsole("Compiling and loading plugins..");
DirectoryInfo pluginsDirectoryInfo = new DirectoryInfo(this.PluginBaseDirectory);
FileInfo[] a_pluginsFileInfo = pluginsDirectoryInfo.GetFiles("*.cs");
foreach (FileInfo pluginFile in a_pluginsFileInfo) {
string className = Regex.Replace(pluginFile.Name, "\\.cs$", "");
if (this.IgnoredPluginClassNames.Contains(className) == false) {
this.CompilePlugin(pluginFile, className, pluginsCodeDomProvider, parameters);
this.LoadPlugin(className, pluginFactory, pluginSandboxPermissions.IsUnrestricted());
}
else {
this.WritePluginConsole("Compiling {0}... ^1^bIgnored", className);
}
}
pluginsCodeDomProvider.Dispose();
}
catch (Exception e) {
this.WritePluginConsole(e.Message);
}
}
private void ThrowIfErrorsIn(CompilerResults results, IEnumerable<SourceFile> files)
{
if (results.Errors.Count > 0)
{
StringBuilder message = new StringBuilder();
CodeDomProvider cSharpCodeProvider;
try
{
cSharpCodeProvider = CodeDomProvider.GetCompilerInfo("csharp").CreateProvider();
}
catch (SecurityException)
{
cSharpCodeProvider = new CSharpCodeProvider();
}
catch (ConfigurationException)
{
cSharpCodeProvider = new CSharpCodeProvider();
}
try
{
foreach (SourceFile file in files)
{
CompilerResults result = cSharpCodeProvider.CompileAssemblyFromSource(parameters, file.ConcreteClass);
if (result.Errors.Count > 0)
foreach (CompilerError err in result.Errors)
message.AppendLine(string.Format(@"
On '{0}' (class name: {1}) Line {2}, Column {3}, {4} {5}:
{6}
========================================",
file.ViewName,
file.ClassName,
err.Line,
err.Column,
err.IsWarning ? "Warning" : "Error",
err.ErrorNumber,
err.ErrorText));
}
}
finally
{
cSharpCodeProvider.Dispose();
}
throw new Exception("Error while compiling views: " + message);
}
}
internal static Assembly GetProxyAssembly(string wsdlUri, string codeNamespace)
{
var provider = new CSharpCodeProvider();
var client = new WebClient();
var referenceAssemblies = new[] { "system.dll", "System.Xml.dll", "System.Web.Services.dll" };
var wsdlStream = client.OpenRead(wsdlUri);
var wsdl = ServiceDescription.Read(wsdlStream);
var wsdlImport = new ServiceDescriptionImporter();
wsdlImport.AddServiceDescription(wsdl, null, null);
var proxyClassNamespace = new CodeNamespace(codeNamespace);
var codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(proxyClassNamespace);
var warnings = wsdlImport.Import(proxyClassNamespace, codeCompileUnit);
if (warnings != 0)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while importing the WSDL!");
}
var compileParam = new CompilerParameters(referenceAssemblies)
{
GenerateInMemory = false,
OutputAssembly = GetProxyFileName()
};
CompilerResults compilerResults = provider.CompileAssemblyFromDom(compileParam, codeCompileUnit);
if (compilerResults.Errors.HasErrors)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while executing CompileAssemblyFromDom");
}
provider.Dispose();
return compilerResults.CompiledAssembly;
}
/// <summary>
/// Compile Script -> Return Assembly
/// </summary>
public Assembly CompileScript(IRefObject ScriptObject, out CompilerResults Result, String script, bool ClientSide = false)
{
String ClassName, PrefixName, AssemblyName = "";
switch (ScriptObject.Type)
{
case IRefObject.ScriptType.WEAPON:
ClassName = "ScriptWeapon";
PrefixName = "WeaponPrefix";
ServerWeapon tempWeap = (ServerWeapon)ScriptObject;
AssemblyName = tempWeap.Name.Replace("-", "weapon").Replace("*", "weapon");
break;
case IRefObject.ScriptType.CLASS:
PrefixName = "NpcClass";
ServerClass tempClass = (ServerClass)ScriptObject;
ClassName = tempClass.Name;
AssemblyName = "NpcClass." + tempClass.Name + ".dll";
break;
default:
ClassName = "ScriptLevelNpc";
PrefixName = "LevelNpcPrefix";
//ScriptLevelNpc tempNpc = (ScriptLevelNpc)ScriptObject;
AssemblyName = "";
break;
}
// Setup our options
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = false;
if (ClientSide || ScriptObject.Type == IRefObject.ScriptType.CLASS)
options.GenerateInMemory = false;
else
options.GenerateInMemory = true;
if (!ClientSide)
options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("OpenGraal.Core.dll");
options.ReferencedAssemblies.Add("OpenGraal.Common.dll");
options.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
options.ReferencedAssemblies.Add("MonoGame.Framework.dll");
if (this.GetClasses() != null)
{
foreach (KeyValuePair<string, ServerClass> npcClass in this.GetClasses())
{
if (npcClass.Value.Asm != null)
options.ReferencedAssemblies.Add(npcClass.Value.Asm);
}
}
//options.ReferencedAssemblies.
options.CompilerOptions = "/optimize";
if (AssemblyName == "")
AssemblyName = PrefixName + NextId[(int)ScriptObject.Type];
if (ClientSide)
options.OutputAssembly = AssemblyName + "_ClientSide.dll";
if (ScriptObject.Type == IRefObject.ScriptType.CLASS)
options.OutputAssembly = AssemblyName;
// Compile our code
CSharpCodeProvider csProvider = new Microsoft.CSharp.CSharpCodeProvider();
string usingNamespace = "";
usingNamespace = "using Microsoft.Xna.Framework.Input;";
string[] CompileData = new string[1];
if (ScriptObject.Type != IRefObject.ScriptType.CLASS)
CompileData.SetValue("using System;" + usingNamespace + "using OpenGraal; using OpenGraal.Core; using OpenGraal.Common.Levels; using OpenGraal.Common.Players; using OpenGraal.Common.Scripting; " + (this.GetClasses() != null && this.GetClasses().Count > 0 ? "using OpenGraal.Common.Scripting.NpcClass;" : "") + " public class " + PrefixName + NextId[(int)ScriptObject.Type] + " : " + ClassName + " { public " + PrefixName + NextId[(int)ScriptObject.Type] + "(CSocket Server, IRefObject Ref) : base(Server, Ref) { } " + script + " } ", 0);
else
CompileData.SetValue("using System;" + usingNamespace + "using OpenGraal; using OpenGraal.Core; using OpenGraal.Common.Levels; using OpenGraal.Common.Players; using OpenGraal.Common.Scripting; namespace OpenGraal.Common.Scripting.NpcClass { public class " + ClassName + " { " + script + "\n } }", 0);
Result = null;
try
{
Result = csProvider.CompileAssemblyFromSource(options, CompileData);
}
catch (Exception e)
{
return null;
}
csProvider.Dispose();
NextId[(int)ScriptObject.Type]++;
return (Result.Errors.HasErrors ? null : Result.CompiledAssembly);
}
/// <exception cref="Exception"><c>Exception</c>.</exception>
public void CreateLauncher(bool retributionLauncher)
{
LoggingManager.SendMessage("ModPacker - Generating launcher for mod " + ModManager.ModName);
string outputPath = m_sOutputDirectory + "Launch " + ModManager.ModName + ".exe";
CodeDomProvider provider = null;
try
{
var provOpts = new Dictionary<string, string> { { "CompilerVersion", "v2.0" } };
provider = new CSharpCodeProvider(provOpts);
var compilerParams = new CompilerParameters
{
GenerateExecutable = true,
IncludeDebugInformation = false,
OutputAssembly = outputPath
};
compilerParams.ReferencedAssemblies.Add("System.dll");
// set an icon if the user wishes to include one
if (m_sIconPath != string.Empty && File.Exists(m_sIconPath))
compilerParams.CompilerOptions = "/win32icon:\"" + m_sIconPath + "\"";
string tmp = Resources.CrudeLauncherSource.Replace("_MODNAME_", ModManager.ModName);
tmp = tmp.Replace("_APPID_", retributionLauncher ? GameConstants.RETRIBUTION_APP_ID : GameConstants.CR_APP_ID);
provider.CompileAssemblyFromSource(compilerParams, tmp);
provider.Dispose();
}
catch (Exception ex)
{
if (provider != null)
provider.Dispose();
LoggingManager.SendMessage("ModPacker - Failed to create launcher for mod " + ModManager.ModName);
LoggingManager.HandleException(ex);
throw;
}
LoggingManager.SendMessage("ModPacker - Successfully created launcher for mod " + ModManager.ModName);
}
public static ValuesPair<CodeQuery, List<String>> GetCodeQuery(Type type, string typeWrapperCode)
{
CSharpCodeProvider cscp = null;
try
{
cscp = new CSharpCodeProvider();
ValuesPair<CodeQuery, List<String>> res =
new ValuesPair<CodeQuery, List<string>>(null, new List<string>());
CodeQuery query = new CodeQuery();
query.CodeText = typeWrapperCode;
query.ObjectType = type.FullName;
CompilerParameters cp = new CompilerParameters();
cp.GenerateInMemory = true;
cp.TreatWarningsAsErrors = false;
foreach(Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
if(asm.IsDynamic == false)
cp.ReferencedAssemblies.Add(asm.Location);
CompilerResults cr = cscp.CompileAssemblyFromSource(cp, typeWrapperCode);
if(cr.Errors.Count > 0)
{
foreach(CompilerError err in cr.Errors)
res.Value2.Add(String.Format("[{0},{1}] {2} {3}: {4}",
err.Line, err.Column, err.IsWarning ? "Warning" : "Error", err.ErrorNumber, err.ErrorText));
}
if(cr.Errors.HasErrors)
return res;
MethodInfo mi = cr.CompiledAssembly.GetType(type.Name).GetMethod("DynamicMethod",
BindingFlags.NonPublic | BindingFlags.Instance);
MethodBody mb = mi.GetMethodBody();
query.MaxStackSize = mb.MaxStackSize;
query.Body = mb.GetILAsByteArray();
query.Schema = Discover(query.Body, mi, type);
if(mb.LocalVariables.Count > 0)
{
query.LocalVariables = new List<KeyValuePair<Type, bool>>(mb.LocalVariables.Count);
foreach(LocalVariableInfo lvi in mb.LocalVariables)
query.LocalVariables.Add(new KeyValuePair<Type, bool>(lvi.LocalType, lvi.IsPinned));
}
res.Value1 = query;
return res;
}
finally
{
if(cscp != null)
cscp.Dispose();
}
}
public List<string> AnswerCheck(int id, string source)
{
string fileName = @"c:\Test\"+DateTime.Now.Ticks+".dll";
Task task = new Task(id);
//Configure compiler
Dictionary<string, string> CompilerOptions = new Dictionary<string, string>
{
{"CompilerVersion", "v3.5" }
};
CSharpCodeProvider provider = new CSharpCodeProvider(CompilerOptions);
CompilerParameters compileParam = new CompilerParameters
{
OutputAssembly = fileName,
GenerateExecutable = false
};
CompilerResults result = provider.CompileAssemblyFromSource(compileParam, source);
provider.Dispose();
//check result of compile
if (result.Errors.Count != 0)
{
List<string> list = new List<string>();
foreach (CompilerError err in result.Errors)
list.Add(err.ToString());
return list;
}
//Invoke user method
Assembly assembly = result.CompiledAssembly;
Type type = assembly.GetType("Task.User");
if (type == null)
{
throw new Exception("Type not found!");
}
MethodInfo method = type.GetMethod(task.MethodName);
if (method != null)
{
//Check answer
int res = (int)method.Invoke(null, null);
if (res == task.Answer)
return new List<string> { "true" };
else
return new List<string> { "false" };
}
else
throw new Exception("method not found!");
}
