Существует ли следующий универсальный метод в .NET 4.0 framework?

Question

Существует ли следующая универсальная функция где-нибудь в .NET 4.0 framework?Я хотел бы использовать его повторно, если он это делает, а не писать сам:

public static class Lambda 
{ 
  public static U Wrap<U>(Func<U> f) 
  { 
    return f(); 
  } 
} 

Он допускает следующую конструкцию (т. Е. Лямбда-выражения, встроенные в предложение select запроса LINQ):

string test="12,23,34,23,12";
var res=from string s in test.Split(',') 
        select Lambda.Wrap(() => {string u=s+s; return int.Parse(u);});

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

Answer 1

Вы можете использовать синтаксис let в своем коде:

string test = "12,23,34,23,12";
var res = from string s in test.Split(',') 
          let u = s+s
          select int.Parse(u);

Альтернативно, вы можете использовать методы расширения LINQ напрямую вместо специального синтаксиса:

string test = "12,23,34,23,12";
var res = test.Split(',')
              .Select(s => { var u = s + s; return int.Parse(u); });

Поскольку вопрос был обновлен:

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

Вот небольшое исследование:

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

// with 'f' as some arbitrary lambda, then this:
var res = from string s in test.Split(',')
          select f.Wrap();

// is the same as:
var res = from string s in test.Split(',')
          select f();

Но если вы сделаете это, f никак не может зависеть от s (например, таким образом вы не сможете написать пример кода):

// e.g. where does s come from?
var f = () => { var u = s+s; return int.Parse(u); }; 

// we can write it like this, as a function of 's':
var f2 = s => { var u = s+s; return int.Parse(u); };
//but then you can just use "select f2(s)" and we're back not needing Wrap any more

Что мы 'действительно ищем произвольные замыкания над s.Чтобы это произошло, лямбды должны быть определены inline, где s находится в области видимости, так что вы на самом деле больше не принимаете действительно «произвольные» лямбды, и они должны быть записаны непосредственно в коде.

Вот почему я предложил синтаксис let, поскольку любая лямбда-код, которую вы можете придумать, может быть преобразована в этот синтаксис, и она соответствует остальной части синтаксиса запроса.Для этого и предназначен let!:)

В качестве альтернативы, вы можете просто использовать лямбда-выражения, которые принимают параметры, подобные f2 выше.

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

Мне было бы интересно узнать, почему вы хотите использовать лямбда-синтаксис с синтаксисом запроса?

Надеюсь, это поможет:)

Answer 2

Чем это отличается от

var res = test.Split(',').Select(s => {
                                        var u = s + s;
                                        return int.Parse(u);
                                      });

Да, это компилируется и запускается.

Answer 3

Нет, его не существует.Решение Onkelborg - лучшее, что вы можете сделать из коробки, поэтому, если вы действительно хотите выполнить произвольный блок кода в выражении LINQ, я бы написал предложенную вами функцию Wrap, чтобы получить вывод типа C # для пинкаи сделать его менее уродливым.

Answer 4

Согласно Reflector, этот метод не существует.Но я не понимаю, зачем вам это нужно: