static void Main(string[] args)
{
AssemblyDomain.Init();
var hwFunc = FastMethodOperator
.RandomDomain()
.Param(typeof(string), "str1")
.Param <string>("str2")
.Body("return str1+str2;")
.Return <string>()
.Compile <Func <string, string, string> >();
Console.WriteLine(hwFunc("Hello", " World!"));
var a123 = NClass.UseDomain(typeof(Program).GetDomain());
var domain = DomainManagement.Random;
var type = NDelegate.UseDomain(domain).GetType("public class A{ public A(){Name=\"1\"; }public string Name;}");
var func = NDelegate.UseDomain(domain).Func <string>("return (new A()).Name;");
Console.WriteLine(type.FullName);
Console.WriteLine(func());
//type.RemoveReferences();
type = NDelegate.UseDomain(domain).GetType("public class A{ public A(){Name=\"2\"; }public string Name;}");
func = NDelegate.UseDomain(domain).Func <string>("return (new A()).Name;");
Console.WriteLine(type.FullName);
Console.WriteLine(func());
domain = DomainManagement.Create("a");
using (DomainManagement.Lock("a"))
{
Console.WriteLine(domain == (AssemblyDomain)AssemblyLoadContext.CurrentContextualReflectionContext);
}
}
public string GetResult1()
{
string result;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Sql", "ClassLibrary1.dll");
Assert.True(File.Exists(path));
using (DomainManagment.CreateAndLock("TempDADomain11"))
{
var domain = DomainManagment.CurrentDomain;
var assemebly = domain.LoadStream(path);
var action = FastMethodOperator.Default()
.Using(assemebly)
.MethodBody(@"
try{
Class1 a = new Class1();
return a.Show();
}
catch(Exception e){
Console.WriteLine(e.Message);
return e.Message;
}
return default;").Return <string>()
.Complie <Func <string> >();
result = action();
domain.Dispose();
}
return(result);
}
public static void Show1()
{
string result;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Sql", "ClassLibrary1.dll");
using (DomainManagement.CreateAndLock("TempDomain11"))
{
var domain = DomainManagement.CurrentDomain;
var assemebly = domain.LoadPluginFromStream(path);
var action = FastMethodOperator.DefaultDomain()
.Using(assemebly)
.Body(@"
try{
Class1 a = new Class1();
return a.Show();
}
catch(Exception e){
return e.Message;
}
return default;").Return <string>()
.Compile <Func <string> >();
result = action();
Console.WriteLine(result);
}
}
public static Delegate Creator(Type type)
{
return(FastMethodOperator
.Use(type.GetDomain())
.Body($"return new {type.GetDevelopName()}();")
.Return(type)
.Compile());
}
public static void RunDelegate3()
{
var delegateAction = FastMethodOperator.Random()
.Body(@"var temp = obj;")
.Compile <Action <string> >();
delegateAction?.Invoke("Hello");
Assert.NotNull(delegateAction);
}
public static void RunDelegate2()
{
var delegateAction = FastMethodOperator.Random()
.Body(@"return arg1 +"" ""+ arg2;")
.Compile <Func <string, string, string> >();
string result = delegateAction?.Invoke("Hello", "World2!");
Assert.Equal("Hello World2!", result);
}
public Delegate TypeRouter(NBuildInfo info)
{
string methodBody;
// 简单类型
// SimpleType
if (info.ArrayBaseType.IsSimpleType())
{
methodBody = GenerateSimpleTypeClone(info);
}
else if (info.ArrayBaseType == typeof(object))
{
// 多维+复杂
// MultiD+Complex
if (info.ArrayDimensions > 1)
{
methodBody = GenerateMultiDWithObjectClone(info);
}
// 1维+复杂 及 锯齿+复杂
// 1D+Complex and Jagged+Complex
else
{
methodBody = GenerateJaggedWithObjectClone2(info);
}
}
else
{
// 多维+复杂
// MultiD+Complex
if (info.ArrayDimensions > 1)
{
methodBody = GenerateMultiDWithComplexClone(info);
}
// 1维+复杂 及 锯齿+复杂
// 1D+Complex and Jagged+Complex
else
{
methodBody = GenerateJaggedWithComplexClone2(info);
}
}
var action = FastMethodOperator.Create(info.CurrentType.GetDomain())
.Using("DeepClone")
.Using(typeof(Array))
.Param(info.FatherType, "oldIns")
.MethodBody(methodBody)
.Return(info.FatherType)
.Complie();
return(action);
}
public static void RunInnerDelegate()
{
var delegateAction = FastMethodOperator
.DefaultDomain()
.Body(@"
OopTestModel.InnerClass a = new OopTestModel.InnerClass();
a.Name =""abc"";
return a;")
.Return <OopTestModel.InnerClass>()
.Compile();
var result = ((Func <OopTestModel.InnerClass>)delegateAction)?.Invoke();
Assert.Equal("abc", result.Name);
}
public static async void RunAsyncDelegate1()
{
var delegateAction = FastMethodOperator.Default()
.Async()
.Body(@"
await Task.Delay(100);
string result = arg1 +"" ""+ arg2;
return result;")
.Compile <Func <string, string, Task <string> > >();
string result = await delegateAction?.Invoke("Hello", "World2!");
Assert.Equal("Hello World2!", result);
}
public static void RunDelegate1()
{
var delegateAction = FastMethodOperator
.Random()
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
string result = str1 +"" ""+ str2;
return result;")
.Return <string>()
.Compile <Func <string, string, string> >();
string result = delegateAction?.Invoke("Hello", "World2!");
Assert.Equal("Hello World2!", result);
}
private Func <TIn, TOut> GetFunc <TIn, TOut>(string argsName = "arguments")
{
return(FastMethodOperator.RandomDomain(o =>
{
o.ThrowAndLogCompilerError();
o.ThrowAndLogSyntaxError();
o.UseStreamCompile();
foreach (var ns in _usingList)
{
o.Add($"using {ns};");
}
}).Param <TIn>(argsName)
.Body(_body)
.Return <TOut>()
.Compile <Func <TIn, TOut> >());
}
public void Test3()
{
var builder = FastMethodOperator.Default();
var delegateAction = builder
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result)1;
return result;")
.Return <string>()
.Compile();
Assert.Null(delegateAction);
Assert.Equal(CompileError.Syntax, builder.Compiler.CompileException.ErrorFlag);
Assert.Equal(CompileError.Syntax, builder.Compiler.SyntaxExceptions[0].ErrorFlag);
}
public static void RunDelegate2()
{
var delegateAction = FastMethodOperator
.DefaultDomain()
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result);
return result;")
.Return <string>()
.Compile <Func <string, string, string> >();
string result = delegateAction?.Invoke("Hello", "World2!");
Assert.Equal("Hello World2!", result);
}
public static void RunDelegate1()
{
var delegateAction = FastMethodOperator
.Create()
.Param <string>("str1")
.Param <string>("str2")
.MethodBody(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result);
return result;")
.Return <string>()
.Complie();
string result = ((Func <string, string, string>)delegateAction)?.Invoke("Hello", "World1!");
Assert.Equal("Hello World1!", result);
}
public static async void RunAsyncDelegate4()
{
var delegateAction = FastMethodOperator.Create()
.UseAsync()
.MethodBody(@"
await Task.Delay(100);
string result = arg1 +"" ""+ arg2;
Console.WriteLine(result);
return result;")
.Complie <Func <string, string, Task <string> > >();
string result = await delegateAction?.Invoke("Hello", "World2!");
Assert.Equal("Hello World2!", result);
}
internal string ForTest1()
{
var domain = DomainManagement.Create("SingleDomainAsmTest1");
var assembly = domain.CreateAssembly("AsmTest1");
var @interface = assembly
.CreateInterface("IAsmT1")
.Using("System")
.Public()
.Body("string ShowMethod(string str);");
var @class = assembly
.CreateClass("ClassAsm")
.Using("System")
.Public()
.Inheritance("IAsmT1")
.Method(method => method
.Public()
.DefinedName("ShowMethod")
.Param <string>("str")
.Body("return str+AsmEnum.Test.ToString();")
.Return <string>()
);
var @enum = assembly
.CreateEnum("AsmEnum")
.Public()
.EnumField("Test")
.EnumField("Test1")
.EnumField("Test2", 1);
var result = assembly.GetAssembly();
var type = assembly.GetTypeFromFullName(@class.NamespaceScript + "." + "ClassAsm");
var builder = FastMethodOperator.DefaultDomain();
builder.AssemblyBuilder.Compiler.Domain = domain;
var @delegate = builder.Using(type).Body(@"
ClassAsm obj = new ClassAsm();
return obj.ShowMethod(""Hello"");
").Compile <Func <string, string> >();
DomainManagement.Get("SingleDomainAsmTest1").Dispose();
return(@delegate("hello"));
}
public Delegate TypeRouter(NBuildInfo info)
{
if (info.CurrentType.IsGenericType)
{
StringBuilder scriptBuilder = new StringBuilder();
scriptBuilder.AppendLine(@"if(old!=default){ return ");
// 初始化目标，区分实体类和接口
if (!info.CurrentType.IsInterface)
{
scriptBuilder.AppendLine($"new {info.CurrentTypeName}");
}
scriptBuilder.AppendLine("(old.Select(item=>");
var parameters = info.CurrentType.GetGenericArguments();
if (parameters[0].IsSimpleType())
{
scriptBuilder.Append("item");
}
else if (parameters[0] == typeof(object))
{
scriptBuilder.Append("ObjectCloneOperator.Clone(item)");
}
else
{
scriptBuilder.Append("CloneOperator.Clone(item)");
}
scriptBuilder.Append("));");
scriptBuilder.AppendLine(@"}return default;");
var action = FastMethodOperator.UseDomain(info.CurrentType.GetDomain())
.Using("DeepClone")
.Using("System.Linq")
.Param(info.FatherType, "old")
.Body(scriptBuilder.ToString())
.Return(info.FatherType)
.Compile();
return(action);
}
else
{
throw new Exception("暂不支持");
}
}
public static async void RunAsyncDelegate1()
{
var delegateAction = FastMethodOperator
.Default()
.UseAsync()
.Param <string>("str1")
.Param <string>("str2")
.MethodBody(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result);
return result;")
.Return <Task <string> >()
.Complie();
string result = await((Func <string, string, Task <string> >)delegateAction)?.Invoke("Hello", "World1!");
Assert.Equal("Hello World1!", result);
}
public void Test3()
{
var builder = FastMethodOperator.DefaultDomain();
builder.AssemblyBuilder.Syntax.ErrorBehavior = ExceptionBehavior.None;
var delegateAction = builder
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result)1;
return result;")
.Return <string>()
.Compile();
Assert.Null(delegateAction);
Assert.Equal(ExceptionKind.Syntax, builder.Exception.ErrorFlag);
}
public string GetResult2()
{
string result;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Static", "ClassLibrary5.dll");
Assert.True(File.Exists(path));
using (DomainManagement.CreateAndLock("TempDomain12"))
{
var domain = DomainManagement.CurrentDomain;
var assemebly = domain.LoadPlugin(path);
var action = FastMethodOperator.UseDomain(domain)
.Body(@"Test.Instance.Name=""11""; return Test.Instance.Name;")
.Compile <Func <string> >();
result = action();
domain.Dispose();
domain.Unload();
}
return(result);
}
public static async void RunAsyncDelegate2()
{
var delegateAction = FastMethodOperator.Default()
.Async()
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
await Task.Delay(1000);
string result = str1 +"" ""+ str2;
return result;")
.Return <Task <string> >()
.Compile();
string result = await((Func <string, string, Task <string> >)delegateAction)?.Invoke("Hello", "World1!");
Assert.Equal("Hello World1!", result);
}
public void TestHelloWorld()
{
using (DomainManagement.CreateAndLock("MyDomain"))
{
var domain = DomainManagement.CurrentDomain;
var assembly = domain.CreateAssembly("MyAssembly");
//创建一个接口
assembly
.CreateInterface("InterfaceTest")
.Using("System")
.Public()
.Body("string ShowMethod(string str);");
//创建一个类并实现接口
var nameSpace = assembly
.CreateClass("TestClass")
.Using("System")
.Public()
.Inheritance("InterfaceTest")
.Method(method => method
.Public()
.DefinedName("ShowMethod")
.Param <string>("str")
.Body("return str+\" World!\";")
.Return <string>()).NamespaceScript;
var result = assembly.GetAssembly();
var type = assembly.GetTypeFromShortName("TestClass");
//单独创建一个程序集方法
var func = FastMethodOperator.UseDomain(domain)
.Using(type)
.Body(@"
TestClass obj = new TestClass();
return obj.ShowMethod(arg);")
.Compile <Func <string, string> >();
Assert.Equal("Hello World!", func("Hello"));
}
}
public string GetResult3()
{
string result;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Json", "ClassLibrary6.dll");
Assert.True(File.Exists(path));
using (DomainManagment.CreateAndLock("TempDomain13"))
{
var domain = DomainManagment.CurrentDomain;
var assemebly = domain.LoadStream(path);
var action = FastMethodOperator.Default()
.Using(assemebly)
.MethodBody(@"Class1 obj = new Class1(); return obj.Get();")
.Complie <Func <string> >();
result = action();
domain.Dispose();
domain.Unload();
}
return(result);
}
public Delegate TypeRouter(NBuildInfo info)
{
var instanceName = "oldSource";
info.FatherType = info.FatherType == typeof(object) ? info.CurrentType : info.FatherType;
if (info.CurrentType != info.FatherType)
{
instanceName = "old";
}
CtorHandler = new CtorTempalte(info.CurrentType, instanceName);
StringBuilder scriptBuilder = new StringBuilder();
var memberBuilder = new StringBuilder();
var builder = FastMethodOperator.UseDomain(info.CurrentType.GetDomain());
//构造函数处理: 不存在public无参构造函数无法克隆;
if (info.CurrentType.GetConstructor(new Type[0]) == null)
{
return(default);
public string GetResult3()
{
string result;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Json", "ClassLibrary6.dll");
Assert.True(File.Exists(path));
using (DomainManagement.CreateAndLock("TempDomain13"))
{
var domain = DomainManagement.CurrentDomain;
var assemebly = domain.LoadPluginFromStream(path);
var action = FastMethodOperator.UseDomain(domain,
item => item.Compiler.ErrorBehavior = Natasha.Error.Model.ExceptionBehavior.Log
)
.Using(assemebly)
.Body(@"Class1 obj = new Class1(); return obj.Get();")
.Compile <Func <string> >();
result = action();
domain.Dispose();
domain.Unload();
}
return(result);
}
public static void Test()
{
for (int i = 0; i < count; i++)
{
var ad = DomainManagement.Create("test" + i.ToString());
var builder = FastMethodOperator.Default();
builder.AssemblyBuilder.Compiler.Domain = ad;
func[i] = builder.Body($@"
int[] a = new int[40960];
for(int i =0;i<40960;i++){{a[i]=i;}}
string temp = @""111111111111111111111111111111111111111111111111111111111111111111111111
2222222222222222222222222222222222223333333333333333333333333333
2222222222222222222222222
44444444444444444444444444444444444444444444444444444444444444444444
555555555555555555555555555555555555555555555555555555555555
6666666666666666666666666666666666666666666666666666666666
77777777777777777777777777777777777777777777722221111111111111111111111111111111"";
Console.WriteLine(""HelloWorld111111111111111111111111111111111111111!"");
return a;
").Compile <Func <int[]> >();
func[i]();
}
}
public SimpleBuilder()
{
_script = new StringBuilder();
_destType = typeof(TDest);
_handler = FastMethodOperator.New;
}
public Delegate TypeRouter(NBuildInfo info)
{
StringBuilder scriptBuilder = new StringBuilder();
scriptBuilder.AppendLine(@"if(old!=default){ return ");
//初始化目标，区分实体类和接口
if (!info.CurrentType.IsInterface)
{
scriptBuilder.AppendLine($"new {info.CurrentTypeName}");
}
scriptBuilder.AppendLine("(old.Select(item=>KeyValuePair.Create(");
//克隆Key
var keyType = info.CurrentType.GetGenericArguments()[0];
if (keyType.IsSimpleType())
{
scriptBuilder.Append($"item.Key,");
}
else if (keyType == typeof(object))
{
scriptBuilder.AppendLine($"ObjectCloneOperator.Clone(item.Key),");
}
else
{
scriptBuilder.AppendLine($"CloneOperator.Clone(item.Key),");
}
//克隆Value
var valueType = info.CurrentType.GetGenericArguments()[1];
if (valueType.IsSimpleType())
{
scriptBuilder.Append($"item.Value");
}
else if (keyType == typeof(object))
{
scriptBuilder.AppendLine($"ObjectCloneOperator.Clone(item.Value),");
}
else
{
scriptBuilder.AppendLine($"CloneOperator.Clone(item.Value)");
}
//补全括号，返回默认值。
scriptBuilder.AppendLine(")));}return default;");
var action = FastMethodOperator.Create(info.CurrentType.GetDomain())
.Using("DeepClone")
.Using("System.Linq")
.Using(typeof(IDictionary))
.Using(typeof(KeyValuePair <,>))
.Param(info.FatherType, "old")
.MethodBody(scriptBuilder.ToString())
.Return(info.FatherType)
.Complie();
return(action);
}
public void Test2()
{
var domain = DomainManagement.Create("SingleDomainAsmTest2");
var assembly = domain.CreateAssembly("AsmTest1");
var @interface = assembly
.CreateInterface("IAsmT1")
.Using("System")
.Public()
.Body("string ShowMethod(string str);");
var @class = assembly
.CreateClass("ClassAsm")
.Using("System")
.Public()
.Inheritance("IAsmT1")
.Method(method => method
.Public()
.DefinedName("ShowMethod")
.Param <string>("str")
.Body("return str+AsmEnum.Test.ToString();")
.Return <string>()
);
var @enum = assembly
.CreateEnum("AsmEnum")
.Public()
.EnumField("Test")
.EnumField("Test1")
.EnumField("Test2", 1);
var result = assembly.GetAssembly();
var type = assembly.GetTypeFromFullName(@class.NamespaceScript + "." + "ClassAsm");
domain.Remove(type.Assembly);
assembly = domain.CreateAssembly("AsmTest2");
@interface = assembly
.CreateInterface("IAsmT1")
.Using("System")
.Public()
.Body("string ShowMethod(string str);");
@class = assembly
.CreateClass("ClassAsm")
.Using("System")
.Public()
.Inheritance("IAsmT1")
.Method(method => method
.Public()
.DefinedName("ShowMethod")
.Param <string>("str")
.Body("return str+AsmEnum.Test.ToString()+\"1\";")
.Return <string>()
);
@enum = assembly
.CreateEnum("AsmEnum")
.Public()
.EnumField("Test")
.EnumField("Test1")
.EnumField("Test2", 1);
result = assembly.GetAssembly();
type = assembly.GetTypeFromFullName(@class.NamespaceScript + ".ClassAsm");
var builder = FastMethodOperator.DefaultDomain();
builder.AssemblyBuilder.Compiler.Domain = domain;
var @delegate = builder.Using(type).Body(@"
ClassAsm obj = new ClassAsm();
return obj.ShowMethod(""Hello"");
").Compile <Func <string, string> >();
Assert.Equal("HelloTest1", @delegate("hello"));
#if !NETCOREAPP2_2
@delegate.DisposeDomain();
for (int i = 0; i < 10; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.True(DomainManagement.IsDeleted("SingleDomainAsmTest1"));
#endif
}
public static void Show()
{
//默认共享域
NStruct nStruct = new NStruct();
//nStruct
// .Namespace("Core30")
// .OopName("Test")
// .Ctor(builder => builder
// .PublicMember
// .Param<string>("name")
// .Body("Name=name;"))
// .PublicField<string>("Name");
//var type = nStruct.GetType();
var domain1 = DomainManagment.Create("TempDomain");
// nStruct = new NStruct();
// nStruct
// .Namespace("Core30")
// .OopName("Test1")
// .Ctor(builder => builder
// .PublicMember
// .Param<string>("name")
// .Body(@"Name=name+""1"";"))
// .PublicField<string>("Name");
//var type1 = nStruct.GetType();
// domain1.RemoveType(type1);
// nStruct = new NStruct();
// nStruct
// .Namespace("Core30")
// .OopName("Test")
// .Ctor(builder => builder
// .PublicMember
// .Param<string>("name")
// .Body(@"Name=name+""2"";"))
// .PublicField<string>("Name");
// var type3 = nStruct.GetType();
// domain1.RemoveType(type3);
nStruct = new NStruct();
nStruct.Compiler.Domain = domain1;
nStruct
.Namespace("Core30")
.DefinedName("Test")
.Ctor(builder => builder
.Public()
.Param <string>("name")
.Body(@"Name=name+""3"";"))
.PublicField <string>("Name");
var type4 = nStruct.GetType();
//nStruct = new NStruct();
//nStruct
// .INDelegate(domain1)
// .Namespace("Core30")
// .OopName("Test")
// .Ctor(builder => builder
// .PublicMember
// .Param<string>("name")
// .Body(@"Name=name+""1"";"))
// .PublicField<string>("Name");
//var type2 = nStruct.GetType();
var temp = FastMethodOperator.Default();
temp.Compiler.Domain = domain1;
temp
//.Using<Test>()
//.Using(type)
.Using(type4)
//.MethodAttribute<MethodImplAttribute>("MethodImplOptions.NoInlining")
.Body(@"
Test obj = new Test(""Hello World!"");
Console.WriteLine(obj.Name);"
);
action = temp.Compile <Action>();
action();
DomainManagment.Get("TempDomain").Dispose();
}
