public void Test1()
{
var func = NDelegate
.RandomDomain(item => item.UseShareLibraries = true)
.Func <int>("return (new ConcurrentQueue<string>()).Count;");
Assert.Equal(0, func());
func = NDelegate
.RandomDomain()
.Func <int>("return (new ConcurrentQueue<string>()).Count;");
Assert.Equal(0, func());
}
public void LoadFromDll1()
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Static", "ClassLibrary6.dll");
var domain = DomainManagement.Random;
var assemebly = domain.LoadPluginFromStream(path);
var action = NDelegate
.UseDomain(domain)
.AddUsing(assemebly)
.Func <string>("Test.Instance.Name=\"11\"; return Test.Instance.Name;");
Assert.Equal("11", action());
}
public S Execute <S>()
{
if (!_currentCache.TryGetValue(_script, out var @delegate))
{
var action = NDelegate
.RandomDomain()
.WithFirstArgInvisible()
.Func <T, S>(_script);
_currentCache[_script] = @delegate;
return(action(_value));
}
return(((Func <T, S>)@delegate)(_value));
}
public void Test()
{
var action = NDelegate
.RandomDomain()
.SetClass(item => item.AllowPrivate <ReadonlyModel>())
.Action <ReadonlyModel>($"{"obj.@interface".ReadonlyScript()} = new DefaultReadolyInterface();");
ReadonlyModel model = new ReadonlyModel();
action(model);
Assert.NotNull(model.GetInterface());
}
public void Execute()
{
if (!_currentCache.TryGetValue(_script, out var @delegate))
{
var action = NDelegate
.RandomDomain()
.WithFirstArgInvisible()
.Action <T>(_script);
_currentCache[_script] = @delegate;
action(_value);
return;
}
((Action <T>)@delegate)(_value);
}
/// <summary>
/// 初始化 Natasha 组件并预热
/// </summary>
/// <returns></returns>
public static async Task InitializeAndPreheating(bool initializeReference = true)
{
Initialize(initializeReference);
var domain = DomainManagement.Random;
if (initializeReference)
{
domain.AddReferencesFromDllFile(typeof(object).Assembly.Location);
}
var action = NDelegate.UseDomain(domain).Action("");
action();
action.DisposeDomain();
}
/// <summary>
/// 对类型进行初始化配置
/// </summary>
/// <param name="freeSql"></param>
/// <param name="types"></param>
public static void InitializeTypes(IFreeSql freeSql, params Type[] types)
{
var domain = DomainManagement.Random;
foreach (var item in types)
{
if (item.IsClass)
{
_realTableNameMapping[item] = NDelegate
.UseDomain(domain)
.Func <IFreeSql, string>($"TableInfomation<{item.GetDevelopName()}>.Initialize(arg);return TableInfomation<{item.GetDevelopName()}>.TableName;")(freeSql);
}
}
domain.Dispose();
}
static void Main(string[] args)
{
NatashaInitializer.Initialize();
string text = @"namespace HelloWorld
{
public class Test
{
public Test(){
Name=""111"";
}
public string Name;
public int Age{get;set;}
}
}";
//根据脚本创建动态类
AssemblyCSharpBuilder oop = new AssemblyCSharpBuilder("test");
oop.Domain = DomainManagement.Random;
//oop.Domain.AddReferencesFromDllFile(typeof(object).Assembly.Location);
oop.Add(text);
Type type = oop.GetTypeFromShortName("Test");
Console.WriteLine(type.Name);
var action = NDelegate.UseDomain(oop.Domain).Action("");
var a = action.Method;
Console.WriteLine(action.Method.Module.Assembly);
Console.WriteLine(DomainManagement.IsDeleted(action.GetDomain().Name));
//var nClass = NClass
// .RandomDomain();
//nClass.DelegateHandler.
//type = NClass
// .RandomDomain().Namespace("")
// .Name("Test")
// .Ctor(item => item
// .Public()
// .Body("Name = null;")
// )
// .PublicField<string>("Name")
// .GetType();
//type.Assembly
//CSharpScript.EvaluateAsync
Console.ReadKey();
}
/// <summary>
/// 初始化 Natasha 组件并预热
/// </summary>
/// <returns></returns>
public static async Task InitializeAndPreheating()
{
if (!_hasInitialize)
{
lock (_lock)
{
if (!_hasInitialize)
{
_hasInitialize = true;
var action = NDelegate.RandomDomain().Action("");
action();
action.DisposeDomain();
}
}
}
}
static PrimaryKeyOperator()
{
var primaryKey = TableInfomation <TEntity> .PrimaryKey;
UpdateWhere = NDelegate
.DefaultDomain()
.Action <IUpdate <TEntity>, TPrimary>($"arg1.Where(item=>item.{primaryKey}==arg2);");
SelectWhere = NDelegate
.DefaultDomain()
.Action <ISelect <TEntity>, TPrimary>($"arg1.Where(item=>item.{primaryKey}==arg2);");
DeleteWhere = NDelegate
.DefaultDomain()
.Action <IDelete <TEntity>, TPrimary>($"arg1.Where(item=>item.{primaryKey}==arg2);");
PriamryKeyGetter = NDelegate
.DefaultDomain()
.Func <TEntity, TPrimary>($"return arg.{primaryKey};");
}
public void DiffDllTest2()
{
string path1 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Diff", "fileV1", "asmV1", "TestRefererenceLibrary.dll");
string path2 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Lib", "Diff", "fileV1", "asmV2", "TestReferenceLibrary2.dll");
var domain = DomainManagement.Random;
//Load B => C v1.0
var assembly = domain.LoadPlugin(path1);
//Load A => C v2.0
var assembly2 = domain.LoadPlugin(path2);
var result = NDelegate.UseDomain(domain).Func <string>("return new TestRefererenceLibrary2.TestReference().Get();")();
var result2 = NDelegate.UseDomain(domain).Func <string>("return new TestRefererenceLibrary.TestReference().Get();")();
Assert.Equal(result, result2);
Assert.Equal("2.0.0.0", result);
}
public void TestTypeEqual()
{
var domain = DomainManagement.Random;
var type = NDelegate.UseDomain(domain, builder => {
builder
.CustomerUsing() //使用用户自定义的Using
.SetAssemblyName("MyAssemblyName") //设置程序集名
.ThrowAndLogCompilerError() //抛出并记录编译器的异常
.ThrowSyntaxError() //抛出语法树异常
.UseStreamCompile(); //使用流编译
}).GetType(
@"public class DomainTest1{
public string Name;
public int Operator;
}");
Assert.Equal(domain, type.GetDomain());
}
public void Test6()
{
string assemblyName = "tsda";
AssemblyCSharpBuilder builder = new AssemblyCSharpBuilder(assemblyName);
builder.Compiler.Domain = DomainManagement.Create("a");
builder.Add("public class TSDA{}");
var assembly = builder.GetAssembly();
assembly.RemoveReferences();
Assert.NotNull(assembly);
builder = new AssemblyCSharpBuilder();
builder.Compiler.Domain = DomainManagement.Create("a");
builder.Add("public class TSDA{}");
var assembly1 = builder.GetAssembly();
Assert.NotEqual(assembly, assembly1);
var func = NDelegate.CreateDomain("a").Func <string>("return typeof(TSDA).Assembly.FullName;");
Assert.Equal(assembly1.FullName, func());
}
static void Main(string[] args)
{
NatashaInitializer.InitializeAndPreheating();
//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!"));
string temp = NDelegate.RandomDomain().Func <string>("return (new A()).Name;")();
Console.WriteLine(temp);
//var a123 = NClass.UseDomain(typeof(Program).GetDomain());
//var domain = DomainManagement.Random;
//var type = NDelegate.UseDomain(domain,item=>item.AssemblyName="a").GetType($"[assembly: AssemblyKeyFileAttribute(\"c:\\\\vs2019\\\\natasha.snk\")]" +"[assembly: AssemblyVersion(\"1.3.3.3\")]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,item=>item.AssemblyName="a").GetType($"[assembly: AssemblyKeyFileAttribute(\"c:\\\\vs2019\\\\natasha.snk\")]" + "[assembly: AssemblyVersion(\"2.3.3.4\")]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 == (NatashaAssemblyDomain)AssemblyLoadContext.CurrentContextualReflectionContext);
//}
Console.ReadKey();
}
/// <summary>
/// 初始化 Natasha 组件并预热
/// </summary>
/// <returns></returns>
public static async Task InitializeAndPreheating(bool initializeReference = true)
{
await Initialize(initializeReference);
var domain = DomainManagement.Random;
if (!initializeReference)
{
domain.AddReferencesFromDllFile(typeof(object).Assembly.Location);
}
#if DEBUG
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
#endif
var action = NDelegate.UseDomain(domain).Action("");
#if DEBUG
stopwatch.Stop();
Console.WriteLine($"\r\n================ [Preheating]\t预热总时长: {stopwatch.ElapsedMilliseconds}ms ================ \r\n");
#endif
action();
action.DisposeDomain();
}
static void Main(string[] args)
{
//NatashaInitializer.Initialize();
//注册+预热组件 , 之后编译会更加快速
NatashaInitializer.Preheating();
string str = "return \"S1,S2,3,4,5,6\".Split(\",\").Where(u => u.StartsWith(\"D\")).Count()>0;";
Stopwatch sw = new Stopwatch();
sw.Start();
//NDelegate.CreateDomain("a", item => item.DisableSemanticCheck().ConfigCompilerOption(opt => opt.AddSupperess("CS8019").UseSuppressReportor(false)))
//List<Task> tasks = new List<Task>();
//for (int i = 0; i < 4; i++)
//{
// tasks.Add(Task.Factory.StartNew(() => {
// for (int i = 0; i < 50; i++)
// {
// str = $"return \"S1,{i},3,4,5,6\".Split(\",\").Where(u => u.StartsWith(\"D\")).Count()>0;";
// var func = NDelegate.CreateDomain("MyDomain", item => item.DisableSemanticCheck().ConfigCompilerOption(opt => opt.AddSupperess("CS8019").UseSuppressReportor(false))).Func<bool>(str);
// var aa = func();
// //func.DisposeDomain();
// }
// }));
//}
//Task.WaitAll(tasks.ToArray());
for (int i = 0; i < 200; i++)
{
str = $"return \"S1,{i},3,4,5,6\".Split(\",\").Where(u => u.StartsWith(\"D\")).Count()>0;";
var func = NDelegate.CreateDomain("MyDomain", item => item.DisableSemanticCheck().ConfigCompilerOption(opt => opt.AddSupperess("CS8019").UseSuppressReportor(false))).Func <bool>(str);
var aa = func();
//func.DisposeDomain();
}
sw.Stop();
var yb = sw.ElapsedMilliseconds;//毫秒
Console.ReadKey();
}
static InsertOperator()
{
if (TableInfomation <TEntity> .PrimaryKey != default && TableInfomation <TEntity> .PrimaryKeyIsLong)
{
Insert = NDelegate
.UseDomain(typeof(TEntity).GetDomain())
.Func <IFreeSql, TEntity[], bool>($@"
var insert = arg1.Insert(arg2).IgnoreColumns(PropertiesCache<{typeof(TEntity).GetDevelopName()}>.BlockInsertCoulmns);
var id = insert.ExecuteIdentity();
arg2[arg2.Length - 1].{TableInfomation<TEntity>.PrimaryKey} = id;
return id != 0;
");
}
else
{
Insert = NDelegate
.UseDomain(typeof(TEntity).GetDomain())
.Func <IFreeSql, TEntity[], bool>($@"
var insert = arg1.Insert(arg2).IgnoreColumns(PropertiesCache<{typeof(TEntity).GetDevelopName()}>.BlockInsertCoulmns);
return insert.ExecuteAffrows() == arg2.Length;
");
}
}
static HttpContextUpdateOperator()
{
var stringBuilder = new StringBuilder();
var propNames = typeof(TEntity).GetProperties().Select(item => item.Name);
var allowList = PropertiesCache <TEntity> .GetAllowUpdateFields();
stringBuilder.AppendLine($"Expression<Func<{typeof(TEntity).GetDevelopName()},bool>> exp = default;");
Dictionary <string, string> dict = new Dictionary <string, string>();
foreach (var name in propNames)
{
if (allowList.Contains(name))
{
dict[name] = $"exp = obj => obj.{name} == arg2.{name};";
}
}
stringBuilder.AppendLine(BTFTemplate.GetGroupPrecisionPointBTFScript(dict, "arg1"));
stringBuilder.AppendLine("return exp;");
UpdateFieldsHandler += NDelegate
.DefaultDomain()
.UnsafeFunc <string, TEntity, Expression <Func <TEntity, bool> > >(stringBuilder.ToString());
}
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);
}
Console.ReadKey();
}
static void Main(string[] args)
{
var a123 = NClass.Use(typeof(Program).GetDomain());
var domain = DomainManagment.Random;
var type = NDelegate.Use(domain).GetType("public class A{ public A(){Name=\"1\"; }public string Name;}");
Console.WriteLine(type.FullName);
var func = NDelegate.Use(domain).Func <string>("return (new A()).Name;");
Console.WriteLine(func());
type.RemoveReferences();
type = NDelegate.Use(domain).GetType("public class A{ public A(){Name=\"2\"; }public string Name;}");
func = NDelegate.Use(domain).Func <string>("return (new A()).Name;");
Console.WriteLine(type.FullName);
Console.WriteLine(func());
domain = DomainManagment.Create("a");
using (DomainManagment.Lock("a"))
{
Console.WriteLine(domain == (AssemblyDomain)AssemblyLoadContext.CurrentContextualReflectionContext);
}
}
public void Test5()
{
NSucceedLog.Enabled = true;
#if !NETCOREAPP2_2
lock (obj)
{
Assembly result1;
var domain = DomainManagement.Random;
//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.LoadPlugin(path);
var type1 = result1.GetTypes().First(item => item.Name == "Class1");
//Assert.NotEqual(result1, result2);
//Assert.Equal(type1.Name, type2.Name);
var func = NDelegate.
UseDomain(domain)
.AddUsing("ClassLibrary1")
.Func <object>("return new Class1();");
Assert.Equal(result1, func().GetType().Assembly);
domain.RemoveReference(path);
}
#endif
}
public static void RunDelegate3()
{
var func = NDelegate.CreateDomain("NDelegate3").Func <string, string, string>("return arg1+arg2;");
Assert.Equal("12", func("1", "2"));
}
public static IEnumerable <TReturn> ToList <TReturn>(ISelect <TEntity> select, Expression <Func <TEntity, TReturn> > expression)
{
//查询表达式树是否为之前处理过的
if (JoinAction <TEntity, TReturn> .Action == null)
{
//给匿名类创建一个代理类
StringBuilder fieldsScript = new StringBuilder();
StringBuilder joinScript = new StringBuilder();
// 获取构造函数参数
var arguments = ((NewExpression)expression.Body).Arguments;
//获取匿名类成员
var members = ((NewExpression)expression.Body).Members;
for (int i = 0; i < arguments.Count; i++)
{
if (arguments[i].NodeType == ExpressionType.MemberAccess)
{
var memberExpression = (MemberExpression)arguments[i];
var memberName = memberExpression.Member.Name;
// 方法类型参数
if (memberExpression.Expression.NodeType == ExpressionType.Convert ||
memberExpression.Expression.NodeType == ExpressionType.Call)
{
var scriptKey = memberExpression.Expression.ToString();
var aliasName = "";
if (JoinExpressionMapping[scriptKey] == default)
{
string targetMemberName = default;
var methodExp = (MethodCallExpression)memberExpression.Expression;
if (methodExp.Arguments[1].NodeType == ExpressionType.Quote)
{
var unaryExp = (UnaryExpression)(methodExp.Arguments[1]);
if (unaryExp.NodeType == ExpressionType.Quote)
{
var lbdExp = (LambdaExpression)(unaryExp.Operand);
if (lbdExp.Body.NodeType == ExpressionType.Convert)
{
var bodyExp = (UnaryExpression)lbdExp.Body;
if (bodyExp.Operand.NodeType == ExpressionType.MemberAccess)
{
var memberExp = (MemberExpression)(bodyExp.Operand);
var tempValues = memberExp.ToString().Split('.');
aliasName = tempValues[0];
targetMemberName = tempValues[1];
_joinDict[scriptKey] = aliasName;
JoinExpressionMapping = _joinDict.PrecisioTree();
}
}
}
}
if (methodExp.NodeType == ExpressionType.Call)
{
var joinTableType = methodExp.Method.GetGenericArguments()[0].GetDevelopName();
string condition = default;
if (methodExp.Arguments.Count > 2)
{
var exp = methodExp.Arguments[2];
if (exp.NodeType == ExpressionType.Quote)
{
condition = "&&" + ((LambdaExpression)(((UnaryExpression)exp).Operand)).Body.ToString();
}
}
var joinType = methodExp.Method.Name;
MemberExpression memberExp = default;
if (methodExp.Arguments[0].NodeType == ExpressionType.Convert)
{
memberExp = (MemberExpression)((UnaryExpression)(methodExp.Arguments[0])).Operand;
}
else if (methodExp.Arguments[0].NodeType == ExpressionType.MemberAccess)
{
memberExp = (MemberExpression)(methodExp.Arguments[0]);
}
if (memberExp != default)
{
var sourceMemberName = memberExp.Member.Name;
if (joinType == "AriesInnerJoin")
{
joinScript.Append($"obj.InnerJoin<{joinTableType}>((a,{aliasName})=>a.{sourceMemberName} == {aliasName}.{targetMemberName}{condition});");
}
else if (joinType == "AriesLeftJoin")
{
joinScript.Append($"obj.LeftJoin<{joinTableType}>((a,{aliasName})=>a.{sourceMemberName} == {aliasName}.{targetMemberName}{condition});");
}
else if (joinType == "AriesRightJoin")
{
joinScript.Append($"obj.RightJoin<{joinTableType}>((a,{aliasName})=>a.{sourceMemberName} == {aliasName}.{targetMemberName}{condition});");
}
}
}
}
fieldsScript.Append($"{JoinExpressionMapping[scriptKey]}.\"{memberName}\" AS \"{members[i].Name}\",");
}
else
{
if (members[i].Name == memberName)
{
fieldsScript.Append($"a.\"{memberName}\",");
}
else
{
fieldsScript.Append($"a.\"{memberName}\" AS \"{members[i].Name}\",");
}
}
}
}
if (fieldsScript.Length > 1)
{
fieldsScript.Length -= 1;
JoinAction <TEntity, TReturn> .FieldsScript = fieldsScript.ToString();
JoinAction <TEntity, TReturn> .Action = NDelegate
.DefaultDomain()
.Action <ISelect <TEntity> >(joinScript.ToString());
}
}
//调用 TReturn 的处理函数
JoinAction <TEntity, TReturn> .Action(select);
//返回执行结果
return(select.ToList <TReturn>(JoinAction <TEntity, TReturn> .FieldsScript));
//return ProxyCaller<TEntity, TReturn>.ToList(code, select);
}
public static NDelegate WithCS0104Handler(this NDelegate template)
{
template.AssemblyBuilder.AddSemanticAnalysistor(AmbiguityUsings.NDelegateCreator(template));
return(template);
}
public IEnumerable <object> ToList <TReturn>(Expression <Func <TEntity, TReturn> > expression)
{
var code = expression.GetHashCode();
if (SelectHandler == null)
{
SelectHandler = SqlHandler.Select <TEntity>();
}
var type = typeof(TReturn);
if (!JoinExpressionMapping.Contains(code))
{
var nclass = NClass.DefaultDomain().Public();
StringBuilder script = new StringBuilder();
// 获取构造函数参数
var arguments = ((NewExpression)expression.Body).Arguments;
//获取匿名类成员
var members = ((NewExpression)expression.Body).Members;
var joinTypeFlagMapping = new Dictionary <Type, JoinTypeFlag>();
for (int i = 0; i < arguments.Count; i++)
{
// 方法类型参数
if (arguments[i].NodeType == ExpressionType.Call)
{
var methodExpression = (MethodCallExpression)arguments[i];
var methodDeclaringType = methodExpression.Method.DeclaringType;
if (methodDeclaringType.IsGenericType && methodDeclaringType.GetGenericTypeDefinition().Name.Contains("Join"))
{
var joinType = methodDeclaringType.GetGenericArguments()[0];
if (methodExpression.Arguments[0].NodeType == ExpressionType.Quote)
{
var quoteExpression = (UnaryExpression)methodExpression.Arguments[0];
if (quoteExpression.Operand.NodeType == ExpressionType.Lambda)
{
var lambdaExpression = (LambdaExpression)quoteExpression.Operand;
if (lambdaExpression.Body.NodeType == ExpressionType.MemberAccess)
{
var memberExpression = (MemberExpression)lambdaExpression.Body;
nclass.Property(item => item
.Public()
.Type(((PropertyInfo)memberExpression.Member).PropertyType)
.Name(memberExpression.Member.Name));
var definitionType = methodDeclaringType.GetGenericTypeDefinition();
if (definitionType == typeof(InnerJoin <>))
{
joinTypeFlagMapping[joinType] = JoinTypeFlag.Inner;
script.Append(InnerJoin.GetJoinScript(joinType));
}
else if (definitionType == typeof(LeftJoin <>))
{
joinTypeFlagMapping[joinType] = JoinTypeFlag.Left;
script.Append(LeftJoin.GetJoinScript(joinType));
}
else if (definitionType == typeof(RightJoin <>))
{
joinTypeFlagMapping[joinType] = JoinTypeFlag.Right;
script.Append(RightJoin.GetJoinScript(joinType));
}
script.Append($".\"{memberExpression.Member.Name}\" AS \"{members[i].Name}\",");
}
}
}
}
}
else if (arguments[i].NodeType == ExpressionType.MemberAccess)
{
var memberExpression = (MemberExpression)arguments[i];
nclass.Property(item => item
.Public()
.Type(((PropertyInfo)memberExpression.Member).PropertyType)
.Name(memberExpression.Member.Name));
script.Append($"a.\"{memberExpression.Member.Name}\",");
}
//JoinObjectCache<ISelect<T>, TReturn>.GetObjects = NDelegate.RandomDomain().Func<ISelect<T>, object>(builder.ToString());
}
if (script.Length > 1)
{
script.Length -= 1;
var joinScript = script.ToString();
JoinExpressionMapping = JoinExpressionMapping.Add(code);
var tempClass = nclass.GetType();
ProxyCaller <TEntity, TReturn> .Add(code, NDelegate
.DefaultDomain(item => item.LogSyntaxError())
.Func <ISelect <TEntity>, IEnumerable <object> >($"return arg.ToList<{tempClass.GetDevelopName()}>(\"{joinScript.Replace("\"","\\\"")}\");"));
var builder = new StringBuilder();
foreach (var item in joinTypeFlagMapping)
{
var joinFieldCache = OrmNavigate <TEntity> .JoinScriptMapping[item.Key];
string joinAlias = string.Empty;
switch (item.Value)
{
case JoinTypeFlag.Left:
joinAlias = LeftJoin.GetJoinScript(item.Key);
builder.Append($"obj.LeftJoin(\"");
break;
case JoinTypeFlag.Inner:
joinAlias = InnerJoin.GetJoinScript(item.Key);
builder.Append($"obj.InnerJoin(\"");
break;
case JoinTypeFlag.Right:
joinAlias = RightJoin.GetJoinScript(item.Key);
builder.Append($"obj.RightJoin(\"");
break;
default:
break;
}
var joinFieldScript = $"\"{item.Key.Name}\" AS {joinAlias} ON a.\"{joinFieldCache.src}\" = {joinAlias}.\"{joinFieldCache.dst}\"";
builder.Append(joinFieldScript.Replace("\"", "\\\""));
builder.AppendLine("\");");
}
//$"\"{typeof(TJoinEntity).Name}\" AS {InnerJoinHelper<TJoinEntity>.JoinAliasName} ON a.\"{srcFieldName}\" = {InnerJoinHelper<TJoinEntity>.JoinAliasName}.\"{destFieldName}\"")
JoinFiller <TEntity, TReturn> .Add(code, NDelegate
.DefaultDomain()
.Action <ISelect <TEntity> >(builder.ToString()));
}
}
JoinFiller <TEntity, TReturn> .HandlerSelect(code, SelectHandler);
return(ProxyCaller <TEntity, TReturn> .ToList(code, SelectHandler));
}
public static string HandlerType(string key, Type type, string method)
{
if (!LibraTypeManagement.HasMethod(type, method))
{
return("该类型不支持远程调用!");
}
var methodInfo = type.GetMethod(method);
var methodCallBuilder = new StringBuilder();
var parameterInfos = methodInfo.GetParameters();
ParameterInfo firstParameterInfo = default;
string parameterName = default;
var classBuilder = new StringBuilder();
if (parameterInfos.Length > 1)
{
parameterName = "parameters";
var parameterBuilder = new StringBuilder();
var className = "N" + Guid.NewGuid().ToString("N");
classBuilder.Append($"public class {className}{{");
foreach (var item in parameterInfos.OrderBy(c => c.Position))
{
parameterBuilder.Append($"parameters.{item.Name},");
classBuilder.Append($"public {item.ParameterType.GetDevelopName()} {item.Name} {{ get;set; }}");
}
classBuilder.Append('}');
methodCallBuilder.AppendLine($"var {parameterName} = string.IsNullOrEmpty(arg) ? default : System.Text.Json.JsonSerializer.Deserialize<{className}>(arg,LibraProtocalAnalysis.JsonOption);");
parameterBuilder.Length -= 1;
parameterName = parameterBuilder.ToString();
}
else if (parameterInfos.Length == 1)
{
parameterName = "parameters";
firstParameterInfo = parameterInfos[0];
var pType = firstParameterInfo.ParameterType;
if (pType.IsPrimitive || pType == typeof(string) || pType == typeof(DateTime))
{
methodCallBuilder.AppendLine($"var {parameterName} = string.IsNullOrEmpty(arg) ? default : System.Text.Json.JsonSerializer.Deserialize<LibraSingleParameter<{firstParameterInfo.ParameterType.GetDevelopName()}>>(arg,LibraProtocalAnalysis.JsonOption);");
parameterName += ".Value";
}
else
{
methodCallBuilder.AppendLine($"var {parameterName} = string.IsNullOrEmpty(arg) ? default : System.Text.Json.JsonSerializer.Deserialize<{firstParameterInfo.ParameterType.GetDevelopName()}>(arg,LibraProtocalAnalysis.JsonOption);");
}
}
//获取调用者
string caller = default;
if (methodInfo.IsStatic)
{
caller = type.GetDevelopName();
}
else
{
caller = $"LibraProtocalAnalysis.Provider.GetService<{type.GetDevelopName()}>()";
}
//调用
if (methodInfo.ReturnType != typeof(void))
{
methodCallBuilder.AppendLine($"var result = new LibraResult<{methodInfo.ReturnType.GetDevelopName()}>(){{ Value = {caller}.{methodInfo.Name}({parameterName}) }};");
methodCallBuilder.AppendLine($"return System.Text.Json.JsonSerializer.Serialize(result);");
}
else
{
methodCallBuilder.AppendLine($"{caller}.{methodInfo.Name}({parameterName});");
methodCallBuilder.AppendLine("return default;");
}
_invokerMapping[key] = NDelegate
.RandomDomain(item =>
{
item
.LogSyntaxError()
.UseFileCompile();
})
.SetClass(item => item.AllowPrivate(type).Body(classBuilder.ToString()))
.Func <string, string>(methodCallBuilder.ToString());
_invokeFastCache = _invokerMapping.PrecisioTree();
return(null);
}
public static void RunDelegate7()
{
var func = NDelegate.CreateDomain("NDelegate7").Func <string>("return OtherNameSpaceMethod.FromDate(DateTime.Now);");
Assert.Equal(DateTime.Now.ToString("yyyy-MM"), func());
}
public static void RunDelegate1()
{
var func = NDelegate.CreateDomain("NDelegate1").Func <string>("return \"1\";");
Assert.Equal("1", func());
}
public ActionResult <IEnumerable <string> > Get()
{
string result = NDelegate.Random().Func <string>("return \"a\";")();
return(new string[] { "value1", result });
}
public static void Main(string[] args)
{
string result = NDelegate.RandomDomain().Func <string>("return \"a\";")();
CreateHostBuilder(args).Build().Run();
}
