Effectively Using Value Types in .Net

The .Net type system offers the following two kinds of types:

• Reference Types
• Value Types

Reference types are nothing but I can say any class you are writing is a reference type getting allocated on the Heap. So, on reference types we can apply OOP methodology, locking and many other methods.

However, in Value types you can't get that flexibility. Also, value types are allocated on the stack, avoiding pressure on the garbage collector. You should choose value types wisely, this means that only choose value types when your application is performance critical, otherwise Value types may include a variety of complexities later in the program. Consider a simple example shown below.

The following program is fairly simple. First, I allocated 10 million instances of int on the stack and then tried to reach the last element in the list. I also repeated that step 25 times and at that time I captured the GC instances and time elapsed. Normally, we can write the following program.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ValueTypes
{
    class Program
    {
        private const int noOfAllocations = 10000000;
        private const int repeats = 20;

        static void searchAllocationinList<TAllocation>(string desc, Func<int, TAllocation> allocator)
            where TAllocation:struct
        {
            List<TAllocation> allocations = new List<TAllocation>();

            //add 10 million ints in the list
            for (int i = 0; i < noOfAllocations; i++)
            {
                allocations.Add(allocator(i));
            }

            //find the last one
            TAllocation findAllocation = allocator(noOfAllocations);

            int GCGeneration = GC.CollectionCount(0);

            Stopwatch stopwatch = Stopwatch.StartNew();

            for (int i = 0; i < repeats; i++)
            {
                allocations.Contains(findAllocation);
            }
            stopwatch.Stop();

            Console.WriteLine("{0} Average time per lookup: {1:0.00}ms\n\tGarbage collections: {2}",
                desc, stopwatch.ElapsedMilliseconds , GC.CollectionCount(0) - GCGeneration);
        }
        static void Main(string[] args)
        {
            searchAllocationinList("Sample Run",i=>new Sample1{x = i,y=i});
            Console.ReadLine();
        }
    }
}

namespace ValueTypes
{
    struct Sample1
    {
        public int x;
        public int y;
    }
}

Now, when I run that, it will produce the following results:

 

Now, in the second version, what I will do is override the equals operation, so it does suppress the use of reflection at runtime, but still involves one boxing operation for comparison.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ValueTypes
{
    struct Sample2
    {
        public int x;
        public int y;

        public override bool Equals(object obj)
        {
            if(!(obj is Sample2)) return false;
            Sample2 obSample2 = (Sample2) obj;
            return x == obSample2.x && y == obSample2.y;
        }
    }

}

Now, when I invoke it as in the following code:

static void Main(string[] args)
{
    searchAllocationinList("Sample Run",i=>new Sample1{x = i,y=i});
    searchAllocationinList("Sample Run 2",i=>new Sample2{x=i,y=i});
    Console.ReadLine();
}

It will produce the following result. It does improve the performance.



Now, let's see another example with IEquatable implementation.

using System;

namespace ValueTypes
{
    struct Sample3 :IEquatable<Sample3>
    {
        public int x;
        public int y;

        public bool Equals(Sample3 objSample3)
        {
            if (!(objSample3 is Sample3)) return false;
            Sample3 obSample2 = (Sample3)objSample3;
            return x == obSample2.x && y == obSample2.y;
        }
    }

}

static void Main(string[] args)
{
    searchAllocationinList("Sample Run",i=>new Sample1{x = i,y=i});
    searchAllocationinList("Sample Run 2",i=>new Sample2{x=i,y=i});
    searchAllocationinList("Sample Run 3", i => new Sample3 { x = i, y = i });
    Console.ReadLine();
}

It will produce the following optimized result.



Therefore, the Contains method checks for equality in the list and if we have a collection like the preceding one then it would be a big performance issue. Now, with an IEquatble implementation the job is done and done faster. This interface has just one method, the equals method, that takes a value type as a parameter. Hence, rather than relying on the default implementation of object.valueType, this kind of approach will be a real performance booster. Thanks for joining me.