Func<int, int, int> add = (a, b)=>a+b;
Func<int, int> add2 = Specialize(add, 2);

Expression<Func<int, (int, int)>> t = a=>(a, a);

Expression<Func<int, (int, int)>> t = a=>Tuple.Create(a, a);

struct Cell {
   int _index;
   NodeBase _child;
   delegate * <NodeBase, ref T> _getItem;
}

struct BunchX2<TBunch> {
    internal TBunch _0, _1;
}

As opposed to std::vector, the elements of a deque are not stored contiguously: typical implementations use a sequence of individually allocated fixed-size arrays, with additional bookkeeping, which means indexed access to deque must perform two pointer dereferences, compared to vector's indexed access which performs only one.

S>Expression<Func<int, (int, int)>> t = a=>(a, a);
S>

S>Expression<Func<int, (int, int)>> t = a=>Tuple.Create(a, a);
S>

Expression<Func<int, (int, int)>> t = a => Tuple.Create(a, a);

Expression<Func<int, Tuple<int, int>>> t2 = a => Tuple.Create(a, a);

Func<int, int> f = a => {
    return a;
};

Expression<Func<int, int>> t3 = a => {
    return a;
};

Expression<Func<int, int>> t4 = a => a;

            b.Foo();
00007FFCCD6A6962  mov         rcx,qword ptr [rbp-88h]  // rcx = b, это this для будущего вызова метода
00007FFCCD6A6969  mov         rax,qword ptr [rbp-88h]  // кошмар! надо было просто mov rax,qword ptr [rcx]
00007FFCCD6A6970  mov         rax,qword ptr [rax]      // rax = b.GetType()???
00007FFCCD6A6973  mov         rax,qword ptr [rax+40h]  // rax = typeinfo.VMT???
00007FFCCD6A6977  call        qword ptr [rax+20h]      // indirect call to [VMT+20h]
            b.Bar();
00007FFCCD6A697A  mov         rcx,qword ptr [rbp-88h]  
00007FFCCD6A6981  mov         rax,qword ptr [rbp-88h]  
00007FFCCD6A6988  mov         rax,qword ptr [rax]  
00007FFCCD6A698B  mov         rax,qword ptr [rax+40h]  
00007FFCCD6A698F  call        qword ptr [rax+28h]     // отличия только тут, другой слот

V>>struct Cell {
V>>   int _index;
V>>   NodeBase _child;
V>>   delegate * <NodeBase, ref T> _getItem;
V>>}
V>>

V>Expression<Func<int, Tuple<int, int>>> t2 = a => Tuple.Create(a, a);
V>

from p in Person where {var s = new StringBuilder(); foreach(var ch in p.Name} if (p.IsLetterOrDigit) s.Append(ch); return s.ToString()=="John";} select p

Ага, значит TypeHandle может быть как указателем на MethodTable, так и указателем на TypeDesc, в зависимости от типа объекта. Для массивов он указывает на TypeDesc. Тип object[][] — это массив, элементами которого являются object[], для которых TypeHandle=TypeDesc. Эта информация объясняет наш пример, но всё ещё остаются некоторые вопросы. Например: а как же отличить, на что именно указывает TypeHandle? Поможет нам в этом дальнейшее изучение исходников CLI:

   FORCEINLINE BOOL IsUnsharedMT() const {
        LEAF_CONTRACT;
        STATIC_CONTRACT_SO_TOLERANT;
        return((m_asTAddr & 2) == 0);
    }

    FORCEINLINE BOOL IsTypeDesc() const  {
        WRAPPER_CONTRACT;
        return(!IsUnsharedMT());
    }

Всё зависит от второго бита в адресе: нулевое значение определяет MethodTable, а единичное — TypeDesc. Если мы работаем с шестнадцатеричными адресами, то можно легко определить вид TypeHandle по последней цифре:

MethodTable: 0, 1, 4, 5, 8, 9, C, D
TypeDesc : 2, 3, 6, 7, A, B, E, F
А теперь взглянем ещё раз на дамп памяти нашего примера. Можно видеть, что для System.Object[] в дампе присутствуют указатели как на его TypeDesc, так и на MethodTable. Не смотря на то, что под TypeHandle в данном случае подразумевается TypeDesc, заголовочный указатель для a[0] всё-таки указывает на MethodTable. Поэтому некорректно говорить о том, что в заголовке каждого объекта хранится TypeHandle: там хранится указатель на MethodTable, а это далеко не всегда одно и то же.

Пример 4
Последний пример проиллюстрирует недавно полученное правило про последнюю цифру адреса. Мы можем получить TypeHandle прямо из управляемого кода, а по этому значению мы можем определить, что именно под ним подразумевается:

private void Run()
{
    Print(typeof(int));
    Print(typeof(object));
    Print(typeof(Stream));
    Print(typeof(int[]));
    Print(typeof(int[][]));
    Print(typeof(object[]));
}


private void Print(Type type)
{
    bool isTypeDesc = ((int)type.TypeHandle.Value & 2) > 0;
    Console.WriteLine("{0}: {1} => {2}", 
        type.Name.PadRight(10), 
        type.TypeHandle.Value.ToString("X"), 
        (isTypeDesc ? "TypeDesc" : "MethodTable"));
}

У меня этот код выводит следующее:

Int32 : 65C4C480 => MethodTable
Object : 65C4B060 => MethodTable
Stream : 65C4D954 => MethodTable
Int32[] : 65854C8A => TypeDesc
Int32[][] : 658F6BD6 => TypeDesc
Object[] : 65854D7A => TypeDesc
Выводы
В ходе нашего маленького исследования были получены следующие выводы:

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