Extension method vs static method precedence

Question

Consider the following program:

class A
{
    public static void Foo()
    {
    }
}

static class Ext
{
    public static void Foo(this A a)
    {
    }
}

class Program
{
    static void Main(string[] args)
    {
        var a = new A();
        a.Foo();
    }
}

This fails to compile, with the error:

Member 'Test.A.Foo()' cannot be accessed with an instance reference; qualify it with a type name instead

Why is the compiler ignoring the extension method?

Answer 1

What you are trying to do isn't allowed. The C# MSDN Extension Method Article specifically states that:

You can use extension methods to extend a class or interface, but not to override them. An extension method with the same name and signature as an interface or class method will never be called. At compile time, extension methods always have lower priority than instance methods defined in the type itself.

Thank goodness it isn't allowed as that would just be awful to have to maintain.

---

EDIT: So people are saying that static methods aren't instance methods, which is correct. But try doing this:

class A
{
   public static void Foo() {}
   public void Foo() {}
}

That won't compile either because of a name ambiguity. That is exactly what would happen if you were allowed to use the extension method. It would introduce the exact same ambiguity. Now, given that one method is static and one is instance, should that mean that there is no ambiguity, perhaps. But at the current state it does introduce ambiguity which is yet another reason why it wouldn't be allowed.

Edit #2: From a comment @ErenErsonmez made:

However, as long as the extension method doesn't have the same signature as an instance method, I don't understand how it could ever cause ambiguity with a static method

If you change the signature of the extension method it will definitely work. So the following will work:

class A
        {
            public static void Foo() { }
        }

    static class Ext
    {
        public static void Foo(this A me, int i)
        { }
    }
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.Foo(10);

            Console.ReadLine();
        }
    }

So it looks more like the issue is an ambiguity one and not that there can't ever be an extension method of the same name as a method that already exists.