OOPS In C#

-

Object Oriented Programming (OOP) concepts
Abstraction
 Encapsulation
 Inheritance
Polymorphism
OOP Features
  1. The software is divided into a number of small units called objects. The data and functions are built around these objects.
  2. The data of the objects can be accessed only by the functions associated with that object.
  3. The functions of one object can access the functions of another object
Class
·         A class is the core of any modern Object Oriented Programming language
·         A class is a blueprint of an object that contains variables for storing data and functions to perform operations on the data. 
·         A class will not occupy any memory space and hence it is only a logical representation of data.
Example
class Employee
{
 
}.
Object
An object is a software bundle of related variable and methods.
 
An object is an instance of a class
A class will not occupy any memory space. Hence to work with the data represented by the class you must create a variable for the class, that is called an object. 
When an object is created using the new operator, memory is allocated for the class in the heap, the object is called an instance and its starting address will be stored in the object in stack memory.
When an object is created without the new operator, memory will not be allocated in the heap, in other words an instance will not be created and the object in the stack contains the value null.
When an object contains null, then it is not possible to access the members of the class using that object.
 
class Employee
{
 
} 
Employee objEmp = new Employee();
All the programming languages supporting Object Oriented Programming will be supporting these three main concepts:
  1. Encapsulation
  2. Inheritance
  3. Polymorphism
Abstraction
Abstraction is the process of hiding the working style of an object, and showing the information of an object in an understandable manner.
Real-world Example of Abstraction
Suppose you have an object Mobile Phone.

Suppose you have 3 mobile phones as in the following:

Nokia 1400 (Features: Calling, SMS)
Nokia 2700 (Features: Calling, SMS, FM Radio, MP3, Camera)
Black Berry (Features:Calling, SMS, FM Radio, MP3, Camera, Video Recording, Reading E-mails)

Abstract information (necessary and common information) for the object "Mobile Phone" is that it makes a call to any number and can send SMS.

So that, for a mobile phone object you will have the abstract class as in the following:
   abstract class MobilePhone
    {
        public void Calling();
        public void SendSMS();
    }

    public class Nokia1400 : MobilePhone
    {
    }

    public class Nokia2700 : MobilePhone
    {
        public void FMRadio();
        public void MP3();
        public void Camera();
    }

    public class BlackBerry : MobilePhone
    {
        public void FMRadio();
        public void MP3();
        public void Camera();
        public void Recording();
        public void ReadAndSendEmails();
    }

Abstraction means putting all the variables and methods in a class that are necessary.
For example: Abstract class and abstract method.
Abstraction is a common thing.
Example
If somebody in your collage tells you to fill in an application form, you will provide your details, like name, address, date of birth, which semester, percentage you have etcetera.
If some doctor gives you an application to fill in the details, you will provide the details, like name, address, date of birth, blood group, height and weight.
See in the preceding example what is in common?
Age, name and address, so you can create a class that consists of the common data. That is called an abstract class. 
·         That class is not complete and it can be inherited by other classes.

Encapsulation
Wrapping up a data member and a method together into a single unit (in other words class) is called Encapsulation.

Encapsulation is like enclosing in a capsule. That is enclosing the related operations and data related to an object into that object.

Encapsulation is like your bag in which you can keep your pen, book etcetera. It means this is the property of encapsulating members and functions.

    class Bag
    {
        book;
        pen;
        ReadBook();
    }

Encapsulation means hiding the internal details of an object, in other words how an object does something.

Encapsulation prevents clients from seeing its inside view, where the behaviour of the abstraction is implemented.

Encapsulation is a technique used to protect the information in an object from another object.

Hide the data for security such as making the variables private, and expose the property to access the private data that will be public.
So, when you access the property you can validate the data and set it.

Example 1
    class Demo
    {
        private int _mark;

        public int Mark
        {
            get { return _mark; }
            set { if (_mark > 0) _mark = value; else _mark = 0; }
        }
    }

Real-world Example of Encapsulation
Let's use as an example Mobile Phones and Mobile Phone Manufacturers.
Suppose you are a Mobile Phone Manufacturer and you have designed and developed a Mobile Phone design (a class). Now by using machinery you are manufacturing Mobile Phones (objects) for selling, when you sell your Mobile Phone the user only learns how to use the Mobile Phone but not how the Mobile Phone works.

This means that you are creating the class with functions and by with objects (capsules) of which you are making available the functionality of your class by that object and without the interference in the original class.

Example 2
TV operation 
It is encapsulated with a cover and we can operate it with a remote and there is no need to open the TV to change the channel. 
Here everything is private except the remote, so that anyone can access the remote to operate and change the things in the TV.

Inheritance
When a class includes a property of another class it is known as inheritance.
Inheritance is a process of object reusability.
For example, a child includes  the properties of its parents.
    public class ParentClass
    {
        public ParentClass()
        {
            Console.WriteLine("Parent Constructor.");
        }

        public void print()
        {
            Console.WriteLine("I'm a Parent Class.");
        }
    }

    public class ChildClass : ParentClass
    {
        public ChildClass()
        {
            Console.WriteLine("Child Constructor.");
        }

        public static void Main()
        {
            ChildClass child = new ChildClass();

            child.print();
        }
    }

Output
    Parent Constructor.
    Child Constructor.
    I'm a Parent Class.



Polymorphism
Polymorphism means one name, many forms.
One function behaves in different forms.
In other words, "Many forms of a single object is called Polymorphism."

Real-world Example of Polymorphism
Example 1
A teacher behaves students.
A teacher behaves his/her seniors.
Here teacher is an object but the attitude is different in different situations.
Example 2
A person behaves the son in a house at the same time that the person behaves an employee in an office.
Example 3
Your mobile phone, one name but many forms:
  • As phone
  • As camera
  • As mp3 player
  • As radio
Polymorphism in .Net 
The Differences between Abstraction and Encapsulation
Abstraction
Encapsulation
1.  Abstraction solves the problem at the design level.
1. Encapsulation solves the problem in the implementation level.
2. Abstraction hides unwanted data and provides relevant data.
2. Encapsulation means hiding the code and data into a single unit to protect the data from the outside world.
3. Abstraction lets you focus on what the object does instead of how it does it
3. Encapsulation means hiding the internal details or mechanics of how an object does something.
4. Abstraction: Outer layout, used in terms of design.
For example:
An external of a Mobile Phone, like it has a display screen and keypad buttons to dial a number.
 
4. Encapsulation- Inner layout, used in terms of implementation.
For example: the internal details of a Mobile Phone, how the keypad button and display screen are connected with each other using circuits.
·          The easier way to understand abstraction and encapsulation is as follows.
·         Real-world Example
·         Use an example of a Mobile Phone
·         You have a Mobile Phone, you can dial a number using keypad buttons. You don't even know how these are working internally. This is called Abstraction. You only have the information that is necessary to dial a number. But not internal working of the mobile.

But how does the Mobile Phone work internally? How are the keypad buttons connected with internal circuit? That is called Encapsulation.
·         Summary
·         "Encapsulation is accomplished using classes. Keeping data and methods that access that data into a single unit." 
·         "Abstraction is accomplished using an Interface. Just giving the abstract information about what it can do without specifying the details."
·         "Information/Data hiding is accomplished using modifiers by keeping the instance variables private or protected."

Abstract Class

Can't create object for abstract class

    class Program
    {
        public abstract class A
        {
            public void funA()
            {
                Console.WriteLine("FunA");
            }
          
            public abstract void Func();
          
            public virtual void funOveride()
            {
                Console.WriteLine("FunOverride Base");
            }
        }
        public class B : A
        {
            public void funB()
            {
                Console.WriteLine("FunB");
            }
            public override void Func()
            {
                Console.WriteLine("FunC");
            }
            public override void funOveride()
            {
                Console.WriteLine("FunB");
            }
        }

        static void Main(string[] args)
        {
            //Cannot create object for abstract
            B obj = new B();
            obj.funA();
            obj.funB();
            Console.ReadLine();

        }

Comments

Post a Comment

Popular posts from this blog

Sites.Selected | Graph API SharePoint Permission

-
Image
  SharePoint Site Collection Permission   The "sites.selected" permission in Microsoft Graph API allows you to grant an application access to specific SharePoint sites instead of all SharePoint sites in the tenant.   Step1: To   Configure "Sites.Selected" Permission in Azure App Registration To use "sites.selected" , you need to: Register an App in Azure AD . Grant "Sites.Selected" Permission to the app. Manually Grant Access to the specific SharePoint site. Use Microsoft Graph API or PowerShell to assign the required role (Read/Write).   Step 1: Register an App in Azure AD Go to Azure Portal → Azure Active Directory → App Registrations . Click New registration . Provide a name (e.g., SharePointAccessApp). Choose Accounts in this organizational directory only . Click Register . Step 2: Add "Sites.Selected" API Permission Navigate ...
Read more

Configure the SharePoint Online App Catalog

-
Image
  You can create an Sharepoint Online app catalog site collection in few simple steps: Sign into Office 365 as a global admin or SharePoint admin. Select the app launcher icon   in the upper left and choose  Admin  to open the Office 365 admin center (if you don’t see the Admin tile, you don’t have Office 365 administrator permissions in your organization). In the left pane, choose  Admin centers  >  SharePoint .  Click on  ‘More Features’  from the left navigation/pane. Now, click on the  ‘Open’  button under Apps. Select  apps  in the left pane, and then select  App Catalog. Select  Create a new Sharepoint app catalog site , and then select  OK . On the Create App Catalog Site Collection page, enter the required information, and then select  OK . An app catalog site collection has been created.  Once the App Catalog site collection is created successfully, click on the new link to th...
Read more

Azure Function | Sharepoint List item | Call from Power Automate Flow

-
  🔹 Steps to Set Up an Azure Function for SharePoint List Item Creation 1️⃣ Create an Azure Function App Go to Azure Portal → Function Apps → Click Create . Choose: Subscription : Select your subscription. Resource Group : Create a new one or use an existing one. Function App Name : Enter a unique name. Runtime Stack : Choose .NET , Python , or Node.js . Region : Select a preferred region. Plan Type : Choose Consumption (Serverless) . Click Review + Create → Then Create . 2️⃣ Create a New Function Inside the Function App Open your Function App → Click Functions → + Add Function . Choose HTTP Trigger (for now, Power Automate will trigger this function). Name your function (e.g., SharePointNewItemTrigger ). Set Authorization Level to Function . Click Create . 3️⃣ Get SharePoint List Data Using Microsoft Graph API Since Azure Functions cannot directly detect SharePoint list changes, we use Power Automate to send data when an item is added. Modify the...
Read more