动态执行C# 代码

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Reflection;
usingSystem.Globalization;
usingMicrosoft.CSharp;
usingSystem.CodeDom;
usingSystem.CodeDom.Compiler;
usingSystem.Text;
usingSystem.IO;
usingSystem.Xml;

namespaceTest
{
classProgram
{
staticvoidMain(string[]args)
{
Console.Write(">>");
Stringcmd;
Contextcxt=newContext();
while((cmd=Console.ReadLine().Trim())!="exit")
{
if(!String.IsNullOrEmpty(cmd))
{
Console.WriteLine();
cxt.Invoke(cmd);
}
Console.Write("/n>>");
}
}
}

publicclassContext
{
publicCSharpCodeProviderCodeProvider{get;set;}
publicIDictionary<String,Assembly>Assemblys{get;set;}

publicContext()
{
CodeProvider=newCSharpCodeProvider(newDictionary<string,string>(){{"CompilerVersion","v3.5"}});
Assemblys=newDictionary<String,Assembly>();
Assembly[]al=AppDomain.CurrentDomain.GetAssemblies();
foreach(Assemblyainal)
{
AddAssembly(a);
}
AppDomain.CurrentDomain.AssemblyLoad+=newAssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
}

privatevoidAddAssembly(Assemblya)
{
if(a!=null)
{
Assemblys.Add(a.FullName,a);
}
}

voidCurrentDomain_AssemblyLoad(objectsender,AssemblyLoadEventArgsargs)
{
Assemblya=args.LoadedAssembly;
if(!Assemblys.ContainsKey(a.FullName))
{
AddAssembly(a);
}
}

publicCompilerParametersCreateCompilerParameters()
{
CompilerParameterscp=newCompilerParameters();
cp.GenerateExecutable=false;
cp.GenerateInMemory=true;
if(Assemblys!=null)
{
foreach(AssemblyainAssemblys.Values)
{
cp.ReferencedAssemblies.Add(a.Location);
}
}
returncp;
}

publicvoidInvoke(Stringcmd)
{
StringinputCmdString=cmd.Trim();
if(String.IsNullOrEmpty(inputCmdString))return;

StringfullCmd=BuildFullCmd(inputCmdString);

CompilerResultscr=CodeProvider.CompileAssemblyFromSource(CreateCompilerParameters(),fullCmd);

if(cr.Errors.HasErrors)
{
BooleanrecompileSwitch=true;

foreach(CompilerErrorerrincr.Errors)
{
//CS0201:Onlyassignment,call,increment,decrement,andnewobjectexpressionscanbe
//usedasastatement
if(!err.ErrorNumber.Equals("CS0201"))
{
recompileSwitch=false;
break;
}
}

//重新编译
if(recompileSwitch)
{
StringdynaName="TempArg_Dynamic_"+DateTime.Now.Ticks.ToString();
inputCmdString=String.Format("var{0}=",dynaName)+inputCmdString;
inputCmdString+=";/nSystem.Console.WriteLine("+dynaName+");";

fullCmd=BuildFullCmd(inputCmdString);
cr=CodeProvider.CompileAssemblyFromSource(CreateCompilerParameters(),fullCmd);
}

if(cr.Errors.HasErrors)
{
Console.WriteLine("编译错误：");
foreach(CompilerErrorerrincr.Errors)
{
Console.WriteLine(err.ErrorNumber);
Console.WriteLine(err.ErrorText);
}

return;
}
}

Assemblyassem=cr.CompiledAssembly;
ObjectdynamicObject=assem.CreateInstance("Test.DynamicClass");
Typet=assem.GetType("Test.DynamicClass");
MethodInfominfo=t.GetMethod("MethodInstance");
minfo.Invoke(dynamicObject,null);
}

privateStringBuildFullCmd(StringinputCmdString)
{
StringfullCmd=String.Empty;

[email protected]"
namespaceTest
{
publicclassDynamicClass
{
publicvoidMethodInstance()
{
"[email protected]";
}
}
}";
returnfullCmd;
}
}
}

publicSortedDictionary<String,Object>Instances{get;set;}
publicObjectthis[StringinstanceName]
{
get
{
if(Instances.ContainsKey(instanceName))
{
returnInstances[instanceName];
}
else
{
returnnull;
}
}
set
{
if(Instances.ContainsKey(instanceName))
{
Instances.Remove(instanceName);
}
Instances.Add(instanceName,value);
}
}

privateStringBuildFullCmd(StringinputCmdString)
{
StringfullCmd=String.Empty;

[email protected]"
usingTest;

publicclassDynamicClass
{
privateContextm_context;

publicvoidMethodInstance(Contextcontext)
{
m_context=context;
"[email protected]";
}
}";
returnfullCmd;
}

publicclassObjectHelper<T>
{
privateStringm_objName;

publicContextContext{get;privateset;}

publicTObj
{
get
{
Objectobj=Context[m_objName];
return(T)obj;
}
set{Context[m_objName]=value;}
}

publicObjectHelper(Contextcxt,StringobjName)
{
m_objName=objName;
Context=cxt;
}
}

Regexre;

//处理未初始化的环境变量
re=newRegex(@"^(/$)(/w)+");
if(inputCmdString!=null)
{
Matchm=re.Match(inputCmdString);
if(m!=null&&m.Length>1)
{
StringoutArgName=inputCmdString.Substring(m.Index,m.Length).Substring(1);
if(this[outArgName]==null)
{
StringinnerArgName="TempArg_"+outArgName;
inputCmdString="var"+inputCmdString.Replace("$"+outArgName,innerArgName);
inputCmdString+=";m_context[/""+outArgName+"/"]="+innerArgName+";";
}
}
}

//处理其它环境变量
re=newRegex(@"(/$)(/w)+");
IDictionary<String,String>ArgsList=newDictionary<String,String>();
if(inputCmdString!=null)
{
MatchCollectionmc=re.Matches(inputCmdString);
if(mc!=null)
{
foreach(Matchminmc)
{
if(m.Length>1)
{
StringoutArgName=inputCmdString.Substring(m.Index,m.Length).Substring(1);
if(!ArgsList.ContainsKey(outArgName))
{
Objectobj=this[outArgName];
if(obj==null)thrownewException("不存在环境变量"+outArgName);
StringinnerArgName=String.Format(@"(newObjectHelper<{0}>(m_context,""{1}"")).Obj",obj.GetType(),outArgName);
ArgsList.Add(outArgName,innerArgName);
}
}
}
}

foreach(StringoutArginArgsList.Keys)
{
inputCmdString=inputCmdString.Replace("$"+outArg,ArgsList[outArg]);
}
}