CODEWITHSUNDEEP
c#.netreflectioncasting
Bob The Janitor
Bob The Janitor

Reputation: 20802

Why is casting faster than reflection in .NET?

I have an event handler that needs to determine a type and execute code if it matches a specific type. Originally we cast it to an object and if it wasn't null we executed the code, to speed it up I used reflection and it actually slowed it down and I don't understand why.

here is a code sample 

Trace.Write("Starting using Reflection");
if (e.Item.GetType() == typeof(GridDataItem))
{
      bool isWatch = Convert.ToBoolean(e.Item.OwnerTableView.DataKeyValues[e.Item.ItemIndex]["IsWatch"]);
      if (isWatch)
      {
          e.Item.Style["Font-Weight"] = "bold";
      }
 }
 Trace.Write("Ending using Reflection");
 Trace.Write("Starting using Cast");
 GridDataItem gridItem = e.Item as GridDataItem;
 if (gridItem !=null)
 {
     bool isWatch = Convert.ToBoolean(gridItem.OwnerTableView.DataKeyValues[e.Item.ItemIndex]["IsWatch"]);
     if (isWatch)
     {
         gridItem.Style["Font-Weight"] = "bold";
     }
  }
  Trace.Write("Ending using Cast");

And this is the trace output I get

Starting using Reflection  0.79137944962406 0.576538
Ending using Reflection    0.791600842105263    0.000221
Starting using Cast    0.791623353383459    0.000023
Ending using Cast      0.791649308270677    0.000026
Starting using Reflection  0.876253801503759    0.084604
Ending using Reflection    0.87631790075188 0.000064
Starting using Cast    0.87633445112782 0.000017
Ending using Cast      0.87634950075188 0.000015

it's not a lot, but if we had to do this a lot over time it could add up.

Upvotes: 11

Views: 2137

Answers (6)

Rune FS
Rune FS

Reputation: 21742

Well, I guess a short answer to the best practice part would be to never use reflection if you can get the same result with regular code.

When optimizing code it's usually a good idea to estimate where the time spent optimizing will result in the greatest performance gain. reimplementing operators natively in the language is seldom going to be on the top of that list

Upvotes: 0

clemahieu
clemahieu

Reputation: 1429

Casts can be done as integer comparisons within the runtime but reflection involves full method calls.

Upvotes: 1

tvanfosson
tvanfosson

Reputation: 532465

Why aren't you using the is operator? I think it's more readable as you don't have the explicit cast, then check. It simply checks that the variable is of the correct type.

if (e.Item is GridDataItem)
{
    bool isWatch = Convert.ToBoolean(e.Item.OwnerTableView.DataKeyValues[e.Item.ItemIndex]["IsWatch"]);
    if (isWatch)
    {
        e.Item.Style["Font-Weight"] = "bold";
    }
}

Upvotes: 1

William Edmondson
William Edmondson

Reputation: 3637

Casting tells the runtime you "know" the type of a particular object. While you may possibly be wrong the runtime believes you and doesn't take the extra time needed to go check the assembly's meta data.

Upvotes: 2

kemiller2002
kemiller2002

Reputation: 115488

Reflection has to go at runtime and determine what properties etc. the object has at runtime. Casting tells the application that it should expect that an object has X properties and should function in a certain way.

Upvotes: 3

Andrew Hare
Andrew Hare

Reputation: 351526

Reflection is slow because you are querying the assembly's metadata whereas casting simply changes the type of the object you are referencing.

The assembly's metadata is a useful store of information but that information is best used at compilation time rather than at execution time. That metadata is used by the compiler for static type checking (among other things). You are using that same metadata to look up type information at execution time (which is fine if you have no other choice) which is significantly slower than casting.

Upvotes: 16

Related Questions