KST - C#.

net OOP

KST
We are provider of quality IT solution & reliable service in agile software
development

With the ever-increasing pace of globalisation and business connectivity, the demand
for IT professional is greater than ever. We work closely with our clients to create
software solution that helps small and large businesses alike to achieve their goals.

What is OOP
OOP (Object Oriented Programming) is a programming paradigm based on the concept of
objects, which can contain data and code: data in the form of fields (often known as
attributes or properties), and code, in the form of procedures (often known as
methods). Programming language support OOP: C#, Java, etc OOP language allows to break
the program into the bit-sized problems that can be solved easily (one object at a
time). The new technology promises greater programmer productivity, better quality of
software and lesser maintenance cost. OOP systems can be easily upgraded from small to
large systems.

In this explanation we will use C# dotnet, you can install dotnet core or visual
studio 2022 community. https://visualstudio.microsoft.com/vs/community/
What will we discuss
Classes
Constructor
Properties
Events
Static
Members
Interfaces
Inheritance
Polymorphism

Classes
Classes model real-world objects and define:
state
behavior
fields
methods
operations
Classes describe sturture of objects
In C# classe have:
Fields
Contants
Methods
Properties
Indexers
Events
Operators
Constrtuctors
Destructors
Interfaces
Inner classes
etc

Access modifiers (scope)

public, private, protected, internal
and can be static

// This is begin of class definition named Cat

public class Cat : Animal // This Cat Class inherit (base) class from Animal Class
{
// Fields
private string name;
private string owner;

// Constructor
public Cat(string name, string owner)
{
this.name = name;
this.owner = owner;
}
 // Property
public string Name
{
get { return name; }
set { name = value; }
}

public string Owner

{
get { return owner; }
set { owner = value; }
}

// Method
public void Meong()
{
Console.WriteLine("Meooongg!!!");
}
} // End of class definition

Access Modifier
public - accessible from any class
protected - accessible from the class itself and all its descendent classes
private - accessible from the class itself only
internal - accessible from current assembly (used by default)

Class and Object

For this section we will use Cat Class we talk before. To use class as object, we can
do this: Define From Cat Class we have two objects: cat1 and cat2

Cat cat1 = new Cat();

cat1.name = "kuroneko";
cat1.owner = "Yoza";

Cat cat2 = new Cat("kuroneko", "Yoza");

Methods

cat1.Meong(); // Meooongg!!!

Read and Manipulate

Cat cat2 = new Cat("kuroneko", "Yoza");

Console.WriteLine(cat2.Name) // kuroneko
cat2.Name = "shironeko";
Console.WriteLine(cat2.Name); // shironeko

Constructor
Constructors are special methods

Constructors has the same name as the class

 Have no return type

Can have parameters

Can be private, protected, internal, public

Default Constructor*

public class Point

{
private int x;
private int y;

public Point()
{
x = 0;
y = 0;
}

// other code ...

}

With Parameter

As rule constructors should initialize all own class fields

public class Person

{
private string name;
private int age;

public Person()
{
name = "NO NAME";
age = 0;
}

public Person(string name, int age)

{
this.name = name;
this.age = age;
}
}

Inline initialization

public class Time

{
private int hour = 12; // Inline initialization
private int minute = 0; // Inline initialization

public Time(){}

public Time(int hour, int minute)

 {
this.hour = hour; // Invoed after the inline
this.minute = minute // initialization!
}

// Other code
}

Chaining

public class Point

{
private int x;
private int y;

public Point() : this(0,0) {} // Reuse constructor

public Point(int x, int y)

{
this.x = x;
this.y = y;
}

// other code ...

}

Fields, Constants, Readonly and Properties

Fields conatin data for class instance
Can arbitratry type
Have given scope
Can be deccalred with a specific value

class Person
{
private string firstName;
private string lastName;
private int age = 2;
private string[] hobbies;
}

Constat fields are defined like fields, but:

Defined with const

Must be initialized at their definition
Their value can not be changed at runtime

public class Math

{
public const double PI = 3.14
}
Read-Only Fields, Initialized at the definition or in the constructor, and can not be
modified, also it represent runtime constant.

public class ReadOnlyExample

{
private readonly int size;
public ReadOnlyExample(int size)
{
this.size = size; // can not be further modified
}
}

Properties can be:

Read-Only
Write-Only
Read and Write

Properties should have:

Access modifier (public, protected, etc.)

Return type
Unique name
Get and / or Set part
Can contain code processing data in specific way

public class Point

{
private int x;
private int y;

public int X
{
get { return x; }
set { x = value; }
}

public int Y
{
get { return y; }
set { y = value; }
}
}

Properties are not abligatory bound to a class field - can be calculated

dynamically:

public class Rectangle

{
private float width;
private float height;

public float Area

{
 get { return width * height; }
}
}

Automatic Properties Properties could be defined without and underlying field behind
them

It is automatically created by the C# compiler

class Uer
{
public int Id { get; set; }
}

Static Members
Static can be used for

Fields
Properties
Methods
Events
Constructors

Static Non-Static

Associated with a type, not with an The opposite, assocuated with an

instance instance

Initialzed just befor type is used for the Initialized when the constructor
first time is called

public class Rectangle

{
public static float GetArea(float width, float height)
{
return width * height;
}
}

// example:
Rectangle.GetArea(2,5);

Structures
Structures represents a combination of fields with data

Look like the classes but are value types

Their content is stored in the stack
Transmitted by value
Destroyed when go out of scope

However classes are reference type and are placed in dynamic memory (heap)

Their creation and destruction is slower

struct Point
{
public int X, Y;
}

struct Color
{
public byte red;
public byte green;
public byte blue;
}

struct Square
{
public Point location;
public int size;
public Color borderColor;
public Color surfaceColor;
}

When to Use Structures?

Use structures
To make your type behave as a primitive type
If you create many instances and after that you free them - e.g. in a
cycle

Do not use structures

When you often transmit your instances as method parameters
If you use collections without generics (too much boxing/unboxing)

Delegates

Abstraction

Encapsulation

Inheritance

Polymorphism