C#에서 클래스 속성 변경을 모니터링하는 방법에 대한 코드 사례 공유

　　C#은 클래스 속성의 변경 사항(큰 고양이가 어떤 장난감을 움직였는지)을 모니터링합니다.

　EF를 사용하여 데이터베이스 엔터티를 업데이트하는 경우. 우리가 원하는 것은 테이블의 하나 또는 일부 필드를 업데이트하는 것입니다. 설정을 통해 어떤 필드를 업데이트할지 컨텍스트에 알릴 수 있습니다. 그러나 일반적으로 우리는 데이터 지속성 계층을 캡슐화합니다. 일반 작업을 통해. 현재로서는 애플리케이션 수준에서 어떤 필드가 수정되었는지 알 수 있는 방법이 없습니다.

저도 최근에 EF를 배우고 있는데 우연히 이런 문제를 접하게 되었습니다. 물론 애플리케이션 수준에서 직접 사용하는 경우 필드의 IsModified 상태만 설정할 수 있습니다. 다음과 같습니다
db.Entry(model).Property(x => x.Token).IsModified = false;
단, 학습 및 데모에 한합니다. 공식 개발에서 이러한 기본 작업은 일반적으로 애플리케이션 수준에 노출되지 않습니다. 데이터베이스 지속성 계층이 캡슐화됩니다. 그리고 엔터티 팩토리(웨어하우스)와 엔터티 Generic을 통해 추가, 삭제, 수정, 조회가 제공됩니다.
자세한 내용은 "Entity Framework 기반 리포지토리 패턴 디자인" 등의 기사를 참조하세요.
이러한 메서드에는 모두 업데이트 및 삭제 시 다음과 같은 유사한 코드가 있습니다.

　　　　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;
            }
        }

개인적 이해: 업데이트(TEntity TObject)가 엔터티를 메서드에 전달한 다음 이를 연결합니다. 데이터베이스 컨텍스트에 추가하고 데이터를 수정된 것으로 표시합니다. 그런 다음 업데이트하십시오.
이 경우 엔터티의 모든 필드가 업데이트됩니다. 그런 다음 이 엔터티가 데이터베이스에서 발견되었는지 또는 데이터베이스의 레코드와 일치하는지 확인해야 합니다. C/S 구조에서는 문제가 없는데 B/S 구조에서는 어떤가요? 엔터티의 모든 필드를 패키징하여 클라이언트에 보내는 것은 불가능합니다. 그런 다음 클라이언트는 이를 수정하여 서버에 반환한 다음 웨어하우스 메서드를 호출하여 업데이트할 수 있습니다. 가장 간단하게 말하면 사용자 비밀번호를 변경하려면 사용자 ID와 새 비밀번호만 있으면 됩니다. 또는 사용자 계정을 잠그려면 사용자 ID, 잠금 상태, 잠금 시간만 있으면 됩니다. 이러한 방식으로 전체 사용자 엔터티를 패키지하여 전달하는 것은 불가능합니다. 어떤 분들은 저장할 때 ID를 기준으로 데이터베이스를 먼저 확인한 뒤, 수정된 속성값을 추가한 뒤 업데이트하면 된다고 말씀하시는 분들도 계십니다. 이는 다시 문제로 돌아갑니다. 웨어하우스 메소드에는 일반 유형만 있고 웨어하우스 업데이트 메소드를 호출하면 엔터티 유형을 전달합니다. 창고에서는 귀하가 어떤 법인인지, 어떤 필드가 업데이트되었는지 알 수 없습니다.
물론 트리거를 통해 데이터베이스 업데이트가 먼저 삭제된 다음 삽입된다는 것을 알고 있으므로 몇 가지 필드를 업데이트하는 것과 전체 열을 업데이트하는 것에는 큰 차이가 없습니다.

이제 창고 업데이트 및 기타 엔터티 일반 정보와 같은 정보는 제쳐두세요. 엔터티가 변경될 때 어떤 속성이 수정되었는지 어떻게 알 수 있는지 살펴보세요.
일반적으로 엔터티는 다음과 같습니다.

 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     }

코드 보기

이 엔터티의 속성을 수정하려는 경우:

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

그럼 이건 엔터티는 조작을 위해 기본 레이어로 전달됩니다.

db.Update(entity);

　전혀 문제가 없지만 내 문제는 내 애플리케이션 레이어가 어떤 속성을 수정했는지 맨 아래 레이어가 어떻게 알 수 있느냐는 것입니다. 이러한 속성을 수정했음을 맨 아래 레이어에 알리는 또 다른 방법을 추가합니다.

db.Update(entity,"Account");

별 문제 없는 것 같습니다.

그런데 계정을 수정했는데 매개변수에 비밀번호가 전달되면 어떻게 되나요? 따라서 전체 특성이 수정되었는지 여부에 대한 상태를 저장하려면 엔터티에 대한 컬렉션이 있어야 합니다. 그런 다음 기본 Update 메서드로 이동하여 다음 단계를 위해 업데이트된 필드를 가져옵니다.
이 아이디어를 통해 엔터티에 사전을 추가하려고 생각했습니다.

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

속성에 값이 할당되면 사전에 추가됩니다. (물론 이 작업은 프로그램의 오버헤드를 증가시킵니다)

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方法有了更好的认识。

 

위 내용은 C#에서 클래스 속성 변경을 모니터링하는 방법에 대한 코드 사례 공유의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!