A Complete Guide To Object Oriented Programming In C#

The following example shows one constructor for a custom class.

using System;    
namespace oops    
{    
    class customer    
    {    
        // Member Variables    
        public string Name;    
    
        //constuctor for initializing fields    
        public customer(string fname, string lname)    
        {    
            Name= fname +" "+ lname;    
        }     
        //method for displaying customer records    
        public void AppendData()    
        {    
            Console.WriteLine(Name);    
        }    
         //Entry point    
        static void Main(string[] args)    
        {    
            // object instantiation    
            customer obj = new customer("Barack", "Obama");    
    
            //Method calling    
            obj.AppendData();    
        }    
    }    
} 

Note

The moment a new statement is executed, the default constructor is called.

Static Constructor

A constructor can be static. You create a static constructor to initialize static fields. Static constructors are not called explicitly with the new statement. They are called when the class is first referenced. There are some limitations of the static constructor, as in the following;

• Static constructors are parameterless.
• Static constructors can't be overloaded.
• There is no accessibility specified for Static constructors.

In the following example, the customer class has a static constructor that initializes the static field, and this constructor is called when the class is referenced in the Main () at line 26 as in the following:

using System;    
namespace oops    
{    
    class customer    
    {    
        // Member Variables    
        static private int x;    
    
        //constuctor for static initializing fields    
        static customer()    
        {    
            x = 10;    
        }    
        //method for get  static field    
        static public void getData()    
        {    
            Console.WriteLine(x);    
        }    
         //Entry point    
        static void Main(string[] args)    
        {    
           //static Method calling    
            customer.getData();    
        }    
    }    
}

Destructors

The purpose of the destructor method is to remove unused objects and resources. Destructors are not called directly in the source code but during garbage collection. Garbage collection is nondeterministic. A destructor is invoked at an undetermined moment. More precisely, a programmer can't control its execution; it is called the Finalize () method. Like a constructor, the destructor has the same name as the class, except a destructor is prefixed with a tilde (~). There are some limitations of destructors, as in the following;

• Destructors are parameterless.
• A Destructor can't be overloaded.
• Destructors are not inherited.
• Destructors can cause performance and efficiency implications.

The following implements a destructor and dispose method. First, we initialize the fields via the constructor, do some calculations on that data, and display it to the console. But in line 9, we are implementing the destructor that is calling a Dispose() method to release all the resources.

using System;    
namespace oops    
{    
    class customer    
    {    
        // Member Variables    
        public int x, y;    
        //constuctor for  initializing fields    
        customer()    
        {    
            Console.WriteLine("Fields inititalized");    
            x = 10;    
        }    
        //method for get field    
        public void getData()    
        {    
            y = x * x;    
            Console.WriteLine(y);    
        }    
        //method to release resource explicitly    
        public void Dispose()    
        {    
            Console.WriteLine("Fields cleaned");    
            x = 0;    
            y = 0;    
        }    
        //destructor    
        ~customer()    
        {    
            Dispose();    
        }    
         //Entry point    
        static void Main(string[] args)    
        {    
            //instance created    
            customer obj = new customer();    
    
            obj.getData();    
    
        }    
    }    
}

At line 12, when the instance is created, fields are initialized, but it is not necessary that at the same time, the destructor is also called. Its calling is dependent on garbage collection. If you want to see the destructor being called into action, put a breakpoint (by F9) at line 10 and compile the application. The CLR indicates its execution at the end of the program by highlighting line 10 using the yellow color.

Method Overloading

Method overloading allows multiple implementations of the same method in a class. Overloaded methods share the same name but have a unique signature. The number of parameters, types of parameters, or both must be different. A function can't be overloaded based on a different return type alone.

using System;    
namespace oops    
{    
    class funOverload    
    {    
        public string name;    
    
        //overloaded functions    
        public void setName(string last)    
        {    
            name = last;    
        }    
    
        public void setName(string first, string last)    
        {    
            name = first + "" + last;    
        }    
    
        public void setName(string first, string middle, string last)    
        {    
            name = first + "" + middle + "" + last;    
        }    
    
        //Entry point    
        static void Main(string[] args)    
        {    
            funOverload obj = new funOverload();    
    
            obj.setName("barack");    
            obj.setName("barack "," obama ");    
            obj.setName("barack ","hussian","obama");    
     
        }    
    }    
}

In lines 3, 4, and 5, we define three methods with the same name but different parameters. In the Main (), the moment you create an instance of the class and call the functions setName() via obj at lines 7, 8, and 9, IntelliSense will automatically show three signatures.

Encapsulation

Encapsulation is the mechanism that binds together the code and the data it manipulates and keeps both safe from outside interference and misuse. For example, code and data may be combined in OOP to create a self-contained box. When code and data are linked together in this way, an object is created, and encapsulation exists.

Within an object, code, data, or both may be private or public to that object. Private code is known to and accessible only by another part of the object; private code or data may not be accessible by a piece of the program that exists outside the object. Conversely, when the code and data are public, other portions of your program may access it even though it is defined within an object.

using System;    
namespace oops    
{    
    class Encapsulation    
    {    
        /// <summary>    
        /// Every member Variable and Function of the class are bind    
        /// with the Encapsulation class object only and safe with     
        /// the outside inference    
        /// </summary>    
    
        // Encapsulation Begin    
        int x;    
    
        //class constructor    
        public Encapsulation(int iX)    
        {    
            this.x = iX;    
        }    
    
        //calculating the square    
        public void MySquare()    
        {    
            int Calc = x * x;    
            Console.WriteLine(Calc);    
        }           
    
        // End of Encapsulation    
    
         //Entry point    
        static void Main(string[] args)    
        {    
            //instance created    
            customer obj = new customer(20);    
               
            obj. MySquare();    
                
        }    
    
    }    
}

Inheritance

Inheritance is the process by which one object can acquire the properties of another object. Inheritance is a "is a kind of" relationship. It supports the concept of classification in which an object needs only to define those qualities that make it unique within the class. Inheritance involves a base class and a derived class. The derived class inherits from the base class and can override inherited members and add new members to extend the base class.

A base type represents the generalization, whereas a derived type represents a specification of an instance. Such as Employees that can have diverse types, such as hourly, salaried and temporary, so in that case, Employees is the general base class, and hourly, salaried and temporary employee are specialized derived classes.

Classes can inherit from a single class and one or more interfaces. When inheriting from a class, the derived class inherits the members, including the base class's code. The important point is that Constructors and Destructors are not inherited from the base class.

The syntax of inheritance is as in the following;

Class derivedClass : baseClass, Iterface1, Interface2 { body }

For example, we are defining two classes, Father and Child. You notice in line 7 we are implementing inheritance by using a colon (:); at this moment, all the properties belonging to the Father Class is accessible to the Child class automatically.

using System;    
namespace oops    
{    
    //Base Class    
    public class Father    
    {    
        public void FatherMethod()    
        {    
            Console.WriteLine("this property belong to Father");    
        }    
    }    
     
    //Derived class    
    public class Child : Father    
    {    
        public void ChildMethod()    
        {    
            Console.WriteLine("this property belong to Child");    
        }    
    }    
    class Inheritance    
    {    
        //Entry point    
        static void Main(string[] args)    
        {    
    
            Father fObj = new Father();    
            fObj.FatherMethod();    
     
            //Here Child object can access both class methods    
            Child cObj = new Child();    
            cObj.FatherMethod();    
            cObj.ChildMethod();      
        }    
    }    
}

In line 11, the Intellisense only shows the Father class functions, but in lines 15 to 16, the Child class object can access both class methods as in the following.

We can create a class in the VB.Net language or another .NET supported language and inherit them in a C# .Net class and vice versa. But a class developed in C++ or another unmanaged environment can't be inherited in .NET.

Note

The multiple inheritance feature is not supported by C#, but you can achieve multiple inheritance via multiple hierarchical base classes and interfaces. Here is a detailed article on this: How to implement Multiple Inheritance in C# (c-sharpcorner.com).

Accessibility

Accessibility sets the visibility of the member to outside assemblies or derived types. The following table describes member accessibility;

Constructor in Inheritance

Constructors in a base class are not inherited in a derived class. Instead, a derived class has a base portion and a derived portion. The base portion initializes the base portion, and the constructor of the derived class initializes the derived portion.

The following is the syntax of a constructor in inheritance;

Accessibility modifier classname(parameterlist1) : base(parameterlist2) { body }

So the base keyword refers to the base class constructor, while parameterlist2 determines which overloaded base class constructor is called.

In the following example, the Child class's constructor calls the single-argument constructor of the base Father class;

using System;    
namespace oops    
{    
    //Base Class    
    public class Father    
    {    
    
        //constructor    
        public Father()    
        {    
            Console.WriteLine("Father class constructor");    
        }    
    
        public void FatherMethod()    
        {    
            Console.WriteLine("this property belong to Father");    
        }    
    }    
    
    //Derived class    
    public class Child : Father    
    {    
        public Child()    
            : base()    
        {    
            Console.WriteLine("child class constructor");    
        }    
        public void ChildMethod()    
        {    
            Console.WriteLine("this property belong to Child");    
        }    
    }    
    class Inheritance    
    {    
        //Entry point    
        static void Main(string[] args)    
        {    
            //Here Child object can access both class methods    
            Child cObj = new Child();    
            cObj.FatherMethod();    
            cObj.ChildMethod();    
            Console.ReadKey();    
        }    
    }    
}

In line 4, we are defining a base Father Class constructor, and in the derived class Child, in line 8, we are initializing it explicitly via the base keyword. Therefore, if we pass any parameter in the base class constructor, we have to provide them in the base block of the child class constructor.

Virtual Methods

By declaring a base class function as virtual, you allow the function to be overridden in any derived class. The idea behind a virtual function is to redefine the implementation of the base class method in the derived class as required. If a method is virtual in the base class, we have to provide the override keyword in the derived class. Neither member fields nor static functions can be declared as virtual.

using System;    
namespace oops    
{    
    class myBase    
    {    
        //virtual function    
        public virtual void VirtualMethod()    
        {    
            Console.WriteLine("virtual method defined in the base class");    
        }    
    }    
    
    class myDerived : myBase     
    {    
        // redifing the implementation of base class method    
        public override void VirtualMethod()    
        {    
            Console.WriteLine("virtual method defined in the Derive class");    
        }    
    }    
    class virtualClass    
    {    
        static void Main(string[] args)    
        {    
            // class instance    
            new myDerived().VirtualMethod();    
            Console.ReadKey();      
        }    
    }    
}

Hiding Methods

If a method with the same signature is declared in both base and derived classes, but the methods are not declared as virtual and overridden respectively, then the derived class version is said to hide the base class version. In most cases, you would want to override methods rather than hide them. Otherwise, .NET automatically generates a warning.

In the following example, we define a VirutalMethod() in the myBase class but do not override it in the derived class. In that case, the compiler will generate a warning. The compiler will assume that you are hiding the base class method. So to overcome that problem, if you prefix the new keyword in the derived class method, the compiler will prefer the most derived version method. You can still access the base class method in the derived class using the base keyword.

using System;    
namespace oops    
{    
    class myBase    
    {    
        //virtual function    
        public virtual void VirtualMethod()    
        {    
            Console.WriteLine("virtual method defined in the base class");    
        }    
    }    
    
    class myDerived : myBase     
    {    
        // hiding the implementation of base class method    
        public new void VirtualMethod()    
        {    
            Console.WriteLine("virtual method defined in the Derive class");    
    
            //still access the base class method    
            base.VirtualMethod();    
        }    
    }    
    class virtualClass    
    {    
        static void Main(string[] args)    
        {    
            // class instance    
            new myDerived().VirtualMethod();    
            Console.ReadKey();      
        }    
    }    
}

Abstract Classes

C# allows both classes and functions to be declared abstract using the abstract keyword. You can't create an instance of an abstract class. An abstract member has a signature, but no function body and must be overridden in any non-abstract derived class. Abstract classes exist primarily for inheritance. Member functions, properties, and indexers can be abstract. A class with one or more abstract members must be abstract as well. Static members can't be abstract.

In this example, we declare an abstract class Employess with a method displayData() that does not have an implementation. Then we implement the displayData() body in the derived class. One point noted here is that we must prefix the abstract method with the override keyword in the derived class.

using System;    
namespace oops    
{    
    //abstract class    
    public abstract class Employess    
    {    
        //abstract method with no implementation    
        public abstract void displayData();    
    }    
    
    //derived class    
    public class test : Employess    
    {    
        //abstract class method implementation    
        public override void displayData()    
        {    
            Console.WriteLine("Abstract class method");    
        }    
    }    
    class abstractClass    
    {    
        static void Main(string[] args)    
        {    
            // class instance    
            new test().displayData();        
        }    
    }    
} 

Sealed Classes

Sealed classes are the reverse of abstract classes. While abstract classes are inherited and refined in the derived class, sealed classes cannot be inherited. Instead, you can create an instance of a sealed class. A sealed class is used to prevent further refinement through inheritance. Here is a detailed article on Sealed Class in C# (c-sharpcorner.com).

Suppose you are a class library developer, and some classes in the class library are extensible, but others are not, so those classes are marked as sealed.

using System;    
namespace oops    
{    
    sealed class SealedClass    
    {    
        void myfunv();    
    }    
    
    public class test : SealedClass //wrong. will give compilation error    
    {    
    }    
}

Interface

An interface is a set of related functions that must be implemented in a derived class. Members of an interface are implicitly public and abstract. Interfaces are similar to abstract classes. First, both types must be inherited; second, you cannot create an instance of either. Although there are several differences as in the following;

• An Abstract class can contain some implementations, but an interface can't.
• An Interface can only inherit other interfaces, but abstract classes can inherit from other classes and interfaces.
• An Abstract class can contain constructors and destructors, but an interface can't.
• An Abstract class contains fields, but interfaces don't.

So the question is, which of these to choose? Select interfaces because, with an interface, the derived type can still inherit from another type, and interfaces are more straightforward than abstract classes.

using System;    
namespace oops    
{    
    // interface    
    public interface xyz    
    {    
       void methodA();    
       void methodB();    
    }    
    
    // interface method implementation    
    class test : xyz    
    {    
        public void methodA()    
        {    
            Console.WriteLine("methodA");     
        }    
        public void methodB()    
        {    
            Console.WriteLine("methodB");     
        }    
    }    
    class interfaceDemo     
    {    
        static void Main(string[] args)    
        {    
            test obj = new test();    
            obj.methodA();    
            obj.methodB();    
        }    
    }       
}

An interface can be inherited from other interfaces as in the following:

public interface xyz    
{    
    void methodA();    
    void methodB();    
}    
    
public interface abc : xyz    
{    
    void methodC();    
} 

Here is a detailed article on Understanding Interfaces in C# (c-sharpcorner.com).

Polymorphism

Polymorphism is the ability to treat various objects in the same manner. It is one of the significant benefits of inheritance. We can decide the correct call at runtime based on the derived type of the base reference. This is called late binding.

In the following example, we can write a generic algorithm that uses the base type functions instead of having a separate routine for the hrDepart, itDepart, and financeDepart classes. The method LeaderName() declared in the abstract base class is redefined as per our needs in 2 different classes.

using System;    
namespace oops    
{    
    public abstract class Employee    
    {    
        public virtual void LeaderName()    
        {    
        }    
    }    
    
    public class hrDepart : Employee    
    {    
        public override void LeaderName()    
        {    
            Console.WriteLine("Mr. jone");     
        }    
    }    
    public class itDepart : Employee    
    {    
        public override void LeaderName()    
        {    
            Console.WriteLine("Mr. Tom");    
        }    
    }    
    
    public class financeDepart : Employee    
    {    
        public override void LeaderName()    
        {    
            Console.WriteLine("Mr. Linus");    
        }    
    }    
    
    class PolymorphismDemo    
    {    
        static void Main(string[] args)    
        {    
            hrDepart obj1 = new hrDepart();    
            itDepart obj2 = new itDepart();    
            financeDepart obj3 = new financeDepart();    
    
            obj1.LeaderName();    
            obj2.LeaderName();    
            obj3.LeaderName();    
    
            Console.ReadKey();    
        }    
    }    
}

Here is a detailed article on Understanding Polymorphism In C# (c-sharpcorner.com).

Summary

Object-oriented programing is the modern programming practice for building sophisticated software. C# programming language is one of the newest, modern, object-oriented programming languages to build Windows desktops, web, and mobile apps. In this tutorial, we learned programming OOP using C# language.

C# language is a powerful programming language. Learn here What Can C# Do For You (c-sharpcorner.com).

Here are more related articles:

Abstract Class In C# (c-sharpcorner.com)