Advantages of OOP
1. Well-designed oop code EASY TO REUSE. Shared modules can be distributed as libraries which can be used in other applications.
2. INCAPSULATION. In well-designed OOP code in order to use OOP objects clients dont’t need to know how objects works internally they work with declared interfaces/contracts only.
3. MAINTAINABILITY. Well-designed code is easy to maintain it is easy to substitute one module with another without breaking functionality.
4. EASY TO WRITE LARGE APPLICATIONS.
Disadvantages of OOP
1. Performance. OOP have to deal with lots of objects in memory
2. LONG LEARNING CURVE.
A process is an inner container which has its own virtual address space
Libraries of code are mapped into the address spaces
A thread is path of execution through code within a single process.
For managed threads within an AppDomain
Each thread has it’s own callstack and copy of cpu registers
1. Better cpu utilization when a process runs on multiple core cpu or multiple processors machine.
2. Better support for asynchronous I/O operations. Performing CPU bound operations while waiting to complete I/O bound operations
3. Better UI responsiveness
Context switching overhead
Added program complexity:
1. More lines of code
2. Hard to maintain (readability)
3. Hard to debug
4. Hard to test
CLR thread class name
Thread life time:
Execution continues until thread returns from its entry point.
1. As a result of a standard method return.
2. As result of unhandled exception
1. As an exception caused by the running thread
2. As a result of calling Abort(), Interrupt() methods.
Coordinated thread shut-down
1. User-defined mechanism
2. Requesting thread waits:
2.1 Polling IsAlive
2.2. Calling Thread.Join
CLR provides per process thread pool
1. Whenever thread is created a few microseconds goes on creating a thread stack and for allocating a memory. Thread pooll cuts overhead by sharing and recycling threads.
2. CLRs pool manager add thread or removes thread from a thread pool on demand.
3. IsBackground property is set to false
When not to use a thread pool
1. When we need foreground thread
2. When we need to set priority to the thread
3. When we run a long running task
4. When we need to identify a thread
Delegates and Async I/O
1. Delegates BeginInvoke queue a request method to the ThreaPool
private int AddMethod(int x)
private delegate string OperationMethod(int x);
OperationMethod test = Method;
test.BeginInvoke(0, null, null);
2.1 In case of Async I/O when we call I/O methods such as BeginRead, BeginWrite these methods calls goes to I/O completion port and these methods do not block the thread.
2.2. When Async I/O methods complete only then this call is queued to the ThreadPool.
Decorator design pattern allows to attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
The Component defines the interface for components that can have dynamically attached responsibilities.
The ConcreteComponent implements the Component’s interface to which responsibilities can be attached dynamically.
The Decorator maintains a reference to the Component’s object and defines the interface that conforms the Component’s interface
The ComponentDecorator adds responsibilities to an attached component.
Command design pattern encapsulates request as an object thereby allowing parameterize other objects with different request, log and queue requests, and support undoable operations.