"Does Not Inherit" Constraint

[TonyValenti]

What is the right way to write this code?

    public interface IAdd<T> {
        void Add(T Value);
    }

    public class CustomObject { }

    public class Foo<T> : IAdd<T>, IAdd<Object> 
        where T:CustomObject {

        public void Add(T Value) {
            
        }

        public void Add(object Value) {
            
        }
    }

I want to implement a "specific" and generic instance of an interface but when I try, I get the "Cannot implement both... because they may unify for some type parameters" although I don't see any possible substitution of T that would result in IAdd<T> unifying to IAdd.

Do I really have to have an IAdd<T> and IAdd interface?

[theunrepentantgeek]

I don't think the constraint you're applying to T is being used by the compiler when it's evaluating whether things will unify.

Untested, but you might be able to do this:

public class Foo<T> : IAdd<T>, IAdd<Object> 
    where T:CustomObject {

    public void Add(CustomObject value) { ... }
    
    void IAdd<T>.Add(T Value) { ... }

    void IAdd<object>.Add(object Value) { ... }
}

That said, I don't see from this toy example why you'd actually need this - it seems that Foo<T> would be violating the SRP.

[svick]

@theunrepentantgeek That still doesn't compile.

[theunrepentantgeek]

Thanks for confirming. 😁