C# Collections (Stack)

---

Collections:

------------
Collection is defined as collection of values.
Collections are broadly classified into two type:
1.Collections that Does Not support random accessing.
Example:
         stack, queue
1.Collections that support random accessing.
Example:
         array, array list, hashtable

Include namespace System.Collections;

Collections that Does Not support random accessing:

1.Stack:

--------

      Stack follows the principle of First In Last Out(FILO) or Last In First Out(LIFO)

The following three operations performed on a stack.

1.Push():  Inserting an element into the stack.

1.Pop():   Deleting an element from the stack.
1.Peek(): Checking the top of the element of the stack.

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

namespace ConsoleApplication23
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack s = new Stack(4);

            s.Push(45);
            s.Push(12);
            s.Push(6);
            s.Push(8);

            Console.WriteLine("No. of elements: " + s.Count);

            IEnumerator ie = s.GetEnumerator();

            Console.WriteLine("Stack Elements are: "+"\n"+"-------------");
            while (ie.MoveNext())
                Console.WriteLine(ie.Current);

            Console.WriteLine("Element deleted from the stack: " + s.Pop());

            Console.WriteLine("Elements in stack after pop( )");
            ie = s.GetEnumerator();
            while (ie.MoveNext())
                Console.WriteLine(ie.Current);

            Console.WriteLine("element on the stack top: " + s.Peek());
        }
    }
}

C# Checked and Unchecked Operators

---

Checked and Unchecked Operators:
--------------------------------

Checked Operators:
------------------
Checked operator generates an overflow exception at run time, if an exception exceeds arithmetic limit of that type.

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

namespace ConsoleApplication21
{
    class demo
    {
        static short s = 32767;

        public int find()
        {
            checked   // checked
            {
                int z = (short)(s + 12);
                return z;
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            demo d=new demo();
            Console.WriteLine(d.find());
        }
    }
}

Unchecked operator:
-------------------
Unchecked operator disables the arithmetic checking at compile time and results of the most significant bits are disabled and the execution continues.

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

namespace ConsoleApplication21
{
    class demo
    {
        static short s = 32767;

        public int find()
        {
            unchecked   // unchecked
            {
                int z = (short)(s + 12);
                return z;
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            demo d=new demo();
            Console.WriteLine(d.find());
        }
    }
}

C# Params Array

---

params array:
-------------
If a method takes params array as a parameter, that parameter can accept any number of arguments.

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

namespace ConsoleApplication20
{
    class demo
    {
        public void add(params int[] a)
        {
            int sum = 0;

            for (int i = 0; i < a.Length; i++)
            {
                sum = sum + a[i];
            }
            Console.WriteLine("Sum of " + a.Length + " numbers is " + sum);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            demo d = new demo();
            d.add(56, 4);
            d.add(1, 2, 3, 4, 5);
            d.add(6, 9, 3);
        }
    }
}

C# Constants

---

Constants:
----------
A value which does not change during the execution of a program is known as constant.
Constants are used in a situations, the value is known when we write a program.
A constant can be based on another constant, but it does no based on value of a variable or a method.
Example:
         const int x=5;    //valid declaration
         const int y=x+3;  //valid declaration

         int y=6;        //valid declaration
         const int x=y+7; //Invalid declaration

At compile time the compiler replaces the occurrence of each constant with a literal value. 
Constants are static by default.

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

namespace ConsoleApplication19
{
    class values
    {
     public   const int x = 4;
      public  const int y = x + 3;
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Sum: " + (values.x + values.y));
        }
    }
}

C# Multicast delegates

---

Multicast Delegate:
-------------------
A single delegate contains several methods in its invocation list is called multicast delegate.
Since a single delegate can return only one value at a time, the return type of the delegate declaration must be void because a delegate contains several methods in its invocation list.
To add a new method to the invocation list use +=
Example:
         mydel m1+=new mydel(arith_oper.add);
To remove a method from the invocation list use -=
Example:
         mydel m1-=new mydel(arith_oper.prod);      

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

namespace ConsoleApplication18
{
    class arith_oper
    {
        public static void add(int a, int b)
        {
            Console.WriteLine("Sum: " +(a + b));
        }

        public static void prod(int a, int b)
        {
            Console.WriteLine("Product: "+ (a * b));
        }

        public static void diff(int a, int b)
        {
            Console.WriteLine("Difference: " + (a - b));
        }
    }
    class Program
    {
        public  delegate void mydel(int a,int b);
        static void Main(string[] args)
        {
            mydel m1 = new mydel(arith_oper.add);

            m1 += new mydel(arith_oper.diff); 

            m1 += new mydel(arith_oper.prod);

            m1(6, 2);

            m1 -= new mydel(arith_oper.prod);
            m1(7, 3);
        }
    }
}

C# Delegates

---

Delegates:
----------
Delegates are references to methods.
Syntax:  

     visibility-mode delegate-return-type delegate-name(parameters-list);
Example:
     public delegate int mydel(int a,int b);
Here delegates declared is converted internally into a class and that class will be made as a sub class of System.MulticastDelegate and Sysytem.MulticastDelegate is a sub class of System.Delegate;
Every delegate declaration is associated with a method or prototype and it contains a method Invoke(). 
Invoke() signature will be same as that of the delegate.

class arith_oper
    {
        public static int add(int a, int b)
        {
            return(a + b);
        }

        public static int prod(int a, int b)
        {
            return(a * b);
        }
    }
    class Program
    {
        public  delegate int mydel(int a,int b);
        static void Main(string[] args)
        {
            mydel m1 = new mydel(arith_oper.add);

            mydel m2 = new mydel(arith_oper.prod); 

            Console.WriteLine("Sum: " + m1(2 - 3));  

            Console.WriteLine("Product: " + m2.Invoke(6 - 8)); 

        }
    }

C# Array (Jagged Array)

---

Jagged Array:
Collection of one dimensional array.
syntax:
       data_type[]][] array_name = new data_type[row_size][];

example:
       int[][] a = new int[3][];

In jagged array, we can specify only the rows.
Save the memory

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

namespace Arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            int[][] a = new int[3][];

            a[0] = new int[] { 2, 3 };
            a[1] = new int[] { 7 };
            a[2] = new int[] { 21, 67, 45 };

            for (int i = 0; i < a.Length; i++)
            {
                Console.WriteLine("Array-" + i); 
                for (int j = 0; j < a[i].Length; j++)
                {
                    Console.WriteLine(a[i][j]);
                }
                Console.WriteLine();
            }

        }
    }
}

C# Array (Multidimensional Array)

Multidimensional Array:
Contains rows and columns.
syntax:

        data_type[,] array_name = new data_type[row_size,column_size];

example:  
        int m=2,n=2;
        int[,] a = new int[m,n];

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

namespace Arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter the size of the matrix");
            int m = int.Parse(Console.ReadLine());
            int n = int.Parse(Console.ReadLine());

            Console.WriteLine("Matrix Size: " + m + " X " + n);

            int[,] a = new int[m, n];


            Console.WriteLine("Enter " + (m * n) + " elements");
            for (int i = 0; i < m; i++)
                for (int j = 0; j < n; j++)
                    a[i, j] = int.Parse(Console.ReadLine());

            Console.WriteLine("Matrix" +"\n"+ "--------");

            //GetLength(0) return number of rows.        
            for (int i = 0; i < a.GetLength(0); i++)
            {

                //GetLength(1) returns number of columns.
                for (int j = 0; j < a.GetLength(1); j++)
                {
                    Console.Write(a[i, j] + "\t");
                }
                Console.WriteLine();

               
            }
            //Rank returns dimension of an array.    
            Console.WriteLine("Rank of a Matrix: " + a.Rank);
        }
    }
}

C# Array (One Dimensional Array)

Arrays:
An array is a collection of homogeneous data element.
Types of arrays:
1. One dimensional array
2. Two dimensional array
3. Jagged array

One dimensional array
syntax:   data_type[] array_name = new data_type[size];

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

namespace Arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter the number of elements");
            int n = int.Parse(Console.ReadLine());

            int []a=new int[n];
            
            Console.WriteLine("Enter " +n+" elements one by one");
            for (int i = 0; i < a.Length; i++)
                a[i] = int.Parse(Console.ReadLine());

            Console.WriteLine("Entered elements are");
            for (int j = 0; j < a.Length; j++)
                Console.WriteLine(a[j]);

            Array.Reverse(a);
            Console.WriteLine("Reversed elements are");
            for (int j = 0; j < a.Length; j++)
                Console.WriteLine(a[j]);

            Array.Sort(a);
            Console.WriteLine("Sorted elements are");
            for (int j = 0; j < a.Length; j++)
                Console.WriteLine(a[j]);

            Console.WriteLine("Enter the key element to be searched");
            int key = int.Parse(Console.ReadLine());

            Console.WriteLine("key element: " +key);

            int index=Array.BinarySearch(a, key);

            if (index > 0)
                Console.WriteLine(key + " present at the " + (index + 1) + " position");
            else
                Console.WriteLine(key + " not present in the list");
        }
    }
}

C# Boxing and Unboxing

Boxing and Unboxing:
Conversion from value type to a reference type is called Boxing.
Conversion from reference type is called Unboxing.

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

namespace BoxingAndUnboxing
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 10;
            string s = a.ToString(); //boxing
            Console.WriteLine("Boxing: " + s);

            int b = Convert.ToInt32(s); //unboxing
            Console.WriteLine("Unboxing: " + b);



        }
    }
}

C# Reference Types

Reference Types:
Reference types are allocated on heap memory 
example: strings, arrays, interfaces, class, delegates events ...

person p1= new person();
person p2=new person(); 
p2=p1;
when we copy one object to another, two copies are stored on stack but both are pointing to the same block of memory on heap.
Reference type contain default value.

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

namespace ReferenceTypes
{
    class Program
    {
        class value
        {
            public   int x;
        }

        static void Main(string[] args)
        {
            value v = new value();
            Console.WriteLine(v.x);
        }
    }
}

C# Structure

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

namespace Structures
{
    struct person
    {
        string name;
        int age;

        public person(string name,int age) 
        {
            this.name = name;
            this.age = age;
        }

        public void print()
        {
            Console.WriteLine("Name: " + name + "\n Age: " + age);
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            person p = new person("Kamran",24);
            p.print();
            
        }
    }
}

C# Enumeration

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

namespace Enumerations
{
    enum quali {BE,MCA,MBA,MS}

    enum desig{Engineer=15000,Lecturer=25000,Manager=40000,TeamLead=60000}

    class employee
    {
        public quali Quali;
        public desig Desig;

        public employee(quali Quali, desig Desig)
        {
            this.Quali = Quali;
            this.Desig = Desig;
        }
    }

    class Program
    {
        static void Main(string[] args)        
        {
            employee emp = new employee(quali.MCA, desig.Lecturer);
            Console.WriteLine("Qualification: " + emp.Quali);
            Console.WriteLine("Designation: " + emp.Desig);
            Console.WriteLine("Salary: " + (int)emp.Desig);

        }
    }
}

C# Exception Handling (Nested Try)

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

namespace ExceptionHandling
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Enter a value");
                int a = int.Parse(Console.ReadLine());

                try
                {
                    Console.WriteLine("Enter one more inetger value");
                    int b = int.Parse(Console.ReadLine());
                    Console.WriteLine("result: " + (a / b));
                }
                catch (FormatException e)
                {
                    Console.WriteLine(e.Message);
                }
            }

            catch (DivideByZeroException e)
            {
                Console.WriteLine(e.Message);
            }              

        }
    }
}

C# Exception Handling (User Defined Exception)

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

namespace ExceptionHandling
{
    class pos_val : Exception
    {
        
        public pos_val(string msg)
            : base(msg)
        {
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Enter Integer Value");
                int a = int.Parse(Console.ReadLine());

                if (a < 0)
                    throw new pos_val("Enter Positive Numbers Only");
                else
                    Console.WriteLine("Value: " + a);
            }
            catch (pos_val e)
            {
                Console.WriteLine(e.Message);
            }

            finally
            {
                Console.WriteLine("End of a Program");
            }


        }
    }
}

C# Exception Handling (Exception)

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

namespace ExceptionHandling
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int a = int.Parse(args[0]);
                int b = int.Parse(args[1]);
                Console.WriteLine("Result: " + (a / b));
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            
        }
    }
}

C# Exception Handling (DivideByZeroException)

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

namespace ExceptionHandling
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Enter two numbers:");
                int a = int.Parse(Console.ReadLine());
                int b = int.Parse(Console.ReadLine());
                Console.WriteLine("Result: " + (a / b));
            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

C# Exception Handling (FormatException)

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

namespace ExceptionHandling
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Enter two integer values");
                int a = int.Parse(Console.ReadLine());
                int b = int.Parse(Console.ReadLine());
                Console.WriteLine("Sum of two numbers: " + (a + b));
            }
            catch (FormatException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

C# Interface (2)

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

namespace Interfaces2
{
    interface university
    {
        void uni_details(string uname);
    }

    interface college
    {
        void col_details(string cname,string loc);
    }

    class student : university, college
    {
        string name, cname, uname, course, loc;

        int s1, s2, s3, age;

        public void uni_details(string name)
        {
            uname = name;
        }

        public void col_details(string name, string location)
        {
            cname = name;
            loc = location;
        }

        public void read(string name, int s1, int s2, int s3, string course, int age)
        {
            this.name = name;
            this.s1 = s1;
            this.s2 = s2;
            this.s3 = s3;
            this.course = course;
            this.age = age;
        }

        public void cal()
        {
            int sum = s1 + s2 + s3;
            double avg = (double)(sum / 3.0);
            Console.WriteLine("Name: " + name + "\n" + "Age: " + age + "\n" + "Course: " + course);
            Console.WriteLine("University: " + uname);
            Console.WriteLine("Subject-1: " + s1 + "\n" + "Subject-2: " + s2);
            Console.WriteLine("Subject-3: " + s3);
            Console.WriteLine("Total: " + sum);
            Console.WriteLine("Average: " + avg);
        }
    }



    class Program
    {
        static void Main(string[] args)
        {
            student s = new student();
            s.uni_details("Azad University");
            s.col_details("Komeil", "Shahr-e Kord");
            s.read("Kamran", 97, 89, 84, "M.Sc", 24);
            s.cal();
        }
    }
}

C# Extending an interface

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

namespace ExtendingAnInterface
{

    interface values
    {
        void input(int a,int b);
    }

    // extending an interface
    interface shape : values
    {

        void area();
    }

    class rect : shape
    {
        int l, w;

        public void input(int a, int b)
        {
            l = a;
            w = b;
        }

        public void area()
        {
            Console.WriteLine("length: " + l + " \n width: " + w);
            Console.WriteLine("Area of Rectangle: " + (l * w));
        }
    }



    class Program
    {
        static void Main(string[] args)
        {
            rect rt = new rect();
            rt.input(4, 5);
            rt.area();
        }
    }
}

C# Interface

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

namespace Interfaces
{
    interface person
    {
           void describe(); // by default, abstract method
    }

    class student : person
    {

        string name;
        int age;

        public student(string name, int age)
        {
            this.name = name;
            this.age = age;
        }

        public void describe()
        {
            Console.WriteLine("Name: " + name + "\n Age: " + age);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            student s = new student("Kamran", 21);
            s.describe();

        }
    }
}

C# Single Inheritance

Inheritance:
============
C# supports three types of Inheritance

1) Single inheritance:
----------------------
 A derived class with only one base class.

2) Multilevel inheritance:
--------------------------
 Deriving a new class from an already derived class.

3) Hierarchical inheritabnce:
-----------------------------
 Properties of the base class can be accquired by 2 or more derived classes.


Syntax:
-------   class derived_class_name : visibility_mode base_class_name
   {
  ----------------------
          }
Example:
--------  class beta : alpha {
             -----------
           }  

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

namespace Single_Inheritance
{
    class alpha
    {
        public int a;
        public void set_a(int a)
        {
            this.a = a;
        }
    }
    class beta : alpha //In c# ':' operator used for inheritance
    {
        public int b;
        public void set_b(int b)
        {
            this.b = b;
        }
        public void print()
        {
            Console.WriteLine("A : " + a + " B : " + b);
            Console.WriteLine("Product : " + (a * b));
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            beta b = new beta();
            b.set_a(12);
            b.set_b(3);
            b.print();
        }
    }
}

C# Method Returning an Object

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

namespace MethodReturningAnObject
{
    class points
    {
        int x, y;
        public points()//default constructor
        {
            x = y = 0;
        }
        public points(int x,int y)//Parameterized constructor
        {
            this.x = x;
            this.y = y;
        }
        public void print()
        {
            Console.WriteLine(x + " " + y);
        }
        //this method is returning an object
        public points add(points p1,points p2)
        {
            points p3 = new points();
            p3.x = p1.x + p2.x;
            p3.y = p1.y + p2.y;
            return p3;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            points p1 = new points(4,7);
            points p2 = new points(1, 2);

            points p3 = new points();
            p1.print();
            p2.print();
            p3 = p3.add(p1, p2);
            Console.WriteLine("-----------");
            p3.print();


        }
    }
}

C# Static Members

Static members:

================

1) Static variables:
====================
 Only one copy of static variable is created and it can be shared by any number of objects.
 The default initial value for a static variable is zero (0).

2) Static method:
=================
 Static method can only can only access the static variable.
 To access static method, it must be invoked through class name.

Syntax:
-------  class_name.static_method_name();

Example
-------  enroll.count(); 

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

namespace StaticMembers
{
    class enroll
    {
        public string name, course;
        public static int k;//Static variable
        public enroll(string n,string c)
        {
            name = n;
            course = c;
            k++;
        }
        public static void count()//Static method
        {
            Console.WriteLine("Total number of students: " + k);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            enroll.count();
            enroll e1 = new enroll("Kamran", "BCA");
            enroll e2 = new enroll("Keyvan", "Msc");
            enroll.count();

            Console.WriteLine("--------------------");
            Console.WriteLine("Name \t Course");
            Console.WriteLine(e1.name + "\t" + e1.course);
            Console.WriteLine(e2.name + "\t" + e2.course);
            Console.WriteLine("--------------------");
        }
    }
}

C# Destructor

Destructor
==========

Destructor is automatically invoked, when the object of the class is destroyed.

To declare destructor it must contain the same name as the class name itself but pre_fixed (~) operator.

Destructor is a complement of the constructor.

Destructor does not contain any parameter, normally it does not contain anything.

Example
-------     class person {
  string name;
  public person(){} //Constructor
  -------------
  -------------
  ~person(){}       //Destructor
     } 
  

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

namespace Destructor
{
    class sample
    {
        public int x;
        public sample(int x)
        {
            this.x = x;
            Console.WriteLine("Constructing.");
        }
        ~sample()
        {
            Console.WriteLine("Destructing!");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            sample s1 = new sample(4);
            sample s2 = new sample(8);

            Console.WriteLine("Value_1 : " + s1.x);
            Console.WriteLine("Value_2 : " + s2.x);
        }
    }
}

C# String Functions

A string is sequence of characters enclosed within a pair of double quotes.
example: "http://dotnet-skills.blogspot.com","Mohammad","123@$#%"

Some of the built in string handling functions are stated below:
1. Length
2. ToUpper()
3. ToLower()
4. IndexOf()
5. LastIndexOf()
6. Split()
7. Replace()
8. Remove()
9. StarstWith()
10.EndsWith() 
11.Equals()
12.Contains()
13.Substring()
14.ToCharArray()
15.CompareTo()
16.Trim()
17.TrimStart()
18.TrimEnd()

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

namespace Strings
{
    class Program
    {
        static void Main(string[] args)
        {
            /* StartsWith(): returns true if the substring is present at 
            the beginning of the string. otherwise, it returns false.*/

            string s1 = "http://dotnet-skills.blogspot.com";
            Console.WriteLine("Result: " + s1.StartsWith("http"));

            //EndsWith(): returns true if the substring is present at 
            // the end of the string. otherwise, it returns false.

            Console.WriteLine("Result: " + s1.EndsWith(".com"));

            //Equals(): used to compare two strings

            string s2 = "dotnet-skills";
            string s3 = "dotnet-skills";

            if (s2.Equals(s3))
                Console.WriteLine("strings are equal");
            else
                Console.WriteLine("strings are not equal");

            //Contains( ): returns true if the substring is present the given
            // string. otherwise, return false.

            string s4 = "http://dotnet-skills.blogspot.com";
            Console.WriteLine(s4.Contains("dotnet"));

            //Substring(): extracts the substring from the given string

            string s5 = "http://dotnet-skills.blogspot.com";
            Console.WriteLine("Substring: " + s5.Substring(7, 13));

            // ToCharArray(): creates array of characters for a given string

            string s6 = ".net technology";

            char[] a = s6.ToCharArray();

            for (int i = 0; i < a.Length; i++)
                Console.WriteLine(a[i]);

        }
    }
}

Out put:

Result: True
Result: True
strings are equal
True
Substring: dotnet-skills
.
n
e
t

t
e
c
h
n
o
l
o
g
y

2010