public void TestCall3()
{
//创建动态类实例代理
var instance = LinkOperator <TestB> .Create();
instance.New();
Assert.Equal("111", instance["Name"].Get <string>());
//调用动态委托赋值
instance.Set("Name", "222");
Assert.Equal("222", instance["Name"].Get <string>());
var c = instance["InstanceC"].Get <TestC>();
Assert.Equal("abc", c.Name);
instance["InstanceC"].Set(new TestC()
{
Name = "bbca"
});
Assert.Equal("bbca", instance["InstanceC"].Get <TestC>().Name);
}
public void TestCall1()
{
//ScriptComplier.Init();
string text = @"using System;
using System.Collections;
using System.Linq;
using System.Text;
namespace HelloWorld
{
public class Test
{
public Test(){
Name=""111"";
}
public string Name;
public int Age{get;set;}
}
}";
//根据脚本创建动态类
Type type = (new OopComplier()).GetClassType(text);
//创建动态类实例代理
var instance = LinkOperator.Create(type);
instance.New();
//Get动态调用
Assert.Equal("111", instance["Name"].Get <string>());
//调用动态委托赋值
instance.Set("Name", "222");
Assert.Equal("222", instance["Name"].Get <string>());
}
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 ExpressionBuilder(LinkOperator link, ExpressionBuilder left, LogicalOperator opr, params ExpressionBuilder[] right)
{
buffer = link.ToString() + " " + left.buffer + " " + opr.ToString();
if (opr == LogicalOperator.BETWEEN)
{
buffer += " " + right[0].buffer + " AND " + right[1].buffer;
return;
}
if (opr == LogicalOperator.In)
{
buffer += " {";
bool first = true;
foreach (ExpressionBuilder eb in right)
{
if (!first)
{
buffer += ", ";
}
buffer += eb.buffer;
}
buffer += "}";
return;
}
buffer += " " + right[0];
}
/// <summary>
/// 创建语句
/// </summary>
protected void CreateWhereClause(IEntityBase JoinEntity
, string FieldName, Operator OperatorType
, LinkOperator LinkNextOperator)
{
this.CheckField(JoinEntity, FieldName);
IDvWhere newpw = new DvWhere();
newpw.ClauseItem(JoinEntity, JoinEntity.GetType().GetProperty(FieldName)
, GetDescription(OperatorType), GetDescription(LinkNextOperator));
this.wherelist.Add(newpw);
}
public void TestCall2()
{
//创建动态类实例代理
var instance = LinkOperator <TestB> .Create();
instance.New();
Assert.Equal("111", instance["Name"].Get <string>());
//调用动态委托赋值
instance.Set("Name", "222");
Assert.Equal("222", instance["Name"].Get <string>());
}
public void TestCall3()
{
//创建动态类实例代理
var instance = LinkOperator.Create(typeof(FakeStaticTestModel1));
FakeStaticTestModel1.Name = "111";
Assert.Equal("111", instance["Name"].Get <string>());
instance["Name"].Set("222");
Assert.Equal("222", instance["Name"].Get <string>());
FakeStaticTestModel1.Age = 1001;
Assert.Equal(1001, instance.Get <int>("Age"));
FakeStaticTestModel1.Temp = DateTime.Now;
instance["Temp"].Set(FakeStaticTestModel1.Temp);
Assert.Equal(FakeStaticTestModel1.Temp, instance["Temp"].Get <DateTime>());
}
public void TestCall2()
{
//创建动态类实例代理
CallerManagement.AddType(typeof(StaticTestModel1));
var instance = LinkOperator.CreateFromType(typeof(StaticTestModel1));
StaticTestModel1.Name = "111";
Assert.Equal("111", instance["Name"].Get <string>());
instance["Name"].Set("222");
Assert.Equal("222", instance["Name"].Get <string>());
StaticTestModel1.Age = 1001;
Assert.Equal(1001, instance.Get <int>("Age"));
StaticTestModel1.Temp = DateTime.Now;
instance["Temp"].Set(StaticTestModel1.Temp);
Assert.Equal(StaticTestModel1.Temp, instance["Temp"].Get <DateTime>());
}
public void TestCall1()
{
//ScriptComplier.Init();
string text = @"using System;
using System.Collections;
using System.Linq;
using System.Text;
namespace HelloWorld
{
public class Test2
{
public Test2(){
Name=""111"";
}
public string Name;
public int Age{get;set;}
}
}";
//根据脚本创建动态类
var oop = new AssemblyCSharpBuilder();
oop.Syntax.Add(text);
var type = oop.GetTypeFromShortName("Test2");
NErrorLog.Enabled = true;
//创建动态类实例代理
CallerManagement.AddType(type);
var instance = LinkOperator.CreateFromType(type);
instance.New();
//Get动态调用
Assert.Equal("111", instance["Name"].Get <string>());
//调用动态委托赋值
instance.Set("Name", "222");
Assert.Equal("222", instance["Name"].Get <string>());
}
static void Main(string[] args)
{
TempTime = DateTime.Now;
Stopwatch stopwatch = new Stopwatch();
for (int j = 0; j < 20; j++)
{
Console.WriteLine("=========================================");
stopwatch.Restart();
for (int i = 0; i < 40000; i++)
{
var tEntity = new TestB();
if (tEntity.A2ge712 == "111")
{
//调用动态委托赋值
tEntity.A2ge712 = "222";
}
}
stopwatch.Stop();
Console.WriteLine("原生调用:\t\t" + stopwatch.Elapsed);
var entity = LinkOperator.Create(typeof(TestB));
stopwatch.Restart();
for (int i = 0; i < 40000; i++)
{
entity.New();
if (entity.Get <string>("A2ge712") == "111")
{
//调用动态委托赋值
entity.Set("A2ge712", "222");
}
}
stopwatch.Stop();
Console.WriteLine("NCaller SimpleCaller:\t" + stopwatch.Elapsed);
stopwatch.Restart();
for (int i = 0; i < 40000; i++)
{
RunDynamic(new TestB());
}
stopwatch.Stop();
Console.WriteLine("Dynamic :\t\t" + stopwatch.Elapsed);
var dict = DictOperator.Create(typeof(TestB));
stopwatch.Restart();
for (int i = 0; i < 40000; i++)
{
dict.New();
if ((string)(dict["A2ge712"]) == "111")
{
//调用动态委托赋值
dict["A2ge712"] = "222";
}
}
stopwatch.Stop();
Console.WriteLine("NCaller DictCaller:\t" + stopwatch.Elapsed);
stopwatch.Restart();
for (int i = 0; i < 40000; i++)
{
RunDynamic(new TestB());
}
stopwatch.Stop();
Console.WriteLine("Dynamic :\t\t" + stopwatch.Elapsed);
stopwatch.Restart();
for (int i = 0; i < 40000; i++)
{
var tEntity = (new TestB()).LinkCaller();
if (tEntity.Get <string>("A2ge712") == "111")
{
//调用动态委托赋值
tEntity.Set("A2ge712", "222");
}
}
stopwatch.Stop();
Console.WriteLine("NCaller Extension:\t" + stopwatch.Elapsed);
//entity = DynamicCaller.Create(typeof(TestB));
//stopwatch.Restart();
//for (int i = 0; i < 40000; i++)
//{
// entity.New();
// if (entity.Get<DateTime>("Time") != TempTime)
// {
// //调用动态委托赋值
// entity.Set("Time", TempTime);
// }
//}
//stopwatch.Stop();
//Console.WriteLine("NCaller SimpleCaller:\t" + stopwatch.Elapsed);
//stopwatch.Restart();
//for (int i = 0; i < 40000; i++)
//{
// RunDynamicTime(new TestB());
//}
//stopwatch.Stop();
//Console.WriteLine("Dynamic :\t\t" + stopwatch.Elapsed);
//entity = DynamicCaller.Create(typeof(TestB));
//stopwatch.Restart();
//for (int i = 0; i < 40000; i++)
//{
// entity.New();
// if (entity.Get<DateTime>("Time") != TempTime)
// {
// //调用动态委托赋值
// entity.Set("Time", TempTime);
// }
//}
//stopwatch.Stop();
//Console.WriteLine("NCaller SimpleCaller:\t" + stopwatch.Elapsed);
Console.WriteLine("=========================================");
}
//var dict = DictOperator<TestB>.Create();
//dict["Name"] = "Hello";
//dict["Age"] = 100;
//dict["Time"] = DateTime.Now;
Console.ReadKey();
}
/// <summary>
/// 根据条件查询指定实体对象的所有值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Field"></param>
/// <param name="EntityInstance"></param>
/// <param name="LinkOpr"></param>
/// <param name="Opr"></param>
/// <returns></returns>
public virtual List <T> QueryEntityList <T>(IEntityBase EntityInstance, string Field, Operator Opr, LinkOperator LinkOpr)
{
List <T> result = new List <T>();
IDvTable dvt = DalCreateDriveTable(EntityInstance);
dvt.WhereClause(Field, Opr, LinkOpr);
DataSet ds = dvt.Select();
result = this.dh.Convert <T>(EntityInstance.GetType(), ds);
return(result);
}
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="Entity"></param>
/// <param name="Field"></param>
/// <param name="Opr"></param>
/// <param name="LinkOpr"></param>
/// <returns></returns>
public virtual int UpdateEntityData(IEntityBase Entity, string Field, Operator Opr, LinkOperator LinkOpr)
{
IDvTable dvt = this.EntityFact.CreateDriveTable(Entity);
dvt.WhereClause(Field, Opr, LinkOpr);
int i = dvt.Update();
return(i);
}
/// <summary>
/// 创建条件子语句，指定要作为条件子语句的实体对象
/// </summary>
/// <param name="JoinEntity">在联立的实体对象中查找</param>
/// <param name="FieldName">字段名</param>
/// <param name="OperatorType">运算符</param>
/// <param name="LinkNextOperator">其后的逻辑操作符，当存在多个条件时，确定他们之间的关系</param>
public void WhereClause(IEntityBase JoinEntity, string FieldName, Operator OperatorType, LinkOperator LinkNextOperator)
{
if (this.join.Entitys.Contains(JoinEntity))
{
CreateWhereClause(JoinEntity, FieldName, OperatorType, LinkNextOperator);
}
}
/// <summary>
/// 创建查询条件子语句
/// </summary>
/// <param name="FieldName"></param>
/// <param name="OperatorType"></param>
/// <param name="LinkNextOperator"></param>
public void WhereClause(string FieldName, Operator OperatorType, LinkOperator LinkNextOperator)
{
CreateWhereClause(this.entity, FieldName, OperatorType, LinkNextOperator);
}
