Console app: Building a Library Management System in C#

Introduction

In this blog post, I will guide you through creating a simple Library Management System in C# that utilizes the concepts of encapsulation, polymorphism, and inheritance. This exercise is perfect for practicing object-oriented programming principles.

Objective

Create a simple Library Management System that demonstrates encapsulation, polymorphism, and inheritance.

Requirements

1. Encapsulation

•    Create a `Book` class with private properties: `Title`, `Author`, `ISBN`, and `IsAvailable`.
•    Provide public methods to get and set these properties as needed.

2. Inheritance

•    Create a base class `LibraryItem` with common properties such as `ID`, `Title`, and `IsAvailable`.
•    The `Book` class should inherit from `LibraryItem`.
•    Create another derived class `Magazine` that inherits from `LibraryItem` and has additional properties such as `IssueNumber` and `Publisher`.

3. Polymorphism

• Create a method `DisplayDetails` in the `LibraryItem` class that can be overridden by the derived classes `Book` and `Magazine`.
• Implement the `DisplayDetails` method in both the `Book` and `Magazine` classes to show their specific details.

4. Implementation

• In the `Main` method, create a list of `LibraryItem` and add instances of `Book` and `Magazine` to it.
• Loop through the list and call the `DisplayDetails` method on each item, demonstrating polymorphism.

Guidelines

1. Book Class

• Implement encapsulation by using private fields and public properties.
• Inherit from `LibraryItem`.

2. Magazine Class

•  Inherit from `LibraryItem`.
•  Add specific properties for `Magazine`.

3. LibraryItem Class

•  Define common properties.
•  Implement a virtual method `DisplayDetails`.

4. Main Method

• Create instances of `Book` and `Magazine`.
• Add them to a list of `LibraryItem`.
• Iterate through the list and call `DisplayDetails` on each item.

Code Snippets

LibraryItem

  internal class LibraryItem
  {
      private string Id { get; set; }
      private string Title { get; set; }
      private bool IsAvailable { get; set; }

      public LibraryItem(string id, string title, bool isAvailable)
      {
          SetTitle(title);
          SetId(id);
          SetIsAvailable(isAvailable);
      }

      public string GetTitle()
      {
          return Title;
      }

      public void SetTitle(string title)
      {
          Title = title;
      }

      public string GetId()
      {
          return Id;
      }

      public void SetId(string id)
      {
          Id = id;
      }

      public string GetIsAvailable()
      {
          return IsAvailable? "Yes": "No";
      }

      public void SetIsAvailable(bool isAvailable)
      {
          IsAvailable = isAvailable;
      }

      public virtual void DisplayDetails()
      {
          Console.WriteLine($"ID: {GetId()}");
          Console.WriteLine($"Title: {GetTitle()}");
          Console.WriteLine($"Is available: {GetIsAvailable()}");
      }
  }




Book

    internal class Book : LibraryItem
    {
        private string Title { get; set; }
        private string Author { get; set; }
        private string ISBN { get; set; }
        private bool IsAvailable { get; set; }

        public Book(string id, string title, bool isAvailable, string author, string isbn) : base(id, title, isAvailable)
        {
            SetAuthor(author);
            SetISBN(isbn);
        }

        public string GetTitle()
        {
            return Title;
        }

        public void SetTitle(string title)
        {
            Title = title;
        }

        public string GetAuthor()
        {
            return Author;
        }

        public void SetAuthor(string author)
        {
            Author = author;
        }

        public string GetISBN()
        {
            return ISBN;
        }

        public void SetISBN(string isbn)
        {
            ISBN = isbn;
        }

        public bool GetIsAvailable()
        {
            return IsAvailable;
        }

        public void SetIsAvailable(bool isAvailable)
        {
            IsAvailable = isAvailable;
        }

        public override void DisplayDetails()
        {
            base.DisplayDetails();
            Console.WriteLine($"Author: {GetAuthor()}");
            Console.WriteLine($"ISBN: {GetISBN()}");
        }
    }




Magazine

   internal class Magazine : LibraryItem
    {
        public int IssueNumber { get; set; }
        public string Publisher { get; set; }

        public Magazine(string publisher, int issueNumber, string id, string title, bool isAvailable):base(id, title, isAvailable)
        {

            SetIssueNumber(issueNumber);
            SetPublisher(publisher);
        }

        public int GetIssueNumber() { 
            return IssueNumber; 
        }

        public void SetIssueNumber(int issueNumber)
        {
            IssueNumber = issueNumber;
        }

        public string GetPublisher()
        {
            return Publisher;
        }

        public void SetPublisher(string publisher)
        {
            this.Publisher = publisher;
        }

        public override void DisplayDetails()
        {
            base.DisplayDetails();
            Console.WriteLine($"Issue number: {GetIssueNumber()}");
            Console.WriteLine($"Publisher: {GetPublisher()}");

        }
    }




Program

   using LibraryManagementSystem.Class;

    List<LibraryItem> libraryItems = [
        new Book("R001", "Next world", true, "KaveerR", "IS0002K885R222"), 
        new Magazine("2K publish", 1, "R002", "New coding magazine", true)
        ];

    foreach (var item in libraryItems)
    {
        item.DisplayDetails();
        Console.WriteLine("\n");
    }

	Console.ReadLine();

Screenshot

Repository

You can find the complete source code for this project on GitHub: LibraryManagementSystem

Conclusion

This exercise demonstrates how to implement encapsulation, inheritance, and polymorphism in C#. By building this simple Library Management System, you will gain a better understanding of these fundamental object-oriented programming principles.