public void WriteTransformation(ref byte[] buffer, ref int dataLength, WriteByteHandler writeByteHandler)
{
  if (writeByteHandler == null)
    return;
  if (dataLength < 0)
    throw new ArgumentOutOfRangeException("Data length should be non-negative", dataLength, "dataLength");
  if (buffer == null)
    buffer = new byte[0];
  if (dataLength > buffer.Length)
    throw new ArgumentOutOfRangeException("Data length should not exceed the buffer length", dataLength, "dataLength");

  var newBuffer = new byte[dataLength+1];

  newBuffer[0] = PREFIX;
  Array.Copy(buffer, 0, newBuffer, 1, dataLength);
  buffer = newBuffer;
  dataLength++;
}

        public void WriteTransformation(ref byte[] buffer, ref int bufferLength, WriteByteHandler writeByteHandler)
        {
            if (writeByteHandler != null)
            {
                bufferLength = 1 + Math.Min(Math.Max(bufferLength, 0), (buffer != null) ? buffer.Length : 0);

                byte[] newBuffer;

                if (bufferLength - 1 < ((buffer != null) ? buffer.Length : 0))
                {
                    newBuffer = buffer;
                }
                else
                {
                    newBuffer = new byte[bufferLength];

                }

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

                if (newBuffer != null) newBuffer[0] = PREFIX;

                buffer = newBuffer;
            }
        }

bufferLength = .... Math.Max(bufferLength, 0), (buffer != null) ? buffer.Length : 0

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

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

for (int i = vector.size() - 1; i >= 0; i--)
     foo(vector[i]);

for (size_t i = vector.size() - 1; i >= 0u; i--)
     foo(vector[i]);

AN>

Давайте попросим код ошибки от Console.WriteLine и будем извещать пользователя если что не так

static class Program
    {
        static void Main(string[] args)
        {
            DoSomething(new byte[0]);
        }
        static void DoSomething(byte[] arr)
        {
            for(var i = 0; i <= arr.Length() - 1; i++)
            {
                
            }
        }

        private static uint Length(this Array arr)
        {
            return (uint) arr.Length;
        }
    }

AN>Держите

WriteLine()
AN>{
AN>}
AN>

bufferLength = Math.Max(bufferLength, 0)
AN>

return await ххх

s> Если манипулирование абстракциями на таком уровне является проблемой для команды, то ну ее нафик, эту абстракцию.
Дело не в конкретной проблеме, а в общем подходе. И дело, в основном, упирается во время.
s> А может стоит подтянуть команду? Все же это не ахти какой уровень владения программированием.
Сегодня она одна, завтра совсем другая. Главный принцип "не выпендриваться".

void f()
AN>{
AN>  int A1=0;
AN>}
AN>

public class X
AN>{
AN>   public int A2 = 0;
AN>}
AN>

AN>Я это тоже заметил Просто мы находимся в различных средах.

HttpWebRequest req = (HttpWebRequest)WebRequest.Create("http://someurl.com/");
HttpWebResponse resp = req.GetResponse();

s>> И я даже как-то не уверен, можно ли на .net написать "однопотоковое" приложение. Можно не запускать никаких вспомогательных потоков явно, но это не значит что их не будет .

var bufferLength2 = 0;
bufferLength = Math.Max(bufferLength, bufferLength2); // ниужели так бы не смущало?

var maximum = max(a, max(b, max(c, d)));

s>> s>> Думать можно разными путями, а уж недумая —

s>>

AN>

AN>Так что быстрее? Думать или не думать

s>> AN>  methodInfo.Invoke(target, null);
s>> AN>

foreach (var group in hash
        .GroupBy(rq => rq.IsRead)
        .Select(grp => new { IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds) }))
    MarkMsgsRead(
        _provider,
        group.Ids,
        group.IsRead);

if (buffer != null)

foreach (var group in hash
AN>        .GroupBy(rq => rq.IsRead)
AN>        .Select(grp => new { IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds) }))
AN>    MarkMsgsRead(
AN>        _provider,
AN>        group.Ids,
AN>        group.IsRead);

void FindAndMarkMsgs(bool isRead)
{
   MarkMsgsRead(_provider, hash.Where(rq => rq.IsRead == isRead).Select(rq => rq.Id), isRead);  
}

FindAndMarkMsgs(true);
FindAndMarkMsgs(false);

static void ParseCommandLineArgs(params string[] args)
{
    string param1 = "undefined";
    string param2 = "undefined";
    int i = 0;
    while(i < args.Length)
    {
        if (args[i] == "param1" && args.Length > ++i)
        {
            param1 = args[i++];
        }
        else if (args[i] == "param2" && args.Length > ++i)
        {
            param2 = args[i++];
        }
    }
    Console.WriteLine("param1 = {0}, param2 = {1}", param1, param2);
}
void Main()
{
    // Выведет: param1 = value1, param2 = value2
    ParseCommandLineArgs("param1", "value1", "param2", "value2");
    // А здесь: param1 = value1, param2 = undefined
    ParseCommandLineArgs("param1", "value1", "param2");

}

_FR>А где бы вы применили этот оператор в показанном коде?

(buffer != null) ? buffer : 0

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

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

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

    byte[] newBuffer;

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

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

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

    // Добавляем комментарий:
    // Теперь нам нужно скопировать все элементы из массива buffer в newBuffer, сместив
    // каждый из них на  один индекс вправо, чтобы в нулевой индекс поместить PREFIX
    for (int i = bufferLength - 1; i > 0; i--)
    {
        newBuffer[i] = buffer[i - 1];
    }

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

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

foreach (var group in hash

U> AN>        .GroupBy(rq => rq.IsRead)
U> AN>        .Select(grp => new { IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds) }))

U> AN>    MarkMsgsRead(
U> AN>        _provider,
U> AN>        group.Ids,
U> AN>        group.IsRead);

U> По-моему как раз наоборот простой читаемый код

foreach (var group in hash

foreach (var group in hash
        .GroupBy(rq => rq.IsRead)
        .Select(grp => new { IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds) }))
{
    MarkMsgsRead(
        _provider,
        group.Ids,
        group.IsRead);
}

            var groups = groupBy.Select(
                delegate(IGrouping<bool, MarkRequest> grp)
                    {
                        return new {IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds)};
                    }
                );

 if (buffer != null)

Примечание:
Добавить байт в буфер вначале, до данных, 
непонятно как, так как при другом типе выходного потока байт добавлять не нужно, 
а данные приходят "снаружи".

AN>> А для NET 2.0 это тоже будет работать?

bufferLength = 1 + Math.Min(Math.Max(bufferLength, 0), (buffer != null) ? buffer.Length : 0);

ST> Если следовать твоей логике, то вероятность ошибок в моем коде должна быть в 5 раз выше, ведь именно во столько раз там меньше проверок

кода больше, вероятность ошибок возрастает, ведь вполне можно забыть добавить еще одну проверку при добавлении очередной строки кода

ST> AN>Это видимо надо переносить в раздел "священные войны".

ST> Нет, не нужно Лучше почитать

        // 1
        public static T[] AddToFirst<T>(this T[] array, T item)
        {
            if (array == null) return new T[0];

            T[] newArray = new T[array.Length + 1];
            newArray[0] = item;

            for (int i = 0; i < array.Length; i++)
            {
                newArray[i + 1] = array[i];
            }
            return newArray;
        }
        // 2
        public static void AddToFirst<T>(ref T[] array, T item)
        {
            if (array == null) return;

            T[] newArray = new T[array.Length + 1];
            newArray[0] = item;

            for (int i = 0; i < array.Length; i++)
            {
                newArray[i + 1] = array[i];
            }
            array = newArray;
        }

int[] array = new int[10];
array = array.AddToFirst(100);

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

AN>Теперь уже поняли, появилась новая проблема работы с оффлайн бровсерами

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

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

bufferLength = 1 + Math.Min(Math.Max(bufferLength, 0), (buffer != null) ? buffer.Length : 0);

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

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

L>Зато подойдет Array.Copy

        public void WriteTransformation(ref byte[] buffer, ref int dataLength, WriteByteHandler handler)
        {
            if (buffer == null) return;
            if (dataLength < 0) return;
            if (handler == null) return;

            if (dataLength < buffer.Length)
            {
                for (int i = dataLength; i > 0; i--)
                {
                    buffer[i] = buffer[i - 1];
                }
                buffer[0] = PREFIX;
            }
            if (dataLength >= buffer.Length)
            {
                byte[] newArray = new byte[dataLength + 1];
                for (int i = 0; i < buffer.Length; i++)
                {
                    newArray[i + 1] = buffer[i];
                }
                newArray[0] = PREFIX;
                buffer = newArray;
            }
            dataLength++;
        }

for (int i = 0; i < buffer.Length; i++)
{
    newArray[i + 1] = buffer[i];
}

Array.Copy(buffer, 0, newArray, 1, buffer.Length);

x>         public void WriteTransformation(ref byte[] buffer, ref int dataLength, WriteByteHandler handler)
x>         {
x>             if (buffer == null) return;
x>             if (dataLength < 0) return;
x>             if (handler == null) return;

x>             if (dataLength < buffer.Length)
x>             {
x>                 for (int i = dataLength; i > 0; i--)
x>                 {
x>                     buffer[i] = buffer[i - 1];
x>                 }
x>                 buffer[0] = PREFIX;
x>             }
x>             if (dataLength >= buffer.Length)
x>             {
x>                 byte[] newArray = new byte[dataLength + 1];
x>                 for (int i = 0; i < buffer.Length; i++)
x>                 {
x>                     newArray[i + 1] = buffer[i];
x>                 }
x>                 newArray[0] = PREFIX;
x>                 buffer = newArray;
x>             }
x>             dataLength++;
x>         }
x>

if (dataLength < buffer.Length)
  {
     ...
  }
  if (dataLength >= buffer.Length)

if (dataLength < buffer.Length)
  {
     ...
  }
else

x> for (int i = 0; i < buffer.Length; i++)
x> {
x>     newArray[i + 1] = buffer[i];
x> }
x>

x> Array.Copy(buffer, 0, newArray, 1, buffer.Length);
x>

if (newBuffer != null) if (buffer != null)

           (No new) Repeats 500000 buffer size 256 time 00:00:00.5496574
         (With new) Repeats 500000 buffer size 256 time 00:00:00.4979645
         * 
         * (No new) Repeats 500000 buffer size 512 time 00:00:01.0589830
         (With new) Repeats 500000 buffer size 512 time 00:00:00.9412769
         * 
         * (No new) Repeats 500000 buffer size 1024 time 00:00:02.1139021
         (With new) Repeats 500000 buffer size 1024 time 00:00:01.8606506
         * 
         * (No new) Repeats 100000 buffer size 4096 time 00:00:01.7431369
         (With new) Repeats 100000 buffer size 4096 time 00:00:01.5042657
         * 
         * (No new) Repeats 100000 buffer size 8192 time 00:00:03.3840202
         (With new) Repeats 100000 buffer size 8192 time 00:00:02.9811746

        public static void InitBuffer(byte[] buffer)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = 0x55;
            }
        }

        private static void TestNoNew(int BufferLength, int RepeatCount)
        {
            byte[] buffer;
            Stopwatch timer = new Stopwatch();
            timer.Start();
            buffer = new byte[BufferLength];
            for (int i = 0; i < RepeatCount; i++)
            {
                InitBuffer(buffer);
            }

            timer.Stop();
            Console.WriteLine("(No new) Repeats {0} buffer size {1} time {2}", RepeatCount, BufferLength, timer.Elapsed);
        }

        private static void TestWithNew(int BufferLength, int RepeatCount)
        {
            byte[] buffer;
            Stopwatch timer = new Stopwatch();
            timer.Start();
            for (int i = 0; i < RepeatCount; i++)
            {
                buffer = new byte[BufferLength];
                InitBuffer(buffer);
            }

            timer.Stop();
            Console.WriteLine("(With new) Repeats {0} buffer size {1} time {2}", RepeatCount, BufferLength, timer.Elapsed);
        }

if (newBuffer != null) if (buffer != null)

S> AN>Уже только эту строку можно занести в шедевры "как не надо"

S> AN>Если предоставите линейку напрокат

S> AN>Добавка байт была не починкой, а заданием класса/функции. Приведенный код возник когда выяснилось, что посылка вначале заголовка, а потом основного сообщения приводит к ошибкам на некоторых конфигурациях. Исправлять пришлось тому кто это нашел

S> Мерили в релизе или в дебаге?

  (No new) Repeats 100000 buffer size 8192 time 00:00:02.7632629
(With new) Repeats 100000 buffer size 8192 time 00:00:02.9427531