Tuesday, July 12, 2011

How to Revise Basic OOPs concepts in C Sharp.Net (Summary only)

RAM RAM Friends

How to Revise Basic OOPs concepts in C Sharp.Net (only syntax and concepts but very less or no description) ) like (types of Constructors,Inheritance,Polymorphism,Abstract Class,Interface,Delegate,Events,Sealed Classes,Overriding, etc)

Here I try to explain different OOPs concepts in C#.NET using examples only with very less description as it is only for revision purpose (both syntax & concept).

Below I have shown my sample console program to use different OOPs concepts

*********ArunKakkarConsoleApp1************************


using System;
using System.Collections.Generic;
using System.Text;

using System.Text.RegularExpressions;

//Using Events Method 1 (a) -->>by Inheriting ArrayList
//below namespace is used form Event learning in c#.Net
namespace myListNamespace
{
    using System.Collections;

    //step 1. delegate type for hooking up change (event)  notification
    public delegate void myDelChangedEventHandler(object sender,EventArgs e);

    public class myListClass : ArrayList
    {
        //step 2. declare event that clients can be used to notified
        //--------whenever the event raised (here elements of list change)
        public event myDelChangedEventHandler myEventChanged;

        //step 3. Raise Event (here whenever elements of list changes)
        protected virtual void myEventRaisedOnChanged(EventArgs e)
        {
            if (myEventChanged != null)
                myEventChanged(this, e);      
        }

        //step 4. create such methods etc which may raise the event
        //below are methods(add,clear,this) which r override as they may change the list
        //& in each method event is invoked
        public override int Add(object value)
        {
            int i= base.Add(value);
            myEventRaisedOnChanged(EventArgs.Empty);
            return i;
        }
        public override void Clear()
        {
            base.Clear();
            myEventRaisedOnChanged(EventArgs.Empty);
        }
        public override object this[int index]
        {
            get
            {
               return base[index];
            }
            set
            {
                base[index] = value;
                myEventRaisedOnChanged(EventArgs.Empty);
            }
        }
    }
}
namespace ArunKakkarConsoleApp1
{
    //below namespace is used to learn Events in C#.Net
    using myListNamespace;

    //Different Types of Constructor
    public class InstanceConstructor
    {
        private int x, y;
        public InstanceConstructor()
        {
            x = 0;
            y = 0;
            Console.WriteLine("in Parameterless contructor,x={0}, y={1}", x, y);
        }
        public InstanceConstructor(int i)
        {
            x = i;
            y = 0;
            Console.WriteLine("In single parameter constructor, x={0}, y={1}", x, y);
        }
        public InstanceConstructor(int i, int j)
        {
            this.x = i;
            this.y = j;
            Console.WriteLine("In double parameter constructor, x={0}, y={1}", x, y);
        }
        ~InstanceConstructor()
        {
            Console.WriteLine("Destructor of class InstanceConstructor is called");
            Console.ReadLine();
        }
    }
    public class myDefaultConstructorClass
    {
        private int _x;
        private string _s;
        public int x
        {
            get
            {
                return _x;
            }
            set
            {
                _x = value;
            }      
        }
        public string s
        {
            get
            {
                return _s;
            }
            set
            {
                _s = value;
            }
        }
        public void myShow()
        {
            //if (_x==null )
            //    Console.WriteLine("X is null");
            //if(_x != null )
                Console.WriteLine("x is not null ,x={0}",_x);          
        }
    }
    public class myPrivateConstructor
    {
        public const double pi = 3.14;
        private myPrivateConstructor()
        {
        }
    }
    public class myStaticConstructorClass
    {
        //Static constructor :
        //Static Constructors are used to instantiate static data fields in the class. Static Constructors are called only once no matter how many instances you create for that class.
        //Static Constructors are executed before any other type of constructor. Static Constructors cannot be called explicitly. They are automatically invoked when
            //An instance of the class is created
            //Any of the static members of the class are referenced
        //It is a compile time error to have access modifiers for static constructors.

        public int j;
        public static int i;

        public myStaticConstructorClass()
        {
            j = 25;
            Console.WriteLine("\n Normal Instance constructor of myStaticConstructorClass is invoked");
        }
     
        static myStaticConstructorClass()
        {
            i = 20;
            Console.WriteLine("\n static constructor of myStaticConstructorClass is invoked");
        }
    }
 
    //Static Class
    public static class myStaticClass1
    {
        public static int myVal;
        //we can declare only static constructor in a static class
        //public myStaticClass1()
     
        //we can not use public etc modifire on the static class constructor
        //public static myStaticClass1()

        //not mandatory to declare constructor for a static class i.e. we can use class without any constructor
        static myStaticClass1()
        {
            myVal = 30;
        }
        public static void myShow()
        {
            Console.WriteLine("\n Hello it is myShow() method of myStaticClass1");
        }
        //we can declare only static members in a static class
        //public void myShow2()
        //{  Console.WriteLine("\nHello it is myShow2() method of myStaticClass1");        }
    }
 
    //Polymorphism & Inheritance (Virtual->Override,  Virtual->Override->Sealed, on creating instance of child class,sequence of constructor invoked 1. GrandParent 2.Parent 3.Child)
    public class myParent
    {
        private string s;
        //protected myParent()
        public myParent()
        {
            s=@"This is a string from parent class have both \ and & signs";
            Console.WriteLine("This is myParent class constructor");
        }

        public string ParseBackSlash()
        {
            string s1;
            s1=s;
            s1=s1.Replace("\\",string.Empty);
            return s1;
        }
        public virtual void ShowMsg()
        {
            Console.WriteLine("This is showmsg from myParent class");      
        }
        public virtual void myShowMsg5()
        {
            Console.WriteLine("this is myShowMsg5 method of myParent class");
        }
    }
    public class myChild1 : myParent
    {
        public string ParseAmpersand()
        {
            string s2;
            s2 = base.ParseBackSlash();
            s2 = s2.Replace("&", string.Empty);
            return s2;
        }
        public override void ShowMsg()
        {
            Console.WriteLine("This is showmsg from myChild1 class");      
        }
        public sealed override void myShowMsg5()
        {
           //base.myShowMsg5();
            Console.WriteLine("This is override sealed method myShowMsg5 which is originally of myParent class");

        }
    }
    public class myChild2 : myParent
    {
        public myChild2()
        {
            Console.WriteLine("This is myChild2 class constructor");      
        }

        public override void ShowMsg()
        {
             //base.ShowMsg();
            Console.WriteLine("this is ShowMsg method of myChild2 class");
        }

        public void myShowAns()
        {
            Console.WriteLine("This is myShowAns method of myChild2 class");
        }
    }
    public class myGrandChild1 : myChild2
    {
        public myGrandChild1()
        {
            Console.WriteLine("This is constructor of myGrandChild1 class, its parent class is myChild2, its grandParentClass is myParent");
        }  
    }
 
    //Interface handling
    public interface myInterface_1
    {
        //i/f can't contain fields
        //protected int x;
        string id
        {
            get;
            set;
        }
     
        void myShowResult();

        //if we declare this here & do not implement it & use i/f then show compile time error
        //void myWish();  
    }
    interface myInterface_2
    {
        void myShowResult();
    }
    public class myClassUsingInterface1 :myInterface_1
    {
        protected string  x;
        public string id
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        public myClassUsingInterface1()
        {
            Console.WriteLine("this is constructor of myClassUsingInterface1");
        }
        public void myShowResult()
        {
            Console.WriteLine("This is myshowResult of myInterface_1 implement by myClassUsingInterface1");
        }
    }
    public class myClassUsingInterface2 : myInterface_1, myInterface_2
    {
        string  x;
        public string id
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        public void myShowResult()
        {
            Console.WriteLine("This is myShowResult method which is common in both myInterface_1 & myInterface_2 implement by myClassUsingInterface2");
        }
    }
    //Explicitly members of interfaces
    public class myClassUsingInterface3 : myInterface_1, myInterface_2
    {
        string y;
        public string id
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }      
        }

        //Explicitly members of interfaces>>>> we can't use public etc keywords
        void myInterface_1.myShowResult()
        {
            Console.WriteLine("This is myInterface_1.myShowResult() method called");
        }
        void myInterface_2.myShowResult()
        {
            Console.WriteLine("This is myInterface_2.myShowResult() method called");
        }  
    }
 
    //Abstract Class
    public abstract class myAbstractClass
    {
        public void myShowMessage()
        {
            Console.WriteLine("my showmsg method of myAbstractClass class");      
        }
        public abstract  void myShowMessage2();
    }
    public class myChild3 : myAbstractClass
    {
        public void myShowMessage3()
        {
            base.myShowMessage();
            Console.WriteLine("This is myShowMessage3 method of myChild3 class");
        }
        public override void myShowMessage2()
        {
            //base.myShowMessage2();
            Console.WriteLine("This is from myShowMessage2 override by myChild3 class");
        }  
    }
 
    //Sealed Classes
    public sealed class myChild4 : myChild3
    {
        public int myAddNumbers(int x, int y)
        {
            return x + y;
        }
        public void myShowMsg4()
        {
            Console.WriteLine("this is myShowMsg4 from sealed class myChild4");      
        }

        public void myShowMsg5(int i)
        {
            Console.WriteLine("myShowMsg5 called with i=" + i);
        }
        public void myShowMsg6(int j)
        {
            Console.WriteLine("myShowMsg6 called with j={0}", j);
        }    
    }

    //5. Delegates  & events
    //(publisher [who declare/create event & told all subscriber that a particular event is raised]
    //& subsriber(who write code for event handler))

    //Using Events Method 1 (b) -->>by Inheriting ArrayList
    public class myEventListner
    {
        //step 5. class that listen the events raised by event class
        private myListClass myList;

        //step 6. create method that acts as event handler
        //called whenever list changes
        private void myListChanged(object sender, EventArgs e)
        {
            Console.WriteLine("myListChanged method is called when event(change in list) fired");
        }
        public myEventListner(myListClass myL1)
        {
            myList = myL1;
            //step 7. add events
            myList.myEventChanged += new myDelChangedEventHandler(myListChanged);
        }
        public void myDetach()
        {
            //step 8. Detach the event & delete the list
            myList.myEventChanged -= new myDelChangedEventHandler(myListChanged);
            myList = null;
        }
    }

    //Using Events Method 2 -->> Events as Publisher & Subscriber
    public class myPublisher      
    {
        //using System.Windows.Forms
        public delegate void myDelegate2(object from, EventArgs args);
        public event  myDelegate2  myEvent;
        public void myRaiseMyEvent(EventArgs args)
        {
            myEvent(this, args);
        }

        public void SendTheEvent()
        {
            Console.WriteLine("The event is fired here in SendTheEvent method of publisher class");
            this.myRaiseMyEvent(new EventArgs());      
        }
    }
    public class mySubscriber
    {
        private void myHandleMyEvent(object sender, EventArgs args)
        {
            Console.WriteLine("myEvent is handled in the myHandleMyEvent of the mySubscriber class");
            Console.WriteLine("who is the sender ? " + sender.GetType());
        }
        public mySubscriber()
        {
            myPublisher p1 = new myPublisher();
            p1.myEvent += new myPublisher.myDelegate2(myHandleMyEvent);
            p1.SendTheEvent();
        }
    }

    //Using Events Method 3 --->> Event using built-in event delegate "EventHandler"
    public class myEventPublisherWithDefaultDelegate
    {
        //For events that do not use any additional information, the .NET Framework has already defined an
            //appropriate delegate type: EventHandler.

        //If we not use EventHandler keyword, we need to define a Delegate(say myEvent2Delegate) eqvivalent to EventHanler
        private string _myVal;
        public event EventHandler myEvent2;
        public void myEvent2Raiser(EventArgs e)
        {
            myEvent2(this, e);
        }
        public string myVal
        {
            get
            {
                return _myVal;
            }
            set
            {
                _myVal = value;
                this.myEvent2Raiser(new EventArgs());
            }
        }
    }
    public class myEventSubscriberWithDefaultDelegate
    {
        public void myEvent2Handler(object sender, EventArgs e)
        {
            Console.WriteLine("\nThis is myEvent2Handler called since Event myEvent2 is raised");
            Console.WriteLine("\n It is called by = " + this.GetType());
        }
        public myEventSubscriberWithDefaultDelegate()
        {
            myEventPublisherWithDefaultDelegate p1 = new myEventPublisherWithDefaultDelegate();
            p1.myEvent2 +=new EventHandler(this.myEvent2Handler);
            p1.myVal ="ram Ram";
            p1.myVal +=" Hare Ram";
        }
    }

    class Program
    {
        //Delegate Handling ( Single Cast,  MultiCast )
        public delegate int myDel(int a, int b);
        public delegate void myDel2();
        public delegate void myMultiCastDel(int m);

        static void Main(string[] args)
        {            
            //------------------------ Topics ---------------------------------------------------------------
            //OOPS CONCEPTS
            //1. Types of Constructor (a. Default, b. Instance, c. Private, d. Static) & Destructor
            //2. Types of Classes 
                //a. Static, 
                //b. Abstract {(abstract & override) & abstract methods}, 
                //c. Sealed  (can not be inherited) & sealed override methods
                //complete syntax of a class with all options explained
            //3. Inheritance (Virtual & override), properties, static variables, private,protected,public variables etc
            //4. Polymorphism, Early/Static/CompileTime Binding & Late/Dynamic/Runtime Binding
            //5. Interface & Explicitly declaration
            //6. Delegate (Signle Cast & MultiCast)
            //7. Events
            //-------------------------------            
            //8. Regular Expression
            //9. Number To Words
            //10.Webservice
            //-------------------------------------------------------------------------------------

            //1(a). Type of Constructors-->Instance Constructor
            InstanceConstructor ic1 = new InstanceConstructor();
            InstanceConstructor ic2 = new InstanceConstructor(3);
            InstanceConstructor ic3 = new InstanceConstructor(4,5);

                //Destructor
            ic1 = null;
            GC.Collect(); //Call Garbage collector

            //1(b). Type of Constructors-->Default Constructor
            myDefaultConstructorClass dc1 = new myDefaultConstructorClass();
            Console.WriteLine(" before giving values, x={0},s={0}", dc1.x, dc1.s);
            dc1.myShow();
            dc1.x = 25;
            dc1.s = "Arun Kakkar";
            Console.WriteLine("After giving values, x={0},s={1}", dc1.x, dc1.s);
            dc1.myShow();

            //1(c). Type of Constructors-->Private constructor
            Console.WriteLine("private class value, x=" + myPrivateConstructor.pi);
            Console.ReadLine();

            //1(d). Type of Constructors-->Static Constructor
            Console.WriteLine("mystaticConstructorClass class value, x={0}", myStaticConstructorClass.i);
            Console.ReadLine();

            myStaticConstructorClass scs1=new myStaticConstructorClass();
            Console.WriteLine("\n j={0} and i={1} in myStaticConstructorClass ",scs1.j ,myStaticConstructorClass.i);
            Console.ReadLine();

            //2(a). Types of Classes---> Static Class            
            myStaticClass1.myShow();
            Console.WriteLine("\n MyVal of myStaticClass1 is=" + myStaticClass1.myVal);
            myStaticClass1.myVal = 23;
            Console.WriteLine("\n MyVal after updation of myStaticClass1 is=" + myStaticClass1.myVal);

            //2(b). Types of Classes---> Abstract class 
            myChild3 ch3 = new myChild3();
                //string s1 = "below";
                //s1 = "ch3.myShowMessage=" + ch3.myShowMessage() + "\n";
                //s1 += "ch3.myShowMessage2=" + ch3.myShowMessage2() + "\n";
                //s1 += "ch3.myShowMessage3=" + ch3.myShowMessage3();
            Console.WriteLine("various functions called by myChild3 class of parent abstract class are as below \n");
            ch3.myShowMessage();
            ch3.myShowMessage2();
            ch3.myShowMessage3();

            //2(c). Types of Classes---> Sealed classes 
                //(can not be inherited)
                //A sealed class can not be used as "base class"
                //A sealed class can not be an abstract class.
                //sealing a class means one(class) can not be driven(drived) from it
                // In C# structs are implicitly sealed.
                //In C# methods can't be declared as sealed but when we override a method(in derived class), 
                //we can declared the overriden method as sealed thus we cannot override this method further

                //public virtual void m1();  in any parent class
                //public override sealed void m1() in the child class

            myChild4 ch4 = new myChild4();
            ch4.myShowMsg4();

            //override Sealed method
            myChild1 ch1 = new myChild1();
            ch1.myShowMsg5();

            //3. Inheritance (Virtual & override), properties, static variables, private,protected,public variables etc ***************
                //1. when we create child class instance, then first parent class constructor is called then child class constructor is called
                //    & they (Constructors) are called in order from top to down sequentially.
                //2. "this" keyword show all methods,etc of both current class & all its parent class >>>this.myShowMsg()
                // but "base" keyowrd show methods of only parent class >>>base.myShowMsg()
                //3. if u don't give any modifiers to constructor,variables they are "private" by default
                //4. if both current class & parent class have same name funtion without using "virtual" keyword in the parent, we get compile time error
            myChild1 c1 = new myChild1();
            c1.ShowMsg();
            Console.WriteLine("the parsed string is=" + c1.ParseAmpersand());
            
            myChild2 c2 = new myChild2();
            c2.myShowAns();

            myGrandChild1 mgc1 = new myGrandChild1();
            mgc1.myShowAns();
            mgc1.ShowMsg();

            //4. Polymorphism, Early/Static/CompileTime Binding & Late/Dynamic/Runtime Binding
                //Polymorphism=>Through inheritance, a class can be used as more than one type;
                // it can be used as its own type, any base type, or any interface type if it 
                //implements interface. This is called Polymorphism.
            myParent myP1 = new myParent();
            myChild1 myCh1 = new myChild1();
            myChild2 myCh2 = new myChild2();

                //Early/Static/CompileTime binding
            Console.WriteLine("\n Below are Early Binding ShowMsg calls from myparent,child1,child2 classes");
            myP1.ShowMsg();
            myCh1.ShowMsg();
            myCh2.ShowMsg();
             
            //Late/Dynamic/Runtime binding
            myParent[] myP2 = new myParent[3];
            myP2[0] = new myParent();
            myP2[1] = new myChild1();
            myP2[2] = new myChild2();

            Console.WriteLine("\n Below are Late Binding ShowMsg calls from myparent,child1,child2 classes");
            for (int i = 0; i <= 2; i++)
            {
                myP2[i].ShowMsg();
            }
                    //below can be used instead of above loop
                    //myP2[0].ShowMsg();
                    //myP2[1].ShowMsg();
                    //myP2[2].ShowMsg();

            //5. Interface & Explicitly declaration
                //1. all methods of i/f must be implement by class implement i/f else get compile time error
                //2. inside i/f>>  void myShowMsg(); is enough i.e. no need to be public etc
            myClassUsingInterface1 cui1 = new myClassUsingInterface1();
            cui1.myShowResult();
            cui1.id = "ram ram";
            Console.WriteLine("Value of cui1.id=" + cui1.id);

            myClassUsingInterface2 cui2 = new myClassUsingInterface2();
            cui2.myShowResult();

                //Explicitly members of interfaces
            myClassUsingInterface3 myif3 = new myClassUsingInterface3();
            myif3.id = "ram ram ji from myIf3";
            Console.WriteLine("calling myif3.id=" + myif3.id);

            myInterface_1 myinterface1 = (myInterface_1)myif3;
            myInterface_2 myinterface2 = (myInterface_2)myif3;

            myinterface1.myShowResult();
            myinterface2.myShowResult();
            Console.WriteLine("calling myinterface1.id={0}", myinterface1.id);

            //6. Delegate (Signle Cast & MultiCast)
                //delegate are derived from System.Delegate
                //below line declared above the void main method
                //public delegate int myDel(int a, int b);
            myDel d1=new myDel(ch4.myAddNumbers);
            Console.WriteLine("addition of 20 & 30 using delegates is=" + d1(20, 30));

                //SingleCast delegate
            myDel2 d2 = new myDel2(ch4.myShowMessage);
            Console.WriteLine("void method using delegate is=\n");
            d2();

                //MultiCast Delegate
                //call more than one kind of method in sequence but problem is only same value of parameter is passed in all methods
            Console.WriteLine("Below line show multicast delegate result\n");
            myMultiCastDel d3 = new myMultiCastDel(ch4.myShowMsg5);
            d3 += new myMultiCastDel(ch4.myShowMsg6);
            d3(3);

            //7(a). Events  --->Method 1
                //Event handling using UserDefined EventDelegate
            Console.WriteLine("\nBelow line show delegate and events combination result");
            mySubscriber sub1 = new mySubscriber();

            //7(b). Events  --->Method 2
                //Event Handling using Default (DotNet framework provided EventDelegate named 'EventHandler')
            Console.WriteLine("\nBelow line shows event handling with default in-built EventDelegate named 'EventHandler'");
            myEventSubscriberWithDefaultDelegate mySub1 = new myEventSubscriberWithDefaultDelegate();

            //7(c). Events  --->Method 3
                //create new list to test Events in C#.Net
            myListClass myL = new myListClass();
                //create class that listen event (whenver list item changed) of list 
            myEventListner myE = new myEventListner(myL);
                //Add & remove items from the list
            Console.WriteLine("\nThis line before any event is fired in list class");
            myL.Add("item 1");
            Console.WriteLine("\nThis line after adding item 1 in list class");
            myL.Add("item 2");
            Console.WriteLine("\nThis line after adding item 2 in list class");
            myL.Clear();
            Console.WriteLine("This line after clearing all items in list class");
            myE.myDetach();
            Console.WriteLine("This line after detaching event from the myEventLister class");

            //8. Regular Expression
            Console.WriteLine("Please enter any alphanumeric word only it can include underscore(_) also=");
            string s = Console.ReadLine();
            string r = @"^[\w]+$";
            if (Regex.IsMatch(s, r))
            {
                Console.WriteLine("You have entered an alphanumeric word=" + s);
            }
            else
            {
                Console.WriteLine("Its a wrong word please enter only Alphanumeric word");
            }
            Console.ReadLine();   // just like getch() in C++
         
            //10.Webservice calling --Webservice1    
            localhostAK.ArunKakkarwsCustomers myWS = new localhostAK.ArunKakkarwsCustomers();
            Console.WriteLine("customer name from WebService localhostAK.ArunKakkarwsCustomers is {0}", myWS.GetCustomerName(2));

                //webservice 2
            AKWebService_1.ArunKakkarWebServices akws1 = new AKWebService_1.ArunKakkarWebServices();
            Console.WriteLine("Addition of {0} and {1} from WebService AKWebService_1.ArunKakkarWebServices is {2}",5,9, akws1.Add2IntNo(5,9));

            //globalweather_NetWS   webservice 3 download from net with link http://www.webservicex.com/globalweather.asmx?WSDL
            string myCountry;
            GlobalWeather_NetWS.GlobalWeather gw = new GlobalWeather_NetWS.GlobalWeather();
            Console.WriteLine("\nEnter country name to get list of its all cities");
            myCountry = Console.ReadLine();
            //it return a dataset in xml format
            Console.WriteLine("\n Various cities in {0} are {1}", myCountry, gw.GetCitiesByCountry(myCountry));


            Console.ReadLine();
        }
    }
}




I hope, it would help those who want to just quickly revise OOPs concepts (both syntax & use).
Due to lack of time, I did not provide, description of various terms.

Wish you best of luck for good programming.

No comments:

Post a Comment