Skip to content
The Chat Archive
gpt-4o-2024-08-06· OpenAI WildChat-4.8M (AI2)

c#修改对象的属性值为什么会其他不同对象的相同属性值也会发生变化, [Serializable] public class TriggerEffect { public…

  1. User

    c#修改对象的属性值为什么会其他不同对象的相同属性值也会发生变化, [Serializable] public class TriggerEffect { public string luaPath;

        public PlayerInputEventTypes playerInputEventType;
    
        // 对应效果释放对象的描述,不是具体实例化对象
        public TargetType targetType;
    
        public TargetDirection targetDirection;
    
        public int targetValue;
    
        public int cycleTime;
        
        public TriggerEffect()
        {
        }
        
        // 构造函数
        public TriggerEffect(TriggerEffect triggerEffect)
        {
            luaPath = triggerEffect.luaPath;
            playerInputEventType = triggerEffect.playerInputEventType;
            targetType = triggerEffect.targetType;
            targetDirection = triggerEffect.targetDirection;
            targetValue = triggerEffect.targetValue;
            cycleTime = triggerEffect.cycleTime;
        }
    
        public void SetTriggerValue(int value)
        {
            if (!Equals(targetValue, value))
            {
                targetValue = value;
            }
        }
        
    }  这个targetvalue属性
    
  2. Assistant

    从你描述的问题来看,假设你在C#中有多个TriggerEffect对象实例,但修改一个实例的targetValue属性后,其他实例的targetValue属性也随之改变,那么可能的原因有以下几点:

    1. 共享对象引用:可能在创建新实例时,错误地将同一个TriggerEffect对象的引用直接赋给了多个变量,而不是创建新的独立实例。在这种情况下,修改一个对象的属性自然会影响所有引用该对象的变量。确保在创建新的TriggerEffect对象时使用new关键字创建新的实例。

    2. 深拷贝和浅拷贝问题:你在TriggerEffect的复制构造函数中,确保所有属性都被正确地复制,而不是仅仅复制对象引用。如果有复杂类型或引用类型的属性,你需要选择性地进行深拷贝。

    3. 未实际调用构造函数:检查所有实始化新对象的代码,确保每次都在通过构造函数创建新实例,而不是复制引用。

    可以检查以下代码片段,以确保对象实例独立:

    // 创建新的TriggerEffect对象并使用构造函数初始化
    TriggerEffect effect1 = new TriggerEffect()
    {
        luaPath = "somePath",
        playerInputEventType = PlayerInputEventTypes.SomeType,
        targetType = TargetType.SomeTarget,
        targetDirection = TargetDirection.SomeDirection,
        targetValue = 5,
        cycleTime = 10
    };
    
    TriggerEffect effect2 = new TriggerEffect(effect1); // 通过构造函数创建新实例
    effect2.SetTriggerValue(10);
    
    // 确认两个对象实例是否独立
    Console.WriteLine(effect1.targetValue); // 输出: 5
    Console.WriteLine(effect2.targetValue); // 输出: 10
    

    这样确保通过构造函数正常分配新对象实例,并且不会错误地共享对象间的引用。确保检查代码中可能出现的引用赋值错误。如果问题仍然存在,可以通过调试工具或日志跟踪对象的创建和属性更改路径,寻找问题根源。

  3. User

    List triggerEffects = effect.triggerEffects; foreach (var triggerEffect in triggerEffects) { int targetValue = triggerEffect.targetValue; targetValue -= 1; TriggerEffect triggerEffect2 = new TriggerEffect(triggerEffect); triggerEffect2.SetTriggerValue(targetValue);

                            effect.triggerEffects.Remove(triggerEffect);
                            effect.triggerEffects.Add(triggerEffect2);
                            
                            if (targetValue == 0)
                            {
                                victimObject.SetHealth(GameAttribute.Zero);
                                break;
                            }
                        } 这样写会报错InvalidOperationException: Collection was modified; enumeration operation may not execute.
    
  4. Assistant

    您遇到的 InvalidOperationException 错误是由于在遍历集合(List)的同时,对该集合进行了修改(在循环中删除和添加元素)。在 C# 中,这是不允许的,因为这会导致迭代器的内部状态不一致。

    要解决这个问题,您可以通过以下几种方式来处理:

    1. 使用临时列表存储要移除的项

    在循环之外创建一个临时列表来存储要更换的项,然后在循环之后执行批量修改:

    List<TriggerEffect> triggerEffects = effect.triggerEffects;
    List<TriggerEffect> updatedTriggerEffects = new List<TriggerEffect>();
    
    foreach (var triggerEffect in triggerEffects)
    {
        int targetValue = triggerEffect.targetValue - 1;
        TriggerEffect triggerEffect2 = new TriggerEffect(triggerEffect);
        triggerEffect2.SetTriggerValue(targetValue);
    
        updatedTriggerEffects.Add(triggerEffect2);
        
        if (targetValue == 0)
        {
            victimObject.SetHealth(GameAttribute.Zero);
            break;
        }
    }
    
    // 如果循环正常结束(而不是通过 break 退出),将其替换到原列表中
    effect.triggerEffects.Clear();
    effect.triggerEffects.AddRange(updatedTriggerEffects);
    

    2. 使用 for 循环逆向遍历

    通过从列表的末尾倒序遍历,您可以安全地移除或替换元素而不影响未迭代的元素:

    List<TriggerEffect> triggerEffects = effect.triggerEffects;
    for (int i = triggerEffects.Count - 1; i >= 0; i--)
    {
        var triggerEffect = triggerEffects[i];
    
        int targetValue = triggerEffect.targetValue - 1;
        TriggerEffect triggerEffect2 = new TriggerEffect(triggerEffect);
        triggerEffect2.SetTriggerValue(targetValue);
    
        triggerEffects.RemoveAt(i);
        triggerEffects.Add(triggerEffect2);
        
        if (targetValue == 0)
        {
            victimObject.SetHealth(GameAttribute.Zero);
            break;
        }
    }
    

    注意:上面的代码示例中,我用的是 RemoveAt(i) 和 Add(triggerEffect2) ,这可能在逻辑上没有达到你想要的效果,因为 Add 会在列表末尾添加元素。但因为逻辑上的实现属于你的业务功能,你可以根据自己的需求修改。

    请根据您的具体需求使用合适的方法,但最重要的是确保在修改集合的同时,不要在遍历过程中直接修改集合的结构。

  5. User

    foreach (var effect in victimObject.GetEffects()) { if (effect.keyword == CardKeyWordType.Thorn) { Effect copyEffect = new Effect(effect); List triggerEffects = effect.triggerEffects; for (int i = triggerEffects.Count - 1; i >= 0; i--) { var triggerEffect = triggerEffects[i];

                            int targetValue = triggerEffect.targetValue - 1;
                            TriggerEffect triggerEffect2 = new TriggerEffect(triggerEffect);
                            triggerEffect2.SetTriggerValue(targetValue);
    
                            triggerEffects.RemoveAt(i);
                            triggerEffects.Add(triggerEffect2);
                            
                            victimObject.OnAfterThornValueChanged?.Invoke();
                            if (targetValue == 0)
                            {
                                victimObject.SetHealth(GameAttribute.Zero);
                                break;
                            }
                        }
                        copyEffect.SetTriggerEffects(triggerEffects);
                        victimObject.GetEffects().Remove(effect);
                        victimObject.AddEffect(copyEffect);
                    }
                } 这样还会InvalidOperationException: Collection was modified; enumeration operation may not execute.报错
    
  6. Assistant

    你仍然会遇到 InvalidOperationException,因为你正在遍历 victimObject.GetEffects() 集合的同时,对该集合进行了修改(通过 Remove 和 Add 操作)。

    为了解决这个问题,你可以对 victimObject.GetEffects() 使用一个临时列表来存储需要移除的效果,然后在遍历完成之后,进行移除和添加操作。下面是如何实现此修改的示例:

    List<Effect> effectsToRemove = new List<Effect>();
    List<Effect> effectsToAdd = new List<Effect>();
    
    foreach (var effect in victimObject.GetEffects())
    {
        if (effect.keyword == CardKeyWordType.Thorn)
        {
            Effect copyEffect = new Effect(effect);
            List<TriggerEffect> triggerEffects = effect.triggerEffects;
            
            for (int i = triggerEffects.Count - 1; i >= 0; i--)
            {
                var triggerEffect = triggerEffects[i];
    
                int targetValue = triggerEffect.targetValue - 1;
                TriggerEffect triggerEffect2 = new TriggerEffect(triggerEffect);
                triggerEffect2.SetTriggerValue(targetValue);
    
                triggerEffects.RemoveAt(i);
                triggerEffects.Add(triggerEffect2);
    
                victimObject.OnAfterThornValueChanged?.Invoke();
                if (targetValue == 0)
                {
                    victimObject.SetHealth(GameAttribute.Zero);
                    break;
                }
            }
    
            copyEffect.SetTriggerEffects(triggerEffects);
            effectsToRemove.Add(effect);
            effectsToAdd.Add(copyEffect);
        }
    }
    
    // 批量移除和添加
    foreach (var effect in effectsToRemove)
    {
        victimObject.GetEffects().Remove(effect);
    }
    
    foreach (var effect in effectsToAdd)
    {
        victimObject.AddEffect(effect);
    }
    

    在上面的代码中,我们通过 effectsToRemove 和 effectsToAdd 这两个列表来暂存需要修改的效果,完成遍历后再统一进行修改操作。这样就不会在遍历过程中直接修改集合,避免了 InvalidOperationException。

  7. User

    foreach (var effect in victimObject.GetEffects()) { if (effect.keyword == CardKeyWordType.Thorn) { Effect copyEffect = new Effect(effect); List triggerEffects = copyEffect.triggerEffects;

                        for (int i = triggerEffects.Count - 1; i >= 0; i--)
                        {
                            var triggerEffect = triggerEffects[i];
    
                            int targetValue = triggerEffect.targetValue - 1;
                            TriggerEffect triggerEffect2 = new TriggerEffect(triggerEffect);
                            triggerEffect2.SetTriggerValue(targetValue);
    
                            triggerEffects.RemoveAt(i);
                            triggerEffects.Add(triggerEffect2);
    
                            victimObject.OnAfterThornValueChanged?.Invoke();
                            if (targetValue == 0)
                            {
                                victimObject.SetHealth(GameAttribute.Zero);
                                break;
                            }
                        }
    
                        copyEffect.SetTriggerEffects(triggerEffects);
                        effectsToRemove.Add(effect);
                        effectsToAdd.Add(copyEffect);
                    }
                } 为什么修改的是copyeffect的值,effect里面的值也会改呢?      public class Effect
    {
        // 词条:站吼
        public CardKeyWordType keyword;
    
        // 触发的效果 站吼附带的效果: 对敌方英雄造成1点伤害,治疗己方英雄1点,还要抽一张卡
        public List<TriggerEffect> triggerEffects = new();
    
        // 触发的条件
        public TargetType triggerCondition;
        
        public Effect()
        {
        }
    
        public Effect(Effect effect)
        {
            keyword = effect.keyword;
            triggerEffects = effect.triggerEffects;
            triggerCondition = effect.triggerCondition;
        }
        
        public void SetTriggerEffects(List<TriggerEffect> triggereffects)
        {
            if (!Equals(triggerEffects, triggereffects))
            {
                triggerEffects = triggereffects;
            }
        }
    }
    
  8. Assistant

    在您的代码中,当您构造 Effect 的副本时,您使用的是构造函数 public Effect(Effect effect),该构造函数仅复制了原始对象 Effect 的属性引用,尤其是 triggerEffects。这意味着 copyEffect.triggerEffects 和 effect.triggerEffects 实际上指向的是同一个 List<TriggerEffect> 实例。因此,无论您对 copyEffect.triggerEffects 做了什么更改,都会反映在 effect.triggerEffects 中,因为它们引用的是相同的列表。

    要解决这个问题,您需要确保在构造 Effect 的副本时,也复制 triggerEffects 列表的内容,而不是直接复制列表的引用。您可以通过创建 triggerEffects 的深拷贝来实现:

    更新 Effect 的构造函数以执行深拷贝:

    public Effect(Effect effect)
    {
        keyword = effect.keyword;
        triggerEffects = effect.triggerEffects.Select(te => new TriggerEffect(te)).ToList(); // 深拷贝
        triggerCondition = effect.triggerCondition;
    }
    

    在这段代码中,我们使用了 LINQ 的 Select 方法来遍历 effect.triggerEffects 列表,并为列表中的每个 TriggerEffect 对象创建一个新的实例,从而实现了深拷贝。这样,新创建的 copyEffect.triggerEffects 将是一个与 effect.triggerEffects 分开的列表,您可以安全地修改它,而不会影响原始 Effect 的 triggerEffects 列表。

    请确保 TriggerEffect 类的复制构造函数(public TriggerEffect(TriggerEffect triggerEffect)) 能够正确地拷贝其所有属性,以确保深拷贝的每个部分都是独立的。

  9. User

    C#的深拷贝和浅拷贝可以介绍一下嘛

  10. Assistant

    当然!在 C# 中,拷贝一个对象通常涉及到浅拷贝和深拷贝这两种方式。理解这两者之间的差异是非常重要的,因为它们处理对象引用的方式不同。

    浅拷贝 (Shallow Copy)

    浅拷贝会创建一个新对象,但新对象中的字段将包含与原始对象相同的引用。这意味着浅拷贝只复制对象的顶层,对于包含引用类型的成员,浅拷贝会让原对象和复制对象共享这些引用类型。

    • 方法:一般通过 .MemberwiseClone() 方法实现。这个方法是 Object 类中的一个保护方法,它只复制对象的非静态字段。
    • 适用场景:浅拷贝适用于简单对象结构或者对象内部成员全是值类型的场景。

    示例:

    public class Person
    {
        public string Name;
        public Person(string name)
        {
            Name = name;
        }
    
        public Person ShallowCopy()
        {
            return (Person)this.MemberwiseClone();
        }
    }
    
    Person person1 = new Person("Alice");
    Person person2 = person1.ShallowCopy();
    
    person2.Name = "Bob";
    
    Console.WriteLine(person1.Name); // 输出为 "Bob",因为只有一个字符串对象
    

    深拷贝 (Deep Copy)

    深拷贝会创建一个全新的对象,以及它包含的所有对象的副本。这意味着新对象不会与原始对象共享任何引用类型的成员,整个对象结构都被复制。

    • 方法:没有内置的方法来实现深拷贝,通常需要自己实现。有多种方式可以实现深拷贝:
      • 手动实现:逐个拷贝对象的每个字段和属性,如果字段是引用类型,则递归地进行深拷贝。
      • 序列化:将对象序列化为流,再反序列化生成新对象。

    示例:

    手动实现深拷贝:

    public class Address
    {
        public string City;
        public Address(string city)
        {
            City = city;
        }
    
        public Address DeepCopy()
        {
            return new Address(City);
        }
    }
    
    public class Person
    {
        public string Name;
        public Address Address;
        public Person(string name, Address address)
        {
            Name = name;
            Address = address;
        }
    
        public Person DeepCopy()
        {
            return new Person(Name, Address.DeepCopy());
        }
    }
    
    Person person1 = new Person("Alice", new Address("New York"));
    Person person2 = person1.DeepCopy();
    
    person2.Name = "Bob";
    person2.Address.City = "Los Angeles";
    
    Console.WriteLine(person1.Name); // 输出为 "Alice"
    Console.WriteLine(person1.Address.City); // 输出为 "New York"
    

    总结

    • 浅拷贝适用于不需要复制引用对象的场景,快速且简单。
    • 深拷贝适用于需要复制整个对象图的场景,复杂度高,但更安全地让新对象独立于原对象。

    对于需要频繁复制复杂对象图的场景,清晰理解如何正确应用深拷贝和浅拷贝将极大提高代码的可靠性和性能。