CODEWITHSUNDEEP
c#
Yauda
Yauda

Reputation: 169

Passing inherited class

I'm trying some simple code to understand the generics in C#. The purpose of the code here is to have a trainer that has her own animal and will ask it to do various stuff (for the sake of the example, to jump).

The problem is with the constructor of the trainer. I would like to be able to pass a Dog, or a Cat. They both inherit from the same class, but because I specified the type definition it seems I can't pass them as argument, they can't be both valid. Is there a way to specify a generic class like "Animal" so I could pass a dog or a cat and keep it as a member?

class AnimalDefinition
{
    public Fur Fur;
}

class DogDefinition : AnimalDefinition
{
    public BarkSound Bark;
}

class CatDefinition : AnimalDefinition
{
    public MeowSound Meow;
}

class Animal<TDefinition> where TDefinition : AnimalDefinition
{
    public TDefinition Definition;

    public void Jump()
    {
        Console.WriteLine("Jump.");
    }
}

class Dog : Animal<DogDefinition> 
{
    public Dog(DogDefinition def)
    {
        Definition = def;
    }
}

class Cat : Animal<CatDefinition> 
{
    public Cat(CatDefinition def)
    {
        Definition = def;
    }
}

class Trainer
{
    Animal _animal;

    public Trainer(Animal myAnimal)
    {
        _animal = myAnimal;
    }

    public MakeJump()
    {
        _animal.Jump();
    }

    public Listen()
    {
         // if T is DogDefinition hear barking
         // else if T is CatDefinition hear a meowing, etc
    }
}

EDIT: Additional question following Chris Berger's answer (which works, but I didn't change the code to keep the question/answer logical). I added a definition member in the Animal class. Is there any way I can access Bark or Meow from inside the Trainer class or will I have to derivate the class Trainer with CatTrainer : Trainer<CatDefinition>? That is, is there something similar to what we have with classes, 

if(T is CatDefinition)
{ // Meowing} 
else 
{}

Upvotes: 3

Views: 86

Answers (1)

Chris Berger
Chris Berger

Reputation: 555

I think I agree with the first commenter, that you don't necessarily want generics for this, but assuming you have some other reason for wanting generics...

The solution here is to create a class Animal, which Animal<T> derives from.

For example:

public class Animal 
{ 
    public virtual void Jump()
    {   
        Console.WriteLine("Jump.");
    }               
}

public class Animal<T> : Animal where T : AnimalDefinition
{
     public override void Jump() 
     {
        //you can override Jump here if you want to
     }
}

public class Dog : Animal<DogDefinition>  {}
public class Cat : Animal<CatDefinition>  {}

Or, actually, a second option is to give Trainer visibility to the generic parameter:

public class Animal<T> where T : AnimalDefinition
{
     public void Jump() 
     {
         Console.WriteLine("Jump.");
     }
}

public class Dog : Animal<DogDefinition>  {}
public class Cat : Animal<CatDefinition>  {}

public class Trainer<T> where T : AnimalDefinition
{
    Animal<T> _animal;

    public Trainer(Animal<T> myAnimal)
    {
        _animal = myAnimal;
    }

    public MakeJump()
    {
        _animal.Jump();
    }
}

And as a tangent... this might be a good place to use a self-referential generic.

public class Animal<T> where T : Animal<T> { }
public class Dog : Animal<Dog> { }

Here's a little more reading on that pattern: https://blogs.msdn.microsoft.com/simonince/2008/06/12/generics-the-self-referencing-generics-pattern/

Upvotes: 2

Related Questions