2nd Approach – Using the “Constructor”

Constructor is a special type of method that is present in all classes, even if you don’t explicitly define it in the class itself.

Constructors are used for creating an instance of the object…. this basically means that whenever you declare a new instance of a class, e.g.:

        Employee Dave = new Employee()

Then the constructor get’s executed, and in the above case, the only thing it does is set a side a memory container, waiting to be filled in. You can identify a constructor in a class by the fact that the constructor’s name must be the same as the class’s name itself. Hence in the case of the the “Employee” class, we didn’t explicitly declare the Employee constructor,

Tip: it is best practice to only define one class per cs file.

Tip: For consistency, and to make life easier, the cs file’s name should be named after the class’s name.

Let’s say we have a warehouse ordering system…which we breakdown into 3 cs files:

1. Program.cs – this is the main starting point of our component, and hence it contains the “Main” method to reflect this. All this will do is create a “Warehouse” object and then apply a non-static method to that object.
2. Warehouse.cs – the warehouse class has a constructor, to make it easy to create an object using this class. It also has a method, which in turn instantiates an object belonging to the “item” class.
3. Item.cs – this only returns

First let’s create a new project:

Notice the

So far we have looked at 5 ways to store data in a class’s object (aka an instance) in the form of “properties”. Of which one of the recommended ways of setting values to properties, is by using the constructor method, e.g.:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

class Employee
{
    public string Firstname { get; set; }
    public int Age { get; set; }
    public double Salary { get; set; }

    public Employee(string firstname, int age, double salary)
    {

        Firstname = firstname;
        Age = age;
        Salary = salary;
  															

Lets say we have a supermarket and it sells a different types of fruits, then you could create a class for each type of fruit:

The above will output:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritenceInAction
{
    class Program
    {
        static void Main(string[] args)
        {
			// Here we create an object using the orange class
            Orange AnOrange = new Orange(1.25, 45, "Spain", "25-01-2015", "sweet", true, "clementine");
			string ContainsSeedsSentence;
            if (AnOrange.ContainsSeeds)
            {
     															

Method Overloading is basically a technique that lets you have different versions of the same method, where each version of the method does a different thing.

It essentially makes methods more versatile.

Each version of the method accepts different/types of input parameters.

The way you control which of version method you want to trigger, is by specifying the correct number/type of input parameters for that corresponding method.

In the following example, we have 2 methods, which in this case achieves the same goal by different means. The here is to instantiate an object:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

class Employee
{
    public string Firstname { get; set; }
    public int Age { get; set; }
    public double Salary { get;															

In the previous unit we came across:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritenceInAction
{
    class Program
    {
        static void Main(string[] args)
        {
            // Here we create an object using the orange class
            Orange AnOrange = new Orange(1.25, 45, "Spain", "25-01-2015", "sweet", true, "clementine");
            string ContainsSeedsSentence;
            if (AnOrange.ContainsSeeds)
            {
  															

A variable is essentially a container that’s used for storing data. This container has a name assigned to it. In programming, this name is used to refer to the variable’s content.

In c# there are actually three high-level types of variables:

• Value Types
• Reference types
• Pointer types (we will ignore this for now, but will cover it later)

Value Types

The following variable types fall under this category:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritenceInAction
{
    class Program
    {
        static void Main(string[] args)
        {
            Orange AnOrange = new Orange(1.25, 45, "Spain", "25-01-2015", "sweet", true, "clementine");

            // The "SomeInfo" method hasn't been explicitly defined in the Orange class, 
			// Howeever the following method call															

using System;
class ConcatenateStrings
{
	static void Main()
	{
		string firstname = "James" ;
		string lastname = "Bond" ;
		string fullname = firstname + " " + lastname;
		Console.WriteLine ("My name is " + lastname + ", " + fullname );

                string country = "uk";
            															

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RandomNumberGenerator
{
    class Program
    {
        static void Main(string[] args)
        {
			Random RandomNumber = new Random();
			
			Console.WriteLine("Here is a list of random numbers:");
			Console.WriteLine(RandomNumber.Next());
			Console.WriteLine(RandomNumber.Next());
			Console.WriteLine(RandomNumber.Next());
			Console.WriteLine(RandomNumber.Next());
			Console.WriteLine(RandomNumber.Next());
			
		}
    }
	
}