Узнать размер переменной

byte MyByte;
int Size = sizeof(byte);

Type MyType = MyByte.GetType();

int Size = sizeof(MyByte); // не работает

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;
 
public static class MemoryCalculator
{
    /// <summary>
    /// Вычисляет приблизительный размер объекта в байтах.
    /// Для значимых типов используется Marshal.SizeOf,
    /// для ссылочных – рекурсивно обходятся все поля, свойства и эвенты.
    /// Чтобы избежать зацикливания, уже посещённые объекты не обрабатываются повторно.
    /// </summary>
    public static long CalculateSize<T>(T value)
    {
        // Используем хэш-сет для отслеживания уже посещённых объектов (по ссылке)
        var visited = new HashSet<object>(new ReferenceEqualityComparer());
        return CalculateSizeRecursive(value, visited);
    }
 
    private static long CalculateSizeRecursive(object value, HashSet<object> visited)
    {
        if (value == null)
            return 0;
 
        Type type = value.GetType();
 
        // Если тип является значимым, можно вызвать Marshal.SizeOf
        if (type.IsValueType)
        {
            try
            {
                return Marshal.SizeOf(type);
            }
            catch
            {
                // При ошибке – возвращаем 0 или можно добавить логирование
                return 0;
            }
        }
 
        // Для строк – специальный случай
        if (value is string str)
        {
            try
            {
                // Базовый размер строки + размер каждого символа (2 байта на char)
                return Marshal.SizeOf(typeof(string)) + (str.Length * sizeof(char));
            }
            catch
            {
                return 0;
            }
        }
 
        // Если объект уже посетили, чтобы избежать циклических ссылок, возвращаем 0
        if (visited.Contains(value))
            return 0;
        visited.Add(value);
 
        long size = 0;
 
        try
        {
            // Если объект реализует IEnumerable, можно перебрать элементы
            if (value is IEnumerable enumerable && !(value is IDictionary))
            {
                foreach (var item in enumerable)
                {
                    size += CalculateSizeRecursive(item, visited);
                }
            }
 
            // Обрабатываем поля – публичные, приватные, internal и т.д.
            FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (FieldInfo field in fields)
            {
                try
                {
                    object fieldValue = field.GetValue(value);
                    size += CalculateSizeRecursive(fieldValue, visited);
                }
                catch
                {
                    // Игнорируем ошибки доступа и продолжем обход
                }
            }
 
            // Обрабатываем свойства, если они доступны для чтения и не являются индексаторами
            PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (PropertyInfo property in properties)
            {
                // Пропускаем индексаторы
                if (property.GetIndexParameters().Length > 0)
                    continue;
                if (!property.CanRead)
                    continue;
                try
                {
                    object propValue = property.GetValue(value);
                    size += CalculateSizeRecursive(propValue, visited);
                }
                catch
                {
                    // Если возникает ошибка при получении значения свойства, продолжаем
                }
            }
 
            // Обрабатываем эвенты
            EventInfo[] events = type.GetEvents(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (EventInfo evt in events)
            {
                try
                {
                    // Обычно за эвентом скрывается поле-делегат с таким же именем
                    FieldInfo eventField = type.GetField(evt.Name, BindingFlags.Instance | BindingFlags.NonPublic);
                    if (eventField != null)
                    {
                        object eventDelegate = eventField.GetValue(value);
                        size += CalculateSizeRecursive(eventDelegate, visited);
                    }
                }
                catch
                {
                    // Игнорируем ошибки, связанные с эвентами
                }
            }
 
        
        }
        catch
        {
            
        }
        return size;
    }
}
 
/// <summary>
/// Класс для сравнения объектов по ссылке, используется для предотвращения циклического обхода.
/// </summary>
public class ReferenceEqualityComparer : IEqualityComparer<object>
{
    public new bool Equals(object x, object y)
    {
        return ReferenceEquals(x, y);
    }
 
    public int GetHashCode(object obj)
    {
        if (obj == null)
            return 0;
        return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
    }
}