使用具有不同约束的泛型类

Question

I have two legacy C# user controls I need to work together. I have an existing dialog onto which I need to add an existing generic usercontrol.

I have tried to sample the hierarchy below

interface Foo<T> {}
interface Bar<T> 
{
    T DataObject { get; set; }
}

public class ClassA<T> where T : Foo<T>
{
    public ClassA(T dataObject)
    {
        //Do stuff if T implements Bar<T> - Pseudocode ahead
        if(var T is Bar<T>)
        {
            var x = new ClassB<T>();
            //x is typesafe, and I can set DataObject
            x.DataObject = dataObject;
        }
   }
}

public class ClassB<T> where T : Bar<T> 
{
   T DataObject { get; set; }
}

The existing dialog, ClassA currently don't have any generic contraints, but could easily be changed to require T implementing Foo<T> . The userControl, ClassB is based on another interface, Bar<T> . In practice, Bar<T> objects always implements Foo<T> - in theory of course not.

Are there any construction I can use to declare an object of type ClassB , and get compile time validation?

The construction above will give me a compile error stating:

The type 'T' cannot be used as type parameter 'T' in the generic type of method ClassB<T> . There is no implicit reference conversion from 'T' for Bar<T>

I can make the ClassB object with Reflection, setting the properties using Reflection as well - but I would prefer a compile time solution.

But in my current situation with two existing dialogs - i'm not sure I am able to.

Any help is appreciated - also just if it is stating what I expect, that it can't be done.

--EDIT

Trying to elaborate a bit. The problem rises when I have a ClassC that implements both Foo<T> and Bar<T>

public class ClassC<T> : Foo<T>, Bar<T>
{
   T DataProperty
}

If I make an instance of ClassA<ClassC> , that is T in the specific instance is ClassC - then is there a way in code I can use T in creating an instance of ClassB - in this case T in ClassA does live up to the ClassB constraints, since T is ClassC .

I havent figured out how or if possible - tend to believe I can't.

As I wrote above, I have a solution based on reflection, i'm just not fan of using reflection and getting run-time validation only. But in this case with two legacy objects that need to work together I might be running out of options.

Answer 1

First of all, your types are a bit weird. They are kind-of recursive, with ClassB<T> requiring a T that implements Bar<T> which has the same structure as ClassB<T> . Maybe you meant to ClassB<T> to implement Bar<T> instead of requiring it as a type parameter?

---

Anyway you cannot do this. In order to be able to write ClassB<T> , the compiler needs to ensure that T is a valid type parameter for ClassB<> at runtime . This can only be the case when the type parameters on ClassA<T> for T are at least as restrictive as the ones from ClassB<T> .

Unfortunately, even a hard type check which would ensure that this is the case will not allow you to write ClassB<T> .

So without being able to write ClassB<T> , you will not be able to get static type safety at compile-time. So even when you create an instance of ClassB<T> (which you can), you won't be able to access DataProperty on it since you will not be able to cast it as a ClassB<T> .

So in order to solve this, you would either have to access DataProperty using reflection only, or call a method inside ClassA<T> that does have the type constraint. I'll show you both solutions:

public class ClassA<T>
    where T : Foo<T>
{
    public ClassA(T dataObject)
    {
        if (typeof(Bar<T>).IsAssignableFrom(typeof(T)))
        {
            // method 1, calling a generic function
            MethodInfo mi = typeof(ClassA<T>).GetMethod("SetBDataObject").MakeGenericMethod(typeof(Bar<T>));
            mi.Invoke(this, new object[] { dataObject });

            // method 2, doing it all with reflection
            Type type = typeof(ClassB<>).MakeGenericType(typeof(T));
            object x = Activator.CreateInstance(type);
            type.GetProperty("DataObject").SetValue(x, dataObject);
        }
    }

    public object SetBDataObject<TB> (TB obj)
        where TB : Bar<TB>
    {
        var x = new ClassB<TB>();
        x.DataObject = obj;
        return x;
    }
}

Answer 2

The first thing that probably is confusing in your code, is that you have used the same letter T as the Type parameter in both classes ClassA<T> and ClassB<T> .

I'll start by stating the obvious:
when you call var x = new ClassB<T>(); the constraint for T here is in the context of ClassA<T> (ie T : Foo<T> ), while new ClassB<T>() expects T to match the constraint of T : Bar<T> .

It seems to me that underlying reason for the issue you are having is a design problem. It looks like you a little mix up between types and classes .

Lets walk it through:
from the Gang of Four Design Patterns book :

An objects's class defines how the object is implemented .The class defines object's internal state and the implementation of its operations.

In contrast, an objects's type only refers to its interface -the set of requests to which it can respond.

An object can have many type, and object of different classes can have the same type.

The usage of interfaces in your code implies coding against types (that's good!).
Checking for if (dataObject is Bar<T>) and upon the result constructing a ClassB<U> where !typeof(U).Equals(typeof(T) implies heavily relying on implementation (eg class ).

If you ask me, I think you should try one of the following:

1. Use the factory pattern for constructing ClassB . In the dedicated factory you can add some more logics and verifications in order to decide how to construct it (from your code, it is not clear since the types do not match...).

2. If possible, resolve the relation between Foo<T> and Foo<T> and declare the constraints in the interfaces. In that case, both interfaces should have same constraints fto T