ST>public byte[] WriteTransformation(byte[] buffer, int bufferLength)

Так ли это уж хорошо в данном случае менять сигнутуру? В первом варианте было понятно, что buffer может поменяться, тут же надо знать реализацию.

ST>{
ST>    // Выделяем проверку предусловий в отдельный блок, что на порядок упрощает весь остальной код.

И возможно ломает существующий код. :)

ST>    // Контракты просто упрощают запись, но никто не мешает проверить предусловия руками.
ST>    Contract.Requires(buffer != null);
ST>    Contract.Requires(bufferLength >= 0);
ST>    Contract.Ensures(Contract.Result<byte[]>() != null);

Ни одного из этих предусловий нет в коде.

ST>    // Прежде всего убираем не используемый параметр, 

Неиспользуемый? 
[q]
if (writeByteHandler != null)
[/q]

ST>если же он используется, то добавляем
ST>    // соответствующее предусловие.

Какое? И что вы будете возвращать, если writeByteHandler == null. У вас же Contract.Ensures(Contract.Result<byte[]>() != null) :)

ST>    // А теперь демонстрируем уличную магию того, как проверка предусловий упрощает код:
ST>    // Было: bufferLength = 1 + Math.Min(Math.Max(bufferLength, 0), (buffer != null) ? buffer.Length : 0);
ST>    // Меняем: (buffer != null) ? buffer.Length : 0 --> buffer.Length, благодаря buffer != null
ST>    // Меняем: Math.Max(bufferLength, 0) --> bufferLength, благодаря bufferLength >= 0
ST>    // Добавляем комментарий и вот, что мы получаем в итоге:
            
ST>    // Необходимость +1 обусловлена тем, что в нулевой байт выходного буфера мы поместим PREFIX
ST>    bufferLength = 1 + Math.Min(bufferLength, buffer.Length);

Переиспользование переменной для разных нужд. Фаулер негодуэ. :)

ST>    byte[] newBuffer;

ST>    // Теперь меняем следующий код:
ST>    // Было: if (bufferLength - 1 < ((buffer != null) ? buffer.Length : 0))
ST>    // Проверка buffer != null, уже не нужна
ST>    // Получаем: if (buffer.Length > bufferLength - 1)
ST>    // Заменяем > на >=:
ST>    // if (buffer.Lengh >= bufferLength)
ST>    // Инвертируем логику, поскольку она проще
ST>    // Результат: if (buffer.Lenfth < bufferLenfth) ...
ST>    // Добавляем комментарий и вот, что получаем в результате:

ST>    // Нам нужно удостовериться, что в исходном массиве есть место под дополнительный
ST>    // байт префикса:
ST>    if (buffer.Length < bufferLength )
ST>    {
ST>        newBuffer = new byte[bufferLength];
ST>    }
ST>    else
ST>    {
ST>        newBuffer = buffer;
ST>    }

ST>    // Все, что удалось улучшить в этом коде, так это избавиться от лишних
ST>    // проверок и добавить комментарий, поясняющий причину перебора элементов
ST>    // "справа". Кстати, Array.CopyTo здесь не подойдет, поскольку он копирует
ST>    // *все* элементы массива, а реальный размер массива buffer может быть большим

Зато подойдет Array.Copy :)

ST>    // Добавляем комментарий:
ST>    // Теперь нам нужно скопировать все элементы из массива buffer в newBuffer, сместив
ST>    // каждый из них на  один индекс вправо, чтобы в нулевой индекс поместить PREFIX

Имхо, единственный нетривиальный момент этого кода (обратный ход цикла) вы и не удосужились откомментировать.

ST>    for (int i = bufferLength - 1; i > 0; i--)
ST>    {
ST>        newBuffer[i] = buffer[i - 1];
ST>    }

ST>    // Здесь тоже проверка уже не нужна
ST>    newBuffer[0] = PREFIX;

ST>    // У нас все еще есть проблема, поскольку в некоторых случаях мы меняем переданный буфер,
ST>    // так что, если размер этого массива обычно небольшой, то я бы предпочел, чтобы всегда
ST>    // возвращался новый объект.
ST>    // Неизменяемость (или имутабельность) - это отличная техника программирования!
ST>    return newBuffer;
ST>}
ST>

x> public void WriteTransformation(ref byte[] buffer, ref int bufferLength, WriteByteHandler writeByteHandler)
x>

ST>>public byte[] WriteTransformation(byte[] buffer, int bufferLength)

L>if (writeByteHandler != null)

P> public static string GetX(int id)
P> {
P>     return id.ToString().Substring(id.ToString().Length - 1, 1);
P> }
P>

P> public static int GetX(int id)
P> {
P>     return id % 10;
P> }
P>