Untitled

ConsoleIO.cs
/*
Nu kommer all in- och utmatning att hanteras via IIO-gränssnittet och du kan enkelt byta ut ConsoleIO mot en annan
implementering av IIO om du behöver anpassa in- och utmatningen till en annan plattform eller användargränssnitt.
*/

GoalGenerator.cs
//Använt Linq

GoalGeneratorFactory
//

GuessChecker
//rad 5: Anledningen till att vi ändrar från int till string är att om man skriver 0018 som gissning så kommer C# lagra 
         det som 18 i en int. Då blir det svårare att jämföra hundratal och tusental med goal-siffran.

GuessCheckerFactory
//

MainGame
//

PlayerData
//Ändrat Name till Player för att kunna skapa många olika slags spelare, såsom Monster, Warrior eller Wizard osv.

PlayerDataStorage
////In the provided code, the Instance property of the PlayerDataStorage class is written with a capital 'I' to follow the 
naming convention commonly used for singleton instances in C#.

//By convention, when creating a singleton instance, it is common to use the name "Instance" with a capital 'I' as a property name. 
This convention helps to distinguish the singleton instance from other properties or variables within the class.

//The use of a singleton pattern allows for the creation of only one instance of the class and provides a global point of access to 
that instance. In this case, the Instance property ensures that only one instance of the PlayerDataStorage class is created and 
returned when accessed.

//Note that the use of a singleton pattern and the specific naming convention for the instance property are not enforced by 
the C# language itself but rather a convention followed by developers for clarity and consistency.


//In the provided code, the Instance property is used to implement the Singleton design pattern. The purpose of the Singleton pattern 
is to ensure that only one instance of a class is created and provide a global point of access to that instance.

//By using the Instance property, the PlayerDataStorage class guarantees that there is only a single instance of the class throughout 
the application.When accessed for the first time, the Instance property checks if the instance variable is null and creates a new 
instance of PlayerDataStorage if it is.Subsequent calls to Instance will return the already created instance.

//The difference between instance with a lowercase 'i' and Instance with an uppercase 'I' lies in their usage and scope. The instance
variable is a private static field within the PlayerDataStorage class. It holds the reference to the single instance of PlayerDataStorage
that is created. It is only accessed and modified within the PlayerDataStorage class.

//On the other hand, the Instance property is a public static property that provides the global access point to the single instance of
PlayerDataStorage. It can be accessed from other classes in the application to obtain the singleton instance.

//The capitalization of 'I' in Instance is a common convention used to indicate that it is a public property representing the singleton 
instance. It helps to differentiate it from the private instance variable and other properties or variables in the class.
_______________
Singleton.cs
//One of the commonly used design patterns is the Singleton pattern, which ensures that only one instance of a class can be created.

//In the given program, the PlayerDataStorage class could benefit from using the Singleton pattern.Currently, each
//instance of the PlayerDataStorage class operates on the same file, but each instance opens and closes the file individually,
//which could be inefficient.

//In the modified code, the PlayerDataStorage class now has a private constructor, a private static instance field, and a public static
Instance property that provides access to the singleton instance. The instance is lazily initialized, and a lock is used to ensure 
thread safety.

//Now, instead of creating an instance of PlayerDataStorage using new PlayerDataStorage(resultFilePath), you can access the singleton 
instance by calling PlayerDataStorage.Instance. For example:

//IPlayerDataStorage storage = PlayerDataStorage.Instance;


//By using the Singleton pattern, you ensure that all parts of the program access the same instance of PlayerDataStorage and avoid 
unnecessary file opening and closing operations.



Sammanfattning:
För det första så har vi delat in denna långa kod i olika interfaces och klasser enligt OOP.

Vi har kikat lite på namngivningen och bytt namn till lite mer läsbara namn.
Exempel: checkBC är numera GuessChecker (en klass).
         makeGoal heter GoalGenerator (en klass).
         Name är bytt till Player i PlayerData för att det är mer skalbart om man vill utveckla spelet i framtiden. 
         T ex för att kunna skapa många olika slags spelare, såsom Monster, Warrior eller Wizard osv. Den blir mer 
         värdeladdad, alltså man kan ge en Player fler egenskaper såsom ett namn, yrke, ras med mera.

Vi har valt att använda Factory Method-pattern för att kapsla in interfaces så att ingen utifrån kan påverka koden. 
Utöver det är det också enklare att utveckla spelet och anpassa det utefter nya förutsättningar.
Detta mönster är särskilt användbart när man har ett system med många objekt som delar vissa gemensamma egenskaper, men som också kan 
variera i hur de skapas eller konfigureras. Genom att använda Factory Method kan man definiera ett gemensamt gränssnitt (interface) för 
objektskapande och låta olika fabriker implementera detta gränssnitt på olika sätt för att skapa olika typer av objekt.
Metoden är användbar när man har ett större system med gemensamma egenskaper. 
Detta gäller klasserna för GoalGenerator och GuessChecker.


I klassen PlayerDataStorage arbetade varje instans av klassen PlayerDataStorage med samma fil, men varje instans öppnade och 
stängde filen individuellt, vilket kunde vara ineffektivt. Singleton-pattern säkerställer att endast en instans av en klass kan 
skapas när den faktiskt behövs, istället för att den startas direkt när programmet startas eller när klassen laddas. 
Genom att använda Singleton-pattern säkerställer vi att alla delar av programmet har åtkomst till samma instans av PlayerDataStorage 
och undviker onödiga öppnings- och stängningsoperationer av filer. Med hjälp av "lock"-uttrycket förhindrar vi att flera anrop får 
tillgång till och möjlighet att ställa till det i spelet.

___________________________________________________________

















::(Factory Method är ett designmönster inom programvaruutveckling som används för att skapa objekt på ett flexibelt och hanterbart sätt.
En av huvudorsakerna till att man använder Factory Method är för att separera objektskapandet från dess faktiska användning.

Istället för att direkt skapa objekt med hjälp av en konstruktor, använder man sig av en särskild "fabrik" (Factory) för att producera
dessa objekt. Detta ger flera fördelar. För det första kan man enkelt ändra implementationen av objektskapandet i framtiden utan att 
påverka koden som använder objekten. Det gör det också möjligt att hantera olika varianter eller typer av objekt på ett strukturerat 
sätt.

Sammanfattningsvis, Factory Method möjliggör en ren och strukturerad kodbas genom att isolera objektskapandet och tillåter enkel 
anpassning och utökning av objektskapandet i framtiden. Det hjälper också till att hantera komplexiteten när det gäller att skapa och 
använda olika objekttyper.)