Basic Concepts of OOPs in .Net

-
Introduction

.NET is fully object oriented platform that allow languages to take full advantage of these OO features. The features include:

Namespace
Classes
Abstract
Encapsulation
Overloading
New.
Overriding
Interfaces
Polymorphism

Let’s take a quick look at what each of this term means.

Namespace

Even though namespace is not really an OOPs feature, .NET use it extensively. Namespace is nothing but a logical container for various classes. Under given namespace class names must be unique. Namespace server two purposes – they provide logical organization of classes and they also avoid ambiguity.

Classes

Class is nothing but a template or blue-print for an entity. For example you may have a class that represents real life entity – Employee. The class will provide properties (Name, Age…) as well as actions (CalculateSalary, GoOnLeave…) of the entity.

Objects

Instances of classes are called as objects. For example there might be three instances of the Employee class mentioned above. They might represent individual employees – John, Bob and Tom.

Encapsulation

Each object typically deals with some kind of data or the other. Not all the data needs to be exposed to external systems. This can be controlled via data encapsulation.

Overloading

Overloading refers to the methods or functions having same name but varying parameters. The parameters should vary with respect to data types and order.
If no modifier is specified, the method is given private access.

Inheritance

Inheritance refers to extending functionality of existing class. Inheritance is useful when developing "object models" for your system. .NET supports only single inheritance.

Overriding

Overriding refers to the methods in the child class having the same signature (name as well as parameters) as of the parent class methods.

Interfaces

Interfaces are nothing but models of class properties and methods without any implementation. The class implements the interface. Once a class implements any interface it must implement all the properties and methods (although the implementation can be empty or null implementation).

Polymorphism

Polymorphism refers to the ability of the system to call correct implementation of methods with the same name. For example, Clerk as well as Manager class might have a method called CalculateSalary(). However, at runtime depending on whether the underlying object is of type Clerk or Manager correct version of the method is called.

Creating namespaces

Namespaces are created using keyword – Namespace (namespace in C#). Following example shows how to declare a namespace.

[VB.NET]
Namespace MyNamespace
…
End Namespace

[C#]
namespace MyNamespace
{
…
}

Note that one assembly can have one or more namespaces. Also, one namespace can span across multiple assemblies. You can create nested namespaces as follows:

[VB.NET]
Namespace MyNamespace
     Namespace MuSubNamespace
     …
     End Namespace
End Namespace

[C#]
     namespace MyNamespace
     {
         namespace MySubNamespace
         {
          …
         }
     } 

If you are using VS.NET then the project name acts as the default namespace name.

Creating classes

Creating classes is similar to creating namespaces.

[VB.NET]
    Public Class Class1
    …
    End Class

[C#]
    public class Class1
    {
      …
    }

Generally classes will be part of some of the namespace.

Creating Properties

Properties encapsulate data members of your class. Properties can be read-write, read only or write only. Here is how you create read-write properties:

[VB.NET]
      Public Class Employee

           private strName As String

           Public Property Name As String
           Get
               return strName;
           End Get

           Set(value As String)
              strName=value;
           End Set
           End Property
     End Class

[C#]
      public class Class1
      {
         public string Name
         {
           string strName;
           get
           {
               return strName;
           }
           set
           {
               strName=value;
           }
         }
     }

Here,

VB.NET uses Property keyword to declare properties. C# does not have this keyword
Property definition consists of two parts Get and Set. The get part returns the property value and set par sets some private variable.
The value in Set routine is received via implicit variable called value in C#. VB.NET allows you to change this.

Creating methods

Methods represent actions performed by the object. In VB.NET functions and sub routines are collectively called as methods. In C# everything is function.

[VB.NET]
      Public Sub CalculateSalary()
      …
      End Sub

[C#]
      public void CalculateSalary()
      {
        …
      }

Method overloading

Method overloading refers to methods with same name but different types or order of parameters. Following example make it clear:

[VB.NET]
      Public Sub CalculateSalary()
         …
      End Sub

      Public Sub CalculateSalary(month as Integer)
      …
      End Sub

[C#]
      public void CalculateSalary()
      {
       …
      }

      public void CalculateSalary(int month)
      {
      …
      }

In VB.NET you can also use optional parameters to achieve similar functionality. However, it is recommended to use overloading instead to make your code consistent across languages.

Inheritance

Inheritance is the ability to extend existing class further. Unlike languages like C++ that allow multiple inheritance .NET allows only single inheritance. This means that at a time you can inherit from a single class.

[VB.NET]
       Public Class Manager
           Inherits Employee
           …
       End Class

[C#]
       public class Manager : Employee
       {
         …
       }

In the above example, we create a class called Manager that inherits from Employee class. As you can guess Manager is specific implementation of generic Employee class. VB.NET uses Inherits keyword to indicate the parent class where as C# uses : operator to indicate that.

Method Overriding

In order to override method in child class they need to be marked as Overridable (VB.NET) or virtual (C#) in the parent class.

[VB.NET]
      Public Overridable Function CalculateSalary() As Integer
         …
      End Function

[C#]
      public virtual int CalculateSalary()
      {
       …
      }

Then in the child class you can create a method with the same signature and specify that it overrides the base class method.

[VB.NET]
      Public Overrides Function CalculateSalary() As Integer
        …
      End Function

[C#]
      public override int CalculateSalary()
      {
          …
      }

Note that if you do not provide the Overrides (VB.NET) or override (C#) keywords in the child class the compiler issues a warning that you are hiding a base class member. In this case you can either put the above keywords or use Shadows (VB.NET) or new (C#) keywords. Using these keywords ,however, will hide the base class members.

Creating Interfaces

Just like classes are templates for real life entities, interfaces can be thought of as templates for classes. They bring uniformity in your object model.

[VB.NET]
      Public Interface IEmployee
         Property EmployeeID() As Integer
         Property Name() As String
         Property Age() As Integer
         Function CalculateSalary() As Integer
      End Interface

[C#]
      public interface  IEmployee
      {
        int EmployeeID
      {
       get;
      }

          string Name
          {
             get;
             set;
          }

          int Age
          {
             get;
             set;
          }

          int CalculateSalary();
          }

As you can see VB.NET uses Interface keyword to define an interface. Similarly, C# uses interface keyword. Note, how they contain only property and method signatures and no code at all.

Implementing Interfaces

The main difference between inheritance based programming and interfaces based programming is that – interfaces just specify signatures of properties and methods for a class. Your class "implements" the interface by providing implementation for various properties and methods. Unlike inheritance there is no "code" inherited from interfaces. Your class can implement one or more interfaces.

[VB.NET]
        Public Class Manager
             Implements IEmployee
             …
             Public Function CalculateSalary() As Integer Implements IEmployee.CalculateSalary

             …
             End Function
End Class

[C#]
      public class Manager : IEmployee
      {
         …
         public int CalculateSalary()
         {
            …
         }

     }

Above example shows how VB.NET uses Implements keyword to implement an interface. Note how VB.NET also requires the use of Implements keyword for each property and method. You must have guessed from this that in VB.NET you can give different name to the implemented member than the interface. This feature is not available in C#. C# do not have a special keyword and uses the same : operator to implement the interface.

Polymorphism

Consider following lines of code:

[VB.NET]
        Dim emp As Employee
        emp = New Clerk()
        Console.WriteLine ("Clerk Salary :{0}", emp.CalculateSalary())
       
        emp = New Manager()
        Console.WriteLine ("Manager Salary :{0}", emp.CalculateSalary())
       

[C#]
       Employee emp;
       emp=new Clerk();
       Console.WriteLine ("Clerk Salary :{0}",emp.CalculateSalary());

       emp=new Manager();
       Console.WriteLine ("Manager Salary :{0}",emp.CalculateSalary());


Here, we have declared a variable of type Employee. A variable of parent class type can point to instance of any of its children. First, we point it to an instance of Clerk class. Then we point it to an instance of Manager class. Even though the variable is of type Employee, depending on which child type it is pointing to it calls the correct implementation of CalculateSalary() method. The underlying system does this via inheritance polymorphism. Similar thing can also be achieved in interface polymorphism.

[VB.NET]
        Dim emp As IEmployee
        emp = New Clerk()
        Console.WriteLine ("Clerk Salary :{0}", emp.CalculateSalary())

        emp = New Manager()
        Console.WriteLine ("Manager Salary :{0}", emp.CalculateSalary())


[C#]
      IEmployee emp;
      emp=new Clerk();
      Console.WriteLine ("Clerk Salary :{0}",emp.CalculateSalary());

      emp=new Manager();
      Console.WriteLine ("Manager Salary :{0}",emp.CalculateSalary());
  

Comments

Post a Comment

Popular posts from this blog

SharePoint 2007 - Simple Task Dashboard

-
Image
example of creating a simple Task Dashboard. This is a pretty basic example of using all OOTB (out of the box) features and combining them to quickly build a solution. Scenario: We want to provide a way for users to easily see a summary of the current project tasks. We want them to be able to see the following information: Open Tasks Assigned to Them Overdue Tasks Tasks Due This Week Task Calendar Tasks Assigned to Others Solution: To build this solution we will be using several different tools available in SharePoint, all included in the list below: Task List Task List Views We will create views for each of the different ways we want to see the data displayed on our dashboard. Web Part Page List View Web Parts Custom Navigation The first thing we will do is create our task lists and then configure all the views that we need. To create the list, go to View All Site Content, Create and then select the Task list. Next, we will need to configure our custom views. To do this, w
Read more

MERGE transformation in SSIS

-
Image
In this post we are gonna discuss about MERGE transformation. MERGE in SSIS is equal to UNION ALL in SQL Server. This transformation unions two datasets/tables.The merge Transformation combines two  sorted  dataset into single dataset. Highlighted the text SORTED in last statement because “It is not possible to use MERGE when the inputs are NOT SORTED”. There is one more transformation which is very similar to this i.e UNION ALL. The Merge Transformation is similar to the union all transformations. Use the union all transformation instead of the merge transformation in the following situations. The transformation inputs are not sorted The combined output does not need to be sorted. The transformation has more than two inputs. MERGE takes ONLY TWO inputs where as UNION ALL can take more than two. Now lets see how to configure MERGE transformation with an example. I created TWO tables with names MergeA and MergeB and inserted few records into each table as shown below.
Read more