OOPS in CSharp

OOPS Concepts in C#:

Object in C#:

An object is an instance of a class and represents a specific occurrence of the class template. We create an object using the new keyword, which initializes the object by calling the class's constructor and returns a reference to it. Using this reference variable, we can access the object's data and members.

Each object has a unique state and behavior, with its own fields and methods as defined by the class. Access modifiers (like public, private, etc.) determine the visibility and accessibility of an object's data and members. Objects can also inherit characteristics from other classes and can demonstrate polymorphism in C#. Additionally, memory management for objects is handled automatically by the .NET runtime's garbage collector, which reclaims memory from objects that are no longer in use.

Car myCar = new Car { Make = "Toyota", Model = "Corolla" };

myCar.StartEngine(); // Output: Engine started.

By organizing code into classes and objects, OOP leverages key principles such as encapsulation, inheritance, polymorphism, and abstraction to enhance flexibility, reduce redundancy, and improve code management.

Class in C#

A class is a template for creating objects.

It defines the structure (data) and behavior (methods) that objects created from the class will have.

we define class by class keyword.

A class can include:

Constructors: Special methods used to initialize objects when they are created. They can be parameterless or take arguments.

Destructors: Methods called when an object is being destroyed, though they are less commonly used due to garbage collection.

Access Modifiers: Keywords like public, private, protected, and internal that control the visibility and accessibility of the class and its members.

Inheritance: The ability for one class to inherit from another, allowing for code reuse and hierarchical class structures.

Abstract Classes: Classes that cannot be instantiated directly and are intended to be subclassed.

Static Classes and Members: Classes and members that belong to the class itself rather than to instances of the class. Static classes cannot be instantiated.

Interfaces: Contracts that classes can implement, providing a way to define common behavior without enforcing a class hierarchy.

Properties and Fields: Fields are data members of a class, while properties provide a way to access and modify these fields in a controlled manner.

Method Overloading and Overriding: Methods can be overloaded (same name, different parameters) and overridden (redefined in derived classes) to provide specific functionality.

Example:

public class Car

{

public string Make { get; set; }

public string Model { get; set; }

public void StartEngine()

{

Console.WriteLine("Engine started.");

}

Constructor in C#

A constructor in C# is a special method that is called when an instance of a class is created. It is used to initialize the object's state or perform setup tasks. Constructors have the following characteristics:

Name: A constructor must have the same name as the class.
No Return Type: Constructors do not have a return type, not even void.
Called Automatically: A constructor is invoked automatically when a new instance of the class is created using the new keyword.
Overloading: A class can have multiple constructors with different parameter lists, allowing flexibility in object creation (constructor overloading).

Constructors Types:

Default Constructor

Parameterized Constructor

Static Constructor

Private Constructor

Copy Constructor

Static Constructors in C#:

Automatic Invocation: Static constructors are called automatically when a static member or method is accessed for the first time, ensuring proper initialization.
No Parameters: Static constructors cannot accept parameters and are used for initializing static members or performing one-time setup tasks.
Thread Safety: Static constructors are thread-safe, ensuring they are executed only once, even when accessed by multiple threads.
Private by Default: Static constructors are private by default and cannot be explicitly called, with the runtime controlling when they are invoked.
Exception Handling: If a static constructor throws an exception, it prevents further usage of the class, throwing a TypeInitializationException on subsequent attempts.
Static Classes: Static classes can only contain static members, and their only constructor is a static one, as they cannot be instantiated.
Static Constructors in Non-Static Classes: Non-static classes can have static constructors to initialize static members before any instance is created. These constructors run once when a static member is accessed.
Default Static Constructor: If no static constructor is provided, the compiler generates a default one to initialize static members.

Conclusion:

Static constructors are essential for initializing static members or performing one-time setup. They are automatically invoked, thread-safe, private by default, and controlled by the runtime.

Finalize:

*********

In C#, the Finalize method (often seen as a destructor) is used to clean up unmanaged resources in classes that handle such resources. However, it can introduce overhead due to delayed garbage collection and additional processing since objects with finalizers are queued for finalization.

Key Points:

Purpose: Finalizers clean up unmanaged resources when an object is collected by the garbage collector.

Overhead: Finalizers lead to delayed resource release and increased memory usage because objects aren't collected immediately.

Best Practice: Implement the IDisposable interface for explicit resource management. This allows users to release resources promptly and avoid relying solely on finalizers.

Suppress Finalization: After implementing Dispose, call GC.SuppressFinalize(this) to prevent the finalizer from executing, reducing overhead.

Dispose:

********

Purpose: The Dispose method, part of the IDisposable interface, allows for the deterministic release of managed and unmanaged resources when they are no longer needed.

Deterministic Cleanup: By implementing Dispose, developers can control exactly when resources (like file handles and database connections) are freed, avoiding reliance on the garbage collector.

Implementation Steps:

Implement IDisposable: Create a class that includes the IDisposable interface.

Define the Dispose Method: This public method is called to release resources.

Suppress Finalization: Call GC.SuppressFinalize(this) in Dispose to prevent the finalizer from executing if resources are already cleaned up.

Protected Dispose Method: Optionally create a protected method to handle both managed and unmanaged resource cleanup differently.

Usage: It's best practice to use a using statement when working with objects that implement IDisposable, ensuring resources are automatically released.

Key Benefits

Prevents Resource Leaks: Ensures timely cleanup of resources, which is essential for performance and reliability.

Improves Code Clarity: Provides a clear pattern for managing resources, making code easier to maintain.

Overall, implementing the Dispose pattern is crucial for effective resource management in .NET applications.

Delegates in C# are reference types that hold references to methods, allowing type-safe method invocation. They are derived from System.Delegate.

Delegates are declared using the delegate keyword followed by a method signature. The delegate object references methods that match this signature. Delegates can reference instance methods or static methods and can invoke methods dynamically at runtime.

Delegates support both synchronous and asynchronous method calls. They come in three types:

Single delegates, which can invoke a single method.

Multicast delegates, which can invoke multiple methods. Methods can be added or removed using the + and - operators, and all methods are invoked in sequence.

Generic delegates, introduced in .NET Framework 3.5, include Action<T> and Func<T, TResult>. These provide type safety and flexibility without needing explicit delegate definitions.

Delegates are used for event handling, callback methods, and designing extensible APIs where methods can be passed as parameters. They also support anonymous methods and lambda expressions for inline method definitions.

Delegates in C#

Definition: Delegates are reference types in C# that encapsulate method references, enabling type-safe method invocation. They are derived from System.Delegate and act as type-safe function pointers.

Single Delegate: References a single method.

Multicast Delegate: References multiple methods. When invoked, all methods in the invocation list are executed sequentially. Methods can be added or removed using + and - operators.

Generic Delegates: Introduced in .NET Framework 3.5, they include:

Func<T, TResult>: Represents methods that return a result.

Action<T>: Represents methods that do not return a result.

Anonymous Methods and Lambda Expressions: Provide shorthand ways to define inline methods.

Anonymous Methods: Defined without naming a method.

Lambda Expressions: Offer a more concise syntax compared to anonymous methods.

Covariance and Contravariance: Allow flexibility in method return types and parameters.

Covariance: Allows a method to return a more derived type.

Contravariance: Allows a method to accept parameters of a less derived type.

Invocation: Delegates can be invoked using standard method call syntax or the Invoke method.

Uses: Delegates are crucial for event handling, callback methods, and designing flexible APIs. They support passing methods as parameters and enable extensible programming.

Performance and Considerations:

Performance: Multicast delegates can impact performance, especially with long delegate chains or anonymous methods capturing state.

Exception Handling: In multicast delegates, if one method throws an exception, the remaining methods continue to execute.

Equality: Delegates are equal if they are of the same type and reference the same method.

Abstraction:

Abstraction in C# is a fundamental concept in object-oriented programming (OOP) that allows you to hide complex implementation details and show only the essential features of an object.

Abstraction helps to create a clear separation between what an object does and how it does it, improving code readability and maintainability..

In C#, abstraction can be achieved by using Abstract Classes, Abstract Methods, Interfaces, Encapsulation.

Abstract Classes: Provide a base class with both abstract methods (without implementation) and concrete methods (with implementation).

Abstract Methods: Must be implemented by any non-abstract derived class.

Interfaces: Define a contract that implementing classes must follow, without providing any implementation.

Encapsulation: Hides internal state and requires interaction through public methods or properties.

1. Example using Abstract Classes:

Coding:

using System;

public abstract class Vehicle

{

public abstract void Start(); // Abstract method (no implementation)

public void Refuel() // Concrete method (with implementation)

{

Console.WriteLine("The vehicle is being refueled.");

}

public class Car : Vehicle

{

public override void Start()

{

Console.WriteLine("Car is starting.");

}

Explanation:

In this example, `Vehicle` is an abstract class with an abstract method `Start` (which must be implemented by derived classes) and a concrete method `Refuel` (with its own implementation). The `Car` class inherits from `Vehicle` and provides its specific implementation for the `Start` method.

Encapsulation in C#:

Encapsulation ensures that data and methods are bundled together, protected, and exposed in a controlled manner. This approach hides complexity and maintains a consistent interface by using classes to provide a single unit of functionality. Properties provide a controlled way to access data with optional validation or logic, whereas fields are typically private and directly hold the data. Encapsulation supports abstraction by hiding implementation details and exposing only necessary functionality through a clear interface. Access control restricts direct access to data, ensuring integrity through private fields and controlled exposure via methods or properties. It shields the internal state from unauthorized modifications by using validation logic in properties and methods. Access modifiers (public, private, protected, internal) control how data and methods are exposed, including to derived classes. Properties can be defined as read-only (only get access) or write-only (only set access), allowing control over how data is accessed and modified. Collections can be encapsulated by exposing them as read-only interfaces to prevent external modification while still allowing internal manipulation.

Encapsulation also supports the Dependency Inversion Principle by allowing high-level modules to interact with abstractions rather than concrete implementations, which promotes flexibility and reduces coupling. It facilitates defensive programming by providing controlled access to the internal state of an object, including validation checks to prevent invalid state changes. Encapsulation is used in various design patterns such as Singleton, Factory, and Proxy for controlled object creation and access. It helps manage access to shared resources and reduces issues related to concurrent access. Encapsulation works alongside principles like Interface Segregation to ensure that interfaces are designed to provide only the methods relevant to the implementing class. Proper encapsulation facilitates unit testing by allowing you to test the class’s public interface while keeping internal details hidden. It also ensures data integrity by providing mechanisms to prevent unauthorized or inconsistent modifications to an object's state. Although encapsulation is crucial, reflection can be used to bypass it, allowing access to private members and potentially leading to maintenance challenges. Additionally, the `internal` access modifier allows access within the same assembly, providing a way to encapsulate functionality shared within a specific scope but hidden from external consumers.