Extension Method Performance

You won't suffer any performance since the extension methods are all bound at compile time (how do you say that?).

Extension methods are just a compile-time change from:

x.GetValueAsBoolean()

to

Extensions.GetValueAsBoolean(x)

That's all that's involved - translating what looks like an instance method call into a call to a static method.

If you don't have performance problems with the static method, then making it an extension method won't introduce any new problems.

EDIT: IL, as requested...

Taking this sample:

using System;

public static class Extensions
{
    public static void Dump(this string x)
    {
        Console.WriteLine(x);
    }
}

class Test
{
    static void Extension()
    {
        "test".Dump();
    }

    static void Normal()
    {
        Extensions.Dump("test");
    }
}

Here's the IL for Extension and Normal:

.method private hidebysig static void  Extension() cil managed
{
  // Code size       13 (0xd)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldstr      "test"
  IL_0006:  call       void Extensions::Dump(string)
  IL_000b:  nop
  IL_000c:  ret
} // end of method Test::Extension

.method private hidebysig static void  Normal() cil managed
{
  // Code size       13 (0xd)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldstr      "test"
  IL_0006:  call       void Extensions::Dump(string)
  IL_000b:  nop
  IL_000c:  ret
} // end of method Test::Normal

As you can see, they're exactly the same.

Extension methods are just compiler voodoo, so they have all the performance implications of normal methods at runtime.

Extension methods can greatly impact compile time. On a large project I was on, our compile times went from 15 minutes to 3 minutes by simply moving extension methods to different namespaces. Same exact code, just copy and pasted to different namespaces.

If you are considering compile time as part of your "performance" metric, then performance is certainly impacted. As a developer, 15 minute build times vs 3 minute build times is significant.

The main issue for us was that we had a large number of extension methods in only a few namespaces. Every class or project that referenced the bloated namespaces (with a using statement) caused the compiler to search through a huge number of extension methods. Apparently this search is not optimal and slowed the IDE down. Intellisense was terribly slow and became unresponsive.

By simply moving the extension methods into seperate, more granular namespaces, the compile time shot way down. Definitely worth considering.