Рассмотрим следующие простые манипуляции над коллекцией:
static List<int> x = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var result = x.Where(i => i % 2 == 0).Where(i => i > 5);
Теперь позвольте использовать выражения. Следующий код примерно эквивалентен:
static void UsingLambda() {
Func<IEnumerable<int>, IEnumerable<int>> lambda = l => l.Where(i => i % 2 == 0).Where(i => i > 5);
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
var sss = lambda(x).ToList();
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda: {0}", tn - t0);
}
Но я хочу построить выражение "на лету", поэтому здесь новый тест:
static void UsingCompiledExpression() {
var f1 = (Expression<Func<IEnumerable<int>, IEnumerable<int>>>)(l => l.Where(i => i % 2 == 0));
var f2 = (Expression<Func<IEnumerable<int>, IEnumerable<int>>>)(l => l.Where(i => i > 5));
var argX = Expression.Parameter(typeof(IEnumerable<int>), "x");
var f3 = Expression.Invoke(f2, Expression.Invoke(f1, argX));
var f = Expression.Lambda<Func<IEnumerable<int>, IEnumerable<int>>>(f3, argX);
var c3 = f.Compile();
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
var sss = c3(x).ToList();
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda compiled: {0}", tn - t0);
}
Конечно, это не совсем так, как указано выше, поэтому, чтобы быть справедливым, я немного изменяю первый:
static void UsingLambdaCombined() {
Func<IEnumerable<int>, IEnumerable<int>> f1 = l => l.Where(i => i % 2 == 0);
Func<IEnumerable<int>, IEnumerable<int>> f2 = l => l.Where(i => i > 5);
Func<IEnumerable<int>, IEnumerable<int>> lambdaCombined = l => f2(f1(l));
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
var sss = lambdaCombined(x).ToList();
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda combined: {0}", tn - t0);
}
Теперь идут результаты для MAX = 100000, VS2008, отладка ON:
Using lambda compiled: 23437500
Using lambda: 1250000
Using lambda combined: 1406250
И с отладкой OFF:
Using lambda compiled: 21718750
Using lambda: 937500
Using lambda combined: 1093750
Surprise. Скомпилированное выражение примерно на 17 раз медленнее, чем другие альтернативы. Теперь возникают вопросы:
- Я сравниваю неэквивалентные выражения?
- Есть ли механизм, позволяющий .NET "оптимизировать" скомпилированное выражение?
- Как выражать один и тот же цепной вызов
l.Where(i => i % 2 == 0).Where(i => i > 5);программно?
Еще несколько статистических данных. Visual Studio 2010, отладка включена, оптимизация выключена:
Using lambda: 1093974
Using lambda compiled: 15315636
Using lambda combined: 781410
Отладка включена, оптимизация включена:
Using lambda: 781305
Using lambda compiled: 15469839
Using lambda combined: 468783
Отладка выключена, оптимизация включена:
Using lambda: 625020
Using lambda compiled: 14687970
Using lambda combined: 468765
Новый сюрприз. Переключение с VS2008 (С# 3) на VS2010 (С# 4) делает UsingLambdaCombined быстрее, чем родной лямбда.
Хорошо, я нашел способ улучшить производительность, скомпилированную лямбдой, более чем на порядок. Вот кончик; после запуска профилировщика 92% времени тратится на:
System.Reflection.Emit.DynamicMethod.CreateDelegate(class System.Type, object)
Хмммм... Почему он создает нового делегата на каждой итерации? Я не уверен, но решение следует в отдельном сообщении.
