problema con struct e proprietà in C#

Question

in un file che ho definito una struttura pubblica

public struct mystruct 
{ 
    public Double struct1; 
    public Decimal struct2; 
} 

In un altro ho provato a fare questo:

class Test 
{ 
    mystruct my_va; 

    public mystruct my_va 
    { 
     get { return my_va; } 
     set { my_va = value; } 
    } 

    public Test() 
    { 
     my_va.struct1 = 10; 
    } 
} 

Intellisense riconosce My_va.struct1 ma compilatore dice

Errore 1 Impossibile modificare il valore di ritorno di 'TEST.mystruct' perché non è un variabile

Come correggere la sintassi?

Answer 1

Si consiglia vivamente di evitare le strutture mutevoli. Esibiscono ogni sorta di comportamento sorprendente.

Soluzione: rendere la vostra struttura immutabile.

public struct MyStruct 
{ 
    public readonly double Value1; 
    public readonly decimal Value2; 

    public MyStruct(double value1, decimal value2) 
    { 
     this.Value1 = value1; 
     this.Value2 = value2; 
    } 
} 

Usage:

class Test 
{ 
    private MyStruct myStruct; 

    public Test() 
    { 
     myStruct = new MyStruct(10, 42); 
    } 

    public MyStruct MyStruct 
    { 
     get { return myStruct; } 
     set { myStruct = value; } 
    } 
} 

Answer 2

Sì, è assolutamente giusto. Vedete, quando si ottiene prelevaMy_va, si sta recuperando un valore - una copia del valore corrente di my_va. Cambiare quel valore non avrebbe alcun vantaggio, perché avresti immediatamente scartato la copia. Il compilatore ti impedisce di scrivere codice che non fa quello che sembra.

In generale, evitare le strutture mutabili. Sono cattivi In questo caso, si potrebbe (per esempio) il cambiamento mystruct di essere immutabile, ma con un metodo come questo:

public mystruct WithStruct1(double newValue) 
{ 
    return new mystruct(newValue, struct2); 
} 

quindi modificare il codice di costruzione per:

My_va = My_va.WithStruct1(10); 

... anche se in questo caso è molto più probabile (dato che sei in un costruttore) che si dovrebbe scrivere:

My_va = new mystruct(10, 0); 

Non solo si dovrebbe struct b E immutabile, dovrebbero essere piuttosto rari nella maggior parte delle codebase, IMO. Oltre a Noda Time, non ho quasi mai scritto i miei tipi di valori personalizzati.

Infine, si prega di imparare la .NET naming conventions e cercare di seguirli, anche per il codice di esempio :)

Answer 3

più semplice correzione: Modificare la struttura per una classe.

Answer 4

Lavoro con un elenco di strutture e l'ho risolto in un modo diverso.

struct Pixel 
{ Public int X; 
    Public int C; 
} 
List<Pixel> PixelList = new List<Pixel> 
TempPixel = new Pixel(); 

Ora, quando voglio impostare un codice di valore che in questo modo:

TempPixel = PixelList[i]; 
TempPixel.X= 23; // set some value 
PixelList[i] = TempPixel 

Il codice è un po 'strano, forse, ma si risolve il problema. Risolve il problema che a una struttura non può essere assegnato direttamente un singolo valore, ma può essere una copia di un tipo simile. solving errore CS1612:

https://msdn.microsoft.com/query/dev10.query?appId=Dev10IDEF1&l=EN-US&k=k%28CS1612%29;k%28TargetFrameworkMoniker-%22.NETFRAMEWORK%2cVERSION%3dV2.0%22%29;k%28DevLang-CSHARP%29&rd=true

Answer 5

Purtroppo questo errore può essere generato in modo non corretto quando si assegna ad una proprietà (cioè chiamando una setter proprietà). Una struttura immutabile può ancora avere un setter di proprietà valido, purché il setter di proprietà non assegni effettivamente alcun campo nella struct. Ad esempio,

public struct Relay 
{ 
    public Relay(Func<string> getText, Action<string> setText) 
    { 
     this.GetText = getText; 
     this.SetText = setText; 
    } 
    private readonly Func<string> GetText; 
    private readonly Action<string> SetText; 

    public string Text { 
     get { return this.GetText(); } 
     set { this.SetText(value); } 
    } 
} 

class Example 
{ 
    private Relay Relay { 
     get { return new Relay(() => this.text, t => { this.text = t; }); } 
    } 

    private string text; 


    public Method() 
    { 
     var r = new Relay(); 
     r.Text = "hello"; // not a compile error (although there is a null reference) 

     // Inappropriately generates a compiler error 
     this.Relay.Text = "hello"; 

     r = this.Relay; 
     r.Text = "hello"; // OK 
    } 
}