Perché "someString + = AnotherString = someString;" valido in C#

Question

Stavo scrivendo un po 'di codice oggi ed ero a metà riga quando ho aperto la scheda di un altro monitor per controllare qualcosa. Quando ho guardato indietro, ReSharper aveva colorato la terza riga sotto grigio con la nota "Il valore assegnato non è usato in nessun percorso di esecuzione".

var ltlName = (Literal) e.Item.FindControl("ltlName"); 
string name = item.FirstName; 
name += 

ltlName.Text = name; 

Sono stato confuso; sicuramente questo codice non può essere compilato. Ma lo fa, e funziona anche lui. La linea "name + =" non ha alcun effetto (che potrei dire) sulla stringa. Cosa sta succedendo qui?

(Visual Studio 2008, .NET 3.5)

Answer 1

Sta facendo questo:

name += ltlName.Text = name; 

o per renderlo leggermente più chiaro:

name += (ltlName.Text = name); 

.210

Il risultato della setter di proprietà è il valore che è stato impostato, in modo che funziona un po 'come questo:

string tmp = name; 
ltlName.Text = tmp; 
name += tmp; 

E' più semplice di osservare questo quando hai diverse variabili coinvolte, però, e solo semplice assegnazione come il passo finale piuttosto che un compito composto. Ecco un esempio completo:

using System; 

class Test 
{ 
    public string Text { get; set; } 

    static void Main() 
    { 
     Test t = new Test(); 

     string x = t.Text = "Hello"; 
     Console.WriteLine(x); // Prints Hello 
    } 
} 

I semplici assegnazione regole (sezione 7.17.1) vengono utilizzati per determinare il risultato dell'espressione:

Il risultato di una semplice assegnazione espressione è il valore assegnato a l'operando di sinistra. Il risultato ha lo stesso tipo dell'operando sinistro ed è sempre classificato come valore.

Così il tipo di ltlName.Text = name è dello stesso tipo di ltlName.Text, e il valore è quello che è stato assegnato. Il fatto che sia una proprietà piuttosto che un campo o una variabile locale non lo cambia.

Answer 2

noti che ritorni a capo non sono speciali in C#. A causa della seguente riga, la dichiarazione completa al compilatore è

name += ltlName.Text = name; 

che è una dichiarazione valida (assegna name-ltlName.Text, quindi aggiungere a name.)

Answer 3

In C#, le nuove righe non terminano le istruzioni: solo il punto e virgola. Così la seguente riga di codice è in esecuzione:

name += ltlName.Text = name; 

Answer 4

Perché gli spazi bianchi è irrilevante in C#, linea 3, 4 e 5 formano una dichiarazione:

name += ltlName.Text = name; 

Answer 5

sta interessando la corda, ma non fino a dopo la stringa è usata per influenzare il letterale sul display. Come ha sottolineato KennyTM, entrambe le linee formano una singola affermazione. A differenza di VB, il ritorno a capo non termina un'istruzione in C#. Il punto e virgola sì. Quindi, cosa sta succedendo qui è che la stringa viene impostata sul letterale e il risultato di tale operazione ("vero" forse?o solo la stringa stessa? Non ricordo) viene aggiunto alla stringa.

Answer 6

Come previsto, il risultato è il nome concatenato a se stesso. Quindi ottieni "namename".

obj.Text è solo una proprietà, quindi la linea finisce la conversione in

//name += obj.Text = name; 
obj.setText(name); 
name += obj.Text; 

sorgente completo sotto

public class Program 
{ 
    public static void Main(string[] args) 
    { 
     MyClass obj = new MyClass(); 
     string name = "name"; 
     name += obj.Text = name; 
     Console.Write(name); //prints namename 
    } 
}