C# class factory newbie

Question

Cela peut être un mauvais titre pour ce que je cherche, mais je pense que se résume à une usine de classe.

J'ai trois classes:

class Horse : Animal 
    class Cow : Animal 

Ce que je veux créer est une méthode animal, pseudocoded, fonctionnerait comme ceci:

List<Horse or Cow> (Animal horseOrCow) 
    { 
     if (horseOrCow is of type Horse) 
     return a list of 10 Horse objects; 
     else 
     return a list of 10 Cow objects; 
    } 

Une simplification bien sûr, mais une fois que je Saisir comment faire cela, je devrais être capable de comprendre le reste.

(Editer: Typo fixe).

Answer 1

Vous pouvez utiliser le is-operator et Enumerable.OfType + Enumerable.Take:

public List<Animal> getMammals(Mammal horseOrCow) 
{ 
    if (horseOrCow is Horse) 
     return allAnimals.OfType<Horse>().Take(10).Cast<Animal>().ToList(); 
    else if (horseOrCow is Cow) 
     return allAnimals.OfType<Cow>().Take(10).Cast<Animal>().ToList(); 
    else 
     throw new ArgumentException("Invalid Mammal", "horseOrCow"); 
} 

en supposant qu'il existe un List<Animal> allAnimals quelque part.

Modifier: Mammal doit aussi être un Animal et depuis Horse et Cow sont Mammals ils devraient hériter de lui.

class Horse : Mammal{ } 
class Cow : Mammal { } 
class Animal { } 
class Mammal : Animal { } 

Answer 2

Vous pouvez utiliser generic method of type

List<T> YourMethod<T>(T horseOrCow) where T : Mamal 
{ 
    // your code 
} 

Answer 3

Cela devrait fonctionner pour vous:

abstract class Animal 
abstract class Mammal : Animal 
class Horse : Mammal 
class Cow : Mammal 

List<T> (T mammal) where T : Mammal //mammal is cow or horse 
{ 
    if (horseOrCow is Horse) 
     return new List<Horse>(); //add the horses to your list 
    else 
     return new List<Cow>(); //add the cows to your list 
} 

Answer 4

public class Animal 
{ 
    public enum AnimalType 
    { 
    CowType, 
    HorseType 
    } 


    .... 
    public Animal Create(AnimalType type) 
    { 
    Animal result = null; 
     switch (type) 
     { 
     case HorseType: result = new Horse(); 
     case CowType : .... 
     } 
    return result; 
    } 
} 

Answer 5

Je ne recommanderais pas le type de vérification à l'aide is. Utilisez plutôt dynamic pour déterminer le type d'exécution de l'objet. Il s'agit d'une meilleure solution au problème double dispatch.

Answer 6

public class Animal 
{ 
    public List<Mammal> GetMammalList(Mammal mammal) 
    { 
     List<Mammal> list = new List<Mammal>(); 
     if (mammal.GetType() == typeof(Horse)) 
      for (int x = 0; x < 10; x++) 
       list.Add(new Horse()); 
     else if (mammal.GetType() == typeof(Cow)) 
      for (int x = 0; x < 10; x++) 
       list.Add(new Cow()); 
     else 
      throw new ArgumentOutOfRangeException(); 

     return list; 
    } 
} 

public class Mammal : Animal { } 

public class Horse : Mammal { } 

public class Cow : Mammal { }