I have an overloaded generic method used to obtain the value of a property of an object of type PageData. The properties collection is implemented as a Dictionary<string, object>. The method is used to avoid the tedium of checking if the property is not null and has a value.

A common pattern is to bind a collection of PageData to a repeater. Then within the repeater each PageData is the Container.DataItem which is of type object.

I wrote the origina开发者_StackOverflow社区l extension method against PageData:

public static T GetPropertyValue<T>(this PageData page, string propertyName);

But when data binding, you have to cast the Container.DataItem to PageData:

<%# ((PageData)Container.DataItem).GetPropertyValue("SomeProperty") %>

I got a little itch and wondered if I couldn't overload the method to extend object, place this method in a separate namespace (so as not to pollute everything that inherits object) and only use this namespace in my aspx/ascx files where I know I've databound a collection of PageData. With this, I can then avoid the messy cast in my aspx/ascx e.g.

// The new overload
public static T GetPropertyValue<T>(this object page, string propertyName);

// and the new usage
<%# Container.DataItem.GetPropertyValue("SomeProperty") %>

Inside the object version of GetPropertyValue, I cast the page parameter to PageData

public static T GetPropertyValue<T>(this object page, string propertyName)
{
    PageData data = page as PageData;
    if (data != null)
    {
        return data.GetPropertyValue<T>(propertyName);
    }
    else
    {
        return default(T);
    }
}

and then forward the call onto, what I would expect to be PageData version of GetPropertyValue, however, I'm getting a StackOverflowException as it's just re-calling the object version.

How can I get the compiler to realise that the PageData overload is a better match than the object overload?

The extension method syntax is just syntactic sugar to call static methods on objects. Just call it like you would any other regular static method (casting arguments if necessary).

i.e.,

public static T GetPropertyValue<T>(this object page, string propertyName)
{
    PageData data = page as PageData;
    if (data != null)
    {
        //will call the GetPropertyValue<T>(PageData,string) overload
        return GetPropertyValue<T>(data, propertyName);
    }
    else
    {
        return default(T);
    }
}

[edit]

In light of your comment, I wrote a test program to see this behavior. It looks like it does go with the most local method.

using System;
using Test.Nested;

namespace Test
{
    namespace Nested
    {
        public static class Helper
        {
            public static void Method(this int num)
            {
                Console.WriteLine("Called method : Test.Nested.Helper.Method(int)");
            }
        }
    }

    static class Helper
    {
        public static void Method(this object obj)
        {
            Console.WriteLine("Called method : Test.Helper.Method(object)");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int x = 0;
            x.Method(); //calls the object overload
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
            Console.WriteLine();
        }
    }
}

To make sure the nesting is not affecting anything, tried this also removing the object overload:

using System;
using Test.Nested;

namespace Test
{
    namespace Nested
    {
        public static class Helper
        {
            public static void Method(this int num)
            {
                Console.WriteLine("Called method : Test.Nested.Helper.Method(int)");
            }
        }
    }

    static class Helper
    {
        public static void Method(this string str)
        {
            Console.WriteLine("Called method : Test.Helper.Method(string)");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int x = 0;
            x.Method(); //calls the int overload
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
            Console.WriteLine();
        }
    }
}

Sure enough, the int overload is called.

So I think it's just that, when using the extension method syntax, the compiler looks within the current namespace first for appropriate methods (the "most local"), then other visible namespaces.

It should already be working fine. I've included a short but complete example below. I suggest you double-check your method signatures and calls, and if you're still having problems, try to come up with a similar short-but-complete program to edit into your question. I suspect you'll find the answer while coming up with the program, but at least if you don't, we should be able to reproduce it and fix it.

using System;

static class Extensions
{
    public static void Foo<T>(this string x)
    {
        Console.WriteLine("Foo<{0}>(string)", typeof(T).Name);
    }

    public static void Foo<T>(this object x)
    {
        Console.WriteLine("Foo<{0}>(object)", typeof(T).Name);
        string y = (string) x;
        y.Foo<T>();
    }
}

class Test
{
    static void Main()
    {
        object s = "test";
        s.Foo<int>();
    }
}