Surprising behaviour of extension method resolution

[bernd5]

Compile the following code:

using System;
using System.Collections.Generic;
using Something;

Foo.Bar.A.CallExtMethod(null);

namespace Foo.Bar
{
    //using Something; //<-- with that it would work
    class A
    {
        static internal bool CallExtMethod(params string[] strings)
        {
            return strings.IsNullOrEmpty();
        }
    }
}

namespace Foo
{
    public static class CollectionsExtensions
    {
        //without those extension methods Something.ArrayExtensions.IsNullOrEmpty<T>, would be invoked, too.
        public static bool IsNullOrEmpty<T>(this ICollection<T>? collection)
        {
            return collection == null || collection.Count == 0;
        }

        public static bool IsNullOrEmpty<T>(this IReadOnlyCollection<T>? collection)
        {
            return collection == null || collection.Count == 0;
        }
    }
}

namespace Something
{
    public static class ArrayExtensions
    {
        public static bool IsNullOrEmpty<T>(this T[]? array)
            => array == null || array.Length == 0;
    }
}

I expected that Something.ArrayExtensions.IsNullOrEmpty<T> would be invoked.
But the method search algorithm seems to stop searching for extension methods if multiple candidates where found in current or parent namespace. It seems to continue than with namespaces in using clauses.

Is that behaviour intended?

[DavidArno]

Yes, that behaviour is intended. Extension method resolution works on "closeness" and will stop as soon as it finds a suitable match in the closest possible location. There's a great article by Eric Lippert called Closer is better that explains the mechanism nicely.