开发者

Generics vs Object performance

开发者 https://www.devze.com 2023-02-01 23:57 出处:网络
I\'m doing practice problems from MCTS Exam 70-536 Microsft .Net Framework Application Dev Foundation, and one of the problems is to create two classes, one generic, one object type that both perform

I'm doing practice problems from MCTS Exam 70-536 Microsft .Net Framework Application Dev Foundation, and one of the problems is to create two classes, one generic, one object type that both perform the same thing; in which a loop uses the class and iterated over thousand times. And using the timer, time the performance of both. There was another post at C# generics question that seeks the same questoion but nonone replied.

Basically if in my code I run the generic class first it takes loger to process. If I run the object class first than the object class takes longer to process. The whole idea was to prove that generics perform faster.

开发者_StackOverflow中文版

I used the original users code to save me some time. I didn't particularly see anything wrong with the code and was puzzled by the outcome. Can some one explain why the unusual results?

Thanks,

Risho

Here is the code:

class Program
{
    class Object_Sample
    {            
        public Object_Sample()
        {
            Console.WriteLine("Object_Sample Class");
        }

        public long getTicks()
        {
            return DateTime.Now.Ticks;
        }

        public void display(Object a)
        {
            Console.WriteLine("{0}", a);
        }
    }

    class Generics_Samle<T>
    {            
        public Generics_Samle()
        {
            Console.WriteLine("Generics_Sample Class");
        }

        public long getTicks()
        {
            return DateTime.Now.Ticks;
        }

        public void display(T a)
        {
            Console.WriteLine("{0}", a);
        }
    }

    static void Main(string[] args)
    {            
        long ticks_initial, ticks_final, diff_generics, diff_object;
        Object_Sample OS = new Object_Sample();
        Generics_Samle<int> GS = new Generics_Samle<int>();

        //Generic Sample
        ticks_initial = 0;
        ticks_final = 0;
        ticks_initial = GS.getTicks();

        for (int i = 0; i < 50000; i++)
        {
            GS.display(i);
        }
        ticks_final = GS.getTicks();
        diff_generics = ticks_final - ticks_initial;

        //Object Sample
        ticks_initial = 0;
        ticks_final = 0;
        ticks_initial = OS.getTicks();

        for (int j = 0; j < 50000; j++)
        {
            OS.display(j);
        }

        ticks_final = OS.getTicks();
        diff_object = ticks_final - ticks_initial;

        Console.WriteLine("\nPerformance of Generics {0}", diff_generics);
        Console.WriteLine("Performance of Object {0}", diff_object);

        Console.ReadKey();
    }
}


Well, the first problem I can see is that you're using the DateTime object to measure time in your application (for a very small interval).

You should be using the Stopwatch class. It offers better precision when trying to benchmark code.

The second problem is that you're not allowing for JIT (Just-In-Time compilation). The first call to your code is going to take longer simply because it has to be JIT'd. After that, you'll get your results.

I would make a single call in to your code before you start timing things so you can get an accurate idea of what is happening during the loop.


You should run both classes a separate time before timing it to allow the JITter to run.


Your test is incorrect. Here are your methods:

public void display(T a)
{
    Console.WriteLine("{0}", a); // Console.WriteLine(string format, params object[] args) <- boxing is performed here
}

public void display(Object a)// <- boxing is performed here
{
    Console.WriteLine("{0}", a); 
}

So, in both cases you are using boxing. Much better would be if your class, for example, will count total sum of values, like:

public void add(long a)
{
    Total += a;
}

public void display(Object a)// <- boxing is performed here
{
    Total += (long) a;// <- unboxing is performed here
}


  1. Your timed code includes a Console.WriteLine(). That will take up 99.999999% of the time.
  2. Your assumption that generic will be faster in this situation is wrong. You may have misinterpreted a remark about non-generic collection classes.
  3. This won't be on he exam.


why would it be faster? both ints must be boxed in order to use Console.WriteLine(string, object)

edit: ToString() itself does not seem to cause boxing http://weblogs.asp.net/ngur/archive/2003/12/16/43856.aspx

so when you use Console.WriteLine(a); which would call Console.WriteLine(Int32) that should work i guess (i would need to look into reflector to confirm this)

0

精彩评论

暂无评论...
验证码 换一张
取 消

关注公众号