Можно и нужно ли превратить делегат, модифицирующий массив байтов, в лямбда-выражение?

Question

У меня есть делегат, который выглядит следующим образом:

public delegate byte[] CopyPixelOperation(byte[] pixel);

Это позволяет мне вводить произвольную операцию в функцию, которая перебирает и изменяет каждый пиксель в растровом изображении.Вот пример реализации делегата:

CopyPixelOperation greenify = delegate(byte[] pixel) 
                                {
                                       int redValue = pixel[2];
                                       int greenValue = pixel[1];
                                       int blueValue = pixel[0];

                                       pixel[1] += 10;
                                       pixel[0] -= 10;
                                       pixel[2] -= 10;

                                       return pixel; 
                                };

Я все еще немного шатаюсь по лямбда-выражениям, и я не уверен, как ссылаться на отдельные элементы массива изнутри выражения.Является ли это возможным?Имеет ли это смысл, или я должен просто оставить все как есть?

Answer 1

Да, вы можете использовать лямбда-выражение - но лично я, вероятно, не стал бы.Это выглядит как хорошее место для написания метода вместо:

public static byte[] Greenify(byte[] pixel)
{
   int redValue = pixel[2];
   int greenValue = pixel[1];
   int blueValue = pixel[0];

   pixel[1] += 10;
   pixel[0] -= 10;
   pixel[2] -= 10;

   return pixel; 
}

Вы можете легко создать делегат, соответствующий этому методу, используя преобразование группы методов, когда вынужно это:

CopyPixelOperation operation = Greenify;

или (в качестве аргумента вызова метода):

var result = Apply(Greenify).Then(Save); // Or whatever

Если это не что-то вроде параллельного foreach или ситуации, когда мне действительно нужно захватить контекст, яобычно предпочитают иметь методы над длинными анонимными функциями.

Answer 2

delegate() выражения и лямбды не так уж и отличаются синтаксически. Как минимум, это вопрос удаления ключевого слова delegate и добавления оператора =>. Вы можете выразить свой делегат в виде следующей лямбды:

CopyPixelOperation greenify = (byte[] pixel) =>
{
    int redValue = pixel[2];
    int greenValue = pixel[1];
    int blueValue = pixel[0];

    pixel[1] += 10;
    pixel[0] -= 10;
    pixel[2] -= 10;

    return pixel; 
};

Чтобы еще больше упростить его, вы можете опустить тип аргумента, чтобы (byte[] pixel) стал pixel, и его тип будет выведен из типа делегата CopyPixelOperation.

Answer 3

Насколько я знаю, лямбды и делегаты почти эквивалентны; единственное отличие, кроме синтаксиса, заключается в том, что лямбда-выражения могут быть неявно напечатаны Вам решать, что более читабельно:

CopyPixelOperation greenify = delegate(byte[] pixel) 
                            {
                                   int redValue = pixel[2];
                                   int greenValue = pixel[1];
                                   int blueValue = pixel[0];

                                   pixel[1] += 10;
                                   pixel[0] -= 10;
                                   pixel[2] -= 10;

                                   return pixel; 
                            };

или

CopyPixelOperation greenify = pixel =>
                            {
                                   int redValue = pixel[2];
                                   int greenValue = pixel[1];
                                   int blueValue = pixel[0];

                                   pixel[1] += 10;
                                   pixel[0] -= 10;
                                   pixel[2] -= 10;

                                   return pixel; 
                            };

Также обратите внимание, что CopyPixelOperation может быть

Func<byte[], byte[]>

(Также обратите внимание, что ваш метод сохраняет значения, которые он никогда не использует.)