C# generics - Can I make T be from one of two choices?

Suppose I have the following class hierarchy:

Class A {...}

Class B : A  {...}

Class C : A {...}

What I currently have is

Class D<T> where T : A {...}

but I'd like something of the form

Class D<T> where T in {B,C}

This is due to some odd behavior I'm not responsible for where B and C have common methods which aren't in A, but it would be nice to be able to call them开发者_如何学Go in D on T.

Note: I don't have access to A,B or C to edit them

You need to define an interface for the common methods that are in B and C (lets call it Ibc), make B and C implement this interface, and then you can write:

Class D<T> where T : A, Ibc {...}

This isn't directly possible.

As others suggest, you could define an interface and implement it in both B and C.

If this isn't an option (e.g., if these classes are beyond your control), what I might suggest is this: first, start with an abstract class that includes all the functionality you can achieve with any T deriving from A. Then say you have some methods that exist for both B and C that aren't a part of A. In D you can make these abstract methods to be implemented by subclasses:

public abstract class D<T> where T : A
{
    protected T _member;

    public void DoSomethingAllTsCanDo()
    {
        _member.DoSomething();
    }

    public abstract void DoSomethingOnlyBAndCCanDo();
}

Then you can inherit from the base class for each type B and C and override the abstract method(s) to provide the appropriate functionality:

public class DB : D<B>
{
    public override void DoSomethingOnlyBAndCCanDo()
    {
        _member.DoSomethingOnlyBCanDo();
    }
}

public class DC : D<C>
{
    public override void DoSomethingOnlyBAndCCanDo()
    {
        _member.DoSomethingOnlyCCanDo();
    }
}

First, If B and C have common methods, it is a design flaw they don't share an interface. That said, you can fix that even without having access to B and C.
It is possible to create a common interface. Suppose you have:

public class A
{
}
public class B : A
{
    public void Start() { }
}
public class C : A
{
    public void Start() { }
}

You can create a common interface:

public interface IStartable
{
    void Start();
}

And use it on derived classes from B and C:

public class BetterB : B, IStartable
{
}
public class BetterC : C, IStartable
{
}

You may not be able to achieve that if you get B and C instances as is, but it can be considered if you create them. In fact, with specialized classes of B and C, you may use the interface instead of D<T>.

Do B and C implement the same interface? That may be a better route.

Some options:

1. Make an interface IderivedFromA that contain the common methods from B and C.
   Looks like this is impossible from your question
2. In D cast T to dynamic and call the methods dynamically
   The most easy solution, if you can use .Net 4
3. In D test if the you deal with an B or C, cast, and call
   Will be checked by the compiler, and is possible from .Net 2
4. The Dan Tao answer: Create a specific implementation of D<T> for B and C, these can call the methods from B and C directly. (Didn't think of this one myself).
   Will only work if the "user-source" knows it is dealing with B or C, and does not use the abstract A to use D<A>. Instead it should use DB or DC. But I think this is the case, otherwise you didn't need generics.

The where constrain in C# does not allow you to specify multiple classes as a choice. Also if you will specify multiple where contains, then they both has to be satisfied. There is no OR logic for constrain. Here is specification: http://msdn.microsoft.com/en-us/library/bb384067.aspx

Answers from Grzenio seems right for you. Extract common behavior into the common interface for B and C. Then you can use that interface as a constrain.

Since you don't have access to the source, the only real answer (unless you are willing to lose safety by using dynamic) is explicitly check for B/C and cast.