---

Search posts under C#:

---

Types in c# in C#

How To declare different types in c#

Classes:

Class is a reference type which enables to create own custom types by grouping the variables of other types, events and functions.

The declaration of the class

class Myclass
{
    .... class body
}

In the above code we have declared class as Myclass which defines as base class and class body defines the Fields, Events, constructors, Methods. Class defines the data of the type.

Objects:

object is an instance of the class. Class defines the object but it can not be an object. A program may create many objects of the same class  they can be stored in either a named variable or in an array or collection.

The declaration of the object to a class :

MyClass obj1 = new MyClass();

In the above code we have created the instance(object) to the class Myclass. obj1 is a reference to the myclass which refers new object with out any data.    

Class inheritance:

Inheritance is defined as deriving from base class to the derived class. Base class means parent and derived class is called child.

Example program on inheritance 

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

namespace example
{
    class Program
    {

        class a
        {
            public void display()
            {
                System.Console.WriteLine("www.dotnetfunda.com");
            }
        }
        class b : a 
        {
            public void display1()
            {
                System.Console.WriteLine("www.techfunda.com");
            }
        }

        class c
        {
            public static void Main()
            {
                b x = new b();
                x.display();
                x.display1();
            }
        }
    }
}

In the above code snippet we have defined class inheritance. We have taken three classes in this program  as class a, class b and class c. Class a as (base class) and class b as (derived class) and class c as function to declare the base class and derived class. We have taken class as program and in the class a We have given public void display(), The console.writeline("www.techfunda.com") prints the value as www.techfunda.com. In the class b the derived class of class a (baseclass) We have public void display1() as the system.consol.writeline ("www.dotnetfunda.com") prints the value as www.dotnetfunda.com and in the class c we have declaring  the b x=new b(); and x.display() and x.display1() prints the value as www.techfunda .comand www.dotnetfunda.com.

output

Fields:

Filed is the variable which is the member of the class which are directly declared in the class or structs, A class can use instance fields dnd static fields or both.

The declaration of the field

public class Myclass
{
    public int a; //Field
}

In the above code we have given class as myclass and the fields are written in the brackets.

There are different types of fields modified by field modifiers they are

• Access modifiers
• public 
• internal
• private 
• protected
• static modifier
• Inheritance modifier
• unsafe code modifier
• Read only modifier
• Threading modifier         

Access modifiers 

Access modifiers are the keywords which are used to access the memeber or a type. There are four types of access modifier they are

public access modifier

public access modifiers are having no restrictions to access public members. These are called from external location. These can be accessed by member or class. 

The declaration of public access modifier is 

public class MyClass
{
    .........;        // It can be accessed by any one
}

In the above code we have declared class as Myclass and the type can be accessed by any class, field and methods.

private access modifier:

private access modifier is defined as it access the member of the same class, It  linits the access in its own class.

The declaration of private access modifier is

private class MyClass
{
    .........;       // It can be accessed with in the class and within the assembly.
}

In the above code snippet we have declared the private access modifier. In this we have defined class as Myclass . The private access modifier is accessed is modified in its class only.

Protected access modifier

It is accessed in its class and with in the derived class instances. It is same as public but allows the derived class to access the member.

The declaration of protected access modifier

protected class MyClass
{
    .........;        // It can be accessed within this class and classes derived from it.
}

In the above code we have declared the protected access modifier. We have taken class as Myclass and the protected access modifier it access with in its class and the class derived from it.

Internal access modifier:

It provides access limited to the classes of current project assembly. A type can be accessed by any members in the same assembly and limits the accessibility for another assembly types. 

The declaration of internal access modifier

internal class MyClass
{
    ..........;      // It can be accessed by classes of current assembly.
}

In the above code snippet we have defined the internal access modifier it access the current assemly by its classes.

Protected internal modifier:

It protects the class of both protected and internal class by its current assembly as well as derived class type.

The declaration of protected internal access modifier:

protected internal MyClass
{
    .........;       // It can be accessed by current project classes and derived classes.
}

Static Modifier:

Static is a keyword which declares the static member to the type itsself rather than the specific object, It uses methods , classes, constructors etc. It takes one location in the memory and it will shared from there. It improves the performance of the program and it provides less flexibility. 

The declaration of static modifier: 

static class MyClass
{
    static int a;               // static variable
    public static void fruits() // static method
    {
        .......;
    }
}

In the above code snippet we have defined how to declare the static modifier. In this example it defines the variables and methods usig static modifier.      

Example program on static keyword

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
static class Techfunda
{
    public static int _value = 9;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(++Techfunda._value);
    }
}

In the above code snippet we have defined the static keyword. We have taken class as TechFunda and in the main function of class techfunda we have given the int value as 9 and in the main function of class program we have console.writeline as (++techfunda._value). which prints the value with increment by one.

output

unsafe code modifier:

Pointers which operates requires the unsafe context. This type of keyword is denoted by unsafe keyword of unsafe code modifier.

The declaration of unsafe code modifier

class MyClass
{
    public unsafe void Test() // using unsafe keyword
    {
        int a;                // unsafe context
        int b;                // unsafe context
        // unsafe context.
        // pointers can be used here.
    }
}

Read Only

The readonly is a keyword which is used to prevent the fields from being changed. They can be initiliazed at run time as constant values

The declaration of Readonly

public class MyClass
{
    readonly int fruits = 5; // Read only
}

 In the above example, the field (fruits) has used readonly modifier in which the value of the fruits cannot be changed in the MyClass method.

Volatile

Volatile is the keyword where the modification is done by threads. It is used for the fields by executing the multiple threads.   

The declaration of volatile

class MyClass
{
    public volatile int a; // public field as volatile

    MyClass(int b)
    {
        a = b;
    }
}

Volatile can be used to different types of the following  

• Pointer types
• Reference types
• Integral types
• Generic types  

Methods

A method is a group of statements that together perform a task. Every C# program has at least one class with a method named Main. 

To use the method we need to

•              Define the method
•              Call the method 

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

Inheritance modifiers:

New modifier

public class BaseC
{
    public int x;
    public void Invoke() { }
}
public class DerivedC : BaseC
{
    new public void Invoke() { }
}

Abstract modifier:

public abstract int Find();

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
abstract class Test
{
    public int _a;
    public abstract void A();
}

class Example1 : Test
{
    public override void A()
    {
        Console.WriteLine("techfunda");
        base._a++;
    }
}

class Example2 : Test
{
    public override void A()
    {
        Console.WriteLine("dotnetfunda");
        base._a--;
    }
}

class Program
{
    static void Main()
    {
        
        Test test1 = new Example1();
        test1.A();

        
        Test test2 = new Example2();
        test2.A();
    }
}

class Base
{
    protected virtual void Test() 
    {
        ..............;
    }
}
class Derived : Base
{
    protected override void Test() 
    {
        ..............;
    }
}

sealed class Box  
{
    ........;         
    .......;
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Class1
    {

        public int Sum(int A, int B)
        {
            return A + B;
        }

        public float Sum(int A, float B)
        {
            return A + B;
        }
    }

    class Class2 : Class1
    {
        public int Sum(int A, int B, int C)
        {
            return A + B + C;

        }
    }

    class MainClass
    {
        static void Main()
        {

            Class2 obj = new Class2();

            Console.WriteLine(obj.Sum(5, 2));

            Console.WriteLine(obj.Sum(1, 5.70f));

            Console.WriteLine(obj.Sum(1, 0, 3));

            Console.Read();
        }

    }

Method overriding 

Creating method in a derived class with same name, same parameters and same return type as in base class is called as method overriding. Method overriding is an example program of run time polymorphism

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class BaseClass
    {
        public virtual string YourCity()
        {
            return "Hyderabad";
        }
    }

    class DerivedClass : BaseClass
    {
        public override string YourCity()
        {
            return "Delhi";
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            DerivedClass obj = new DerivedClass();
            string city = obj.YourCity();
            Console.WriteLine(city);
            Console.Read();
        }
    }

output

Passing parameters to Methods

• value parameters
• Reference parameters

Value parameters

This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.

Example program value parameters

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class program
{
    public struct point
    {
        public int A, B;
    }
    static void main()
    {
        point p1 = new point();
        p1.A = 21;
        point p2 = p1;
        Console.WriteLine(p1.A);
        Console.WriteLine(p2.A);
        p1.A = 50;
        Console.WriteLine(p1.A);
        Console.WriteLine(p2.A);

    }
}

In the above code snippet we have declared two integers a, b using int data type, In the main method we created an object p1 for struct point, Finally we are calling the variable p1.A with that object. We also created the copy (p2) of objectp1 we can use this object for different work around. Later we are changing the value of p1.A as 50.

output

Reference parameters

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
{
    static void Main(string[] args)
    {
        string msg = "Hello, Welcome to C#";
        string upperMsg = msg.ToUpper();
        Console.WriteLine(upperMsg);

        double a = 5.0;
        msg = msg + " " + a.ToString();
        Console.WriteLine(msg);
    }
}

Events

Event is a keyword used to perform an action, which provides notifications to the clients. The keyword delegate is used while declaring the event

The declaration of the events 

public delegate void fruit();

The above code specifies it as a event

public event fruit; 

The above code declares the event

Example program on Events

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public delegate void Handler(); 
 class Program
    {
        public static event Handler menu;  

        static void Main()
        {
            menu += new Handler(Birthdays); 
            menu += new Handler(Meetings);  
            menu += new Handler(Reminders); 

            menu.Invoke();                 
        }

        static void Birthdays()
        {
            Console.WriteLine("Today is Nehru's birthday");
        }

        static void Meetings()
        {
            Console.WriteLine("Today's Meetings.....");
        }

        static void Reminders()
        {
            Console.WriteLine("Remind to do ......");
        }
    }

Constants

Constant is a keyword which may be of data type like integer constant, character constant, Floating constant. 

Example program to declare the constant

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
    {
        const string Name = "Techfunda"; 
        static void Main()
        {
            Console.WriteLine("Name: " + Name);
            

            const int Num = 8;        
           
            Console.WriteLine("No: " + Num);
        }
    }

In the above code snippetwe have declare the constant we have taken class as program and in the main function  we defined constant as string name called techfunda and the console.witeline prints as techfunda and constant int number prints the value as in the output

output

Properties 

properties are the extension of the fields. Classes, structures, interface are definedas properties

Example program on properties

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
    class Student
    {
        
        private string name = "not known";
        private int age = 0;

       
       
        
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }

        
        public int Age
        {
            get
            {
                return age;
            }
            set
            {
                age = value;
            }
        }
        public override string ToString()
        {
            return "Name=  " + Name + ", Age = " + Age;
        }
    }

    class program
    {
        public static void Main()
        {

            
            Student s = new Student();

                      
            s.Name = "Techfunda";
            s.Age = 9;
            Console.WriteLine("Student Info: {0}", s);

            
            s.Age += 1;
            Console.WriteLine("Student Info: {0}", s);
            Console.ReadKey();
        }
    }
}

In the above code snippet we have defined properties we have defined private string name and int age in the function In public string name we have get and set  which returns name and value and in the public int age we have get and set which returns age and value, In Public override string To Tostring() we have declared name and age, In the console.Writeline we have techfunda and age value as 9 and incrementing the age value by i prints the value by incrementing the value in the output.

output