Строки в C#

Работа со строками всегда специфична для разных языков программирования. Не обошлось без своей специфики и в C#. Тема вобщем-то не новая и уже обсуждалась много раз, но намедни я столкнулся с ней вновь.
Пришлось мне разбираться с одним багом: web сервис в структурах выходных данных местами выдавал пустые строки. Разбирательства вывели меня на вот этот метод:

protected static void TryToFill(string target, string source)
{
 if (source != null && source.Length > 0)
 {
  target = source;
 }
}

Как вы думаете, что выдаст на консоль вот такой код:

string s = "source";
string t = "";
TryToFill(t, s);
Console.WriteLine("target = '{0}'",t);

На выходе получаем:

target = ‘’

Метод TryToFill был предназначен для заполнения строки target данными из строки source. Но он не работает. Строка target после его вызова остается пустой
Строки в C# - ссылочные типы, память под них выделяется в куче. Передача в метод ссылочного типа в качестве параметра означает передачу ссылки на объект. Все изменения с параметром ссылочного типа внутри метода будут видны снаружи этого метода. Можно проверить. Массив - типичный ссылочный тип в C# - вот с ним и поэксперементируем:

public static void Change(byte[] val)
{
 val[0] +=1;
}

Теперь создаем массив, передаем его в метод и смотрим его состояние до и после.

byte[] b = new byte[]{1,2}; 
Console.WriteLine("b[0] before Change() is '{0}'", b[0]);
Change(b);
Console.WriteLine("b[0] after Change() is '{0}'", b[0]);

Получаем:

b[0] before Change() is '1'
b[0] after Change() is '2'

Что и требовалось доказать. Но почему такой подход не работает со строками?
Все это из-за того, что в .Net строки сделаны immutable. Это означает, что однажды созданный объект больше никогда не меняет своего состояния. Для этого класс String сделан sealed, у него переопределены операции сравнения, доступ к символам строки возможен только на чтение, а при присваивании значения строке компилятор шаманит и создает новый экземпляр строки.
Что происходит в злополучном методе TryToFill? После вызова метода параметр target ссылается туда же, куда и переменная t. Но при присваиваниии target = source, создается копия значения source, на которую теперь ссылается target, а значение пременной t остается неизменным.
Для чего все это нужно?
Вот что говорит на эту тему Brian Harry в "Conversations on .NET":

Q: In reference to string manipulation, it appears that we can no longer directly manipulate the buffer in managed code. For example, string[0] = 'a'. Instead we do something like string.Replace(0, 'a') and get a new string back.

Brian Harry: Yes, the reason for this is that strings are immutable. This makes for a simpler programming model and eliminates problems around synchronization and sharing of strings. In some cases, it allows us to give better performance by avoiding copying strings.

Как ни странно, основной резон – повысить производительность. Память для экземпляра строки один раз выделяется в куче и после этого строка никогда никуда не копируется. Когда нам кажется, что в программе строке присваивается новое значение, происходит выделение памяти под новое значение строки, и ссылка на эту память присваивается переменной. Старое значение становится добычей сборщика мусора. Как известно выделение памяти в CLR происходит очень быстро, и сборщик мусора тоже весьма эффективен. Так что такое решение вполне оправдано.
Еще один положительный момент (которым впрочем почти никто не пользуется) это то, что доступ к строковым переменным из нескольких потоков не надо синхронизировать.