struct c＃

问题描述

据我了解，结构是值类型，这意味着它们在传递时会被复制。因此，如果您更改副本，则仅更改该副本，而不更改原始副本，也更改任何可能存在的其他副本。

但是，您可能有一个带有要列出其值的行为的类列表的结构，例如：

private struct InitData {
    public string name;
    public float initialSpeed;
    public bool loop;
    public List<Settings> settings;
}

设置是一类simple types很多的类，由于需要引用行为，所以该类。

对于我来说，我需要保留一个类的初始值，为此我需要此结构来保留数据。

简单类型的行为符合预期，并且当我从该结构设置值时，它们不会被修改，而List<Settings> Settings会改变值，但它们不会被修改，因为尽管它在结构内部，但仍作为引用类型。 / p>

所以我必须对我的_initData结构实例和对List<Settings> _settings实例进行处理，以打破列表的引用类型行为。

_settings = _initData.settings;
//renew instace to have value behaviour:
_initData.nodeSettings = new List<Settings>();
_initData.nodeSettings = (List<Settings>)DeepCopy(_settings.ToList());

因此，由于每次生成一个新的列表实例似乎不太合适，因此有什么方法可以在结构内部实现值行为，以便数据结构处理具有值类型行为的许多实例或引用（含义列表，数组，向量等）？

解决方法

如@InBetween所述，如果复制包含引用的结构，则仅复制该引用，而不复制该引用所引用的对象。

可变结构为widely considered evil，因此最好避免使用它们。如果不可变结构包含对可变对象的引用，则其行为将与传递的任何其他引用一样，即，当您对对象进行突变时，必须考虑对象是否共享，如果是，则要对对象进行突变，或变异副本。

避免出现任何问题的一种好方法是确保对象始终是不可变的，因此任何更改都需要创建一个副本。使用System.Collections.Immutable库的示例：

public class Settings
{
    //Should only contain immutable fields
    public int MyValue { get; }

    public Settings(int myValue) => MyValue = myValue;

    // Can contain helpers to create a mutated object
    public Settings WithMyValue(int newMyValue) => new Settings(newMyValue);
}
public struct InitData
{
    public string Name { get; }
    public float InitialSpeed { get; }
    public bool Loop { get; }
    public ImmutableList<Settings> Settings { get; }

    public InitData(string name,float initialSpeed,bool loop,ImmutableList<Settings> settings)
    {
        this.Name = name;
        this.InitialSpeed = initialSpeed;
        this.Loop = loop;
        this.Settings = settings;
    }

    public InitData(string name,IEnumerable<Settings> settings)
        : this(name,initialSpeed,loop,settings.ToImmutableList())
    { }

    public InitData MutateSettings(Func<ImmutableList<Settings>,ImmutableList<Settings>> mutator) 
        => new InitData(Name,InitialSpeed,Loop,mutator(Settings));
}

您提到的另一种选择是创建深层副本，例如：

public class Settings
{
    public int MyValue { get; set; }
    public Settings(int myValue) => MyValue = myValue;
    public Settings Clone() => new Settings(MyValue);
}
public struct InitData
{
    public string Name { get; }
    public float InitialSpeed { get; }
    public bool Loop { get; }
    public List<Settings> Settings { get; }

    public InitData(string name,List<Settings> settings)
    {
        this.Name = name;
        this.InitialSpeed = initialSpeed;
        this.Loop = loop;
        Settings = settings;
    }

    public InitData Clone() => new InitData(Name,Settings.Select(s => s.Clone()).ToList());
}

由于InitData是浅不变的，因此它是值还是引用类型都没有关系，但是由于它不是深不变的，因此无论何时需要不变的副本，都需要对其进行克隆。

创建透明创建深层副本的方法可能相当困难。运行时不知道对象是否是深度不可变的，因此它将需要复制所有字段，并且有可能复制的内容可能超出您的预期。您还需要某种方式来处理循环引用。因此，我不知道任何具有此功能的C风格语言。

有一种使用序列化的方法，例如BinaryFormatter，用于深层副本，但我不建议这样做。