C# generics - Can I make T be from one of two choices?
Solution 1
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 {...}
Solution 2
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();
}
}
Solution 3
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>
.
Solution 4
Do B and C implement the same interface? That may be a better route.
Solution 5
Some options:
- Make an interface
IderivedFromA
that contain the common methods fromB
andC
.
Looks like this is impossible from your question - In
D
castT
todynamic
and call the methods dynamically
The most easy solution, if you can use .Net 4 - In
D
test if the you deal with anB
orC
, cast, and call
Will be checked by the compiler, and is possible from .Net 2 -
The Dan Tao answer: Create a specific implementation of
D<T>
forB
andC
, these can call the methods fromB
andC
directly. (Didn't think of this one myself).
Will only work if the "user-source" knows it is dealing withB
orC
, and does not use the abstractA
to useD<A>
. Instead it should useDB
orDC
. But I think this is the case, otherwise you didn't need generics.
Jean-Bernard Pellerin
Updated on June 04, 2022Comments
-
Jean-Bernard Pellerin almost 2 years
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 in D on T.
Note: I don't have access to A,B or C to edit them