User Defined Datatypes:
. To create a User Defined datatype or structure, we will need to use struct Keyword.
1
2. Under a structure, we can have data types and methods.
3. When we declare a variable inside a structure, it should use a proper access specifier.
4. Access specifier is used to expose the variable outside the class or structure.
5. There are 3 types of access specifier :
5.1 Public
5.2 Private
5.3 Protected
5.4 Internal
5.5 Protected Internal.
6. When we are declaring a variable without an access specifier, by default it will
consider it as a private access specifier.
7. We can explicitly define the access specifier as public.
8. Under the Main method, we need to declare user defined structure.
General _general;
9. We can use the structure, whatever the way we need.
Sample Program :
using System;
amespace Sample_UserDefinedDatatype
n
{
internal class Program
{
public static void Main(string[] args)
{
General _general;
onsole.WriteLine("Enter the first number");
C
_general._firstValue = Convert.ToInt32(Console.ReadLine());
/ / Convert is used to change from 1 datatype to another datatype.
// Console.Readline will be considering it as a string.
Console.WriteLine("Enter the second number");
_general._secondValue = Convert.ToInt32(Console.ReadLine());
_general._result = _general._firstValue + _general._secondValue;
onsole.WriteLine("The resultant value is:" + " " + _general._result);
C
Console.ReadLine();
}
}
truct General
s
{
public int _firstValue;
public int _secondValue;
public int _result;
}
class Add {
rivate int _firstValue;
p
private int _secondValue;
private int _result;
}
}
Method:
It is a block/set of code containers surrounded by a specific name, which is called a
Method.
Signature:
ccess-specifier return_type datatype_name (Parameters)
A
{
}
Constructor:
onstructor is a member method of a class
C
Constructor name is the same as the class name.
Types of Constructor:
.
1 efault Constructor
D
2. Parameterized Constructor
3. Copy Constructor
4. Static Constructor
5. Private Constructor
. Default Constructor:
1
Syntax: public ClassName() { }
Description: Default constructors are parameterless constructors provided by the
compiler if no constructor is defined in the class. They initialize fields to their default
values.
Example:
ublic class Person
p
{
public string Name { get; set; }
public int Age { get; set; }
/ / Default Constructor
public Person()
{
Name = "John Doe";
Age = 30;
}
}
2. Parameterized Constructor
yntax: public ClassName(type1 param1, type2 param2, ...) { }
S
Description: Parameterized constructors accept parameters to initialize an
object's state during object creation.
Example:
ublic class Person
p
{
public string Name { get; set; }
public int Age { get; set; }
/ / Parameterized Constructor
public Person(string name, int age)
{
Name = name;
Age = age;
}
}
3. Copy Constructor
yntax: public ClassName(ClassName obj) { }
S
Description: Copy constructors create a new object by copying the values of another
object of the same class.
Example:
ublic class Person
p
{
public string Name { get; set; }
public int Age { get; set; }
/ / Copy Constructor
public Person(Person otherPerson)
{
ame = otherPerson.Name;
N
Age = otherPerson.Age;
}
}
4. Static Constructor
yntax: static ClassName() { }
S
Description: Static constructors are usedtoinitializestaticfieldsorperformanystatic
initialization before the class is used for the first time. They are called automatically
before the first instance is created or any static members are accessed.
Example:
using System;
ublic class MyClass
p
{
private static readonly DateTime creationTime;
/ / Static constructor
static MyClass()
{
creationTime = DateTime.Now;
}
/ / Method to get creation time
public static DateTime GetCreationTime()
{
return creationTime;
}
}
lass Program
c
{
static void Main()
{
// Access the creation time
DateTime time = MyClass.GetCreationTime();
Console.WriteLine($"Object created at: {time}");
}
}
5. Private Constructor
yntax: private ClassName() { }
S
Description: Private constructors prevent the class from being instantiated by clients
and are often used in classes that contain only static members.
Example:
ublic class Singleton
p
{
private static Singleton instance;
/ / Private Constructor
private Singleton() { }
ublic static Singleton GetInstance()
p
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
6. Destructor
yntax: ~ClassName() { }
S
Description: Destructors are used to release resources held by an object before it is
destroyed by the garbage collector. They are less commonly used in C# due to the
presence of garbage collection.
Inheritance:
Inheritance is the process in which a child class inherits properties of the parent class.
Types of Inheritance:
. Single Inheritance
1
2. Multilevel Inheritance
3. Multiple Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance.
Note: C# allows only 2 types of inheritance, that is, single and multilevel inheritance.
Multiple inheritance is not allowed in C#, but could be achieved with the help of
interfaces.
1. Single inheritance:
derived class inherits from only one base class.
A
Example:
ublic class Animal
p
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
ublic class Dog : Animal
p
{
public void Bark()
{
Console.WriteLine("Dog is barking.");
}
}
2. Multilevel Inheritance
A derived class is used as a base class for another class.
Example:
public class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
public class Dog : Animal
{
public void Bark()
{
Console.WriteLine("Dog is barking.");
}
}
3. Multiple Inheritance
In C# Multiple inheritance can be achieved through interfaces. Interfaces inC#
provide a way to define contracts for classes without specifying the
implementation. A classcanimplementmultipleinterfaces,allowingittoinherit
behavior from multiple sources
Example:
using System;
/ / Interface for flying behavior
public interface IFlyable
{
void Fly();
}
/ / Interface for swimming behavior
public interface ISwimmable
{
void Swim();
}
/ / Class implementing both IFlyable and ISwimmable
public class Duck : IFlyable, ISwimmable
{
public void Fly()
{
Console.WriteLine("Duck is flying.");
}
ublic void Swim()
p
{
Console.WriteLine("Duck is swimming.");
}
}
lass Program
c
{
static void Main()
{
Duck duck = new Duck();
duck.Fly(); // Duck is flying
duck.Swim(); // Duck is swimming
}
}
Interfaces:
n interface in C# is a reference type that defines a contract for what a class must
A
implement. It contains onlythedeclarationofmethods,properties,events,orindexers,
without providing any implementation.
Example:
ublic interface IShape
p
{
double Area();
}
ublic class Circle : IShape
p
{
public double Radius { get; set; }
ublic double Area()
p
{
return Math.PI * Radius * Radius;
}
}
Abstract Class
n abstract class in C# is a class that cannot be instantiated on its own and may
A
contain abstract methods, which are declared without an implementation. Abstract
classes can also contain concrete methods with implementations.
Example:
ublic abstract class Shape
p
{
public abstract double Area();
}
ublic class Circle : Shape
p
{
public double Radius { get; set; }
ublic override double Area()
p
{
return Math.PI * Radius * Radius;
}
}
Polymorphism:
olymorphism is the ability of an object to take on multiple forms. In OOP, it allows
P
objects of different classes to be treated as objects of a common superclass.
Types Of Polymorphism:
1. C ompile-Time Polymorphism (Static Binding): This is achieved through method
overloading and operator overloading.
2. Run-Time Polymorphism (Dynamic Binding): This is achieved through method
overriding.
Example:
ublic class Animal
p
{
public virtual void MakeSound()
{
Console.WriteLine("Animal makes a sound");
}
}
ublic class Dog : Animal
p
{
public override void MakeSound()
{
Console.WriteLine("Dog barks");
}
}
nimal animal = new Dog();
A
animal.MakeSound(); // Output: Dog barks
Method Overloading:
ethod overloading allows a class to have multiplemethodswiththesamenamebut
M
different parameters.
ublic class Calculator
p
{
public int Add(int a, int b)
{
return a + b;
}
ublic double Add(double a, double b)
p
{
return a + b;
}
}
Method Overriding:
ethod overridingallowsasubclasstoprovideaspecificimplementationofamethod
M
that is already provided by its superclass.
using System;
ublic class Animal
p
{
public virtual void MakeSound()
{
Console.WriteLine("Animal makes a sound");
}
}
ublic class Dog : Animal
p
{
public override void MakeSound()
{
Console.WriteLine("Dog barks");
}
}
lass Program
c
{
tatic void Main()
s
{
Animal animal = new Dog();
animal.MakeSound(); // Output: Dog barks
}
}
Method Hiding:
ethod hiding allows a subclasstoprovideanewimplementationofamethodthatis
M
already provided by its superclass, effectively hiding the superclass's implementation.
ublic class BaseClass
p
{
public void Display()
{
Console.WriteLine("BaseClass display");
}
}
ublic class DerivedClass : BaseClass
p
{
public new void Display()
{
Console.WriteLine("DerivedClass display");
}
}
aseClass obj1 = new BaseClass();
B
obj1.Display(); // Output: BaseClass display
aseClass obj2 = new DerivedClass();
B
obj2.Display(); // Output: BaseClass display (Method hiding)
Exception Handling:
xception handling is a mechanism in programming that allows you to deal with
E
unexpectedorexceptionalsituationsthatmayoccurduringtheexecutionofaprogram.
It helps in gracefully handling errors and prevents the program from crashing.
In C#exception handling is done using ̀try`, ̀catch`, ̀finally`, and ̀throw` keywords.
Here's a basic example:
using System;
lass Program
c
{
static void Main()
{
try
{
int[] numbers = { 1, 2, 3 };
Console.WriteLine(numbers[5]); // Trying to access an index out of bounds
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
Console.WriteLine("Finallyblockalwaysexecutes,whetheranexceptionoccurs
or not.");
}
Console.WriteLine("Program continues after the exception handling block.");
}
}
In this example, the ̀try` block contains code that might throwanexception(tryingto
access an index out of bounds in an array). If an exception occurs, the ̀catch` block
catches the exception, and you can handle it (printing an errormessageinthiscase).
The ̀finally` block is optional and is used toexecutecleanupcodethatshouldalways
run, whether an exception occurs or not.
