Söka ett inlägg i en loggbok C#

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

namespace TestConsoleApp
{
    //En klass som beskriver själva inlägget
    public class LogEntry
    {
        //Åt helvete med en vektor för att beskriva logentryn här har du 
        //egenskaper som gör att det blir VÄLDIGT mycket enklare att veta
        //vad som är vad... detta går emot uppgiften på E nivå, men fungerar
        //på A nivå då det efterfrågar objektorientering
        public DateTime LogEntryDate { get; set; }
        public string Title { get; set; }
        public string Entry { get; set; }

        public LogEntry(string title, string entry)
        {
            Title = title;
            Entry = entry;
            LogEntryDate = DateTime.Now;
        }

        //Letar efter sökordet i både titel och inlägg, söker mot små bokstäver för att ignorera case
        //returnerar true om logentryn innehåller sökordet
        public bool Contains(string search)
        {
            return Title.ToLower().Contains(search.ToLower()) || Entry.ToLower().Contains(search.ToLower());
        }

        //Här skriver vi över objektets egen ToString metod vilket ersätter sättet att skriva ut när man kör myLogEntry.ToString()
        public override string ToString()
        {
            //Det skulle vara intressant att se om läraren kan detta, det är C# 6 stränginterpolering vilket är ett väldigt trevligt sätt
            //skriva strängar på. I det här fallet visar jag titeln på ena raden och själva inlägget på andra.
            return $@"{Title}
{Entry}";
        }
    }

    //Loggboken innehåller dels en lista med LogEntries men även metoder som används för att manipulera eller söka i listan
    public class LogBook
    {
        //Nyhet i C# 6 som tillåter att man sätter ett defaultvärde på en property, tidigare var man tvungen att göra detta i en konstruktor
        public List<LogEntry> LogEntries { get; set; } = new List<LogEntry>();

        //Enkel metod som plockar in en LogEntry och lägger till den i listan
        public void AddEntry(LogEntry entry)
        {
            LogEntries.Add(entry);
        }

        //Metod som söker fram LogEntries
        public List<LogEntry> SearchEntries(string searchWord)
        {
            //Om användaren skickar in en tom sträng så får denne ut hela listan med LogEntries
            if (string.IsNullOrWhiteSpace(searchWord))
                return LogEntries;

            //Lambdauttryck där jag säger att jag vill ha de LogEntries där LogEntryns.Contains metod returnerar true. Skicka tillbaka resultatet som en lista
            return LogEntries.Where(x => x.Contains(searchWord)).ToList();
        }
    }

    //Klass som hanterar själva programmet, rent krasst borde det vara spöstraff att lägga in all kod direkt i Main metoden, men jag är väldigt
    //medveten om att det är så man brukar göra i skolan. Här har jag dock skapat en separat klass för hanteringen
    public class LogBookWorker
    {
        //Här har vi en instans av själva loggboken 
        private LogBook logBook = new LogBook();

        //Metod som skriver ut själva huvudmenyn
        private void DisplayMenu()
        {
            Console.WriteLine();
            Console.WriteLine("Welcome!");
            Console.WriteLine();
            Console.WriteLine("[1] Write new entry.");
            Console.WriteLine("[2] Search entry.");
            Console.WriteLine("[3] Print all entries.");
            Console.WriteLine("[4] Exit.");
        }

        //Metod som skriver ut en LogEntry. Notera här att jag kör entry.ToString() vilket är den förändring av ToString jag gjorde i själva LogEntryn
        //Rent krasst kan du göra precis som i LogEntryn här också
        private void DisplayEntry(LogEntry entry)
        {
            Console.WriteLine("---");
            Console.WriteLine(entry.ToString());
            Console.WriteLine();
        }

        //Metod som hanterar nya LogEntries. Den läser in data och skickar tillbaka en ny LogEntry som innehåller den data användaren skickade in
        private LogEntry NewEntry()
        {
            Console.WriteLine("New entry");
            Console.WriteLine("Please enter you new log entry");
            Console.WriteLine();
            Console.Write("Title: ");
            string title = Console.ReadLine();
            Console.Write("Entry: ");
            string entry = Console.ReadLine();

            return new LogEntry(title, entry);
        }

        //Metod som hanterar en sökning. Returnerar det eller de sökord användaren matat in
        private string NewSearch()
        {
            Console.WriteLine("Search");
            Console.Write("Search word: ");
            return Console.ReadLine();
        }

        //Här är själva huvudmetoden som hanterar hela loggboksapplikationen. Märk att det INTE är en statisk metod och att den INTE är public static void Main(string[] args)
        public void StartLogBook()
        {
            //Börja med att rensa konsollen
            Console.Clear();

            //Visa meny första gången
            DisplayMenu();

            //Fortsätt till fan avlöser oss... eller att du väljer att avsluta frivilligt
            while (true)
            {
                //Här läser jag in en tangentbordstryckning. Skillnaden mellan ReadLine och ReadKey är att readkey
                //är omedelbar, dvs användaren ges ingen extra möjlighet att skriva i en massa dålig data.
                ConsoleKeyInfo key = Console.ReadKey();

                //Rensa konsollen igen så att den är reda för vad det är för typ av menyalternativ man valt
                Console.Clear();

                switch (key.KeyChar)
                {
                    case '1': //Add entry
                        //Anropa metoden som lägger till en ny LogEntry, lägg in resultatet i logboken utan att lägga in den i en variabel först
                        logBook.AddEntry(NewEntry());
                        //Rensa konsollen för att förbereda för menyn
                        Console.Clear();
                        break;
                    case '2': //Search entries
                        //Anropa logbokens sökfunktion med resultatet av en ny sökning
                        var entries = logBook.SearchEntries(NewSearch());
                        //Rensa konsollen för att förbereda utskrift av hittade LogEntries
                        Console.Clear();
                        //Gå igenom listan och skriv ut alla sökresultat
                        entries.ForEach(x => DisplayEntry(x));
                        break;
                    case '3':
                        //Gå igenom alla LogEntries och skriv ut dem
                        logBook.LogEntries.ForEach(x => DisplayEntry(x));
                        break;
                    case '4':
                        //Lämnar metoden och avslutar programmet
                        return;
                    default:
                        //Om användaren fyller i något ogiltigt tecken vi inte känner igen 
                        //så meddela användaren att det blev fel och att den ska försöka igen
                        Console.WriteLine("Something went wrong, try again.");
                        break;
                }

                //Skriv ut menyn på nytt
                DisplayMenu();
            }
        }
    }

    //Här är själva programmet som startas. Som du ser har jag så lite kod som möjligt i programmet
    //Main metoden ska bara vara ett sätt att starta programmet, inte köra själva programmet
    //På det här sättet så skapar jag en ny instans av LogBookWorker och sen direkt kör igång själva
    //programmet i den nyskapade instansen. Inte en static i övrigt så långt ögat når. Tyvärr är det
    //här något man inte verkar gå igenom på kurser i skolan. Static är bra i vissa begränsade fall,
    //men på det stora hela bör det undvikas så mycket som möjligt i vanlig kod.
    class Program
    {
        static void Main(string[] args)
        {
           new LogBookWorker().StartLogBook();
        }
    }
}