Что вы думаете о многострочных лямбдах в VB 10

Я просто смотрел видео на канале 9 MSDN, которое можно найти здесь, о некоторых новых функциях в Visual Basic 10. Теперь Мне нравятся большинство новых функций, некоторые из которых долгожданы (авто свойства и инициализаторы коллекции), на мой взгляд, были многострочные лямбды, как на С#.

В видео он использовал пример:

Dim scores = {10,20,30,40,50}
Dim thread as new Threading.Thread(Sub()
                                   For Each o in scores
                                     console.writeline(o)
                                     Next
                                   End Sub)

Теперь мне нравится VB во всем этом многословии, но я просто немного обеспокоен тем, что запись sub... end sub inline может немного испортиться, я вижу некоторые достоинства в inlining, когда вы пишете С#, когда у вас есть только использовать что-то вроде c = > {....}, и вы можете вырезать много кода.

Каковы ваши действия в многострочных лямбдах в VB?

Вы найдете их полезными и где?

Ответы

Ответ 1

Лично я считаю, что синтаксис VB для делегатов и lambdas полностью фиктивный. Я имею в виду, давай, AddressOf! Это было хорошо в VB6. Это определенно не очень хорошо на языке, таком как VB.NET, где функции должны рассматриваться как первоклассные граждане (хотя они, конечно, не совсем), и где преобразование из групп методов в делегатов более или менее прозрачно.

Теперь введение встроенных функций ужасно многословно. Я действительно считаю, что подход С# - x => f(x) будет очень хорошо работать в VB, потому что он точно показывает, что он делает. В текущем состоянии я предпочитаю С# для любой работы функционального программирования, что очень жаль, потому что я вообще предпочитаю VB.

Теперь я действительно рад, что VB, наконец, получает многострочные lambdas и выражение lambdas, потому что они по-прежнему полезны иногда (возьмите случай Parallel.For). Но синтаксис испорчен. То же самое касается итераторов, кстати (если они должны попасть в VB10).

Ответ 2

По желанию я разработчик С#, но уже почти год использую VB 9 почти исключительно. # 1 вещь о VB 9, которая ломает мое сердце, - это ограниченные лямбды. Lambdas в VB 9 ограничены следующими способами:

  • Только одно утверждение.
  • Они должны вернуть значение.

Таким образом, метод ForEach в коллекциях не будет работать с lambdas, и будет работать только самая простая операция. Поэтому большую часть времени вы должны переместить свою логику на какой-то другой метод и использовать AddressOf. Много раз это расчитывает читаемость кода драматичным и душераздирающим способом.

Что-то, что я чувствую, многие не подберут, если они не будут использовать анонимные методы на другом языке, который полностью поддерживает их (С#, JavaScript и т.д.), а не калечащую поддержку, которую они имеют в VB 9.

Мне очень приятно, что они фиксируют лямбды в VB 10.

Ответ 3

Я могу думать о двух причинах от головы, почему мне это нравится! Ждал слишком долго для этого.

Сначала:

 Private Sub SomeMethod()
     Dim SomeVariable as String = "Some text."

     AddHandler SomeButton.Click, Sub()
                                      SomeVariable += " Some more text"
                                      MessageBox.Show(SomeVariable)
                                  End Sub

Второй:

 Private Sub SomeMethodRunningInAnotherThread()
     Me.Dispatcher.Invoke(Normal, Sub()
                                      'Do some other stuff '
                                      SomeTextBox.Text = "Test"
                                  End Sub)
 End Sub

Ответ 4

То же самое здесь, я люблю vb. В большинстве случаев вы думаете, а не на самом деле пишете код, так что аргумент аргументации, на мой взгляд, терпит неудачу, поскольку вы обычно смотрите на код или редактируете его, и представьте себе время, когда вы сберегаете понимание своего кода, когда вы читаете его в своем многословие в vb? Гораздо проще и меньше ошибок и ошибок, а не С#.

Кроме того, С# все еще не имеет предложения с условием, а vb имеет это еще до .net дней.

With obj.class.methods

   .property = 1

   .attribute = 2

End with

Представьте себе это с 10 вещами, которые нужно установить? В С# вам нужно будет создать ссылку на obj.class.methods и использовать это для сокращенного выражения, которое будет потрачено впустую в память и неэффективно, поэтому в этом отношении vb использует меньше памяти, и вы не будете наказаны за использование меньше памяти, в отличие от С#.

И аргумент ключевого слова "using" не работает, поскольку использование не работает с большинством объектов или объектов, которые не реализуют idisposable, что абсолютно раздражает.

Затем подумайте обо всех явных кастингах, которые вы должны сделать в С#, в отличие от vb. С# errs будет утверждать, что поощряет лучшую кодировку, но это бессмыслица, так как любому хорошему разработчику не нужно явно бросать что-то 500 раз в день, чтобы понять, что если он не будет иметь неявное кастинг (как это происходит в VB).

Большинство С# errs используют его, потому что они исходят из ac-фона, и это хорошо, но я нахожу, что многие из них начали с него, потому что он содержит букву c, и они думают, что это кулер, потому что в нем нет языковой инновации, что делает его сложнее для разработчика, и это заставляет их чувствовать себя умнее и прохладнее, а выше всех остальных - они не понимают, что сложность скрытия при 0 стоимости - это конечная цель, которую VB может сделать для вас. Обратите внимание на часть с нулевой стоимостью, так как это было бы неплохо, если бы цена была выше нуля.

Ответ 5

Полная поддержка анонимного метода в VB означает, что вы можете начать с более функционального стиля. Если Sub() End Sub нужно идти по отдельным строкам... это больно. Надеюсь, что они разрешат однолинейные анонимные методы, так долго было только одно утверждение.

Ответ 6

Вам понадобится многострочный, как только мы получим библиотеку ParallelFX.

Например, скажем, вы хотели бы сделать этот цикл параллельным:

For i = 0 to 100
  '12 lines of code'
Next

Параллельная версия:

Parallel.For( 0, 100, sub(i)
  '12 lines of code'
  End Sub )

Он работает, превращая кишки петли в совершенно новый юнит. Этот новый sub вызывается N потоками, N обычно представляет собой количество доступных ядер.