S>>public static IEnumerable<T> Compose<T, Y>(this IEnumerable<T> src, Expression<Func<T, Y>> propertyExpression, Expression<Func<Y, bool>> func)
S>>        {
S>>            return src.Where(Expression.Lambda<Func<T, bool>>(Expression.Invoke(func, propertyExpression.Body), propertyExpression.Parameters).Compile());
S>>        }
S>>

public static IQueryable<T> Beetwen<T>(this IQueryable<T> src, string field, DateTime start, DateTime stop) where T: BaseEntity
{
    var p = Expression.Parameter(typeof(T)); // Param_0
    var prop = Expression.PropertyOrField(p, field); //Param_0.field
    var startExpr = Expression.Constant(start);
    var stopExpr = Expression.Constant(stop);

    var firstCondition = Expression.GreaterThanOrEqual(prop, startExpr); // Param_0.field >= start
    var secondCondition = Expression.LessThanOrEqual(prop, stopExpr); // Param_0.field <= stop

    var fullExpression = Expression.AndAlso(firstCondition, secondCondition); // Param_0.field >= start && Param_0.field <= stop

    var func = Expression.Lambda<Func<T,bool>>(fullExpression,p); // Param_0 => Param_0.field >= start && Param_0.field <= stop

    return src.Where(func);
}

 var firstCondition = Expression.GreaterThanOrEqual(prop, startExpr); // Param_0.field >= start
    var secondCondition = Expression.LessThanOrEqual(prop, stopExpr); // Param_0.field <= stop

The following rules determine the implementing method for the operation:
If the Type property of either left or right represents a user-defined type that overloads the "greater than" operator, the MethodInfo that represents that method is the implementing method.
Otherwise, if left.Type and right.Type are numeric types, the implementing method is null.

Наконец, .NET Core — это нижележащая инфраструктура, от которой зависит .NET Native. Когда проектировали .NET Native, стало понятно, что .NET Framework не подойдет в качестве фундамента для библиотек классов этой инфраструктуры. Дело в том, что .NET Native статически связывает инфраструктуру с приложением, а затем удаляет все лишнее, что не нужно приложению. (Здесь я сильно упрощаю общую картину, но идею вы уловили. Подробнее на эту тему см. «Inside .NET Native» по ссылке bit.ly/1UR7ChW.)

Традиционная реализация .NET Framework не предусматривает разбиения на модули, поэтому компоновщик (linker) не может включить в приложение лишь ту часть инфраструктуры, которая нужна приложению. Но .NET Core, по сути, является ответвлением .NET Framework, реализация которой оптимизирована с учетом модульности. Другое преимущество этой реализации — возможность поставлять .NET Core Framework как набор NuGet-пакетов, что позволяет вам обновлять индивидуальные классы вне самой .NET Framework. Однако, прежде чем двигаться дальше, давайте обсудим изменения в NuGet.

V>>А действительно ли тебе требуется объяснение от другого человека, почему так?

при включенной опции "link time code generation"

S>>Знаю, но никому не скажу, особенно про источник.

Strachey [Strachey 67] distinguished, informally, between two major kinds of polymorphism. Parametric
polymorphism is obtained when a function works uniformly on a range of types: these types normally exhibit
some common structure. Ad-hoc polymorphism is obtained when a function works, or appears to work, on
several different types (which may not exhibit a common structure) and may behave in unrelated ways for each
type.

...

Parametric polymorphism is so called because the uniformity of type structure is normally achieved by type parameters, but uniformity can be achieved in different ways, and this more general concept is called universal polymorphism. Universally polymorphic functions will normally work on an infinite number of types (all the types having a given common structure), while an ad-hoc polymorphic function will only work on a finite set of different and potentially unrelated types. In the case of universal polymorphism, one can assert with confidence that some values (i.e., polymorphic functions) have many types, while in ad-hoc polymorphism this is more difficult to maintain, as one may take the position that an ad-hoc polymorphic function is really a small set of monomorphic functions. In terms of implementation, a universally polymorphic function will execute the same code for arguments of any admissible type, while an ad-hoc polymorphic function may execute different code for each type of argument.

http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.117.695

В ряде исчислений, например, в теории квалифицированных типов, ad hoc полиморфизм рассматривается как частный случай параметрического.

Язык С++ предоставляет подсистему шаблонов, использование которых внешне похоже на параметрический полиморфизм, но семантически реализуется сочетанием ad hoc-механизмов

V>"Унутре" ресолвера типов того же Хаскеля параметрический полиморфизм зачастую превращается в сочетание ad hoc + динамического полиморфизма (на основе таблицы ф-ий для классов типов). Но для программиста всё выглядит как чистейшей воды параметрический полиморфизм. А только эта т.з. для нас, программистов, и важна, ИМХО.

Класс типов осуществляет диспетчеризацию статически, сводя параметрический>>> и ad hoc>>> полиморфизм в единую модель[12]. С точки зрения параметрического полиморфизма, класс типов имеет параметр (переменную типа), пробегающий множество типов. С точки зрения ad hoc полиморфизма, это множество не только дискретно, но и задано явным образом до уровня реализации. Проще говоря, сигнатура square :: Num a => a -> a означает, что функция параметрически полиморфна, но спектр типов её параметра ограничен лишь теми типами, что принадлежат к классу типов Num. Благодаря этому, функция типизируется единственным образом, несмотря на обращение к перегруженной функции из её тела.

#include <memory>
#include <vector>

template <class T> using P = std::shared_ptr<T>;

int main()
{
    static_assert(sizeof(P<char>) == sizeof(double));

    std::vector<P<char>> us;
    std::vector<double> vs;

    auto const u = std::make_shared<char>(1);
    us.push_back(u);
    vs.push_back(1);

    return 0;
}

    us.push_back(u);
011810D8  push        eax  
011810D9  lea         ecx,[us]  
011810DC  call        std::vector<std::shared_ptr<char>,std::allocator<std::shared_ptr<char> > >::emplace_back<std::shared_ptr<char> const &> (01181420h)  
    vs.push_back(1);
011810E1  movsd       xmm0,mmword ptr [__real@3ff0000000000000 (011831D0h)]  
011810E9  lea         eax,[ebp-38h]  
011810EC  push        eax  
011810ED  lea         ecx,[vs]  
011810F0  movsd       mmword ptr [ebp-38h],xmm0  
011810F5  call        std::vector<double,std::allocator<double> >::emplace_back<double> (01181350h)