public static Expression <Func <TEntity, bool> > GetFuzzyExpression(FuzzyModel model)
{
var func = FuzzyQueryHandlerMapping[model.FuzzyField];
if (func != default)
{
return(func(model));
}
else if (PropertiesCache <TEntity> .PropMembers.Contains(model.FuzzyField) &&
!PropertiesCache <TEntity> .GetBlockWhereFields().Contains(model.FuzzyField))
{
var action = NDelegate
.DefaultDomain()
.Func <FuzzyModel, Expression <Func <TEntity, bool> > >($@"
Expression<Func<{typeof(TEntity).GetDevelopName()},bool>> exp = default;
if(arg.IgnoreCase) {{
exp = obj => obj.{model.FuzzyField}.Contains(arg.FuzzyValue,StringComparison.CurrentCultureIgnoreCase);
}} else {{
exp = obj => obj.{model.FuzzyField}.Contains(arg.FuzzyValue);
}}
return exp;
");
_dict[model.FuzzyField] = action;
FuzzyQueryHandlerMapping = _dict.PrecisioTree();
return(action(model));
}
return(default);
public void Test4()
{
#if !NETCOREAPP2_2
lock (obj)
{
Assembly result1;
//using (DomainManagment.Lock("Default"))
//{
var domain = DomainManagement.CurrentDomain;
var assembly = domain.CreateAssembly("DAsmTest1");
assembly.AddScript("using System;namespace ClassLibrary1{ public class Class1{public string name;}}");
var result2 = assembly.GetAssembly();
var type2 = result2.GetTypes().First(item => item.Name == "Class1");
domain.Remove(result2);
var assembly1 = domain.CreateAssembly("DAsmTest2");
assembly1.AddScript("using System;namespace ClassLibrary1{ public class Class1{public string name;}}");
result1 = assembly1.GetAssembly();
var type1 = result1.GetTypes().First(item => item.Name == "Class1");
Assert.NotEqual(result1, result2);
Assert.Equal(type1.Name, type2.Name);
//}
var func = NDelegate.DefaultDomain().AddUsing("ClassLibrary1").Func <object>("return new Class1();");
Assert.Equal(result1, func().GetType().Assembly);
DomainManagement.Default.Remove(result1);
}
#endif
}
public void Test5()
{
#if !NETCOREAPP2_2
lock (obj)
{
Assembly result1;
var domain = DomainManagement.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.LoadPluginFromStream(path);
var type1 = result1.GetTypes().First(item => item.Name == "Class1");
//Assert.NotEqual(result1, result2);
//Assert.Equal(type1.Name, type2.Name);
var func = NDelegate.DefaultDomain().Func <object>("return new Class1();", "ClassLibrary1");
Assert.Equal(result1, func().GetType().Assembly);
DomainManagement.Default.Remove(path);
}
#endif
}
public TestCaller()
{
string temp = "Hello";
Dict = new Dictionary <string, Action <CallModel, object> >();
Type type = typeof(CallModel);
CallerManagement.AddType(type);
DictHandler = DictOperator.CreateFromType(type);
FuzzyDictHandler = FuzzyDictOperator.CreateFromType(type);
HashDictHandler = HashDictOperator.CreateFromType(type);
LinkHandler = LinkOperator.CreateFromType(type);
FuzzyLinkHandler = FuzzyLinkOperator.CreateFromType(type);
HashLinkHandler = HashLinkOperator.CreateFromType(type);
Model = new CallModel();
Dynamic = new CallModel();
DictModel = new CallModel();
DictHandler.New();
FuzzyDictHandler.New();
HashDictHandler.New();
LinkHandler.New();
FuzzyLinkHandler.New();
HashLinkHandler.New();
Dict["Name"] = NDelegate.DefaultDomain().Action <CallModel, object>("arg1.Name=(string)arg2;");
}
public TestCaller()
{
NatashaInitializer.InitializeAndPreheating();
string temp = "Hello";
Dict = new Dictionary<string, Action<CallModel, object>>();
Type type = typeof(CallModel);
PrecisionDict = PrecisionDictOperator.CreateFromType(type);
FuzzyDict = FuzzyDictOperator.CreateFromType(type);
HashDict = HashDictOperator.CreateFromType(type);
//LinkHandler = LinkOperator.CreateFromType(type);
//FuzzyLinkHandler = FuzzyLinkOperator.CreateFromType(type);
//HashLinkHandler = HashLinkOperator.CreateFromType(type);
Model = new CallModel();
Dynamic = new CallModel();
DictModel = new CallModel();
PrecisionDict.New();
FuzzyDict.New();
HashDict.New();
Dict["Name"] = NDelegate.DefaultDomain().Action<CallModel, object>("arg1.Name=(string)arg2;");
for (int i = 0; i < 3000; i++)
{
Model.Name = "Hello";
Dynamic.Name = "Hello";
Dict["Name"](DictModel, "Hello");
PrecisionDict.Set("Name", "Hello");
}
}
public void Precache()
{
Type type = typeof(CallModel);
DynamicMethod method = new DynamicMethod("GetString", typeof(string), new Type[] { type });
ILGenerator il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, type.GetField("Age"));
il.Emit(OpCodes.Ret);
EmitGetString = (Func <CallModel, string>)(method.CreateDelegate(typeof(Func <CallModel, string>)));
method = new DynamicMethod("GetDateTime", typeof(DateTime), new Type[] { type });
il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, type.GetField("CreateTime"));
il.Emit(OpCodes.Ret);
EmitGetDateTime = (Func <CallModel, DateTime>)(method.CreateDelegate(typeof(Func <CallModel, DateTime>)));
method = new DynamicMethod("SetDateString", null, new Type[] { type, typeof(string) });
il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, type.GetField("Age"));
il.Emit(OpCodes.Ret);
EmitSetString = (Action <CallModel, string>)(method.CreateDelegate(typeof(Action <CallModel, string>)));
method = new DynamicMethod("SetDateTime", null, new Type[] { type, typeof(DateTime) });
il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, type.GetField("CreateTime"));
il.Emit(OpCodes.Ret);
EmitSetDateTime = (Action <CallModel, DateTime>)(method.CreateDelegate(typeof(Action <CallModel, DateTime>)));
NatashaGetString = NDelegate.DefaultDomain().Func <CallModel, string>("return arg.Age;");
NatashaGetString(OriginModel);
OriginGetString = item => item.Age;
NatashaGetDateTime = NDelegate.DefaultDomain().Func <CallModel, DateTime>("return arg.CreateTime;");
NatashaGetDateTime(OriginModel);
OriginGetDateTime = item => item.CreateTime;
NatashaSetString = NDelegate.DefaultDomain().Action <CallModel, string>("arg1.Age=arg2;");
NatashaSetString(OriginModel, OriginModel.Age);
OriginSetString = (item, value) => item.Age = value;
NatashaSetDateTime = DelegateOperator <ValueDelegate> .Delegate("model.CreateTime=value;");
NatashaSetDateTime(OriginModel, OriginModel.CreateTime);
OriginSetDateTime = OriginDateTime;
}
public static void Initialize(IFreeSql freeSql, params Type[] types)
{
foreach (var item in types)
{
NDelegate
.DefaultDomain()
.Action <IFreeSql>($"TableInfomationInitor<{item.GetDevelopName()}>.Initialize(obj);")(freeSql);
}
}
static InQueryOperator()
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine($"Expression<Func<{typeof(TEntity).GetDevelopName()},bool>> exp = a => arg.Contains(a.{TableInfomation<TEntity>.PrimaryKey}); return exp;");
InHandler = NDelegate
.DefaultDomain()
.Func <long[], Expression <Func <TEntity, bool> > >(stringBuilder.ToString());
}
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};");
}
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());
}
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 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));
}
