这个需求在日常开发里太常见了！我来分享几个高效的实现思路，结合你的SomeClass类来具体拆解：

方案一：手动跟踪属性变更状态 #

给每个属性搭配一个“是否被修改”的标记字段，在属性的setter里判断值是否真的变化，变化就标记为已修改。最后更新数据库时，根据这些标记生成只包含变更字段的SQL。

修改后的SomeClass示例： #

public class SomeClass {
    private int field1;
    private string field2;
    private string field3;
    private byte field4;

    // 新增变更标记字段
    private bool isField1Modified;
    private bool isField2Modified;
    private bool isField3Modified;
    private bool isField4Modified;

    public int Field1 { 
        get { return field1; } 
        set { 
            // 先判断值是否真的变化，避免无意义标记
            if (field1 != value) {
                field1 = value;
                isField1Modified = true;
            }
        } 
    }

    public string Field2 { 
        get { return field2; } 
        set { 
            if (!string.Equals(field2, value, StringComparison.Ordinal)) {
                field2 = value;
                isField2Modified = true;
            }
        } 
    }

    // Field3、Field4的setter同理，这里省略

    // 新增方法：获取所有被修改的字段
    public Dictionary<string, object> GetModifiedFields() {
        var modifiedFields = new Dictionary<string, object>();
        if (isField1Modified) modifiedFields.Add(nameof(Field1), Field1);
        if (isField2Modified) modifiedFields.Add(nameof(Field2), Field2);
        if (isField3Modified) modifiedFields.Add(nameof(Field3), Field3);
        if (isField4Modified) modifiedFields.Add(nameof(Field4), Field4);
        return modifiedFields;
    }
}

用法说明： #

当你修改完属性后，调用GetModifiedFields()拿到所有变更的键值对，然后动态生成UPDATE语句——比如只更新字典里的键对应的字段，完全跳过未修改的属性。

优缺点： #

• ✅ 逻辑直观，完全可控，不依赖第三方工具
• ❌ 属性多的话代码会有点冗余，可以用T4模板或代码生成器自动生成标记和setter逻辑

方案二：利用ORM框架的原生变更追踪 #

如果你用的是Entity Framework Core（EF Core）这类ORM框架，它们本身就自带了变更追踪功能，完全不用自己写额外代码。

示例（EF Core）： #

// 从数据库加载实体
var targetEntity = dbContext.SomeClass.Find(entityId);

// 修改需要更新的属性
targetEntity.Field1 = 200;
targetEntity.Field3 = "Updated Content";

// 保存变更——EF Core会自动生成仅包含Field1和Field3的UPDATE语句
dbContext.SaveChanges();

原理： #

ORM框架在加载实体时会保存一份原始值快照，当你修改属性时，它会自动对比原始值和当前值，标记变更的属性，最终只更新这些字段。

优缺点： #

• ✅ 几乎零代码侵入，省心省力，是最推荐的方案（如果项目用ORM的话）
• ❌ 依赖ORM框架，原生ADO.NET场景不适用；全新创建的实体需要手动Attach到上下文才能追踪变更

方案三：对比原始值快照 #

在实体加载完成后，保存一份所有属性的原始值快照，更新前对比当前值和原始值，找出变化的字段。

修改后的SomeClass示例： #

public class SomeClass {
    // 当前属性值
    private int field1;
    private string field2;
    private string field3;
    private byte field4;

    // 原始值快照
    private int originalField1;
    private string originalField2;
    private string originalField3;
    private byte originalField4;

    // 初始化原始值快照（从数据库加载后调用）
    public void InitializeOriginalValues() {
        originalField1 = field1;
        originalField2 = field2;
        originalField3 = field3;
        originalField4 = field4;
    }

    // 属性的get/set保持原样，无需修改
    public int Field1 { get { return field1; } set { field1 = value; } }
    public string Field2 { get { return field2; } set { field2 = value; } }
    public string Field3 { get { return field3; } set { field3 = value; } }
    public byte Field4 { get { return field4; } set { field4 = value; } }

    // 获取变更字段
    public Dictionary<string, object> GetModifiedFields() {
        var modifiedFields = new Dictionary<string, object>();
        if (field1 != originalField1) modifiedFields.Add(nameof(Field1), Field1);
        if (!string.Equals(field2, originalField2, StringComparison.Ordinal)) modifiedFields.Add(nameof(Field2), Field2);
        if (!string.Equals(field3, originalField3, StringComparison.Ordinal)) modifiedFields.Add(nameof(Field3), Field3);
        if (field4 != originalField4) modifiedFields.Add(nameof(Field4), Field4);
        return modifiedFields;
    }
}

用法说明： #

从数据库加载实体后，先调用InitializeOriginalValues()保存快照；修改属性后，调用GetModifiedFields()拿到变更字段，再生成UPDATE语句。

优缺点： #

• ✅ 不用修改原有属性的setter逻辑，对现有代码侵入小
• ❌ 需要额外存储一份原始值，占用少量内存；如果是引用类型属性，要注意深拷贝避免快照和当前值指向同一对象

方案四：利用AOP（面向切面编程）自动追踪变更 #

如果你的类有几十上百个属性，手动加标记太麻烦，可以用AOP框架（比如PostSharp、Castle DynamicProxy）拦截属性的set操作，自动记录变更。

简化示例（用PostSharp）： #

// 定义一个追踪变更的切面
[Serializable]
public class TrackChangesAttribute : OnMethodBoundaryAspect {
    public override void OnSuccess(MethodExecutionArgs args) {
        // 从set方法名中提取属性名（比如set_Field1 → Field1）
        var propertyName = args.Method.Name.Substring(4);
        if (args.Instance is ITrackable trackableEntity) {
            trackableEntity.MarkPropertyAsModified(propertyName);
        }
    }
}

// 定义追踪接口
public interface ITrackable {
    void MarkPropertyAsModified(string propertyName);
    Dictionary<string, object> GetModifiedFields();
}

// 实现接口并应用切面
public class SomeClass : ITrackable {
    private readonly Dictionary<string, object> _modifiedFields = new();

    [TrackChanges]
    public int Field1 { get; set; }

    [TrackChanges]
    public string Field2 { get; set; }

    [TrackChanges]
    public string Field3 { get; set; }

    [TrackChanges]
    public byte Field4 { get; set; }

    public void MarkPropertyAsModified(string propertyName) {
        var property = GetType().GetProperty(propertyName);
        if (property != null) {
            _modifiedFields[propertyName] = property.GetValue(this);
        }
    }

    public Dictionary<string, object> GetModifiedFields() => _modifiedFields;
}

原理： #

AOP切面会自动拦截所有带[TrackChanges]标记的属性的set操作，一旦属性被修改，就自动记录到变更字典里。

优缺点： #

• ✅ 无侵入性，不用手动写重复的标记逻辑，适合属性极多的场景
• ❌ 依赖AOP框架，有一定学习成本；高性能场景下要考虑切面的微小性能开销

方案选择建议 #

• 如果你已经在用ORM框架（比如EF Core），优先选方案二，省心又高效；
• 原生ADO.NET场景，属性不多的话选方案一；
• 不想改动原有属性结构的话选方案三；
• 属性数量特别多，想减少重复代码的话选方案四。

内容的提问来源于stack exchange，提问作者Ranjit Singh