Code case sharing on how to monitor class attribute changes in C#

　C# Monitor changes in class attributes (what toys did the big cat move)

When using EF to update database entities. Many times what we want is to update one or some fields in the table. Although we can set it to tell the context which fields we want to update. But generally we encapsulate the data persistence layer. Through generic operations. At this time, we have no way of knowing which fields have been modified at the application level.

I have been learning EF recently, and I just encountered this problem. Of course, if you use it directly at the application level, you can just set the IsModified status of the field. As follows
　db.Entry(model).Property(x => x.Token).IsModified = false;
　However, this is limited to learning and demo. In formal development, such low-level operations are generally not exposed to the application level. The database persistence layer will be encapsulated. Then add, delete, modify and query is provided through the entity factory (warehouse) and entity generics.
For details, please refer to articles such as "Repository Pattern Design Based on Entity Framework".
These methods all have one thing in common. When updating and deleting, there are similar codes as follows:

　　　　public virtual void Update(TEntity TObject)
        {
            try
            {
                var entry = Context.Entry(TObject);
                Context.Set<TEntity>().Attach(TObject);
                entry.State = EntityState.Modified;
            }
            catch (OptimisticConcurrencyException ex)
            {
                throw ex;
            }
        }

Personal understanding: Update(TEntity TObject) passes an entity to the method, then attaches it to the database context, and marks the data as modified. Then update.
In this case, all fields of the entity will be updated. Then we need to ensure that this entity is found from the database, or corresponds to the records in the database. This is no problem in the C/S structure, but what about the B/S structure? It is impossible for us to package all the fields of the entity and send them to the client. Then the client can modify them and return them to the server, and then call the warehouse method to update. To put it in the simplest way, to change the user password, we only need a user ID and a new password. Or to lock a user account, you only need a user ID, a lock status, and a lock time. In this way, it is impossible for us to package the entire user entity and pass it around. Some people say that you can first check the database based on the ID when saving, and then append the modified attribute values ​​to it before updating. This gets back to the problem: there are only generic types in the warehouse method, and when you call the warehouse update method, you pass it an entity type. The warehouse does not know which entity you are and which fields have been updated.
Of course, through triggers, we know that database updates are deleted first and then inserted, so there is not much difference between updating a few fields and updating the entire column.

Now put aside information such as warehouse updates and other entity generics. Just look at when an entity changes, how can we know which attributes it has modified.
Normally an entity looks like this

#

 1     /// <summary> 
 2     /// 一个具体的实体 
 3     /// </summary> 
 4     public class AccountEntity : MainEntity 
 5     { 
 6         /// <summary> 
 7         /// 文本类型 
 8         /// </summary> 
 9         public virtual string Account { get; set; }
 10         /// <summary>
 11         /// 又一个文本属性
 12         /// </summary>
 13         public virtual string Password { get; set; }
 14         /// <summary>
 15         /// 数字类型
 16         /// </summary>
 17         public virtual int Sex { get; set; }
 18         /// <summary>
 19         /// 事件类型
 20         /// </summary>
 21         public virtual DateTime Birthday { get; set; }
 22         /// <summary>
 23         /// 双精度浮点数
 24         /// </summary>
 25         public virtual double Height { get; set; }
 26         /// <summary>
 27         /// 十进制数
 28         /// </summary>
 29         public virtual decimal Monery { get; set; }
 30         /// <summary>
 31         /// 二进制
 32         /// </summary>
 33         public virtual byte[] PublicKey { get; set; }
 34         /// <summary>
 35         /// Guid类型
 36         /// </summary>
 37         public virtual Guid AreaId { get; set; }
 38     }

View Code

When we want to modify the properties of this entity:

var entity = new accountEntity();
entity.Id=1;
entity.Account = "给属性赋值';

Then pass this entity to the bottom layer for operation.

db.Update(entity);

　No problem at all, but my question is how do I know at the bottom layer which properties my application layer has modified? Add another method to tell the bottom layer that I have modified these attributes.

db.Update(entity,"Account");

There seems to be nothing wrong with it.

But what if I modify the Account but Password is passed in the parameter? Therefore, there should be a collection on the entity to store whether the entire attribute has been modified. Then go to the underlying Update method to take out the updated fields for the next step.
Through this idea, I thought of adding a dictionary to the entity:

protected Dictionary<string, dynamic> FieldTracking = new Dictionary<string, dynamic>();

When the attribute is assigned a value, is added to the dictionary. (Of course, this operation will increase the overhead of the program)

FieldTracking["Account"]="给属性赋值";

　　然后在底层在取出里面的集合，来区分哪些字段被修改（大花猫动了哪些小玩具）。

　　改造下实体属性

        public virtual string Account
        {
            get
            { return _Account; }
            set {
                _Account = value;
                FieldTracking["Account"] = value;
            }
        }

　　看过编译后的IL代码的都知道，class中的属性最终会编译成两个方法 setvalue和getvalue，那么通过修改set方法添加FieldTracking["Account"] = value;就可以让属性在赋值的时候添加到字典中。

　　很简单吧。

　　你以为这样就完了。如果拿房间来比喻实体、拿玩具来比作属性。我家那大花猫就是修改实体属性的方法。你知道我家有多少玩具吗？你每天回家的时候你知道大花猫动了哪个小玩具吗？给每个玩具装个GPS？哈哈哈哈，别闹，花这心思还不如再买点回来。什么？买回来的还得装，算了。研究下怎么装吧。

　　一个程序可能有上百个实体类，修改现有的实体类，给每个set加一行？作为一个程序员是不可能容忍做这样的操作的。写一个工具，读取所有的实体代码，加上这一行，保存。这是个好办法。那每次添加一个实体类就得调用工具重写来一遍，每次修改属性再调用一遍，恩。没问题。能用就行。这不是一个真心养猫的人的人能容忍的。

　　那怎么办？把猫打死？那玩具的存在将会没有任何意义。想到一个办法，在我离开房子的时候（程序初始化），给房子里的所有房间（实体类）创建一个同样的房间（继承），包含了与原房间所有需要监控（标记为virtual）的玩具的复制，在复制过程中加上GPS（-_~）。然后给猫玩。猫通过我给的门进到这个继承的房间中玩所有玩具的时候，GPS就能将猫的动作全部记录下来。我一回家，这猫玩了哪些玩具一看GPS记录就全知道了。哟，这小崽子，在王元鹅呢。
　　

　　看不懂，没关系，上马：
　　1、在程序集初始化的时候，通过反射，查找所有继承自BaseEntity的实体类。遍历其中的属性。找到标记为virtual进行复制。

　　　　刚开始对于如果找到virtual属性花了不少时间。我总只想着在属性上找，却没想到去set_value方法上去找(其实get_value方法也是)。还是太菜啊。

　　　　注：NoMapAttribute特性是一个自定义的标记，表示不参与映射。因为不参与映射就不需要监控。与本文章代码没有太大的关系。仅供参考。

//获取实体所在的程序集（ClassLibraryDemo）
var assemblyArray = AppDomain.CurrentDomain.GetAssemblies()
        .Where(w => w.GetName().Name == "ClassLibraryDemo")
        .ToList();
//实体的基类
var baseEntityType = typeof(BaseEntity);
//循环程序集
foreach (Assembly item in assemblyArray)
{
    //找到这个程序集中继承自基类的实体
    var types = item.GetTypes().Where(t => t.IsAbstract == false
        && baseEntityType.IsAssignableFrom(t) 
        && t != baseEntityType);
    foreach (Type btItem in types){
        //遍历这个实体类中的属性
var properties = btItem.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                        .Where(w => w.CanRead && w.CanWrite
                            && w.GetCustomAttributes(typeof(NoMapAttribute), false).Any() == false
                            //TODO：要不要检查get方法？
                            && w.GetSetMethod().IsVirtual);
    }
}

　　2、根据1的结果，复制一个新的房间（动态代码生成一个类，这个类继承1中的实体，并且重写了属性的set方法）

　　这个过程就设计到动态代码的生成了。

//首先创建一个与实体类对应的动态类
CodeTypeDeclaration ct = new CodeTypeDeclaration(btItem.Name + "_Dynamic");
//循环实体中的所有标记为virtual的属性
foreach (PropertyInfo fiItem in properties)
{
	//创建一个属性
	var p = new CodeMemberProperty();
	//设置属性为公共、重写
	p.Attributes = MemberAttributes.Public | MemberAttributes.Override;//override
	//设置属性的类型为继承的属性的数据类型
	p.Type = new CodeTypeReference(fiItem.PropertyType);
	//属性名称与继承的一致
	p.Name = fiItem.Name;
	//包含set代码
	p.HasSet = true;
	//包含get代码
	p.HasGet = true;
	//设置get代码
	//return base.Account
	p.GetStatements.Add(new CodeMethodReturnStatement(
                new CodeFieldReferenceExpression(
                        new CodeBaseReferenceExpression(), fiItem.Name)));
	//设置set代码
	//base.Account=value;
	p.SetStatements.Add(
	new CodeAssignStatement(
                new CodeFieldReferenceExpression(
                        new CodeBaseReferenceExpression(), fiItem.Name),
	new CodePropertySetValueReferenceExpression()));
	//FieldTracking["Account"]=value;
	p.SetStatements.Add(new CodeSnippetExpression("FieldTracking[\"" + fiItem.Name + "\"] = value"));
	//将属性添加到类中
	ct.Members.Add(p);
}

　　3、将刚才生成的类加到原类所在的命名空间+".Dynamic"（加后缀以示区分）

//声明一个命名空间（与当前实体类同名+后缀）
CodeNamespace ns = new CodeNamespace(btItem.Namespace + ".Dynamic");
ns.Types.Add(ct);

　　4、编辑生成代码所在的程序集

    //要动态生成代码的程序集
    CodeCompileUnit program = new CodeCompileUnit();
    //添加引用
    program.ReferencedAssemblies.Add("mscorlib.dll");
    program.ReferencedAssemblies.Add("System.dll");
    program.ReferencedAssemblies.Add("System.Core.dll");

    //定义代码工厂
    CSharpCodeProvider provider = new CSharpCodeProvider();
    //编译程序集
    var cr = provider.CompileAssemblyFromDom(new System.CodeDom.Compiler.CompilerParameters();
    //看编译是否通过
    var error = cr.Errors;
    if (error.HasErrors)
    {
        Console.WriteLine("错误列表：");
        //编译不通过
        foreach (dynamic item in error)
        {
            Console.WriteLine("ErrorNumber:{0};Line:{1};ErrorText{2}",
                item.ErrorNumber,
                item.Line, 
                item.ErrorText);
        }
        return;
    }
    else
    {
        Console.WriteLine("编译成功。");
    }

 

 　　查看生成的代码

//查看生成的代码
var codeText = new StringBuilder();
using (var codeWriter = new StringWriter(codeText))
{
    CodeDomProvider.CreateProvider("CSharp").GenerateCodeFromNamespace(ns,
        codeWriter,
        new CodeGeneratorOptions()
        {
            BlankLinesBetweenMembers = true
        });
}
Console.WriteLine(codeText);

 

　　5、将复制的新类与原类建立映射关系。

foreach (Type item in ts)
{
    //注册(模拟实现，通过字典实现的，也可以通过IOC注入方式处理)
    Mapping.Map(item.BaseType, item);
}

　　6、获得这个复制的实体对象

//创建一个指定的实体对象
AccountEntity ae = Mapping.GetMap<AccountEntity>();

　　7、对这个实体对象的属性进行赋值

//主键赋值不会修改属性更新
ae.BaseEntity_Id = 1;//不会变(未标记为virtual)
ae.MainEntity_Name = "大花猫";
ae.MainEntity_UpdateTime = DateTime.Now;
//修改某个属性
ae.Account = "admin";
ae.Account = "以最后一次的修改为准";

　　8、调用底层方法，底层根据这个实体属性获得被修改的属性名称

//调用基类中的方法 获取变动的属性
var up = ae.GetFieldTracking();
Console.WriteLine("有修改的字段：");
up.ForEach(fe =>
{
    Console.WriteLine(fe + ":" + ae[fe]);
});

　　9、完美

　　

 

　　就这样，在底层就能知道哪些实体被赋值过了。

　　当然，有些实体我们只是需要用来计算，则可以调用方法将赋值过的属性进行删除

//删除变更字段
ae.RemoveChanges("Account");

　　这只是一个简单的实现，还有一种比较复杂的情况，在第6步，获得这个复制的实体对象时，怎么用一个现有的new出来的实体对象去创建建并监控呢。就像，别人送我一房间现成的玩具，给我的时候猫就在里面玩了。嗷，把猫打死吧。

　　总结：

再次认识到反射的强大。
也第一次实现了代码生成代码并使用的经历。
对字段和属性的区别有了更深的认识。
对访问修饰符和虚virtual方法有了更好的认识。

 

The above is the detailed content of Code case sharing on how to monitor class attribute changes in C#. For more information, please follow other related articles on the PHP Chinese website!