Q:

Append to string

URL is a string, so why can't I concatenate like so:
string url = "something";
url + string.Format("group={0}&", Id);

Is this because string is a reference type, and it's actually trying to add it to the reference rather than the object?
What is the best way to achieve what I want?

A:

Needs assignment
url += string.Format("group={0}&", Id);

or
url = url + string.Format("group={0}&", Id);

A:

The + operator doesn't change the variable that you use in the expression. It doesn't do that for a numeric value either:
int i = 42;
i + 4; // doesn't change the variable i

You have to assign the result to a string variable:
url = url + string.Format("group={0}&", Id);

You can also use the += operator, that will produce the exact same runtime code:
url += string.Format("group={0}&", Id);

Note that this doesn't change the string, it produces a new string from the two strings. What the code actually does is:
string temp = String.Concat(url, string.Format("group={0}&", Id));
url = temp;

A:

Several answers mention immutability, and that's not what this is. 
The line of code 
a + b; 

Is simply not legal as a standalone statement. You will get the error 

Only assignment, call, increment, decrement, and new object expressions can be used as a statement.

Making System.String mutable would not change this. Making + mutate one or both of the operands would not change this. The line of code simply is not legal. 
a = a + b; // legal

To be clear, you can define your own type, define a + operator, inside the method of that operator mutate one of the operands (which would probably anger your consumers, mutable type or not), and then return it, and it still would not make the standalone line a + b; legal. You must use its result in something that is involved in one of the above expressions (assignment, call, etc.).
public class Foo
{
    public int Bar;

    public static Foo operator +(Foo a, Foo b)
    {
        a.Bar += b.Bar; // horrible mutation
        return new Foo() { Bar = a.Bar };
    }
}

///

Foo a = new Foo() { Bar = 1 };
Foo b = new Foo() { Bar = 2 };
a + b; // still not legal

