Come si rende una struttura immutabile?

Question

Tutto su Stack Overflow e Internet Vedo che è un buon principio di progettazione mantenere le strutture immutabili. Sfortunatamente, non vedo mai alcuna implementazione che possa effettivamente rendere queste strutture veramente immutabili.

Supponendo che una struttura non abbia alcun tipo di riferimento al suo interno, come posso effettivamente rendere una struttura immutabile? Cioè, come posso impedire la mutazione di uno qualsiasi dei suoi campi primitivi (forse da un'eccezione in fase di compilazione/runtime)?

ho scritto un semplice test di tentare fare una struct immutabile, ma nemmeno utilizzando il System.ComponentModel.ImmutableObjectAttribute lavorato:

class Program 
{ 
    static void Main(string[] args) 
    { 
     ImmutableStruct immStruct1 = new ImmutableStruct(); 
     Console.WriteLine(immStruct1); //Before mutation. 

     immStruct1.field1 = 1; 
     immStruct1.field2 = "Hello"; 
     immStruct1.field3 = new object(); 
     Console.WriteLine(immStruct1); //After 1st mutation. 

     immStruct1.field1 = 2; 
     immStruct1.field2 = "World"; 
     immStruct1.field3 = new object(); 
     Console.WriteLine(immStruct1); //After 2nd mutation. 

     Console.ReadKey(); 
    } 
} 

[ImmutableObject(true)] 
struct ImmutableStruct 
{ 
    public int field1; 
    public string field2; 
    public object field3; 

    public override string ToString() 
    { 
     string field3String = "null"; 
     if (field3 != null) 
     { 
      field3String = field3.GetHashCode().ToString(); 
     } 
     return String.Format("Field1: {0}, Field2: {1}, Field3: {2}", field1, field2, field3String); 
    } 
} 

Answer 1

Effettuare i campi private readonly e passare l'initi al Valori nel costruttore

public struct ImmutableStruct 
{ 
    private readonly int _field1; 
    private readonly string _field2; 
    private readonly object _field3; 

    public ImmutableStruct(int f1, string f2, object f3) 
    { 
     _field1 = f1; 
     _field2 = f2; 
     _field3 = f3; 
    } 

    public int Field1 { get { return _field1; } } 
    public string Field2 { get { return _field2; } } 
    public object Field3 { get { return _field3; } } 
} 

A partire con C# 6.0 (Visual Studio 2015) È possibile utilizzare getter solo le proprietà

public struct ImmutableStruct 
{ 
    public ImmutableStruct(int f1, string f2, object f3) 
    { 
     Field1 = f1; 
     Field2 = f2; 
     Field3 = f3; 
    } 

    public int Field1 { get; } 
    public string Field2 { get; } 
    public object Field3 { get; } 
} 

Si noti che in sola lettura campi e Getter solo le proprietà possono essere inizializzati sia nel costruttore o, in classi, anche con inizializzatori di campo o proprietà public int Field1 { get; } = 7;.

Non è garantito che il costruttore sia eseguito su una struttura. Per esempio. se si dispone di una matrice di strutture, è necessario chiamare gli inizializzatori in modo esplicito per ciascun elemento dell'array. Per gli array di tipi di riferimento, tutti gli elementi vengono inizialmente inizializzati su null, il che rende evidente che è necessario chiamare new su ciascun elemento. Ma è facile dimenticarlo per i tipi di valori come le strutture.

var immutables = new ImmutableStruct[10]; 
immutables[0] = new ImmutableStruct(5, "hello", new Person()); 

Answer 2

Mantenere i vostri dati immutabili privato:

struct ImmutableStruct 
{ 
    private int field1; 
    private string field2; 
    private object field3; 

    public ImmutableStruct(int f1, string f2, object f3) 
    { 
     field1 = f1; 
     field2 = f2; 
     field3 = f3; 
    } 

    public int Field1 => field1; 
    public string Field2 => field2; 
    public object Field3 => field3; 
} 

o meno ingombrante:

struct ImmutableStruct 
{ 
    public ImmutableStruct(int f1, string f2, object f3) 
    { 
     Field1 = f1; 
     Field2 = f2; 
     Field3 = f3; 
    } 

    public int Field1 { get; } 
    public string Field2 { get; } 
    public object Field3 { get; } 
}