# How C# Inheritance Saved Me 100 Lines of Code

I was creating a Blackjack console game in C# as a college assessment. While creating this I created two classes, one for a `Player` and one for a `Dealer`. Both the dealer and the player were using the same methods. I encountered a problem when I changed the method code in the `Player` but not the `Dealer`, and I questioned why the game would not do what I intended for the dealer. I realised that because the code was duplicated and I only changed it in one place, I would need to change it a second time.

This issue brought me down a search of using a method in two classes but only having to write it once. I found the Stack Overflow question title [Best way to share a function between two class files](https://stackoverflow.com/questions/18376188/best-way-to-share-a-function-between-two-class-files), this talked about something called a `Base` class and this class could be inherited from other classes. This then brought me down the route of *Inheritance*, I looked at [Inheritance (Derived and Base Class)](https://www.w3schools.com/cs/cs_inheritance.php) and [Inheritance](https://www.tutorialspoint.com/csharp/csharp_inheritance.htm) as resources and implemented this into my Blackjack program.

## What is inheritance?

Inheritance is a way of reusing code, saving time and reducing maintenance. Simply put, if creating a new class that will use the same functionality as another class you can have the new class inherit this functionality from what is known as the base class (original class). The new class inheriting from the base class would be known as the derived class. The syntax for inheritance is using the class names for the derived and base class `Derived : Base`

## How this helped me...

Using inheritance helped me to reduce the amount of code that I had to write. I was able to reuse the code defined in one class, from another. In my case, the `Player` class was the base class and the `Dealer` inherited its functionality from the `Player`. This helps with the maintenance of my code, I will no longer run into the issue of having to change the code in multiple places, erasing any duplication. This will be helpful in the future if the code ever needs to be updated or altered.

```csharp
public class Player {
    // Properties
    public Card[] Hand { get; set; }

    // Methods
    public void GiveCards(Card[] cards) { /*removed for simplicity*/ }
    public int GetHandValue() { /*removed for simplicity*/ }
    private bool HasAnAce() { /*removed for simplicity*/ }
    private int NumOfAces() { /*removed for simplicity*/ }
}

public class Dealer : Player {
    // Properties
    public Deck Deck { get; set; }

    // Methods and properties are inherited from the player class
}
```

The code snippet above shows the properties and methods in the `Player` class, these are the methods and properties that the `Dealer` class inherits. It can be seen that `Dealer` inherits from `Player` because of the syntax used.

### Why the access modifiers used are important when using Inheritance...

For the method to be inherited it should not be set to `private`, if you want to use it in another class that is not inheriting, this is because the code set with a `private` access modifier is only accessible in the same class or derived class. To use inheritance the code can be set to `public`, as `public` access modifiers are accessible to all classes. For this reason, I chose to use `public` access modifiers for the methods that would be called in another class other than the `derived` class and then I used `private` access modifiers for the methods that were only needed in the `base` class and `derived` class.

![Methods available from the Program.cs on the Player object.](https://cdn.hashnode.com/res/hashnode/image/upload/v1674933280459/7dcf9756-b2e9-4457-a217-03ef676a9aef.png align="center")

The image above shows the methods that are available to the `Player` object in the `Program.cs`, as you can see the two methods set with a `private` access modifier cannot be called.

At the end of the day, a `Dealer` is a type of `Player` in this game.