C#

foreach(object o in container)
{
    string itemTypeName = o.GetType().ToString();
}

---

"When the only tool you have is a hammer, a sore thumb you will have."

using System;
using System.Runtime.InteropServices;
 
[StructLayout(LayoutKind.Explicit)]
public struct IntArray
{
    public const int ElementSize = 4;
    
    [FieldOffset(0)]
    private int _size;
    
    // NB: Be very careful when accessing this array
    // The Length property will be 4 times the actual
    // length!
    [FieldOffset(4), MarshalAs(UnmanagedType.ByValArray)]
    public readonly int[] intArray;
    
    [FieldOffset(4), MarshalAs(UnmanagedType.ByValArray)]
    public readonly byte[] byteArray;
    
    public IntArray(int size)
    {
        _size = size;
        
        // NB: The order is critical here.
        // The size of the int[] array will
        // be overwritten with the size of
        // the byte[] array. If you reverse
        // these lines, you will only be
        // able to access 1/4 of the array.
        intArray = new int[size];
        byteArray = new byte[size * ElementSize];
    }
    
    /// <summary>
    /// The actual size of the intArray.
    /// </summary>
    public int IntSize
    {
        get { return _size; }
    }
    
    /// <summary>
    /// The actual size of the byteArray.
    /// </summary>
    public int ByteSize
    {
        get { return ElementSize * _size; }
    }
    
    /// <summary>
    /// Returns a copy of the byteArray.
    /// </summary>
    public byte[] GetSafeBytes()
    {
        byte[] ret = new byte[ElementSize * _size];
        Buffer.BlockCopy(byteArray, 0, ret, 0, ElementSize * _size);
        return ret;
    }
    
    /// <summary>
    /// Returns a copy of the intArray.
    /// </summary>
    public int[] GetSafeInts()
    {
        int[] ret = new int[_size];
        Buffer.BlockCopy(byteArray, 0, ret, 0, ElementSize * _size);
        return ret;
    }
}