With 5 bits you have 16 different enum values that can be put in (0-15).

That would work, but I think the switch would be faster. The one thing I
worry about with your method is possible array type conversion. I don't
think it would happen but the compiler might put some dynamic type checking
in there that is really unnecessary (to make sure the cast is fair). So I
think a switch is most likely faster (small switches optimize down to tight
machine code), since no dynamic cast is needed. Also no array bounds
checking is needed:

switch (typeNdx)
{
 ArrayType.Int:
   return intArray[itemNdx];
...
}

In C of course, the array indexing would not cause typechecking or array
bounds checking. But even there the switch would probably win because it
does not require an extra memory dereference (every array index operation is
an extra dereference).

I would not precompute the sizes at all. Instead, allocate the typespecific
arrays on the fly, in the same way an arraylist works. For example, here is
a types-pecific arraylist sort of collection. It is a bit of code, I will
put it in the next message.

Thanks! Structs in C# wrap bitfields beautifully. I think perhaps Brad Adams
and others should not discourage mutable structs so much, because they are
very useful when used as fields in objects. And the compiler can catch the
use of a temporary struct as an lvalue.

I thought of a way to clean up the "magic numbers" a bit (0x7 and 29 in my
sample). In the ArrayType enum:

[Flags]
enum ArrayType : unsigned int
{
   Int = 0x1,
   Double = Int << 1,
   ...
  All = Int | Double | ...
}

That would give you an unshifted bit mask in the enum, called All. Then, if
you write a function which can count the bits in an unsigned int, you could
compute the constants this way:

static readonly insigned int typeShift = 32 -
BitFunctions.CountBits(ArrayType.All);
static readonly unsigned int typeMask = ArrayType.All << typeShift;
static readonly unsigned int indexMask = ~typeMask;

and in the property:

ArrayType Type
{
get { return (ArrayType)(data >> typeShift); }
set { data = Index | ((unsigned int)value) << typeShift); }
}

Note the change to the set function! I made a mistake before, and swapped
the words "value" and "data".  I just wrote the code out without an editor
or compiler.

- Frank

Here is the basic code for an arraylist style collection. I took out some of
the ICollection stuff, enumerator, etc. It is called PointList, but really
it is an array of Vector structs (x and y values). So you can see how it can
be used for any data type. Just swap your type name for "Vector".

 public class PointList
 {
   // -------- static members --------
   private const int DefaultCapacity = 4;

   // -------- instance members --------
   private Vector[] items;
   private int count;

   publicPointList()
   {
     items = new Vector[DefaultCapacity];
   }

   public int Count
   {
     get { return count; }
   }

   public int Capacity
   {
     get { return items.Length; }
     set
     {
       if (items.Length == value)
         return;
       Check.Argument(value >= count, "value",
         "Capacity must be greater or equal to Count");
       int newCapacity = value > DefaultCapacity ? value : DefaultCapacity;
       Vector[] newItems = new Vector[newCapacity];
       if (count > 0)
         Array.Copy(items, 0, newItems, 0, count);
       items = newItems;
     }
   }

   public Vector this[int index]
   {
     get { return items[index]; }
     set
     {
       if (index >= count)
         throw new ArgumentOutOfRangeException("index", index,
           "Index must be smaller than Count.");
       if (items[index] == value)
         return;
       items[index] = value;
     }
   }

   public int Add(Vector point)
   {
     if (items.Length == count)
       Capacity = items.Length * 2;
     int index = count;
     items[index] = point;
     ++count;
     return index;
   }

   public void AddRange(Vector[] points)
   {
     int minCapacity = count + points.Length;
     if (minCapacity > items.Length)
       Capacity = minCapacity > DefaultCapacity ? minCapacity :
DefaultCapacity;
     Array.Copy(points, 0, items, count, points.Length);
     count += points.Length;
   }

   public virtual void Clear()
   {
     Array.Clear(items, 0, count);
     count = 0;
   }
 }

If you cannot use strong typing throughout, and avoid casting to object,
then you may as well stick to an ArrayList and boxing. The only interface
that can be used to efficiently retrieve the data is a strongly typed one,
GetInt, GetDouble, etc. Otherwise the whole concept is defeated.

Regarding the overhead from the copy, shift, logical ops, etc. These are all
very fast and inlined. This is the great thing about structs. Time it and
see. Make sure the class you use is not derived from MarshalByRefObject,
which defeats inlining. Based on my own perf tuning experience strongly
typed arrays should beat the boxing alternative hands down.

regards, Frank