C# Questions:

1.What is the difference between == and Equals() in C#?

== Operator:

• Used for comparing value types and reference types.

• For value types, it checks if the values are equal.

• For reference types, it checks if the two objects refer to the same instance.

Equals() Method:

• A method that can be overridden in a class.

• Used for comparing the contents or state of objects, not just references.

• Often used for a more specific comparison logic beyond reference equality.

2.What are the main differences between a class and a struct in

C#?
Memory Allocation:

​ Class: Reference type, allocated on the heap.

​ Struct: Value type, allocated on the stack or inline in containing types.

Default Behavior:

​ Class: Supports inheritance, polymorphism, and finalization ​

(destructors).

​ Struct: Does not support inheritance (except from interfaces) and ​

cannot have a finalizer.

Immutability:
 Class: Mutable by default, meaning the fields can be modified after the
instance is created.

Struct: Typically used for small data structures and are often immutable to
avoid unintended copying.

Performance:

Class: Can be more performant with large data because only references are
passed around.

Struct: Can be more efficient with small data as it avoids heap allocation
and garbage collection.

Nullability:

Class: Can be null.

Struct: Cannot be null (unless it's a nullable struct, Nullable<T>).

3.Can you explain what a namespace is and how it is used in

C#?
A namespace in C# is a container that holds classes, interfaces, enums, structs,
and other namespaces. It is used to organize code and prevent name collisions by
providing a way to group related types under a unique name.

Usage of Namespaces:

1.Organizing Code

2.Avoiding Name Conflicts

3.Accessing Types
4.What is the purpose of the using statement in C#?
1.Resource Management: Ensures proper disposal of unmanaged resources like
file handles, database connections, etc.

2.Scope Control: Defines a scope at the end of which the resources will be
automatically disposed.

3.Exception Safety: Guarantees resource cleanup even if an exception occurs

within the using block.

5.What are value types and reference types in C#? Give

examples.
• Value Types:

Stored directly in memory, hold data directly.

Examples: int, double, bool, char, struct, enum.

Value types are typically allocated on the stack.

• Reference Types:

Store references to the actual data, which is stored on the heap.

Examples: class, interface, delegate, string, array.

Reference types can be null and are typically allocated on the heap.

6.What is inheritance and how is it implemented in C#?

Inheritance:

• A fundamental concept in object-oriented programming that allows a class to

inherit properties and methods from another class.
• Promotes code reuse and establishes a hierarchical relationship between
classes.

• Allows a class to inherit methods and properties from another class.

Implementation in C#:

• Base class (parent) provides the properties and methods.

• Derived class (child) uses : to inherit from the base class.

• Example: public class Dog : Animal { }

7.Explain polymorphism with an example in C#.

Polymorphism:

• The ability of a method to do different things based on the object it is acting

upon.

• Achieved through method overriding and method overloading.

Example:

public class Animal

public virtual void MakeSound() => Console.WriteLine("Animal sound");

public class Dog : Animal

public override void MakeSound() => Console.WriteLine("Bark");

}
Animal animal = new Dog();

animal.MakeSound(); // Output: Bark

8.What are interfaces and abstract classes? How are they

different?
Interfaces:

• Define a contract of methods and properties that implementing classes must

fulfill.

• Cannot have implementation; only method signatures.

• Allow multiple inheritance.

Abstract Classes:

• Serve as a base class that can contain both abstract methods (without
implementation) and fully implemented methods.

• Cannot be instantiated; meant to be inherited.

• Allow sharing code among derived classes.

Differences:

• Implementation: Interfaces cannot have any implementation, while abstract

classes can.

• Inheritance: A class can implement multiple interfaces but can inherit from only
one abstract class.

• Use Cases: Interfaces define capabilities, while abstract classes are used for a
common base with shared code.
9.What is encapsulation and how is it achieved in C#?
Encapsulation:

The concept of bundling data and methods that operate on that data within a
class.

Restricts direct access to some of the object's components, protecting the object's
integrity.

Achieved in C#:

Access Modifiers: Control access to class members.

• private: Members are accessible only within the class.

• protected: Members are accessible within the class and by derived classes.

• public: Members are accessible from any code.

Properties: Provide controlled access to private fields.

• Use getters and setters to read and write the values.

public class Person

private string name;

public string Name

get { return name; }

set { name = value; }

}
In this example, the name field is encapsulated, with access provided through the
Name property.

10.Explain the concept of method overloading and method

overriding with examples
Method Overloading:

• A feature that allows multiple methods in the same class to have the same name
but different parameters (type, number, or both).

• Helps improve readability and usability.

Method Overriding:

• Allows a derived class to provide a specific implementation of a method already

defined in its base class.

• The overridden method in the base class must be marked with the virtual
keyword, and the overriding method in the derived class must use the override
keyword.

11.What are generics in C# and why are they useful?

Generics:

A feature in C# that allows you to define classes, methods, and data structures
with a placeholder for data types, making them type-safe and reusable.

# Why Generics Are Useful:

• Type Safety:

Ensures that only a specific type of data can be used, reducing runtime errors and
enhancing code reliability.

• Code Reusability:

Allows creating a single class or method that can work with any data type,
reducing code duplication.

• Performance:

Eliminates the need for boxing/unboxing and type casting, improving

performance.

Useful in scenarios where data types are not known until runtime.

12.Explain the difference between Array and ArrayList in C#.

Array:

• Fixed Size: Arrays have a fixed size defined at the time of creation, which cannot
be changed.

• Type Safety: All elements in an array are of a specific type, ensuring type safety.

• Performance: Arrays provide better performance due to less overhead.

Syntax:

int[] numbers = new int[5];

ArrayList:

• Dynamic Size: ArrayLists can dynamically resize as elements are added or

removed.

• Non-Generic: Stores elements as object, allowing different types but lacking

type safety, leading to possible runtime errors.

• Performance: Generally slower than arrays due to boxing/unboxing of value

types and type checking at runtime.

Syntax:

ArrayList list = new ArrayList();

list.Add(1);

list.Add("Hello");

Key Differences:

• Arrays are strongly typed and have a fixed size, while ArrayLists are dynamically
sized and can store elements of any type, sacrificing type safety.

13.What is the difference between String and StringBuilder in

C#?
String:

• Immutable: Strings are immutable; once created, their values cannot be

changed. Any modification creates a new string object.

• Performance: Because they are immutable, frequent modifications (like

concatenation) can lead to performance issues due to the creation of multiple
objects.

• Use Case: Suitable for scenarios where the string value does not change often.

StringBuilder:

• Mutable: Designed for scenarios where a string undergoes multiple

modifications. It allows modification of the string content without creating new
objects.

• Performance: More efficient for frequent string manipulations, such as

concatenation or appending, because it avoids the overhead of creating new
objects.

• Use Case: Ideal for scenarios involving extensive string manipulation.

14.What is the purpose of the async and await keywords in C#?

Purpose of async and await:

• These keywords are used to work with asynchronous programming in C#,

enabling non-blocking operations and improving application responsiveness.

async Keyword:

• Marks a method as asynchronous, allowing the use of await within the method.

• The method returns a Task or Task<T>, representing the ongoing operation.

await Keyword:

• Pauses the execution of the async method until the awaited task completes,
without blocking the thread.

• Ensures that the method continues executing once the task is complete.

Benefits:

• Improves Performance: Especially in I/O-bound operations, by not blocking

threads during long-running tasks.

• Better Resource Utilization: Frees up the main thread for other work while
waiting for asynchronous tasks to complete.

15.Explain the use of delegates in C#.

Delegates:

• Delegates are type-safe pointers to methods, allowing methods to be passed as

parameters and called dynamically.

• They are used to encapsulate a method with a specific signature and return
type.

Use Cases:

• Event Handling: Delegates are commonly used in event-driven programming,

where they are used to define event handlers.

• Callback Methods: Allow a method to call another method at runtime, often

used for callbacks.

• Encapsulation of Method Logic: Delegates can encapsulate a method within an

object, enabling flexible and reusable code.

16.What is the difference between "ref" and "out" parameters

in C#? When would you use each one?
ref Parameter:

• Purpose: Passes a variable by reference, allowing the called method to modify

the value of the variable.

• Requirements: The variable must be initialized before being passed to the

method.

• Usage: Use ref when you want the method to read and modify the caller's
variable.

out Parameter:

• Purpose: Also passes a variable by reference, but it is intended to output data

from the method.

• Requirements: The variable does not need to be initialized before being passed,
but it must be assigned a value within the method.

• Usage: Use out when you want the method to provide multiple outputs or
return values.

Key Differences:

• Initialization: ref requires the variable to be initialized before use, while out does
not.

• Assignment: The out parameter must be assigned within the method, whereas
ref does not have this requirement.

17.Describe the concept of serialization and deserialization in

C#. How do you implement it using attributes or interfaces?
Serialization:

• The process of converting an object into a format that can be easily stored or
transmitted (e.g., JSON, XML, binary).

• Useful for saving the state of an object to a file, sending it over a network, or
persisting it in a database.

Deserialization:

• The reverse process of converting the serialized format back into an object.

• Reconstructs the object from the serialized data, restoring its original state.

18.What is LINQ and how is it used in C#?

LINQ (Language Integrated Query):

A set of features in C# that provides a consistent and readable way to query and
manipulate data from different sources (such as collections, databases, XML, etc.)
using a familiar syntax.

Key Features:

Unified Syntax: Provides a consistent syntax for querying different data sources.

Strongly Typed: Ensures type safety at compile time, reducing runtime errors.

Declarative: Allows developers to write queries that specify what data to retrieve
rather than how to retrieve it.

Usage in C#:

LINQ can be used with various data sources, including objects, SQL databases,
XML documents, and more.

Common LINQ Operations:

• Filtering: where clause

• Projection: select clause

• Sorting: order by clause

• Joining: join clause

• Grouping: group by clause

Advantages:

• Readability: LINQ queries are easy to read and understand, similar to SQL syntax.

• Maintainability: Provides a more readable and maintainable approach to data

querying.

• Type Safety: Queries are checked at compile time, reducing runtime errors.
19. Can you explain the difference between IEnumerable and
IQueryable?
IEnumerable:

• Namespace: System.Collections.Generic

• Definition: Represents a forward-only cursor over a collection of a specified

type.

• Execution: Deferred execution; LINQ queries are executed when the data is
iterated (e.g., with a foreach loop).

• Use Case: Best for in-memory collections like lists, arrays, or any data structure
that implements IEnumerable<T>.

• Data Processing: Processes data in memory, which means it works well for
in-memory collections but can be inefficient for large data sets.

IQueryable:

• Namespace: System.Linq

• Definition: Inherits from IEnumerable and adds functionality for querying data
from out-of-memory sources, such as databases.

• Execution: Deferred execution, but the query can be executed on the data
source itself (e.g., SQL database), which means only the required data is retrieved
and processed.

• Use Case: Best for querying large data sources like databases because it allows
query translation to a query language understood by the data source (e.g., SQL).

• Data Processing: Processes data on the server side, making it more efficient for
large data sets.
Key Differences:

• Data Source: IEnumerable is suitable for in-memory collections, while

IQueryable is designed for out-of-memory data sources like databases.

• Execution Location: IEnumerable processes data in memory after retrieving it,

whereas IQueryable can translate LINQ queries into SQL and execute them on the
database server.

• Performance: IQueryable can be more efficient for large data sets because it can
optimize queries to minimize data transfer.

20.What is a Dictionary in C# and how is it different from a List?

Dictionary in C#:

• Definition: A collection that stores key-value pairs, where each key is unique.

• Namespace: System.Collections.Generic

#Key Features:

• Fast retrieval based on keys, leveraging hash tables for quick lookups.

• Keys are unique, meaning no two entries can have the same key.

• Allows for adding, removing, and checking for keys and values.

List in C#:

• Definition: A collection that stores elements in a linear order, accessible by their

index.

• Namespace: System.Collections.Generic
# Key Features:

• Allows duplicates; elements are not required to be unique.

• Provides indexed access to elements, meaning elements can be accessed via

their position in the list.

• Dynamic in size; can grow or shrink as needed.

Key Differences:

• Data Structure:

Dictionary: Uses key-value pairs, optimized for quick lookups by key.

List: A collection of values, optimized for sequential access.

• Uniqueness:

Dictionary: Keys must be unique; values can be duplicated.

List: No uniqueness constraints; both duplicates and unique values are

allowed.

• Access:

Dictionary: Access elements via keys.

List: Access elements via zero-based indices.

• Use Case:

Dictionary: Suitable for scenarios where quick access, insertion, and

deletion of elements by a key are required.

List: Suitable for scenarios where the order of elements matters, and access
is based on the position in the collection.
21.Explain the concept of a lambda expression and provide an
example.
Lambda Expression:

• A concise way to represent an anonymous method, often used to create

delegates or expression tree types.

• Lambda expressions are particularly useful in LINQ queries, event handling, and
functional programming scenarios.

• The syntax consists of input parameters, the => operator (called the "goes to"
operator), and an expression or a block of code.

Key Points:

• Anonymous: Lambda expressions do not have a name and are used directly
where needed.

• Type Inference: The types of input parameters are usually inferred by the
compiler, although they can be specified explicitly.

• Versatility: Can be used in expressions and statements, including complex

operations or simple calculations.

22.What are anonymous types in C#?

Anonymous Types:

• A feature in C# that allows you to create a new type without explicitly defining it
in your code.

• Useful for creating simple, temporary objects to store a set of read-only

properties.
• The types are defined on the fly and are particularly useful in scenarios where
you need to encapsulate a set of values without creating a formal class.

Key Characteristics:

• Anonymous: The type does not have a specific name.

• Immutable: Properties in an anonymous type are read-only after initialization.

• Type Inference: The compiler automatically infers the types of the properties.

• Scope: The type is only accessible within the method or scope in which it is
defined.

Syntax:

• Defined using the new keyword followed by an object initializer with property
names and values.

23. What is exception handling in C#?

Exception Handling in C#:

A mechanism to handle runtime errors and exceptional situations in a controlled

and predictable manner.

Helps in maintaining the normal flow of the program by catching and managing
exceptions.

Key Components:

1. Try Block:

• Contains the code that may throw an exception.

• If an exception occurs, the control is transferred to the appropriate catch block.

2. Catch Block:
• Handles specific exceptions or a general exception if no specific catch block
matches.

• Allows the program to respond to the error, for example, by logging the error,
retrying the operation, or providing a user-friendly message.

3. Finally Block:

• Executed regardless of whether an exception is thrown or not.

• Typically used for cleaning up resources, such as closing files or releasing

network connections.

24.Explain the difference between try-catch and

try-catch-finally blocks.
Try Catch:

• The try block contains the code that might throw an exception.

catch blocks are used to handle specific exceptions or a general exception. Each
catch block catches a specific type of exception.

• If an exception occurs, the control is passed to the first catch block that matches
the exception type. Subsequent code in the try block and any catch blocks not
matching the exception type are skipped.

• If no exception occurs, the catch blocks are ignored.

Try Catch Finally:

• The finally block executes after the try and catch blocks have finished. It runs
whether an exception was thrown or not.

• Commonly used for cleanup operations, such as closing files, releasing

resources, or resetting states.

• The finally block executes even if a return statement is encountered in the try or
catch block, or if an exception is thrown but not caught in the catch blocks.

Key Differences:

• Exception Handling: Both structures handle exceptions, but try-catch-finally

ensures that certain code (in the finally block) runs regardless of exceptions.

• Usage: Use try-catch when you only need to handle exceptions. Use
try-catch-finally when you also need to guarantee that some code runs after the
exception handling, typically for cleanup purposes.

25.What are extension methods in C#? How do you create and

use extension methods?
Definition:

Extension methods allow you to "extend" existing types with new methods
without modifying the original type or creating a new derived type. They provide a
way to add functionality to types you don't own, such as built-in .NET classes or
third-party libraries.

Key Characteristics:

Extension methods are static methods, but they are called as if they were instance
methods on the extended type.

They are defined in static classes.

The first parameter of an extension method specifies the type it extends and is
preceded by the this keyword.

26.Describe the use of delegates and events in C#. Provide an

example of defining and using delegates and events.
Delegates in C#:

Definition: A delegate is a type that represents references to methods with a

specific parameter list and return type.

Purpose: Used to pass methods as arguments, define callback methods, and

enable event-driven programming.

Events in C#:

Definition: Events are a way for a class to notify other classes or objects when
something of interest occurs.

Purpose: Used to implement the observer pattern, where one or more subscribers
are notified of changes or actions.

27.How do you handle exceptions in C#? Explain the

try-catch-finally block and best practices for exception handling.
Handling Exceptions in C#:

Purpose: Exception handling manages runtime errors, allowing the program to

continue or fail gracefully.

try-catch-finally Block:

try Block: Contains code that might throw an exception.

catch Block: Catches and handles exceptions. Can have multiple catch blocks to
handle different exception types.

finally Block: Executes code regardless of whether an exception occurred. Used for
cleanup activities like closing files or releasing resources.

Best Practices:

• Specific Exceptions: Catch specific exceptions first, before general ones, to

provide precise error handling.

• Avoid Silent Failures: Always log or report exceptions; avoid catching exceptions
without handling them.

• Use finally for Cleanup: Use the finally block for resource management, ensuring
resources are released.

• Minimize Scope: Only wrap code that might throw exceptions; avoid large try
blocks to keep exception handling focused and clear.

• Avoid Using Exceptions for Control Flow: Exceptions are for exceptional
conditions, not regular program flow.

• Document Exceptions: Document methods with potential exceptions for better

code maintainability and clarity.

28.What is the purpose of the "using" statement in C#? How is

it related to IDisposable?
Purpose of the using Statement in C#:

The using statement ensures that resources are properly disposed of when they
are no longer needed, even if an exception occurs. It's particularly useful for
managing unmanaged resources like file handles, database connections, or
network streams.

Relation to IDisposable:

The using statement works with objects that implement the IDisposable interface.
This interface defines the Dispose method, which is responsible for releasing
unmanaged resources.

How It Works:

When the code block inside a using statement is executed, the object is created
and used. Once the block is exited, the Dispose method is automatically called on
the object, ensuring resource cleanup.

29.Explain the differences between value types and reference

types in C#.
Value Types:

Storage: Stored directly in memory on the stack.

Assignment: When assigned to another variable, a copy of the value is made.

# Characteristics:

Contain the actual data.

Changes to one variable do not affect another.

Common value types include int, double, bool, structs, and enum.

Reference Types:

Storage: Store a reference to the data, which is located in the heap.

Assignment: When assigned to another variable, both variables reference the

same memory location.

# Characteristics:

Contain a pointer to the actual data.

Changes to the data via one reference affect all references.

Common reference types include class, interface, delegate, array, and string.

Key Differences:

Memory Allocation: Value types are typically stored on the stack, whereas
reference types are stored on the heap.

Copy Behavior: Value types are copied by value, reference types are copied by
reference.

Performance: Value types are usually more performant due to stack allocation but
lack flexibility. Reference types, being on the heap, are more flexible but can
introduce overhead due to garbage collection and reference management.

30.What is dependency injection (DI) in C#? How do you

implement DI using frameworks like ASP.NET Core DI or
third-party libraries?
Dependency Injection (DI) in C#:

Definition: DI is a design pattern used to implement IoC (Inversion of Control),

allowing a class to receive its dependencies from an external source rather than
creating them itself. This promotes loose coupling, easier testing, and better
maintainability.

Key Points:

• Constructor Injection: Most common method, where dependencies are

provided through class constructors.

• Property Injection: Dependencies are set through properties.

• Method Injection: Dependencies are provided through method parameters.

• Lifetime Management: Services can have different lifetimes (Singleton, Scoped,

Transient) to control their creation and lifespan.

31.How do you work with JSON data in C#? Describe

serialization and deserialization techniques.
Working with JSON Data in C#:
Purpose: JSON (JavaScript Object Notation) is a lightweight data interchange
format. In C#, JSON is commonly used for data exchange, especially in web
applications and APIs.

Serialization:

Definition: Serialization is the process of converting a C# object into a JSON string.

Usage: Often used when sending data to APIs or saving settings.

Deserialization:

Definition: Deserialization is the process of converting a JSON string back into a C#

object.

Usage: Commonly used to parse data received from APIs or files.

32.What are nullable types in C#? How do you handle null

values using nullable types?
Nullable Types in C#:

Definition: Nullable types allow value types (such as int, bool, DateTime) to
represent null, which means they can indicate the absence of a value.

Syntax: A nullable type is declared using the ? suffix after the type, e.g., int? or
bool?.

Handling Null Values:

Checking for Null: Use the HasValue property or the == null check to determine if
the nullable type contains a value.

Accessing the Value: Use the Value property to access the value, or use the
GetValueOrDefault() method to get the value or a default if it's null
33.Describe the concept of garbage collection in C#. How does
the garbage collector manage memory in .NET applications?
Garbage Collection in C#:

Concept: Garbage collection (GC) is an automatic memory management feature in

.NET that reclaims memory occupied by objects that are no longer in use, freeing
up resources and preventing memory leaks.

How the Garbage Collector Works:

• Managed Heap: The .NET runtime uses a managed heap to allocate memory for
objects. Objects are stored in memory, and the garbage collector periodically
cleans up unreferenced objects.

• Generations: The managed heap is divided into three generations (0, 1, and 2) to
optimize the garbage collection process:

• Generation 0: Short-lived objects, collected frequently.

• Generation 1: Medium-lived objects, promoted from Generation 0 if they

survive the first collection.

• Generation 2: Long-lived objects, promoted from Generation 1, collected less

frequently.

• Mark-and-Sweep Algorithm:

• Mark: The GC identifies all objects that are reachable from the application (i.e.,
they are still in use).

• Sweep: It then reclaims the memory occupied by objects that are not marked, as
they are no longer reachable.

• Compaction: After reclaiming memory, the GC may compact the heap by moving
objects to reduce fragmentation and free up contiguous blocks of memory.