Размер общей структуры

Question

мне нужно узнать размер общей структуры (я не могу это сделать, как SizeOf (T) или с помощью Marshal.SizeOf (...) 0> дает мне ошибку)

Так что я написал:

public static class HelperMethods 
{ 
    static HelperMethods() 
    { 
     SizeOfType = createSizeOfFunc(); 
    } 

    public static int SizeOf<T>() 
    { 
     return SizeOfType(typeof(T)); 
    } 

    public static readonly Func<Type, int> SizeOfType = null; 

    private static Func<Type, int> createSizeOfFunc() 
    { 
     var dm = new DynamicMethod("SizeOfType", typeof(int), new Type[] { typeof(Type) }); 

     ILGenerator il = dm.GetILGenerator(); 
     il.Emit(OpCodes.Ldarg_0); 
     il.Emit(OpCodes.Sizeof); //needs to be il.Emit(OpCodes.Sizeof, typeof(something)) 
     il.Emit(OpCodes.Ret); 

     var func = (Func<Type, int>)dm.CreateDelegate(typeof(Func<Type, int>)); 
     return func; 
    } 
} 

diffuclty что il.Emit (OpCodes.Sizeof) нужен аргумент, который я не могу передать его во время метода (SizeOfType) создания. Как передать параметр, который находится в стеке для il.Emit (OpCodes.Sizeof), используя IL? (или другое решение, но я хочу кэшировать функцию (делегат), а не результат, который предлагается во 2-м ответе)

Answer 1

Размер вычислений - это то, что чревато проблемами, потому что вам нужно знать, что имеет смысл в контекст, который вы используете. Я бы предположил, что есть хорошая причина для Marshal.SizeOf, чтобы передать, когда аргумент является общей структурой, но я не знаю, что это такое.

С этим оговоркой этот код, похоже, работает и дает аналогичные результаты для Marshal.SizeOf для не-общих структур. Он генерирует новый динамический метод, который получает размер с помощью идентификатора кода sizeof IL для типа. Затем он кэширует результат (поскольку генерация динамического метода является чем-то дорогостоящим) для будущего использования.

public class A { int x,y,z; } 
public struct B { int x,y,z,w,a,b; } 
public struct C<T> { Guid g; T b,c,d,e,f; } 

public class Program 
{ 
    public static void Main(string[] args) 
    { 
     Console.WriteLine(IntPtr.Size); // on x86 == 4 
     Console.WriteLine(SizeHelper.SizeOf(typeof(C<double>))); // prints 56 on x86 
     Console.WriteLine(SizeHelper.SizeOf(typeof(C<int>))); // prints 36 on x86 
    } 
} 

static class SizeHelper 
{ 
    private static Dictionary<Type, int> sizes = new Dictionary<Type, int>(); 

    public static int SizeOf(Type type) 
    { 
     int size; 
     if (sizes.TryGetValue(type, out size)) 
     { 
      return size; 
     } 

     size = SizeOfType(type); 
     sizes.Add(type, size); 
     return size;    
    } 

    private static int SizeOfType(Type type) 
    { 
     var dm = new DynamicMethod("SizeOfType", typeof(int), new Type[] { }); 
     ILGenerator il = dm.GetILGenerator(); 
     il.Emit(OpCodes.Sizeof, type); 
     il.Emit(OpCodes.Ret); 
     return (int)dm.Invoke(null, null); 
    } 
} 

Редактировать

Насколько я могу сказать, что нет никакого способа, чтобы сделать необщего делегат, который можно кэшировать. Операционный код SizeOf требует токена метаданных. Он не принимает значения из стека оценки.

На самом деле нижеприведенный код работает. Я не уверен, почему Marshal.SizeOf(Type) вызывает исключение аргумента, когда тип является общей структурой, но Marshal.SizeOf(Object) этого не делает.

public static int SizeOf<T>() where T : struct 
    { 
     return Marshal.SizeOf(default(T)); 
    } 

Answer 2

Казалось бы, что ваша цель состоит в том, чтобы разрешить спор Type из ваших функций типа возвращаемого Func<Type, int> во время компиляции. Эта информация неизвестна во время компиляции, и нет явного способа разрешить эту информацию, используя отражение во время выполнения.

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

public static class GlobalExtensions 
{ 

    public static int SizeOf<T>() 
    { 
     return SizeOf(typeof (T)); 
    } 

    public static int SizeOf(this Type type) 
    { 
     var dynamicMethod = new DynamicMethod("SizeOf", typeof(int), Type.EmptyTypes); 
     var generator = dynamicMethod.GetILGenerator(); 

     generator.Emit(OpCodes.Sizeof, type); 
     generator.Emit(OpCodes.Ret); 

     var function = (Func<int>) dynamicMethod.CreateDelegate(typeof(Func<int>)); 
     return function(); 
    } 
} 

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

var size = TypeExtensions.SizeOf<Example<int>>(); 

//alternative syntax... 
size = typeof (Example<int>).SizeOf(); 

Answer 3

Принимая выше мышление на один шаг дальше, я прибыл в:

public static class TypeSize<T> 
{ 
    public readonly static int Size; 

    static TypeSize() 
    { 
     var dm = new DynamicMethod("SizeOfType", typeof(int), new Type[] { }); 
     ILGenerator il = dm.GetILGenerator(); 
     il.Emit(OpCodes.Sizeof, typeof(T)); 
     il.Emit(OpCodes.Ret); 
     Size = (int)dm.Invoke(null, null); 
    } 
} 

... который я считают, что это наиболее эффективное решение проблемы.