repterX

Polymorphism is one of the most impotent feature of OOP that is used to exhibit different form of any particular procedure. With the help of polymorphism , you can use one procedure as many whys as per your requirement.

let's consider it with an example :

you can make a procedure for calculating  the area of geometrical figure and can calculate the are of circle , triangle , or rectangle with same procedure and different parameters for each geometrical figure.

the advantages of polymorphism are as follow:

• Allow you to invoke methods of a derived class through base class reference during runtime.
• Provide different implementation of method in a class that are called through the same name.

• declare the base class method as "virtual"
• Implement the derived class method using the "override" keyword.

The most important reason to use object oriented programming (OOP's) is that , it's supports INHERITANCE. Inheritance is the property in which through a class derived properties from another class. A class that's inherit the properties of another class is called a child or derived class , whereas , the class from which a child class inherit is called as base or parent class. A parent class is the higher level in class hierarchy.

INHERITANCE IS OF FOUR TYPE , WHICH ARE AS FOLLOW:

single inheritance: In which t , there is only one base class or one derived class. This means that a derived class inherit the properties from single base class.

Hierarchical inheritance: In which , multiple derived class are inherit from single base class.

Multilevel inheritance: In which , a child class is derived from a base class , which is turned is derived from another class.

Multiple inheritance: In which , a child class derived from multiple base class.

showing the code how to impement inheritance in C# application

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

namespace inheritance.cs
{
    public class baseclass
    {
        public int datamember;
        public void baseclassmode()
        {
            Console.WriteLine("i am a base class method()");
        }
    }
        public class derivedclass : baseclass
        {
            public void derivedclassmethod()
            {
                Console.WriteLine("i am a derived class method()");
            }
        }
    class Program
    {
        static void Main(string[] args)
        {
            // create a base class object..
            Console.WriteLine("i am accessing base class object..");
            baseclass bc = new baseclass();
            bc.datamember = 1;
            bc.baseclassmode();
            Console.WriteLine("=====================================");
            // create a derived class object..
            Console.WriteLine("i am accessing derived class object..");
            derivedclass dc = new derivedclass();
            dc.datamember = 2;
            dc.baseclassmode();
            dc.derivedclassmethod();
            Console.WriteLine("press enter to quit..");
            Console.ReadKey();
        }
    }

}

value type :

value type are allow you to store the data directly into the variable. They are derived from SYSTEM.VALUETYPE and have a special behavior in Common Language Run-time ( CLR). The value type and their content are stored same location in memory. The default value of value types are stored in stack. int

struct type:

structs types are a special of objects having the properties of value types. As you know that the value types are stored on the stack; inherently the struct types are also stored on the stack.
                                                                       The structs type encapsulate small group of related variable , such as , the name , rollno , age , class name , and section of a student. They can contain constructor , method , properties , operator , event , nested types , indexers , constant and field. While creating the struct type , you should remember that struct members can not be declared as protected as they fail to support inheritance. Under the struct declaration , the field can be initialized only when they are declared as const or static.

the following code shows how to create "struct type":

public struct student 
{
  string name;
  int rollno;
  int classname;                       // fields
  int section;
.........        // method
............ , , // properties
 }
enumeration type:

Enumeration are the user-defined integer data type that are declared using the enum keyword. Using enumeration , you can defined a set of named integral that can be assigned to a variable.
for example :
                         Traffic light have three possible states -- the green light indicating go , the yellow light indicating to get prepared to stop , and the red light to indicating to stop. A traffic light have one of these three states at a time , implying that the traffic light can be only  red , yellow , and green at a time. In such case , you can defined enumeration type variable and assign three value in it.

the following code shows how to create enumeration type :

enum trafficlight
{ red , green , yellow };

to use enumeration type you need to declared a variable of new enumeration type , as showing in the code :

trafficlight t1;

the trafficlight enumeration can take any of the three values , red, green, and yellow.

t1 = trafficlight.red
t1 = trafficlight.green
t1 = trafficlight.yellow

Enumeration by default , being with the value of 0 for the first entry. However you can modify this value by entering a different value for the first entry , as shown in the code:

enum trafficlight
{
  red = 1, green , yellow
}

showing the code for how to use enumeration in C-sharp application

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

namespace enumeration.cs
{

    public enum color { red = 1, green, yellow };
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("plese select 1 for red 2 for green 3 for yello");
            string str = Console.ReadLine();
            int colInt = Int32.Parse(str);
            color col = (color)colInt;
            switch (col)
            {
                case color.red:
                    {
                        Console.WriteLine("the selected color is red..");
                    }
                    break;
                case color.green:
                    {
                        Console.WriteLine("the selected color is green..");
                    }
                    break;
                case color.yellow:
                    {
                        Console.WriteLine("the selected color is yellow..");
                    }
                    break;
                default:
                    {
                        Console.WriteLine("invalid option..");
                    }
                    break;
            }
            Console.ReadKey();
        }
    }

}

what is identifiers and keywords:

In C# , an identifiers is a sequence of character used in identify the variable , constant , or any user defined programming element. An identifiers starts with a letter or an underscore and end with a character. C# identifiers are case sensitive , which means , the variable names sum , Sum , and SUM all three are different from each other.

you must remember the following rules while creating identifiers:

1. An identifiers must begin either with a letter or underscore.
2. An identifiers cane have letter , digits , and underscore.
3. An identifiers must not be a reserved word ( keyword in C# ).
4. An identifiers must be a complete word without any blank space.

We know that visual c# , commonly known as C#, intermediate programming language use to create executable programs. It's an object-oriented programming language , which is combine of power and efficiency of C++ , simplicity and object-oriented approach of JAVA , and creativeness of VISUAL BASIC. Similar to java , C# does not use the multiple inheritance and pointers but provides the garbage collection at run time.