Struct in C#

                                                                                                                                Previous....

                                                                                                                                    Next...... 

In C#, a structure is a value type data type. so it is stored in stack and it use enum,delegate and there may be constructor or not. The struct keyword is used for creating a structure.

Defining a Structure

structure is a homogeneous datatype means there can be more then one datatype. 

For example, here is the way you would declare the Book structure:

struct student
{
   public string name;
   public int class ;
   public string subject;
   public int id;
};  

The following program shows the use of the structure:

using System;
     
struct student
{
   public string name;
   public string aclass;
   public string subject;
   public int id;
};  

public class testStructure
{
   public static void Main(string[] args)
   {

     student student1;       
     student student2;       

      /* student1 detail */
      student1.name = "munesh";
      student1.class = "VI"; 
      student1.subject = "DOT Net programming";
      student1.id = 16;

      /* student 2 detail */
      student2.name = "rahul";
      student2.class = "VII";
      student2.subject =  "C programming";
      student2.id = 20;

      /* print student1 info */
      Console.WriteLine( "student 1 name : {0}", student1.name);
      Console.WriteLine("student1 class : {0}", student1.class);
      Console.WriteLine("student 1 subject : {0}", student1.subject);
      Console.WriteLine("student 1 Id :{0}", student1.id);

      /* print Book2 info */
      Console.WriteLine("student2 name : {0}", student2.name);
      Console.WriteLine("student 2 class : {0}", student2.class);
      Console.WriteLine("student2 subject : {0}", student2.subject);
      Console.WriteLine("student 2 id : {0}", student2.id);       

      Console.Readline();

   }
}

When the above code is compiled and executed, it produces the following result:

student 1 name : munesh
student 1 class : VI
student 1 subject : Dot Net Programming
student 1 id : 16
student 2 name : Rahul
student 2 class : VII
student 2 subject : C programming
student 2 id : 20

Class vs Structure go to this link

                                                                                 Previous....

                                                                                                                                    Next...... 

Enums in C#

                                                                                                                                                   Previous...

                                                                                                                                                        Next...

C# enumerations are value type.  An enumerated type is declared  the enum keyword.

Declaring enum keyword 

enum <enum_name> 
{ 
    enumeration list 
};

Where,

• The enum_name specifies the enumeration type name.
• The enumeration list is a comma-separated list of identifiers.

 enumeration stands for an integer value, one greater than the symbol that precedes it. By default, the value of the first enumeration symbol is 0. For example:

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

Example:

The following example demonstrates use of enum variable:

using System;
namespace enumexample
{
   class EnumProgram
   {
      enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

      static void Main(string[] args)
      {
         int WeekStart = (int)Days.Mon;
         int WeekEnd =   (int)Days.sunday;
         Console.WriteLine("Monday: {0}", WeekStart);
         Console.WriteLine("sunday: {0}", WeekEnd);
         Console.Readline();
      }
   }
}

result

Monday: 1
Friday: 7

---

                                                                                                                                                   Previous...

                                                                                                                                                        Next...

Polymorphism in C#

                                                                                                                                                Previous....

                                                                                                                                                     Next.....

The word polymorphism means having more then one forms. 

Polymorphism can be static or dynamic. In static polymorphism it is determined at the compile time. In dynamic polymorphism , it is decided at run-time.

Static Polymorphism/Function Overloading

It is an compile time polymorphism  because compiler already knows what type object it is linking to and waht type of method going to call. So linking a method at compiler time also called as early binding.
"In this Code method name same but its parameters are different  so it is called operate overloading."

using System;
namespace Polymorphism
{
   class calculation 
   {
      public int add(int a, int b)
      {
         return(a+b);
      }

      public int add(int a, int b,int c)

      {
         return(a+b+c);

      }

     }

Dynamic Polymorphism

It is an Run time polymorphism  because it is link at run time. So linking a method at run time also called as late binding.
"In this Code method name same and its parameters are also same  so it is called operate overriding."

In base class the method is declare "virtual" and in the derived class we override the same method. the virtual keyword indicate the method can be overridden in any derived class.
During run time, method overriding can be achieve by using inheritance principle and using "virtual" and "override" keyword.    

using System;
namespace employee
{
   public string firstname = "FN";
   public string secondname = "SN";

      public virtual void printfullname()
   console.writeline(firstname + " " + lastname);         }}

   public class parttime employee : employee
   {
      public override void printfullname()
      console.writeline("firstname + " " lastname + " parttime");  }}

      public class fulltimeemployee : employee
      {
         public override void printfullname()
        {
      console.writeline("firstname + " " lastname + " fullname");  }}
public class temporaryemployee : employee 
      { public override printfullname()
      { 
        console.writeline("firstname + " " lastname + " temporary ");  }}

         public class programme
      { public static void main()
   employee[] emp = new employee[4];
   emp [0] = new employee();
   emp [1] = new parttimeemployee();
   emp [2] = new fulltimeemployee();
   emp [3] = new tomporarytime employee();
   

     foreach(employee e in emp)

       {
         e.printfullname();
         
      }
   }
}

When the above code is compiled and executed, it produces the following result:

FN SN ,FN SN parttime

FN SN fulltime,FN SN temporary 

                                                                                                                                                                                              Previous....

                                                                                                                                                     Next.....

Inheritance in C#

                                                                                                                                                Previous....

                                                                                                                                                     Next.....

One of the most important concepts in OOPS  is  inheritance. Inheritance allows us to define a class in terms of another class, This also provides an opportunity to reuse the code functionality .

In inheritance a class inherit the property of other class. This existing class is called the base class, and the new class is referred to as the derived class.

Base and Derived Classes

A class can be derived from more than one class or interface, which means that it can inherit data and functions from multiple base class.

 syntax 

<acess-specifier> class <base_class>
{
 data
}
class <derived_class> : <base_class>
{
 data
}

Consider a base class Shape and its derived class Rectangle:

using System;
namespace Inheritance
{
   class Add
   {
      public void number1(int n)
      {
         number1 = n;
      }
      public void number2(int m)
      {
         number2 = m;
      }
      protected int number1;
      protected int number2;

   }

   // Derived class
   class divident: Add
   {
      public int devide()
      { 
         return (number1 / number2); 
      }
   }
   
   class calculator 
   {
      static void Main(string[] args)
      {
         calculator cal = new calculator();

         cal.number1(8);

         cal.number(2);

Console.WriteLine("the number: {0}",  cal.devide());

         Console.Readline();
      }
   }
}

When the above code is compiled and executed, it produces the following result:

the number : 4

Base Class Initialization

The derived class inherits the base class member variables and member methods. Therefore thesuper class object should be created before the subclass is created. You can give instructions for superclass initialization in the member initialization list.

using System;
namespace inheritance
{
   class calculator
   {
      //member variables
      protected double number1;
      protected double number2;
      public calculator(double n1, double n2)
      {
         number1= n1;
         number2 = n2;

      }
      public double product()
      {
         return number2 * number2;

      }
      public void Display()
      {
         Console.WriteLine("number1: {0}", number1);
         Console.WriteLine("number2: {0}", number2);
         Console.WriteLine("product: {0}", product());
      }
   } 
   class Tabletop : calculator
   {
      private double cost;
      public Tabletop(double n1, double n2) : base(n1, n2)
      { }
      public double GetCost()
      {
         double cost;
         product = product() * 70;
         return product;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("product: {0}", product());
      }
   }
   class Executecalculator
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

Multiple Inheritance in C#

C# does not support multiple inheritance. However, you can use interfaces to implement multiple inheritance. 

using System;
namespace Inheritance
{
   class prod 
   {
      public void number1(int n1)
      {
         number1= n1;
      }
      public void number2(int n2)
      {
         munber2 = n2;
      }
      protected int munber1;
      protected int munber2;
   }


   public interface Cost 
   {
      int Cost(int devide);

   }
   // Derived class
   class Rectangle : product, devide
   {
      public int product()
      {
         return (munber1 * munber2);

      }
      public int Cost(int product)
      {
         return product * 70;
      }
   }
   class calculation
   {
      static void Main(string[] args)
      {
         calculation cal = new calculation();
         int product;
         cal.number1(5);
         cal.number2(7);
         product = cal.product();
         // Print the area of the object.
         Console.WriteLine("product: {0}",  cal.product());
         Console.WriteLine("cost: {0}" , cal.Cost(product));
         Console.Readline();
      }
   }
}

When the above code is compiled and executed, it produces the following result:

product: 35
cost: 2450

                                                                                                                                                Previous....
                                                                                                                                                     Next.....