I am trying to create a library that extends from a common base class that
provides common functionality, but I am running into one significant road
block. Let me give you an example.
If I do not do this with Generics, I would do something like this (Foo and
Bar extend from BaseClass):
public abstract class BaseClass
{
}
public class Foo : BaseClass
{
public override string ToString()
{
return "I am a Foo";
}
}
public class Bar : BaseClass
{
public override string ToString()
{
return "I am a Bar";
}
}
Then I could do some things like this:
Foo fooItem = new Foo();
Console.WriteLine(fooItem.ToString());
Bar barItem = new Bar();
Console.WriteLine(barItem.ToString());
And then add them to a common generic list like this:
List<BaseClass> listOfItems = new List<BaseClass>();
listOfItems.Add(fooItem);
listOfItems.Add(barItem);
foreach (BaseClass baseItem in listOfItems)
{
Console.WriteLine(baseItem.ToString());
}
The list of abstract base class items is a concrete class. But now I want
to make the base class generic, to have access to the type information like
this:
public abstract class BaseClass<T> where T : BaseClass<T>
{
public override string ToString()
{
return "I am a " + typeof(T).Name;
}
}
public class Foo : BaseClass<Foo>
{
}
public class Bar : BaseClass<Bar>
{
}
I can still do this, and it works:
Foo fooItem = new Foo();
Console.WriteLine(fooItem.ToString());
Bar barItem = new Bar();
Console.WriteLine(barItem.ToString());
But when I try to define a list of abstract base class items like:
List<BaseClass<>> listOfItems = new List<BaseClass<>>();
It expects a type parameter to be supplied. I can make it a list of
BaseClass<Foo> or BaseClass<Bar> but I want the list to be able to contain
either type. I could make the list of object, but then I don't have the
ability to restrict the type to Foo or Bar. I think what I am looking for is
a contraint that I can place on the type supplied to the list but there does
not seem to be any syntax for this.
Am I missing something in working with Generics?
Jim
