C# 3.0 Extension Methods - Ambiguity and Resolution

Namespaces

An extension method cannot be accessed unless the namespace is in scope. Consider the extension method IsCapitalized in the following example:

IsCapitalized in the following example:An extension method cannot be accessed unless the namespace is in scope. Consider the extension method IsCapitalized in the following example:

  using System;

  namespace Utils
  {
    public static class StringHelper
    {
      public static bool IsCapitalized (this string s)
      {
        if (string.IsNullOrEmpty(s)) return false;
        return char.IsUpper(s[0]);
      }
    }
  }

To useIsCapitalized, the following application must importUtils, in order to avoid a compile-time error:

  namespace MyApp
  {
    using Utils;

    class Test
    {
      static void Main()
      {
        Console.WriteLine("Perth".IsCapitalized());
      }
    }
  }

Extension methods versus instance methods

Any compatible instance method will always take precedence over an extension method. In the following example, Test’s Foo method will always take precedence—even when called with an argument x of type int:

  class Test
  {
    public void Foo (object x) { }     // This method always wins
  }

  static class Extensions
  {
    public static void Foo (this Test t, int x) { }
  }

The only way to call the extension method in this case is via normal static syntax; in other words,Extensions.Foo(...).

Extension methods versus extension methods

If two extension methods have the same signature, the extension method must be called as an ordinary static method to disambiguate the method to call. If one extension method has more specific arguments than another, the more specific extension method takes precedence over the less one. For example:

  static class StringHelper
  {
    public static bool IsCapitalized (this string s)
    {
      if (string.IsNullOrEmpty (s)) return false;
      return char.IsUpper (s[0]);
    }
  }

  static class ObjectHelper
  {
    public static bool IsCapitalized (this object s)
    {
      return true;
    }
  }

Usage:

  // Calls StringHelper.IsCapitalized
  Console.WriteLine("Perth".IsCapitalized());

  // Explictly calling ObjectHelper.IsCapitalized
  Console.WriteLine(ObjectHelper.IsCapitalized("Perth"));

Extension Methods on Interfaces

Extension methods can apply to interfaces:

  using System; using
  System.Collections.Generic;

  static class Test
  {
    static void Main()
    {
      var strings = new string[] { "a", "b", null, "c"};
      foreach (string s in strings.StripNulls())
        Console.WriteLine(s);
    }
    static IEnumerable<T> StripNulls<T> (this IEnumerable<T> seq)
    {
      foreach (T t in seq)
        if (t != null)
          yield return t;
    }
  }

Next: Anonymous Types (C# 3.0) >>
 

More C# Articles
More By O'Reilly Media