Why is "someString += AnotherString = someString;" valid in C#

Question

I was writing some code today and was mid line when I alt-tabbed away to a screen on my other monitor to check something. When I looked back, ReSharper had colored the 3rd line below grey with the note "Value assigned is not used in any execution path".

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

ltlName.Text = name;

I was confused; surely this code can't compile. But it does, and it runs too. The line "name +=" has no effect (that I could tell) on the string. What's going on here?

(Visual Studio 2008, .NET 3.5)

Answer 1

Notice that newlines are not special in C#. Because of the following line, the complete statement to the compiler is

name += ltlName.Text = name;

which is a valid statement (it assigns name to ltlName.Text, then append it to name.)

Answer 2

It's doing this:

name += ltlName.Text = name;

or to make it slightly clearer:

name += (ltlName.Text = name);

The result of the property setter is the value which was set, so it works a bit like this:

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

It's simpler to observe this when you've got different variables involved though, and just simple assignment as the final step rather than a compound assignment. Here's a complete example:

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
    }
}

The simple assignment rules (section 7.17.1) are used to determine the result of the expression:

The result of a simple assignment expression is the value assigned to the left operand. The result has the same type as the left operand and is always classified as a value.

So the type of ltlName.Text = name is the same type as ltlName.Text, and the value is the one that's been assigned. The fact that it's a property rather than a field or local variable doesn't change this.

Answer 3

In C#, newlines don't terminate statements - only semicolons do. So the following line of code is executing:

name += ltlName.Text = name;

Answer 4

Because whitespace is irrelevant in C#, line 3, 4 and 5 form one statement:

name += ltlName.Text = name;

Answer 5

It is affecting the string, but not until after the string is used to affect the literal on the display. As KennyTM pointed out, both lines form a single statement. Unlike VB, the carriage return doesn't end a statement in C#. The semicolon does. So what's happening here is the string is being set to the literal, and the result of that operation ("true" perhaps? or just the string itself? I don't remember) is being appended to the string.

Answer 6

As expected, the result is name concatenated to itself. So you get "namename".

obj.Text is just a property, so the line ends up converting to

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

Full source below

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
    }
}