This chapter contains various code examples to explain these concepts. The code is kept simple and is just for demonstration purposes. Most of the examples involve a .NET Core console application written in C#.

To run and execute the code, you will need the following:

• Visual Studio 2019 (you can also run the application using Visual Studio 2017 version 3 or later)
• .NET Core
• SQL Server (the Express Edition is used in this chapter)

In order to run these code examples, you will need to install Visual Studio or later (you can also use your preferred IDE). To do this, follow these instructions:

1. Download Visual Studio from the following link: https://docs.microsoft.com/en-us/visualstudio...

OOP refers to a software programming approach that uses objects defined as classes. These definitions include fields, sometimes called attributes, to store data and methods in order to provide functionality. The first OOP language was a simulation of real systems known as Simula (https://en.wikipedia.org/wiki/Simula) and was developed at the Norwegian Computing Center in 1960. The first pure OOP language came into existence in 1970 as the Smalltalk (https://en.wikipedia.org/wiki/Smalltalk) language. This language was designed to program the Dynabook (http://history-computer.com/ModernComputer/Personal/Dynabook.html), which is a personal computer created by Alan Kay. Several OOP languages evolved from there, with the most popular being Java, C++, Python, and C#.

One of the most important concepts in OOP is inheritance. Inheritance between classes allows us to define an is-a-type-of relationship; for example, a car is a type of vehicle. The importance of this concept is that it allows for objects of the same type to share similar features. Let's say that we have a system for managing different products of an online bookstore. We might have one class for storing information about a physical book and a different one for storing information about a digital or online book. The features that are similar between the two, such as the name, publisher, and author, could be stored in another class. Both the physical and digital book classes could then inherit from the other class.

Encapsulation is another fundamental concept in OOP where the details of a class, that is, the attributes and methods, can be visible or not visible outside the object. With encapsulation, a developer is providing guidance on how a class should be used as well as helping to prevent a class from being handled incorrectly. For example, let's say we wanted to only allow adding PetAnimal objects by using the AddPet(PetAnimal) method. We would do this by having the PetOwner class's AddPet(PetAnimal) method available while having the Pets attribute restricted to anything outside the PetAnimal class. In C#, this is possible by making the Pets attribute private. One reason for doing this would be if additional logic was required whenever a PetAnimal class was added, such as logging or validating that the PetOwner class could have a pet.

C# supports different levels...

The ability to handle different objects using the same interface is called polymorphism. This provides developers with the ability to build flexibility into applications by writing a single piece of functionality that can be applied to different forms as long as they share a common interface. There are different definitions of polymorphism in OOP, and we will distinguish between two main types:

• Static or early binding: This form of polymorphism happens when the application is compiled.
• Dynamic or late binding: This form of polymorphism happens when the application is running.

Static or early binding polymorphism happens at compile time and it primarily consists of method overloading, where...

In this chapter, we discussed OOP and its three main features: inheritance, encapsulation, and polymorphism. Using these features, the classes within an application can be abstracted to provide definitions that are both easy to understand and protected against being used in a manner that is inconsistent with its purpose. This is an essential difference between OOP and some earlier types of software development language such as structural and procedural programming. With the ability to abstract functionality, the ability to reuse and maintain code is increased.

In the next chapter, we will discuss various patterns used in enterprise software development. We will cover programming patterns as well as software development principles and patterns used in the Software Development Life Cycle (SDLC).

The following questions will allow you to consolidate the information contained in this chapter:

1. What do the terms late and early binding refer to?
2. Does C# support multiple inheritance?
3. In C#, what level of encapsulation could be used to prevent access to a class from outside the library?
4. What is the difference between aggregation and composition?
5. Can interfaces contain properties? (This is a bit of a trick question.)
6. Do dogs eat fish?