C# :: Aufgabe #325

2 Lösungen Lösungen öffentlich
#325

Zoo mittels einer Factory-Methode

Fortgeschrittener - C# von Exception - 12.09.2020 um 16:36 Uhr
Hallo zusammen,

heute erzeugen wir einen Zoo!

Erzeugt hierfür eine Basisklasse (oder Interface) "Animal" und einige Klassen die davon erben (z.B. "Lion", "Penguin", "Crocodile", "Snake").

Als nächsten Schritt wollen wir nun eine Factory-Klasse erzeugen, die sich am "Factory-Method-Pattern" orientiert.
In dieser Klasse soll eine Methode "createAnimal" existieren, die ein "Animal" zurückgibt.
Welches "Animal" zurückgegeben wird überlassen wir vorerst dem reinen Zufall ;)
Daher kann diese Klasse auch "RandomAnimalFactory" genannt werden.

Lasst nun 200 "Animals" in den Zoo einziehen.

Wie ist die Verteilung der "Animals" einer jeden Spezies in unserem Zoo?

Es kann mit der zufälligen Erzeugung zu einem gewissen Ungleichgewicht kommen.
So fühlt sich ein einzelner Pinguin gegen 199 Löwen sicher etwas in der Unterzahl ...

Erstellt nun eine zweite Factory-Klasse "BalancedAnimalFactory".
Diese soll ebenfalls die Methode "createAnimal" enthalten.

(Macht es nun evtl. Sinn sich auch bei den Factory-Klassen über ein Interface gedanken zu machen?)

Diese Factory soll nicht mehr komplett zufällig Tiere erzeugen sondern etwas ausgeglichener.
Die dort vorhandene "createAnimal" Methode soll wie folgt funktionieren:
Angenommen wir haben vier Tier-Klassen ("Lion", "Penguin", "Crocodile", "Snake").
Wird nun ein "Lion" erzeugt, so wird für die nächsten beiden Erzeugungen kein "Lion" mehr erzeugt.

Lasst nun erneut 200 "Animals" einziehen - vielleicht in einen zweiten "Parkabschnitt" (Array)? :)
Muss sich der Pinguin noch immer Sorgen machen?

Viel Spaß!
Bitte melden Sie sich an um zur Aufgabenbeschreibung eine Frage zu stellen.
Frage stellen
Bitte melden Sie sich an um eine Lösung einzureichen.
Lösung einreichen
Votes: 0 Admin: 0

Lösungen:

#1
1x
vote_ok
von Pascal (130 Punkte) - 26.09.2020 um 14:59 Uhr
Hallo Exception

Folgenden Probleme taten sich auf:

In der Factory werden verschiedene Objekttypen erstellt.
Dies habe ich nun so gelöst, dass die verschiedenen Objekttypen (Klassen) in der Factory hinterlegt werden.
Aus diesen Klassen werden dann die entsprechenden Objekte erzeugt.
Die Typesafety leidet etwas unter dieser Lösung.
Eine andere Lösung wäre gewesen, die Tiere zu klonen. Für die Aufgabe hätte es genügt, aber es gefiel mir nicht.

Den Zoo habe ich jetzt so gestaltet, dass er nicht weiss, welche Tiere er von der Factory bekommt.
Somit lässt sich die Factory einfach erweitern ohne dass der Zoo verändert werden muss.
Dafür muss der Zoo nach erhalt der Ware den Bestand umständlich ermitteln.

Für die Balanced Lösung habe ich die bestehende Factory mit einer zusätzlichen Funktion erweitert.
Würde man eine extra Factory erzeugen, dann müsste man später zwei Factories pflegen.

Alternativer Lösungsvorschlag:
Ein AnimalEnum
Dictionary erstellen mit AnimalEnum und AnimalKlasse
Anhand des Enum wird in der Factory das Animal erzeugt
Die Randomfunktion oder Balancedfunktion würde ich im Zoo erstellen.
Somit hätte die Factory die Aufgabe die Tiere zu erzeugen und der Zoo die Aufgabe die Tiere zu bestellen.


Zum Ergebnis:
Ob Random oder Balanced verwendet wird, hat wenig Einfluss auf das Ergebnis.
Bei Random ist die Verteilung meist ausgeglichen.
Bei Balanced wird die Verteilung auch nicht garantiert, da lediglich die letzten zwei Tiere nicht zur Auswahl stehen.

Beispielergebnis:

Random Animal Factory
57 - Penguin
55 - Crocodile
44 - Snake
44 - Lion
Balanced Animal Factory
49 - Crocodile
52 - Snake
50 - Lion
49 - Penguin


Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.Linq;

namespace Zoo
{
    public class Zoo
    {
        private static AnimalFactory animalFactory;
        public static List<IAnimal> AnimalsInZoo = new List<IAnimal>();

        private static void Main()
        {
            animalFactory = new AnimalFactory();
            
            AddRandomAnimals(200);
            Console.WriteLine("Random Animal Factory");
            PrintZoo();

            AddBalancedAnimals(200);
            Console.WriteLine("Balanced Animal Factory");
            PrintZoo();
        }

        private static void AddRandomAnimals(int numberOfAnimals)
        {
            AnimalsInZoo.Clear();
            for (var i = 0; i < numberOfAnimals; i++)
            {
                AnimalsInZoo.Add(animalFactory.CreateRandomAnimal());
            }
        }

        private static void AddBalancedAnimals(int numberOfAnimals)
        {
            AnimalsInZoo.Clear();
            for (var i = 0; i < numberOfAnimals; i++)
            {
                AnimalsInZoo.Add(animalFactory.CreateBalancedAnimal());
            }
        }

        private static void PrintZoo()
        {
            var animalTypeList = AnimalsInZoo.Select(x => x.GetType()).Distinct();
            foreach (var animalType in animalTypeList)
            {
                var sum = AnimalsInZoo.Count(animal => animal.GetType() == animalType);
                Console.WriteLine(sum + " - " + animalType.Name);
            }
        }
    }


    public class AnimalFactory
    {
        private readonly List<Type> animalTypes;
        private Type lastAnimal;
        private Type secondLastAnimal;

        public AnimalFactory()
        {
            var availableAnimalTypes = new List<IAnimal>
            {
                new Crocodile(),
                new Lion(),
                new Penguin(),
                new Snake()
            };
            animalTypes = availableAnimalTypes.Select(animalType => animalType.GetType()).ToList();
        }

        public IAnimal CreateRandomAnimal()
        {
            var random = new Random();
            var index = random.Next(animalTypes.Count);
            var animalClass = animalTypes[index];
            return (IAnimal) Activator.CreateInstance(animalClass);
        }

        public IAnimal CreateBalancedAnimal()
        {
            var random = new Random();
            var animalListReduced = new List<Type>(animalTypes);

            animalListReduced.Remove(lastAnimal);
            animalListReduced.Remove(secondLastAnimal);

            var index = random.Next(animalListReduced.Count);
            var animalClass = animalListReduced[index];
            secondLastAnimal = lastAnimal;
            lastAnimal = animalClass;

            return (IAnimal)Activator.CreateInstance(animalClass);
        }
    }

    public interface IAnimal    {}
	
    public class Lion : IAnimal    {}
	
	public class Penguin : IAnimal	{}
	
	public class Snake : IAnimal	{}
	
	public class Crocodile : IAnimal	{}

}



Schöne Grüsse und besten Dank für die Beschäftigung
Bitte melden Sie sich an um eine Kommentar zu schreiben.
Kommentar schreiben
Admin: 0
#2
vote_ok
von Rulli (70 Punkte) - 29.01.2021 um 14:14 Uhr
Quellcode ausblenden C#-Code
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Aufgabe325.Creators;
using Aufgabe325.Products;

namespace Aufgabe325.BaseClasses
{
   public abstract class BaseFactory : IAnimalFactory
   {
      protected StringBuilder _stringBuilder = null;
      protected Dictionary<string, IAnimal> _animalTypes;
      protected List<IAnimal> _generatetAnimals = null;
      protected Random _random;
      protected BaseFactory _factory;
      protected BaseFactory()
      {
         _stringBuilder = new StringBuilder();
         _generatetAnimals = new List<IAnimal>();
         _random = new Random();
         _animalTypes = new Dictionary<string, IAnimal>()
         {
            {"Lion", new Lion() },
            {"Penguin", new Penguin() },
            {"Crocodile", new Crocodile() },
            {"Snake", new Snake() }
         };
      }

      public List<IAnimal> Animals { get => _generatetAnimals; protected set => _generatetAnimals.Add(value as IAnimal); }
      public int Lions => _generatetAnimals.Where(x => x.GetType() == typeof(Lion)).Count();
      public int Penguins => _generatetAnimals.Where(x => x.GetType() == typeof(Penguin)).Count();
      public int Crocodiles => _generatetAnimals.Where(x => x.GetType() == typeof(Crocodile)).Count();
      public int Snakes => _generatetAnimals.Where(x => x.GetType() == typeof(Snake)).Count();


      public abstract IAnimal CreateAnimal();
      public virtual string GetStatistic()
      {
         int LionsAndPenguins = Lions + Penguins;
         int CrocodileAndSnakes = Crocodiles + Snakes;
         string nameOfFactory = _factory.GetType().Name;
         _stringBuilder.Append($"Generated Animals by {nameOfFactory,-22} :Runs ({Animals.Count,3})\n");
         _stringBuilder.AppendLine("┌──────────────────────┬─────────────────────────┐");
         _stringBuilder.Append($"│ Lions      :    {Lions,-5}│");
         _stringBuilder.Append($"\t  {Lions} + {Penguins} ({LionsAndPenguins,3})  │");
         _stringBuilder.Append($"\n│ Penguins   :    {Penguins,-5}│");
         _stringBuilder.Append($"\t+ {Crocodiles} + {Snakes} ({CrocodileAndSnakes,-3})  │\n");
         _stringBuilder.Append($"│ Crocodiles :    {Crocodiles,-5}├─────────────────────────┤\n");
         _stringBuilder.Append($"│ Snakes     :    {Snakes,-5}│\tAnimals ══ {LionsAndPenguins + CrocodileAndSnakes,-6}│");
         _stringBuilder.AppendLine($"\n└──────────────────────┴─────────────────────────┘");



         return _stringBuilder.ToString();
      }

     
   }



   public abstract class Zoo
   {
      private List<IAnimal> _orderedAnimals = null;
      protected IAnimalFactory _factory = null;

      public Zoo()
      {
         _orderedAnimals = new List<IAnimal>();
      }
      public IEnumerable<IAnimal> OrderedAnimals { get => _orderedAnimals; }
      public IAnimal OrderAnimal(string type)
      {
         var animal = GetAnimal(type);
         _factory.Animals.Add(animal);
         _orderedAnimals.Add(animal);
         return animal;
      }

      public string Average => AverageOfType();
      public int QuantityofOrderedAnimals => _orderedAnimals.Count;
      protected abstract IAnimal GetAnimal(string animal);

      public void RandomGenerated(int runs)
      {
         _factory = new RandomAnimalFactory();

         for (int i = 0; i < runs; i++)
         {
            IAnimal animal = _factory.CreateAnimal();
            _orderedAnimals.Add(animal);
         }
         Console.WriteLine(_factory.GetStatistic());
      }

      public void BalancedGenerated(int runs)
      {
         _factory = new BalancedAnimalFactory();
         for (int i = 0; i < runs; i++)
         {
            IAnimal animal = _factory.CreateAnimal();
            _orderedAnimals.Add(animal);
         }
         Console.WriteLine(_factory.GetStatistic());
      }

      private string AverageOfType()
      {
         return string.Join(
                              "\0",
                              $"\nAnimal in List {QuantityofOrderedAnimals,7}",
                              $"\nLions {QuantityOfArt(new Lion()),16}",
                              $"\nPenguin {QuantityOfArt(new Penguin()),14}",
                              $"\nCrocodiles {QuantityOfArt(new Crocodile()),11}",
                              $"\nSnakes {QuantityOfArt(new Snake()),15}"
                           );

      }
      private int QuantityOfArt(IAnimal type)
      {
         return OrderedAnimals.Where(x => x.GetType() == type.GetType()).Count();
      }
   
}

using System;
using System.Linq;

using Aufgabe325.BaseClasses;
using Aufgabe325.Products;

namespace Aufgabe325.Creators
{
    public interface IRandomAnimalFactory : IAnimalFactory   { }
    public interface IAnimalFactory
    {
      int Crocodiles { get; }
      int Lions { get; }
      int Penguins { get; }
      int Snakes { get; }
      string GetStatistic();
      List<IAnimal> Animals { get; }
      IAnimal CreateAnimal();
    }

   public class BalancedAnimalFactory : BaseFactory
   {
      private int _counter = 0;
      private IAnimal _animal = null;
      private string _lastAnimal = null;

      public BalancedAnimalFactory() : base()
      {
         _factory = this;
      }

      public override IAnimal CreateAnimal()
      {

         do
         {
            int index = _random.Next(_animalTypes.Count);
            _animal = _animalTypes.Values.ElementAt(index);
            _lastAnimal += _animal.GetType().Name.Substring(0, 1);
            if (_lastAnimal.First() == _lastAnimal.GetType().Name[0])
            {
               index = _random.Next(_lastAnimal.Length - 1);
            }

            _counter++;
         } while (_counter < 3);

         _generatetAnimals.Add(_animal);

         return _animal;
      }

      public new void GetStatistic()
      {
         var result = base.GetStatistic();
         Console.WriteLine(result);
      }
   }

    public class RandomAnimalFactory : BaseFactory
    {

      public RandomAnimalFactory() : base()
      {
         _factory = this;
      }

      public override IAnimal CreateAnimal()
      {
         int index = _random.Next(_animalTypes.Count);
         IAnimal animal = _animalTypes.Values.Reverse().ElementAt(index);
         _generatetAnimals.Add(animal);
         return animal;
      }

      public new void GetStatistic()
      {
         var result = base.GetStatistic();
         Console.WriteLine(result);
      }

    }
namespace Aufgabe325.Products
{
   public interface IAnimal
   {
      string ToString();
   }

   public class Crocodile : IAnimal
   {
      public Crocodile() { }

      public override string ToString()
      {
         return nameof(Crocodile);
      }
   }

   public class Lion : IAnimal
   {
      public Lion()  { }
      public override string ToString()
      {
         return nameof(Lion);
      }
   }

   public class Penguin : IAnimal
   {
      public Penguin() {}

      public override string ToString()
      {
         return nameof(Penguin);
      }
   }

   public class Snake : IAnimal
   {
      public Snake()
      {
      }
      public override string ToString()
      {
         return nameof(Snake);
      }
   }


}
using Aufgabe325.BaseClasses;
using Aufgabe325.Products;

namespace Aufgabe325
{
   class ConcreteZoo1 : Zoo
   {
      protected override IAnimal GetAnimal(string animal)
      {
         IAnimal selectedAnimal = _factory.Animals.Find(x => x.GetType().Name == animal);

         return selectedAnimal;
      }


   }

   class Program
   {
      static void Main(string[] args)
      {
         //  composition root 
         var zoo1 = new ConcreteZoo1();
         var zoo2 = new ConcreteZoo1();
         int runs = 200;


         // run logic 
         Console.WriteLine(nameof(zoo1) + "\n---------" + zoo1.Average + "\n---------");
         Console.ReadKey();
         Console.WriteLine(nameof(zoo1) + "\n---------" + "\n---------");
         zoo1.BalancedGenerated(runs);

         Console.WriteLine(nameof(zoo1) + " " + zoo1.Average);
         Console.ReadKey();


         Console.WriteLine();
         zoo1.RandomGenerated(runs);
         Console.WriteLine(nameof(zoo1) + "\n---------" + zoo1.Average + "\n---------");
         Console.WriteLine(nameof(zoo2) + "\n---------" + "\n---------");

       


         Console.ReadKey();
      }


   }
}
}
Bitte melden Sie sich an um eine Kommentar zu schreiben.
Kommentar schreiben
325ClassDiagram.png Solution Explorer.PNG Result Console.PNG Admin: 0
1810838

Du scheinst einen AdBlocker zu nutzen. Ich würde mich freuen, wenn du ihn auf dieser Seite deaktivierst und dich davon überzeugst, dass die Werbung hier nicht störend ist.