public bool GetResult1()
{
bool result = false;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Sql", "ClassLibrary1.dll");
using (DomainManagment.CreateAndLock("TempDomain11"))
{
var domain = DomainManagment.CurrentDomain;
var assemebly = domain.LoadFile(path);
var action = FastMethodOperator.New
.Using(assemebly)
//.Using("MySql.Data.MySqlClient")
.MethodBody(@"
try{
//MySqlConnection conn = new MySqlConnection("""");
//conn.Open();
Class1 a = new Class1();
return a.Show();
}
catch{
}
return false;")
.Complie <Func <bool> >();
result = action();
domain.Dispose();
}
return(result);
}
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);
}
static void Main(string[] args)
{
Show1();
Console.WriteLine(DomainManagment.IsDeleted("TempDomain11"));
Console.ReadKey();
}
public void Test5()
{
#if !NETCOREAPP2_2
lock (obj)
{
Assembly result1;
using (DomainManagment.Lock("Default"))
{
var domain = DomainManagment.CurrentDomain;
//var assembly = domain.CreateAssembly("AsmTest1");
//assembly.AddScript("using System;namespace ClassLibrary1{ public class Class1{public string name;}}");
//var result2 = assembly.Compiler();
//var type2 = assembly.GetType("Class1");
//domain.RemoveAssembly(result2);
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Repeate", "ClassLibrary1.dll");
result1 = domain.LoadStream(path);
var type1 = result1.GetTypes().First(item => item.Name == "Class1");
//Assert.NotEqual(result1, result2);
//Assert.Equal(type1.Name, type2.Name);
}
var func = NDelegate.Default().Func <object>("return new Class1();", "ClassLibrary1");
Assert.Equal(result1, func().GetType().Assembly);
DomainManagment.CurrentDomain.RemoveAssembly(result1);
}
#endif
}
public static void TestMemoery()
{
Console.WriteLine("Memory1");
List <Type> list = new List <Type>();
var domain1 = DomainManagment.Create("TempDomain1");
for (int i = 0; i < 500; i += 1)
{
Console.WriteLine("new");
NClass nStruct = new NClass();
nStruct
.Namespace("Core301")
.OopName($"Test{i}")
.Ctor(builder => builder
.MemberAccess(AccessTypes.Public)
.Param <string>("name")
.Body("Name=name;"))
.PublicField <string>("Name")
.PublicField <string>("Name1")
.PublicField <string>("Name2")
.PublicField <string>("Name3")
.PublicField <string>("Name4");
list.Add(nStruct.GetType());
}
DomainManagment.Get("TempDomain1").Dispose();
}
public static void TestMemoery2()
{
Console.WriteLine("Memory2");
var domain1 = DomainManagment.Create("TempDomain2");
for (int i = 0; i < 10; i += 1)
{
Thread.Sleep(5000);
Console.WriteLine("new");
NClass nStruct = new NClass();
nStruct
.Namespace("Core30")
.OopName($"Test{i}")
.Ctor(builder => builder
.MemberAccess(AccessTypes.Public)
.Param <string>("name")
.Body("Name=name;"))
.PublicField <string>("Name")
.PublicField <string>("Name1")
.PublicField <string>("Name2")
.PublicField <string>("Name3")
.PublicField <string>("Name4");
var type = nStruct.GetType();
}
DomainManagment.Get("TempDomain2").Dispose();
DomainManagment.Get("TempDomain2").Unload();
}
public void Test3()
{
#if !NETCOREAPP2_2
using (DomainManagment.CreateAndLock("Default2"))
{
var domain = DomainManagment.CurrentDomain;
var assembly = domain.CreateAssembly("ClassLibrary1");
assembly.AddScript("using System;namespace ClassLibrary1{ public class Class1{public string name;}}");
var result2 = assembly.Complier();
var type2 = assembly.GetType("ClassLibrary1.Class1");
domain.RemoveAssembly(result2);
var assembly1 = domain.CreateAssembly("AsmTest2");
assembly1.AddScript("using System;namespace ClassLibrary1{ public class Class1{public string name;}}");
var result1 = assembly1.Complier();
var type1 = assembly1.GetType("ClassLibrary1.Class1");
Assert.NotEqual(result1, result2);
Assert.Equal(type1.Name, type2.Name);
lock (obj)
{
var func = NDomain.Default().Func <object>("return new Class1();", "ClassLibrary1");
Assert.Equal(result1, func().GetType().Assembly);
}
}
#endif
}
public void Test1()
{
#if !NETCOREAPP2_2
lock (obj)
{
using (DomainManagment.CreateAndLock("TestSame"))
{
var domain = DomainManagment.CurrentDomain;
var assembly = domain.CreateAssembly("ababab");
assembly.AddScript("using System;namespace ClassLibrary1{ public class Class1{public string name;}}");
var result2 = assembly.Complier();
var type2 = assembly.GetType("ClassLibrary1.Class1");
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Repeate", "ClassLibrary1.dll");
var result1 = domain.LoadStream(path);
var type1 = result1.GetTypes().First(item => item.Name == "Class1");
Assert.True(domain.RemoveDll(path));
Assert.Equal("TestSame", DomainManagment.CurrentDomain.Name);
Assert.NotEqual(result1, result2);
Assert.Equal(type1.Name, type2.Name);
var func = NDomain.Default().Func <object>("return new Class1();", "ClassLibrary1");
Assert.Equal(result2, func().GetType().Assembly);
}
}
#endif
}
public void Test3()
{
using (DomainManagment.CreateAndLock("CDomain1"))
{
var domain = DomainManagment.CurrentDomain;
Assert.Equal("CDomain1", domain.Name);
}
}
public void Test4()
{
using (DomainManagment.CreateAndLock("TempDomain14"))
{
var(Assembly, TypeCache) = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Sql", "ClassLibrary1.dll");
Assert.Equal("ClassLibrary1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", Assembly.FullName);
Assert.Equal("Class1", TypeCache["Class1"].Name);
}
}
public static void Release()
{
func = null;
for (int i = 0; i < count; i++)
{
var handler = DomainManagment.Get("test" + i.ToString());
handler.Dispose();
}
}
public void UnloadTest4()
{
Test4();
for (int i = 0; i < 6; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.True(DomainManagment.IsDeleted("Tesst4Domain"));
}
public void Test3()
{
Assert.Equal("{\"Name\":\"11\"}", GetResult3());
for (int i = 0; i < 6; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.False(DomainManagment.IsDeleted("TempDomain13"));
}
public void Test1()
{
Assert.False(GetResult1());
for (int i = 0; i < 6; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.False(DomainManagment.IsDeleted("TempDomain11"));
}
public static void UnloadDelegate()
{
Assert.Equal(3, RunDelegate6());
for (int i = 0; i < 6; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.True(DomainManagment.IsDeleted("NDomain6"));
}
public void Test2()
{
Assert.Equal("11", GetResult2());
for (int i = 0; i < 6; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.True(DomainManagment.IsDeleted("TempDomain12"));
}
public void Test1()
{
Assert.Equal("Unable to connect to any of the specified MySQL hosts.", GetResult1());
for (int i = 0; i < 6; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.False(DomainManagment.IsDeleted("TempDADomain11"));
}
public static void CheckAlive()
{
for (int i = 0; i < count; i++)
{
if (!DomainManagment.IsDeleted("test" + i.ToString()))
{
Console.WriteLine($"{i} is aliave!");
}
}
}
public static T Create(string domainName, Action <AssemblyComplier> option = default)
{
if (domainName == default || domainName.ToLower() == "default")
{
return(Create(DomainManagment.Default, option));
}
else
{
return(Create(DomainManagment.Create(domainName), option));
}
}
public static T Create(string domainName, ComplierResultError error, ComplierResultTarget target = ComplierResultTarget.Stream)
{
if (domainName == default || domainName.ToLower() == "default")
{
return(Create(DomainManagment.Default, target, error));
}
else
{
return(Create(DomainManagment.Create(domainName), target, error));
}
}
public void UnloadTest3()
{
Test3();
#if !NETCOREAPP2_2
for (int i = 0; i < 10; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.True(DomainManagment.IsDeleted("DomainOperatorTest3"));
#endif
}
public void Test1()
{
//ForTest1();
Assert.Equal("HelloTest", ForTest1());
#if !NETCOREAPP2_2
for (int i = 0; i < 10; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Assert.True(DomainManagment.IsDeleted("SingleDomainAsmTest1"));
#endif
}
public static int CheckAlive()
{
int tempCount = 0;
for (int i = 0; i < count; i++)
{
if (!DomainManagment.IsDeleted("test" + i.ToString()))
{
tempCount++;
Console.WriteLine($"{i} is aliave!");
}
}
return(tempCount);
}
public static void Testqq()
{
Thread.Sleep(5000);
TestMemoery();
for (int i = 0; (!DomainManagment.IsDeleted("TempDomain1")) && (i < 15); i++)
{
Console.WriteLine($"\t第{i}次！");
GC.Collect();
GC.WaitForPendingFinalizers();
Thread.Sleep(500);
}
//Testt();
Console.WriteLine(DomainManagment.IsDeleted("TempDomain1") ? "回收成功！" : "回收失败！");
}
/// <summary>
/// 如果参数为空，则使用默认域
/// 如果参数不为空，则创建以参数为名字的独立域
/// </summary>
/// <param name="domainName">域名</param>
/// <returns></returns>
public static TBuilder Create(string domainName = default, bool complieInFile = default)
{
TBuilder instance = new TBuilder();
instance.Complier.ComplieInFile = complieInFile;
if (domainName == default)
{
instance.Complier.Domain = DomainManagment.Default;
}
else
{
instance.Complier.Domain = DomainManagment.Create(domainName);
}
return(instance);
}
public void Test3()
{
var handler = DomainOperator.Default(ComplierResultError.ThrowException)
+ "DomainOperatorTest3"
& @"public class DomainTest1{
public string Name;
public DomainOperator Operator;
}" | "W1233";
var type = handler.GetType();
Assert.Equal("DomainTest1", type.Name);
DomainManagment.Get("DomainOperatorTest3").Dispose();
//type.DisposeDomain();
}
internal string ForTest1()
{
var domain = DomainManagment.Create("SingleDomainAsmTest1");
var assembly = domain.CreateAssembly("AsmTest1");
var @interface = assembly
.CreateInterface("IAsmT1")
.Using("System")
.Public
.OopBody("string ShowMethod(string str);");
var @class = assembly
.CreateClass("ClassAsm")
.Using("System")
.Public
.Inheritance("IAsmT1")
.Method(method => method
.PublicMember
.Name("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.Complier();
var type = assembly.GetType(@class.NamespaceScript + "." + "ClassAsm");
var builder = FastMethodOperator.Default();
builder.Complier.Domain = domain;
var @delegate = builder.Using(type).MethodBody(@"
ClassAsm obj = new ClassAsm();
return obj.ShowMethod(""Hello"");
").Complie <Func <string, string> >();
DomainManagment.Get("SingleDomainAsmTest1").Dispose();
return(@delegate("hello"));
}
public void Test4()
{
using (DomainManagment.CreateAndLock("TempDomain15"))
{
var(Assembly, Types, Exception) = @"
using System;
namespace TT{
public class Test{
}
}
";
Assert.Equal("Test", Types[0].Name);
}
}
public bool GetResult1()
{
bool result = false;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Sql", "ClassLibrary1.dll");
using (DomainManagment.CreateAndLock("TempDomain11"))
{
var domain = DomainManagment.CurrentDomain;
var assemebly = domain.LoadFile(path);
var action = FastMethodOperator.New
.Using(assemebly)
.MethodBody(@"Class1 a = new Class1();return a.Show();")
.Complie <Func <bool> >();
result = action();
domain.Dispose();
domain.Unload();
}
return(result);
}
public string GetResult2()
{
string result;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Static", "ClassLibrary5.dll");
using (DomainManagment.CreateAndLock("TempDomain12"))
{
var domain = DomainManagment.CurrentDomain;
var assemebly = domain.LoadFile(path);
var action = FastMethodOperator.New
.Using(assemebly)
.MethodBody(@"Test.Instance.Name=""11""; return Test.Instance.Name;")
.Complie <Func <string> >();
result = action();
domain.Dispose();
domain.Unload();
}
return(result);
}
