Question

I created the Class1.GetChild<T>() where T : DependencyObject extension method in lib1.dll assembly. After that, all assemblies that depends on lib1.dll failed to compile with error:

The type ‘System.Windows.DependencyObject’ is defined in an assemebly
that is not referenced. You must add a reference to assembly
‘WindowsBase’ etc…

Why dependent assemblies requires WindowsBase even if they don’t use GetChild?

.

To reproduce (vs2010 .net4):

lib1.dll (references WindowsBase)

namespace lib1
{
    public static class Class1
    {
        public static T GetChild<T>(this DependencyObject src) where T : DependencyObject
        {
            return default(T);
        }
    }

    public static class Class2
    {
        public static int SomeExtMethod(this string src)
        {
            return 0;
        }
    }
}

lib2.dll (references lib1 but not WindowsBase)

using lib1;
class someClass
{
    void someFct()
    {
        "foo".SomeExtMethod(); // error: The type 'System.Windows.DependencyObject'
                // is defined in an assemebly that is not referenced. 
                // You must add a reference to assembly 'WindowsBase' etc..
    }
}

.

Update:

I think there’s definitly something when mixing generic methods and extension methods. I tried to demonstrate the issue in the following sample:

// lib0.dll
namespace lib0
{
    public class Class0 { }
}

// lib1.dll
using lib0;
namespace lib1
{
    public static class Class1
    {
        public static void methodA<T>() where T : Class0 { }    // A
        public static void methodB(Class0 e) { }                // B
        public static void methodC(this int src) { }            // C
    }

    public static class Class2
    {
        public static void methodD(this String s) { }
    }
}

// lib2.dll
using lib1;
class someClass
{
    void someFct()
    {
        Class2.methodD("");  // always compile successfully
        "".methodD();        // raise the 'must add reference to lib0' error depending on config. see details below.
    }
}

A, //B, //C -> compile ok

A, B, //C -> compile ok

//A, B, C -> compile ok

A, //B, C -> raise error

A, B, C -> raise error

//A means methodA is commented. As Damien pointed out, type inference might play some role. Still curious to know the ins and outs.

Answer 1

Your situation has been answered by Microsoft here:
https://connect.microsoft.com/VisualStudio/feedback/details/668498/problem-with-extension-method-in-c-compiler

There are other use-cases as well independent of extension methods which produce this error wrongly.

Consider this:

1. Define a generic method in a type, say TP1, defined in library say LB1.
2. Type constrain the generic method on some type defined in some other library LB2.
3. Define another method in TP1.
4. Now in your library reference only LB1 and try to call the second method of type TP1

If you don’t use TP1 but some other type defined in LB1, you do not get the error.
Also, even if one of the method of type TP1 expects a parameter of the type defined in LB2 (and you do not call this method) it does not produce this error