Долго функционировать как лямда, правильно или неправильно?


Я просматривал код новой напарнице и, хотя в целом я думаю, что это нормально, есть вещь, которая вызывает у меня смешанные чувства:

  private void Method(...)
  {
       Thread t = new Thread(() =>
       {
           // Some ~50 lines of code here
       });
       t.Start();
  }

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



2940
16
задан 15 апреля 2011 в 04:04 Источник Поделиться
Комментарии
8 ответов

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

Если код потока и может быть использован только локально, я бы оставил его там, вне зависимости от ЛСС. Используя лямбда-выражение имеет то преимущество, что вы не 'засорять' класса с дополнительной отдельный метод, который вызывается только из одного места. Это обеспечивает лучшую инкапсуляцию, которая является одним из основных принципов ОО, которая заставляет его сиять.

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

И как заметка на полях; я понимаю, что вы, вероятно, просто назвала код, чтобы получить идею, но я хотел убедиться, что имя метода будет означать только начинается определенное действие, но не закончить его. Е. Г. StartSomeMethod.

10
ответ дан 17 апреля 2011 в 02:04 Источник Поделиться

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

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


Обновление в ответ на Timwi комментарии:

Когда метод так и назвали, имя помогает описать то, что этот метод предназначен , чтобы сделать, как, где он используется и где он определен. Анонимные методы не сделать это, и чтобы понять это, нужно опираться на контекст. Это нормально, когда, если анонимный метод прост, но если его большие и/или глубокие вложенности участвует (в пределах или содержащих различные управляющие структуры) поведение может стать гораздо менее очевидны.

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

Конечно, "читабельность" - это немного субъективно. Большинство людей согласятся на крайний случай, но в крайних случаях, наверное, лучше обсуждать с, и единое мнение тех, кто на самом деле отвечает за поддержание его.

13
ответ дан 15 апреля 2011 в 11:04 Источник Поделиться

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

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

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

6
ответ дан 2 августа 2011 в 07:08 Источник Поделиться

Это зависит :-)

игнорируя разделение вещей на более мелкие дискуссии, методы... код уже в методе. Часть сделать с продевать нитку-это небольшое количество метода. Лямбда-это просто конструкт, чтобы сделать многопоточный код. Если это является целью метода. Тогда это нормально.

Дело доходит до чистоты утилита против. Его легко увидеть с точки зрения 'лямбда' и есть правило, что лямбды должны быть короткими и по существу. Но в данном случае его больше с помощью утилиты лямбда-выражений, чтобы обернуть нитку вокруг кусок кода.

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

Так что есть утилита, используя лямбда-выражения, чтобы обернуть контекстах вокруг куски кода, без необходимости разбивать их в отдельный метод. Но пока его не оправдание для плохо проработана код и вроде Смысл в контексте того, что вы делаете.

3
ответ дан 17 апреля 2011 в 09:04 Источник Поделиться

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

1
ответ дан 16 апреля 2011 в 09:04 Источник Поделиться

С правильным комментарием, что создали "местные функции", чтобы не создавать новые глобальные имена unnecesarily. ИМО это хорошо, что похож на использование локальных переменных против глобальных.

1
ответ дан 22 апреля 2011 в 07:04 Источник Поделиться

Держать его местное хорошее. Однако для наглядности можно присвоить лямбда-выражение к функции или переменной действия, а затем сделать свой резьбонарезание код. Это помогло бы в принятии резьбонарезание код проще разобраться на месте без смешения в реквизитах фактический код, который нарезан. В других языках это не редкость, чтобы объявить метод, чтобы быть с резьбой внутри метода, назвав его (в JavaScript, ада и F#, и т. д.).

1
ответ дан 23 апреля 2011 в 06:04 Источник Поделиться

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

Это не произвольное правило, ни в C# (и других языках) есть специальный синтаксис для одного-выражения лямбда-выражения. Как только вам нужно больше, чем одно выражение краткость лямбд потеряно, и вы в конечном итоге с безымянным телом функции.

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

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

0
ответ дан 18 апреля 2011 в 03:04 Источник Поделиться