Search your questions here
Search results for: in category: C#
In C#, variables are used to store data in memory, which can be used and manipulated in your program. A variable has a name, a type, and a value.
Example
int anotherNumber = 20; // Declaration and initialization
An object is a concrete entity based on a class, and is sometimes referred to as an instance of a class.
Objects can be created by using the new keyword followed by the name of the class.
0 is the default value for number types and null is the defautl value for the reference type.
Events are a way for an object to broadcast (to all interested components in the system) that something has happened. Any other component can subscribe to the event, and be notified when an event is raised.
A class that derives from another class, called the base class, automatically contains all the public, protected, and internal members of the base class except its constructors and finalizers.
using the 'base' keyword.
Example
class BaseClass
{
public BaseClass(int x, string y)
{
Console.WriteLine($"Base class initialized with: x = {x}, y = {y}");
}
}
class DerivedClass : BaseClass
{
public DerivedClass(int a, string b) : base(a, b)
{
Console.WriteLine("Derived class constructor called.");
}
}
class Program
{
static void Main()
{
DerivedClass obj = new DerivedClass(10, "Hello");
}
}
And in the main class,
class Program
{
static void Main()
{
DerivedClass obj = new DerivedClass(42, "Hello World");
}
}
Result:
Base constructor: x = 42, y = Hello World
Derived constructor: a = 42, b = Hello World
by setting Get Accessor. For Example
public string Purpose { get; set; }
public bool IsPayment
{
get
{
return Purpose != null && Purpose.ToLower().Equals("personal");
}
}
Yes
List<object> is flexible and using strongly-typed collections improves code clarity and type safety, especially in larger applications and for dynamic databinding.
A record in C# is a class or struct that provides special syntax and behavior for working with data models. The record modifier instructs the compiler to synthesize members that are useful for types whose primary role is storing data.
If You want to define a data model that depends on value equality.
If You want to define a type for which objects are immutable
An immutable type is one that prevents you from changing any property or field values of an object after it's instantiated. Immutability can be useful when you need a type to be thread-safe.
Record:
You can use positional parameters in a primary constructor to create and
instantiate a type with immutable properties.
You can use a with expression to create a copy of an immutable object with new values in selected properties.
A record's ToString method creates a formatted string that shows an object's type name and the names and values of all its public properties.
A record can inherit from another record. A record can't inherit from a class, and a class can't inherit from a record.
The variable you declare has a type known at compile time. if the type is wrong, it will report the error and you can correct it.
In C#, methods are blocks of code that perform specific actions and can be invoked to execute that action. Methods allow you to define reusable logic, improving code organization and reducing redundancy.
A method is defined within a class or struct and consists of:
Access modifier (e.g., public, private, etc.)
Return type (e.g., void, int, string, etc.)
Method name
Parameters (optional)
In C#, a class is a fundamental building block of object-oriented programming. It serves as a blueprint for creating objects, encapsulating data (fields) and behavior (methods). Classes can also define properties, events, constructors, and more.
Namespaces are logical groupings of classes. Referencing namespaces (with “using” statements) at the top of your code file lets you use their classes in that file.
In the context of C# and .NET, an .exe (executable) file is an executable that contains an entry point for the program.
a .dll (dynamic-link library) file is a code library that doesn’t have a direct entry point but can be called by another program or application.
The entry point in a C# program is typically represented by the Main() method, which is located in the Program class. This method must be static and serves as the starting point for the program’s execution.
Main is declared inside a class or struct. Main must be static and it need not be public
Main can either have a void, int, or, starting with C# 7.1, Task, or Task<int> return type
Main can have any access modifier
The Main method can be declared with or without a string[] parameter that
contains command-line arguments.
In C#, memory management is handled automatically thanks to the garbage collector mechanism. It automatically identifies objects that are no longer used by the program and frees the memory they occupy.
OOP is based on four main principles: encapsulation, inheritance, polymorphism, and abstraction. In C#, this means the following:
Encapsulation allows data and methods to be bundled into a unit (class) and restricts access to certain components.
Inheritance permits one class (the child or derived class) to inherit the attributes and methods of another class (the parent or base class). This promotes the reuse of code and establishes a hierarchical relationship between classes.
Polymorphism is the capability of a single function or method to work in various ways based on its inputs or on which object it is called upon. In C#, polymorphism can be achieved through method overriding, using the override keyword, and method hiding, utilizing the new keyword to hide a method in the base class.
Abstraction allows developers to hide complex implementations and show only the essential features of an object. This means that the user interacts with only what’s necessary and the internal workings are kept hidden. In C#, abstract classes and interfaces are tools that can help achieve abstraction.
In C#, threads can be managed using the Thread class from the System.Threading namespace.
The main difference lies in the fact that threads within a single process can share the same memory area, whereas each process has its own isolated memory context.
In C#, there are primitive data types, such as int, float, double, char, bool, byte,
Nullable types in C# allow representing an absent or uninitialized value for value types.
const variables should be used when you need to define a variable that doesn’t change throughout the program’s life cycle.They must have a value assigned at compile time.
On the other hand, readonly can be initialized in a class constructor and ensure that its value cannot be changed afterward.
For value types, == and Equals() usually work the same way
but for reference types, == checks for reference equality, not content. Equals() can be overridden for custom classes to ensure content-based comparison. As a rule, if you want to compare the content of objects, it’s better to use Equals().
is checks whether an object is an instance of a certain type and returns a Boolean value.
as is used for safe type casting and will return null if the conversion is not possible, rather than throwing an exception.
The ?? operator is a null-coalescing operator that returns the left operand if it’s not null; otherwise, it returns the right one.
It’s useful for setting default values for potentially null values.
In C#, several types of loops are available: for, foreach, while, and do-while. Let’s look at each of them:
for: This is the most commonly used loop when you know the number of iterations beforehand.
foreach: This type of loop is perfect for iterating through collections or arrays when you need to work with each element sequentially.
while: This loop executes as long as the specified condition is true. It’s useful when you don’t know the number of iterations beforehand.
do-while: This loop is similar to while, but the condition is checked after executing the loop body, ensuring the loop body is executed at least once.
The switch operator allows you to check a variable against multiple values.
Sample Code
public static void Main(String[] args) { int nitem = 5; switch (nitem) { case 1: Console.WriteLine("option 1"); break; case 5: Console.WriteLine("option 5"); break; case 9: Console.WriteLine("option 9"); break; default: Console.WriteLine("No match found"); break; } } } |
option 5
continue skips the current loop iteration and proceeds to the next one.
break exits the loop prematurely.
continue is useful when some loop iterations need to be skipped,
and break when you need to terminate the loop execution under a certain condition.
To optimize a loop,
you can use parallelism,
employ efficient data structures,
reduce the number of operations within the loop,
and utilize caching where possible.
yield return allows you to create iterators without the need to generate an auxiliary collection.
It’s useful when you want to lazily generate values as you iterate through a collection.
Encapsulation is ensured through access modifiers such as private, protected, and public.
These modifiers determine the visibility of class members, allowing for the hiding of implementation details and exposing only the necessary API.
Polymorphism in C# is realized through the ability to override methods in subclasses using the virtual and override keywords, as well as through interfaces that allow different classes to have a consistent set of methods.
public
protected
internal
protected internal
private
private protected.
The default accessibility is private
public
Access is not restricted.
protected
Access is limited to the containing class or types derived from the containing class.
internal
Access is limited to the current assembly.
protected internal
Access is limited to the current assembly or types derived from the containing class.
private
Access is limited to the containing type.
private protected
Access is limited to the containing class or types derived from the containing class within the current assembly.
An interface member with private accessibility must have a default implementation. True or False ?
True
These modifiers determine the level of access to class members.
public makes a member accessible to any code;
private restricts access to only the methods of the given class;
protected allows access to the given class and its descendants, and
internal makes a member accessible to any code within the same assembly.
No, C# does not support multiple inheritance for classes. However, a class can implement multiple interfaces.
Method overloading allows having multiple versions of a single method in one class with different parameters.
Method overriding allows a subclass to replace the implementation of a method provided by its base class.
Properties are a special kind of class member in C# that represents access to data with the ability to define logic when reading or writing that data.
They allow you to control access to internal fields and can contain additional logic, for instance, for validation. Fields,
on the other hand, are variables defined in the class and are used to store data
How are constructors used for object initialization and how do they differ from static constructors?
Constructors help initialize an object at the time of its creation, setting the necessary state or performing any other required setup.
Static constructors are used to initialize static members of a class or to perform actions that should occur only once for the class, not for each individual object.
The base keyword allows you to call members from the base class when in a derived class.
It is most commonly used in derived classes to call the constructor of the base class or to access other base class members that were overridden in the derived class.
The this keyword points to the present instance of the class.
It is often used to point to the fields or methods of the current object, especially when method parameter names overlap with class field names.
Both IEnumerable and ICollection are interfaces in the .NET Framework designed for handling collections of data, but they serve different purposes:
IEnumerable provides the basic capability to iterate over a collection. It exposes an enumerator, which supports a simple iteration over a non-generic collection. Essentially, if you only need to enumerate over items, IEnumerable is sufficient.
ICollection extends IEnumerable and provides additional methods for manipulating the size of the collection and for adding, removing, and checking the existence of elements in the collection.
NET provides several primary collection types:
List<T>: A dynamic array of elements. It maintains order and allows duplicate elements.
Dictionary<TKey, TValue>: A collection of key-value pairs. It does not have a defined order, and keys must be unique.
HashSet<T>: A set of unique elements. It does not maintain any specific order.
Queue<T>: A collection supporting First-In-First-Out (FIFO) operations.
Stack<T>: A collection supporting Last-In-First-Out (LIFO) operations.
The primary distinction between List<T> and Dictionary<TKey, TValue> lies in how you access elements.
In List<T>, elements are accessed by their index, whereas in Dictionary<TKey, TValue>, elements are accessed by their key.
IEnumerable and IQueryable are two primary interfaces representing collections in .NET. This is what they do:
IEnumerable: Operates at the object level in memory. When you execute LINQ queries against an IEnumerable interface, operations are performed in memory. It’s suitable for working with in-memory collections such as arrays or lists.
IQueryable: Designed for interacting with external data sources (for example, databases). Queries made with IQueryable get translated into queries specific to the data source (such as SQL for relational databases). This interface allows for deferred execution and out-of-memory (OOM) data querying, making it efficient for large datasets, especially in databases.
The primary distinction lies in flexibility and size.
Arrays have a fixed size once defined, while List<T>can dynamically resize as elements are added or removed.
When you use throw without any argument, you’re essentially rethrowing the current exception, preserving the original stack trace.
This allows for easier debugging as you maintain the information about where the exception was originally thrown.
On the other hand, when you use throw ex, you reset the stack trace to the current catch block, potentially losing valuable information about where and how the exception originated.
Therefore, in general, it’s recommended to use throw by itself within a catch block if you intend to rethrow the caught exception.
In Visual Studio, the two primary build configurations are Debug and Release.
The Debug configuration is tailored for code debugging. It usually includes additional debugging information, doesn’t apply certain compiler optimizations,
The Release configuration is optimized for the final deployment of the application. The code is compiled with full optimization, removing any debugging information, which leads to better performance.
The async and await keywords in C# are used to denote and execute asynchronous operations, allowing for non-blocking code execution.
The async keyword indicates that a method may contain asynchronous code, while await is used to asynchronously wait for a task to complete without freezing the main thread.
Multithreading involves running multiple threads concurrently in a single process to optimize execution. It’s about using multiple threads to achieve parallelism.
Asynchronous programming, on the other hand, focuses on allowing code to continue its execution without waiting for long-running operations (such as I/O) to complete
Careless use of async and await can lead to several issues:
Deadlocks: Especially when mixing synchronous and asynchronous code.
Thread starvation: Over-relying on the thread pool can lead to situations where all threads are consumed, causing delays in processing.
Performance overheads: Unnecessary usage can introduce performance overheads.
Debugging complexity: Asynchronous code can be more challenging to debug due to its non-linear execution flow.
Generics in C# provide a way to define classes, interfaces, and methods that operate on typed parameters while maintaining type safety and performance. Compared to using the object type, generics offer the following advantages:
Type safety: Generics ensure that you are working with the correct data type, eliminating the risk of runtime type errors.
Performance: With generics, there’s no need for boxing or unboxing when dealing with value types, leading to more efficient operations.
Code reusability: Generics allow you to write a piece of code that works with different data types, reducing code duplication.
Elimination of type casting: With generics, explicit type casting is reduced, making the code cleaner and more readable.
List,Dictionary,Sorted List,Queue,Stack,HashSet etc.
In C#, threads can be created using the Thread class from the System.Threading namespace.
Once you’ve instantiated a thread, you can initiate it using the Start() method. Here’s an example:
Thread myThread = new Thread(new ThreadStart(MyFunction));
myThread.Start();
C# provides various synchronization primitives to control access to shared resources and ensure data safety in a multithreaded environment. These include the following:
Monitor: Often used implicitly with the lock keyword to acquire a lock on an object.
Mutex: Similar to Monitor but can be used across multiple processes, ensuring inter-process synchronization.
Semaphore: Controls access to a resource by multiple threads by limiting the number of simultaneous accesses.
ReaderWriterLock and ReaderWriterLockSlim: Allow multiple threads to read shared data, but only one to write, optimizing scenarios with frequent reads and occasional writes.
lock statement: A shorthand for Monitor.Enter and Monitor.Exit, providing a block-based scope for acquiring and releasing a lock.
A deadlock in multithreading occurs when two or more threads are locked in a state where each thread is waiting for another to release a resource, creating a standstill where no thread can proceed. This effectively halts the execution of the threads involved. To avoid deadlocks, consider the following strategies:
Lock ordering: Always acquire locks in a consistent, predetermined order. If all threads follow the same order when acquiring locks, circular waiting (a key condition for deadlocks) can be avoided.
Lock timeouts: Use timeouts when attempting to acquire a lock. If a thread cannot obtain all the necessary locks within a certain time frame, it can release any locks it has acquired and retry.
Deadlock detection: Have mechanisms in place to detect deadlocks. This can be complex and may not be suitable for all scenarios, but in systems where deadlocks can have significant impacts, detection and recovery mechanisms are essential.
ThreadPool manages a pool of worker threads, providing an efficient mechanism for executing short-lived tasks in the background. Benefits include the following:
Reduced overhead: ThreadPool minimizes the overhead associated with thread creation and destruction by reusing threads.
Optimized resource utilization: ThreadPool dynamically adjusts the number of threads in the pool based on the workload, ensuring optimal utilization of system resources.
Ease of use: ThreadPool simplifies parallel execution by abstracting away thread management details, allowing developers to focus on task execution logic.
Task in C# represents an asynchronous operation. It provides a higher-level abstraction over threads and offers several benefits:
Asynchronous programming: With the use of async and await keywords, Task makes it simpler to write asynchronous code.
Resource management: A Task instance may run on a thread from the ThreadPool, optimizing thread utilization and management.
Composability: Tasks can be easily composed, allowing for the creation of chains of asynchronous operations.
Exception handling: Task provides a centralized way to handle exceptions in asynchronous code.
Here are some pros and cons of the code-first and database-first approaches:
Code-first approach:
Advantages:
Greater flexibility and control over the code
Easier to make changes to the model and migrate these to the database
Promotes a code-first development practice where the focus is initially on business logic
Disadvantages:
It can be challenging to use with large, existing databases
There might be a need to manually manage complex migrations
Database-first approach:
Advantages:
Ideally suited for projects with existing databases
It can be a quicker way to start working with large databases
Disadvantages:
Less control over the automatically generated code
Changes in the database may require additional synchronization code or new code generation
Data types
int and long: Used for storing integer values
float and double: Used for floating-point numbers
char: Used for single characters
string: Used for strings of text
bool: Used for Boolean values, which are typically true or false
Operators
Arithmetic operators: +, -, *, /, and % for performing arithmetic operations
Comparison operators: ==, !=, <, >, <=, and >= for comparing values
Logical operators: &&, ||, and ! for creating logical expressions
Bitwise operators: &,|, ^, ~ , << and >> for manipulating with bits
Abstract Class:
Serves as a base class that provides partial implementation of functionality.
Can contain abstract methods (without a body) and fully implemented methods.
Represents an "is-a" relationship (inheritance).
Interface:
Purely defines a contract without providing any implementation (prior to C# 8.0).
From C# 8.0 onward, interfaces can have default implementations using default methods.
Represents a "can-do" relationship (capability).
Abstract Class:
A class can inherit only one abstract class (single inheritance).
Supports inheritance of methods, properties, and fields.
Interface:
A class can implement multiple interfaces (multiple inheritance).
Does not support fields; only methods, properties, events, and indexers can be defined.
Abstract Class:
Can have:
Fields.
Constructors.
Destructors.
Static members.
Non-abstract methods.
Abstract methods (must be overridden in derived classes).
Members can have access modifiers (e.g., public, protected, private).
Interface:
Can have:
Abstract methods (implicitly public and must be implemented by the implementing class).
Properties, events, and indexers (implicitly abstract).
Static methods and default implementations (from C# 8.0 onwards).
Does not allow fields or constructors.
All members are implicitly public.
System.Object
An abstract class is a great choice if you are bringing into account the inheritance concept because it provides the common base class implementation to the derived classes.
• An abstract class is also good if you want to declare non-public members. In an interface, all methods must be public.
• If you want to add new methods in the future, then it is great to go with the abstract class. Because if you add new methods to the interface, then all of the classes that are already implemented in the interface will have to be changed in order to implement these new methods.
• If you want to create multiple versions of your component, then go with the abstract class
When Should You Use an Interface?
• If you are creating functionality that will be useful across a wide range of objects, then you must use an interface. Abstract classes, at the end of the day, should be used for objects that are closely related. But the interfaces are best suited for providing common functionality to unrelated cases.
• Interfaces are a great choice if you think that the API won’t be changing for a while.
• Interfaces are also a great choice. If you want to have something similar to the multiple inheritances, then you can implement various interfaces.
• If we are going to design the small, concise bits of functionality, then you must use interfaces. But if you are designing the large functional units, then you must use an abstract class.
The purpose of an abstract class is to provide a blueprint for derived classes and set some rules what the derived classes must implement when they inherit an abstract class.
As we cannot create objects of an abstract class, we must create a derived class from it. So that we can access members of the abstract class using the object of the derived class.
ENCAPSULATION:- Encapsulation provides the ability to hide the internal details of an object from its users.The concept of encapsulation is also known as data hiding or information hiding. In c# , Encapsulation is implemented using the access modifier keywords.
• Public
• Private
• protected
• Internal
• Protected Internal
It is also concept of oops. It is ability to take more than one form. An operation may exhibit different behaviour in different situations.
Polymorphism allows methods to perform different tasks depending on the type of object that invokes them.
There are two main types of polymorphism:
Compile-time Polymorphism (Static Binding)
This is achieved through method overloading or operator overloading.
Method Overloading: Defining multiple methods in the same class with the same name but different parameter lists.
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}
In this example, the add method is overloaded to handle both integer and double inputs.
Run-time Polymorphism
This is achieved through method overriding. It involves redefining a method in a subclass that already exists in the parent class.
A static class can not be instantiated: You cannot create an object of a static class.
All methods, fields, and properties in a static class must be declared as static.
A static class cannot have instance constructors, but it can have a static constructor.
static classes are implicitly sealed, meaning they cannot be inherited.
The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. The compiler will guarantee that instances of this class cannot be created. Static classes are sealed and therefore cannot be inherited.
Sealed classes are used to restrict the users from inheriting the class.
A class can be sealed by using the sealed keyword. The keyword tells the compiler that the class is sealed, and therefore, cannot be extended. No class can be derived from a sealed class.
In C#, a sealed method is a method that prevents further overriding in derived classes. This is typically used when you want to allow a method to be overridden in an intermediate class but prevent further modifications in classes derived from it.
To create a sealed method:
The method must first be declared as virtual or override in the base class.
In the derived class, you use the sealed modifier along with the override keyword.
In C#, you can call base class methods in a derived class using the base keyword.
The base keyword is used to access members (fields, properties, and methods) of the base class from within a derived class.
base.DisplayMessage();
In C#, collections are used to group and manage multiple elements. The .NET Framework provides a variety of collection types in the System.Collections and System.Collections.Generic namespaces.
Arrays (T[]): Generic
ArrayList – Non Generic
Hash Table – Non Generic
Lists (List<T>): Generic
Dictionaries (Dictionary<TKey, TValue>): Generic
Sets (HashSet<T>):
Sorted List – Generic & Non Generic
Queues (Queue<T>): Generic
Stacks (Stack<T>): Non Generic
LinkedList (LinkedList<T>):
IEnumerable<T> is an interface in the System.Collections.Generic namespace.
• It represents a forward-only cursor of a collection of T, which means you can iterate over the elements of a collection one at a time.
• List<T> is a class in the System.Collections.Generic namespace.
• It implements the IEnumerable<T> interface, among others, but it goes beyond that.
• List<T> is a dynamic array that can grow or shrink in size, and it provides methods for adding, removing, and modifying elements.
If you only need to iterate over a collection and do not need to modify it, you can use IEnumerable<T>. If you need to perform operations like adding, removing, or sorting elements, then List<T> or another specific collection class might be more appropriate.
In C#, you can use the dynamic keyword as the return type of a method or property to indicate that the type of the result is not known until runtime
Use dynamic only when you have scenarios where the type information is not known until runtime or when working with interop scenarios with dynamic languages or APIs.
Example
public dynamic Postdatagraph(string URL, string body)
{
}
Here this method can return any type.
The var keyword can be used to store any data type value.
The var keyword will know the value assigned to it at compile time while dynamic keyword will resolve value assigned to it at run time.
In C#, the lock statement is used to synchronize access to a shared resource by preventing multiple threads from executing a particular section of code concurrently.
It is a simple and effective way to implement mutual exclusion, ensuring that only one thread can enter the locked region at a time.
In C#, the Main method is the entry point of a console application. When the program is run, the execution begins from the Main method.
In C#, value types and reference types are two fundamental categories that define how data is stored and accessed.
1. Value Types
Definition: Value types store their data directly in the memory location allocated to the variable.
Storage: Stored on the stack (in most cases).
Copying: When you assign a value type variable to another, a copy of the value is made, and the two variables operate independently.
Default behavior: They have a default value (e.g., int defaults to 0).
Example Types:
Built-in types: int, float, bool, char, struct
Enumerations: enum
2. Reference Types
Definition: Reference types store a reference (or pointer) to the actual data in memory. The variable itself holds the memory address where the data is located.
At run time, when you declare a
variable of a reference type, the variable contains the value null until you explicitly
create an instance of the class by using the new operator, or assign it an object of a
compatible type created elsewhere.
Storage: The reference is stored on the stack, but the actual object is stored in the heap.
Copying: When you assign a reference type variable to another, they both refer to the same object. Changes made through one reference are reflected in the other.
Default behavior: They are null by default until explicitly initialized.
Managed code in C# refers to code that is executed by the Common Language Runtime (CLR) of the .NET Framework or .NET Core/5+
Key Characteristics of Managed Code:
Runs in the CLR Environment:
The CLR acts as an intermediary between the operating system and the application, handling execution, memory allocation, and other runtime services.
Garbage Collection:
Automatic memory management helps prevent memory leaks by reclaiming unused objects and resources.
Type Safety:
The CLR enforces strict type safety, which ensures data integrity and prevents illegal type conversions.
Interoperability:
Managed code can interoperate with unmanaged code (code that runs outside the CLR, such as native code written in C or C++). Interoperability features like P/Invoke (Platform Invocation) allow managed applications to call unmanaged libraries.
Security:
Managed code benefits from Code Access Security (CAS) and runtime validations, reducing vulnerabilities like buffer overflows.
Portability:
Managed code written in C# can run on any platform where the .NET runtime is available, such as Windows, Linux, and macOS (via .NET Core or .NET 5+).
In C#, classes and structs are both used to define custom types, but they differ significantly in how they are implemented and used.
Class is Reference type.
Struct is Value type.
2. Memory Allocation
Class:
Allocated on the heap.
Instances are accessed via references (pointers to the object).
Garbage collection manages memory.
Struct:
Allocated on the stack (for local variables) or inline within a containing object.
Directly contains the data.
Memory is automatically freed when the variable goes out of scope.
3. Performance
Class:
Slower for small objects due to heap allocation and garbage collection overhead.
Better for large objects or objects that need to persist for longer durations.
Struct:
Faster for small objects because of stack allocation and no need for garbage collection.
Not ideal for large data because copying occurs when passed around.
4. Inheritance
Class:
Supports inheritance (can derive from other classes and be a base class).
Can be abstract or sealed.
Struct:
Does not support inheritance (cannot inherit from another struct or class, but can implement interfaces).
Always implicitly sealed.
5. Default Constructor
Class:
Can define parameterless or custom constructors.
Default constructor initializes all fields to their default values (null, 0, etc.).
Struct:
Cannot define a parameterless constructor (except in C# 10.0+).
The compiler provides an implicit parameterless constructor that initializes fields to default values.
A stack is a "first in - last out" (FILO) collection. New elements are added to the top of the stack. When an element is removed, it is removed from the top of the stack.
Assemblies contain executable code in the form of Intermediate Language (IL) instructions, and symbolic information in the form of metadata.
Before it's executed, the Just-In-Time (JIT) compiler of .NET Common Language Runtime converts the IL code in an assembly to processor-specific code.
The members of a class are either static members or instance members.
A method declared with a static modifier is a static method. A static method doesn't operate on a specific instance and can only directly access static members.
A method declared without a static modifier is an instance method. An instance method operates on a specific instance and can access both static and instance members.
Static members belong to classes, and instance members belong to objects (instances of classes).
- Constants: Constant values associated with the class
- Fields: Variables that are associated with the class
- Methods: Actions that can be performed by the class
- Properties: Actions associated with reading and writing named properties of the class
- Indexers: Actions associated with indexing instances of the class like an array
- Events: Notifications that can be generated by the class
- Operators: Conversions and expression operators supported by the class
- Constructors: Actions required to initialize instances of the class or the class itself
- Finalizers: Actions performed before instances of the class are permanently discarded
- Types: Nested types declared by the class
In C#, a virtual method is a method that is defined in a base class and can be overridden in derived classes.
Virtual methods are used to achieve polymorphism, which allows you to dynamically determine the method implementation to execute at runtime.
In base class, Use the virtual keyword to mark a method as virtual.
In Derived Class,Use the override keyword to override the virtual method.
If a derived class does not override the method, the base class implementation is used.
In C#, an abstract method is a method that is declared in an abstract class but does not contain any implementation.
It serves as a blueprint for derived classes, which must override the method and provide their own implementation.
Abstract methods are used to enforce a contract or a specific behavior that derived classes must follow.
Abstract methods can only exist in classes marked with the abstract keyword.
Abstract methods do not have a body. They are defined using only their signature.
Any non-abstract class that derives from the abstract class must override all its abstract methods.
Abstract methods must be public, protected, or protected internal since they need to be accessible to derived classes.
Static Constructor
A static constructor is used to initialize static members of a class. It is executed once when the type is first accessed, not when an instance of the class is created.
The static constructor is called automatically by the runtime before any static members are accessed or any instances are created
the static constructor cannot be called directly. It is invoked automatically by the runtime.
static constructors do not take parameters.
Static constructors cannot have an access modifier
Instance Constructor
An instance constructor is used to initialize instance members of a class when a new object is created.
The instance constructor is called when an object of the class is instantiated using the new keyword.
An indexer is a member that enables objects to be indexed in the same way as an array.
An indexer is declared like a property except that the name of the member is this followed by a parameter list written between the delimiters [ and ]. Indexers can be overloaded.
An event is a member that enables a class or object to provide notifications.
An event is declared like a field except that the declaration includes an event keyword and the type must be a delegate type.
An operator is a member that defines the meaning of applying a particular expression operator to instances of a class.
Three kinds of operators can be defined:
unary operators, binary operators, and conversion operators.
All operators must be declared as public and static.
A finalizer is a member that implements the actions required to finalize an instance of a class. Typically, a finalizer is needed to release unmanaged resources.
Finalizers can't have parameters, they can't have accessibility modifiers, and they can't be invoked explicitly.
The finalizer for an instance is invoked automatically during garbage collection.
An array is a data structure that contains a number of variables that are accessed through computed indices. The variables contained in an array, also called the elements of the array, are all of the same type. This type is called the element type of the array.
int[] a = new int[10];
int[] a1 = new int[10];
int[,] a2 = new int[10, 5];
string interpolation enables you to format strings by defining expressions whose results are placed in a format string. For example, the following example prints the temperature on a given day from a set of weather data:
Console.WriteLine($"The low and high temperature on {weatherData.Date:MM-DD-YYYY}");
In C#, a delegate is a type that defines a method signature and can hold references to methods with a matching signature.
Essentially, a delegate is like a pointer to a method, allowing methods to be passed as parameters and invoked dynamically at runtime.
Delegates are used in scenarios such as event handling, callback mechanisms, or passing methods as arguments.
|
An Array is strongly-typed. We can store only the same type of data. |
ArrayList is a non-generic collection type. ArrayList's internal Array is of the object type. So, we can store multiple types of data in ArrayList. |
|
Array stores a fixed number of elements. |
ArrayList is dynamic in term of capacity. If the number of element exceeds, ArrayList will increase to double its current size. |
|
Array provides better performance than ArrayList. |
If we are using a large number of ArrayList then it degrades performance because of boxing and unboxing. |
|
Array uses static helper class Array which belongs to system namespace |
ArrayList implements an IList interface so, it provides a method that we can use for easy implementation. |
|
Array belongs to namespace System |
ArrayList belongs to namespace System.Collection |
|
The Array cannot accept null. |
An Array can accept null. |
|
Example:string[] array1=new string[5];array1[0]=”Hello”;array1[1]=”Bye”; |
Example:ArrayList a1=new ArryList();a1.add(null);a1.insert(1,”hi”);a1.add(3);a1.add(8.23); |
What is CTS ?
In C#, CTS stands for the Common Type System. It is a core component of the .NET Framework that defines how types are declared, used, and managed across different .NET languages (such as C#, VB.NET, and F#).
The CTS provides a standard for data types, ensuring that types in one language can interoperate with types in another language seamlessly.
Examples of CTS Types:
Primitive Types: int, bool, char, double
Specialized Types: DateTime, Guid
Reference Types: string, object, class, delegate, array
Value Types: struct, enum
By using the params keyword to indicate that a parameter is a parameter array, you allow your method to be called with a variable number of arguments. The parameter tagged with the params keyword must be an array type, and it must be the last parameter in the method's parameter list.
Optional parameters are specified by including the parameter's default value in the method definition. When the method is called, if no argument is supplied for an optional parameter, the default value is used instead.
Properties behave like fields when they are accessed. However, unlike fields, properties are implemented with accessors that define the statements executed when a property is accessed or assigned.
yes.
Example
public string FirstName { get; set; } = string.Empty;
You can write code in the set accessor to ensure that the values represented by a property are always valid.
public string FirstName
{
get => firstName;
set
{
if (string.IsNullOrWhiteSpace(value))
throw new ArgumentException("First name must not be blank");
firstName = value;
}
}
private string firstName;
You can create read-only properties,
public string FirstName { get; private set; }
Generics in C# allow you to define classes, methods, and data structures with a placeholder for the data type. This enables you to write more reusable and type-safe code, as the type is specified only when the class or method is instantiated or called.
You can create generic class,generic method,generic interface,
generic collections,Nullable types
Benefits of Generics:
C# allows you to constrain the types used with generics. For example, you can restrict the type to classes, interfaces, or even specific base classes.
Type Safety: Generics ensure that you are working with the expected type, reducing runtime errors.
Code Reusability: You can write more flexible and reusable code without duplicating it for different types.
Performance: Since generics work with the type directly (without boxing or unboxing), they can be more performant than using object.
var replacement = source.Replace("mountains", "peaks");
You can use the String.Trim, String.TrimStart, and String.TrimEnd methods to remove any leading or trailing white space.
You can remove text from a string using the String.Remove method.
Yes. using StringComparison.OrdinalIgnoreCase
Example :
bool areEqual = String.Equals(root, root2, StringComparison.OrdinalIgnoreCase);
In C#, the method Object.ReferenceEquals() is used to determine whether two object references refer to the same object in memory. This is a static method in the Object class and can be called on any object type.
Object.ReferenceEquals() compares references, not the actual contents of the objects. This means it checks if the two references are pointing to the same memory location, not whether the objects themselves are equivalent in value.
This method is typically used for comparing reference types (like classes) and can be useful for checking if two variables refer to the same object or if they are pointing to different objects.
Implicit conversions:
Explicit conversions
User-defined conversions:
Conversions with helper classes:
Single Inheritance :-
A derived class that inherits from only one base class. :-
A derived class that inherits from a base class and the derived class itself becomes the base class for another derived class.
Multi level Inheritance :-
Multi-level inheritance occurs when a class is derived from a class that is already derived from another class. In C#, multi-level inheritance follows this structure:
Class A → Class B (inherits A) → Class C (inherits B)
Hierarchial Inheritance :-
Hierarchical Inheritance in C# occurs when multiple child classes inherit from a single parent class. This form of inheritance allows sharing of common functionality defined in the base class while enabling each derived class to implement its unique features.
Multiple Inheritance (using infterface)
C# allows a class to implement multiple interfaces, enabling multiple inheritance-like behavior.
By creating a private constructor.
In C#, operator overloading allows you to define custom behavior for operators when they are used with user-defined types (e.g., classes or structs). This is particularly useful when you want to perform operations on instances of your own types in a natural and intuitive way, just like primitive types.
To overload an operator, you must define a special method in your class or struct using the operator keyword. The method has to be public and static.
In C#, both const and readonly are used to define fields that cannot be modified after their initialization, but they are used in different contexts and have distinct behaviors.
A const field must be assigned a value at the time of its declaration, and that value is fixed at compile time.
const fields are implicitly static, meaning they belong to the type itself rather than to any instance of the class. They cannot be changed at runtime.
const values are typically used for values that are known at compile time (e.g., mathematical constants or configuration settings).
A readonly field can be assigned a value only at the time of declaration or within the constructor of the class. The value can be different for each instance of the class (if it’s an instance field).
readonly fields are not automatically static, so they can be either instance or static fields.
readonly is useful for values that are determined at runtime or that might depend on constructor parameters or other logic.
Internal
In C#, a nullable type is a value type that can also represent null, in addition to its normal range of values. This is particularly useful for value types (like int, double, bool, etc.) which, by default, cannot be assigned null. Nullable types are commonly used when working with databases or situations where a value might be missing or undefined.
Example :
int? myNullableInt = null; // Nullable int
double? myNullableDouble = 3.14; // Nullable double
bool? myNullableBool = null; // Nullable boolean
In C#, method parameters can be specified with various types depending on the kind of data or behavior you want to define.
You can use C#'s primitive data types as parameters in methods.
Example
int
double
char
bool
string
float
long
decimal
byte
You can use reference types such as arrays, objects, or collections as method parameters.
object
array
List<T>
Dictionary<K, V>
Any class or interface type
C# allows for nullable value types. If you want to allow a value type to be null, you can use Nullable<T> or the shorthand T?.
out parameters allow a method to return more than one value. The method must assign a value to an out parameter before it returns.
ref parameters allow you to pass a variable by reference, meaning any changes to the parameter in the method will reflect back in the caller.
params allows you to pass a variable number of arguments to a method, which will be treated as an array.
You can define method parameters that are of a generic type, allowing the method to work with any type while maintaining type safety.
In C#, the as keyword is used for safe type casting. It attempts to cast an object to a specific type, but unlike a direct cast, it will return null instead of throwing an exception if the cast is invalid.
In C#, the unsafe keyword is used to allow code to bypass certain safety checks imposed by the runtime, enabling low-level operations that are typically not allowed in the safe managed environment of C#. This is necessary when working with pointers, directly manipulating memory, or interacting with unmanaged code.
Example for a unsafe method -
public unsafe void UnsafeMethod()
{
int* p = null; // Declaring a pointer
}
string: In C#, a string is immutable, meaning once it is created, its value cannot be changed. When you modify a string, a new string object is created in memory, and the old string remains unchanged. This can lead to inefficiency when performing multiple modifications (e.g., concatenations) on a string.
StringBuilder:
A StringBuilder, on the other hand, is mutable, meaning you can modify the contents of a StringBuilder without creating new objects. This makes it more efficient than string when performing many concatenations or modifications, as it doesn't have the overhead of creating new objects every time.
In C#, the Dispose method is part of the IDisposable interface, which is used to release unmanaged resources, such as file handles, database connections, or memory allocations that are not handled by the garbage collector.
The purpose of implementing Dispose is to ensure that these resources are properly cleaned up when no longer needed, preventing memory leaks and other resource-related issues.
Serialization in C# is the process of converting an object into a format that can be easily stored, transmitted, or reconstructed later. The most common formats are binary, XML, and JSON. The reverse operation, converting data back into an object, is called deserialization.
Binary Serialization: Converts an object to a binary format.
Can be used to store objects in files or streams.
XML Serialization: Converts an object to an XML format.
Uses attributes to specify the serializable members.
JSON Serialization: Converts an object to a JSON format.
Libraries like Newtonsoft.Json or System.Text.Json are typically used.
[Serializable]: The attribute used to mark a class as serializable in C# (for binary serialization).
Create another class which inherits this abstract class and in main class you can call this newly created class and required method.
In C#, a partial class is a class that can be split across multiple files. This allows you to define the class in more than one file, and when the program is compiled, all parts of the class are combined into a single class.
To create a partial class, you simply use the partial keyword before the class definition.
All parts of a partial class must share the same class name and namespace.
It is particularly useful for large classes, auto-generated code (e.g., designer files in WinForms or ASP.NET), or when working with teams.
Even though the class is split across multiple files, the compiler treats them as one single class.
All parts of the partial class must be in the same assembly and namespace.
You cannot define static members in one partial class and instance members in another—both parts must share the same static or instance context.
Allows large classes to be split into smaller, more manageable files.
Multiple developers can work on different parts of the same class simultaneously without interfering with each other.
In C#, a partial method is a method declaration that can be defined in multiple parts across different files, which is especially useful when working with code generation scenarios. Partial methods allow developers to provide the declaration of a method in one part of the partial class or struct and optionally define its implementation in another part.
Features
A partial method consists of a declaration and an optional implementation. The declaration is in one part of the class, and the implementation can be in another part, or it can be omitted altogether.
Partial methods must always have a void return type. You cannot return values from a partial method.
Partial methods cannot have access modifiers like public, private, or protected. They are implicitly private.
Design patterns are proven solutions to common software design problems. They provide a template for solving a problem in a way that is reusable, flexible, and maintainable.
There are 23 design patterns, also known as Gang of Four (GoF) design patterns. They are categorised as Creational,Structural & Behavioural
Creational Design Pattern - It is used for Object Creation and Initialization.
There are 5 patterns in this category.
Factory Method
Abstract Factory
Builder
Prototype
Singleton
Structural Design Patterns - It is used to Manage the Structure of Classes and Interfaces and the Relationship Between the Classes and Interfaces.
There are 7 patterns in this category.
Adapter
Bridge
Composite
Decorator
Façade
Flyweight
Proxy
Behavioral Design Patterns - It is used to define the Communication Between Classes and Objects.
There are 11 patterns in this category.
Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor
Template Method
In C#, a nested class is a class that is defined within another class. Nested classes can be useful when you want to logically group a class within another, making the design more modular and readable. Nested classes can access the members (fields, methods) of the outer class, depending on the access modifiers, but the outer class cannot access the members of the nested class unless they are explicitly provided.
The access level of a nested class (such as public, private, protected, etc.) is independent of the outer class. You can control the visibility of the nested class.
A nested class can access all the members of the outer class if they are public, protected, or internal. However, a non-static nested class can access instance members of the outer class, while a static nested class can only access static members of the outer class.
A nested class that is marked as static can only access static members of the outer class.
A nested class that is not marked as static can access both static and instance members of the outer class.
Create this class as Sealed.
Create this class as Abstract
In C#, an extension method allows you to add new functionality to existing types without modifying their source code. You can create extension methods for types like classes, structs, or interfaces that you don’t have control over. The extension method must be static and defined in a static class.
Define a static class.
Create a static method within that class.
The first parameter of the method specifies the type to which the method is being added, preceded by the this keyword.
Example
using System;
public static class StringExtensions
{
// Extension method to reverse a string
public static string ReverseString(this string str)
{
char[] charArray = str.ToCharArray();
Array.Reverse(charArray);
return new string(charArray);
}
}
There are 5 methods of the system.object.
Tostring(),
GetHashCode,
Equals,
Finalize,
GetType()
A Constructor
B Constructor
C Constructor
A Constructor
B Constructor
C Constructor
A Constructor
B Constructor
C Constructor
Arrays are type-safe, meaning they store elements of a specific type. This avoids the overhead of boxing and unboxing for value types.
ArrayList is non-generic and stores objects, which requires boxing (converting a value type to an object) and unboxing (retrieving the value type from the object). This adds significant overhead for value types.
Asynchronous Programming: Allows tasks to run in the background without blocking the main thread. This is especially useful for tasks like I/O operations, network calls, or any time-consuming process.
async Keyword: Marks a method as asynchronous. This means the method can use the await keyword and may return a task.
await Keyword: Pauses the execution of an async method until the awaited task is complete, without blocking the thread.
A lambda expression in C# is a concise way to represent an anonymous method, commonly used for short operations or when passing a method as a parameter.
Lambda expressions are particularly useful in LINQ queries and event handling.
Benefits
Concise and readable syntax.
Reduces boilerplate code for anonymous methods.
Great for functional-style programming in C#.
In C#, directives are special instructions to the compiler that affect the way the code is processed. Directives are not part of the program's runtime and do not produce any executable code.
They are primarily used for conditional compilation, managing warnings, and including namespaces.
Some common type directives:
Preprocessor Directives
Preprocessor directives begin with the # symbol and are used to control the compilation process. Some common preprocessor directives include:
Example :
#if,#else,#elif,#endif
Interfaces can contain instance methods, properties, events, indexers, or any
combination of those four member types. Interfaces may contain static constructors.
A generic class in C# is a class that allows you to define it with a placeholder for the type of data it stores or processes.
This allows the same class to work with different data types without requiring code duplication.
Generics increase type safety and reusability by catching errors at compile time and avoiding the need for explicit type casting.
Features of Generic Classes in C#
Type Safety: Allows you to avoid runtime type-casting errors.
Code Reusability: One class can work with various types without code duplication.
Performance: Eliminates the overhead of boxing and unboxing for value types.
Flexibility: Works with complex data types like custom classes and collections.
Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without having to explicitly define a type first.
The type name is generated by the compiler and is not available at the source code level. The type of each property is inferred by the compiler.
You create anonymous types by using the new operator together with an object initializer.
Anonymous types contain one or more public read-only properties. No other kinds of class members, such as methods or events, are valid.
By using new modifier.
In C#, virtual members are class members (methods, properties, events) that you can override in a derived class. The virtual keyword is used to allow this behavior.
It essentially marks the member as being able to be redefined by subclasses, enabling polymorphism.
In C#, tuples are a lightweight data structure that allows you to group multiple elements of potentially different types into a single object.
They are especially useful for returning multiple values from a method or for quick grouping of data without creating a separate class or struct.
Example :
var tuple = Tuple.Create(1, "example", true);
Console.WriteLine(tuple.Item1); // 1
Console.WriteLine(tuple.Item2); // "example"
Console.WriteLine(tuple.Item3); // true
A finally block enables you to clean up actions that are performed in a try block. If present, the finally block executes last, after the try block and any matched catch block. A finally block always runs, whether an exception is thrown or a catch block matching the exception type is found.
The finally block can be used to release resources such as file streams, database connections, and graphics handles without waiting for the garbage collector in the runtime to finalize the objects.
it has 2 purposes
1.Namespace Declaration
The using keyword is used to include namespaces in a C# program, allowing you to access classes and methods defined in those namespaces without needing to qualify them with their full names.
2. Resource management.
The using statement can ensure that resources such as file handles, database connections, or other IDisposable objects are properly disposed of when no longer needed.
It has many purposes depending on the situation.
The most common use of the new operator is to create an instance of a class.
You can also use the new operator to create arrays.
When creating an object, the new operator invokes the constructor of the class.
The new modifier is used in a derived class to hide a member of the base class that has the same name. This is different from overriding.
The new operator is also used to create anonymous types.
you can use new to create instances of structs.
In generics, you can use the new() constraint to specify that the type parameter must have a parameterless constructor.
With records, you can use new() for concise initialization.
Call static members by using the class name: ClassName.StaticMember.
This practice makes code more readable by making static access clear.
Reflection in C# is a powerful feature of the .NET framework that allows you to inspect and manipulate the metadata of types, assemblies, and objects at runtime.
This includes examining the properties, methods, events, fields, and other metadata of a type, as well as creating instances of types, invoking methods, or accessing fields and properties dynamically.
The System.Reflection namespace contains the classes and methods necessary for reflection.
Viewing information about assemblies, types, and their members.
Invoking methods at runtime without knowing them at compile time.
Loading assemblies and types dynamically for extensibility.
Converting objects to and from storage formats using metadata.
This is to perform a conditional operation, often used as a shorthand for simple if-else statements.
Example :
int number = 10;
string result = number > 5 ? "Greater than 5" : "5 or less";
Console.WriteLine(result); // Output: "Greater than 5"
If the condition is true, the value of expression1 ("Greater than 5") is returned.
In C#, projection typically refers to the process of transforming or mapping data from one form (or type) to another, often used when working with collections like lists or arrays. A common use case is with LINQ (Language Integrated Query), where you can project elements of a collection into a new form using the Select method.
The standard query operator methods that perform projection are
select,selectmany,Zip
Task, for an async method that performs an operation but returns no value.
Task<TResult>, for an async method that returns a value.
void , for an event handler.
Any type that has an accessible GetAwaiter method. The object returned by the GetAwaiter method must implement the system.Runtime.CompilerServices.ICriticalNotifyCompletion interface.
IAsyncEnumerable<T>, for an async method that returns an async stream
An iterator is an object that traverses a container, particularly lists.
Iterators can be used for:
Performing an action on each item in a collection.
Enumerating a custom collection.
Extending LINQ or other libraries.
Creating a data pipeline where data flows efficiently through iterator methods.
Example
foreach loop
IEnumerable interface
Multicast delegates in C# are a type of delegate that can reference multiple methods at the same time.
When a multicast delegate is invoked, all the methods in its invocation list are called sequentially.
Multicast delegates are especially useful in scenarios like event handling, where multiple listeners might need to respond to a single event.
To concatenate string variables, you can use the + or += operators, string interpolation or the String.Format, String.Concat, String.Join or StringBuilder.Append methods.
The String.Contains, String.StartsWith, and String.EndsWith methods search a string for specific text.
The IndexOf and LastIndexOf methods also search for text in strings. These methods return the location of the text being sought. If the text isn't found, they return -1 .
The System.Text.RegularExpressions.Regex class can be used to search strings.
using Replace method
Sample Code:
string original = "Hello, John!";
string modified = original.Replace("John", "Smith");
The modified string will be Hello Smith.
You can use the String.Trim, String.TrimStart, and String.TrimEnd methods to remove any leading or trailing white space.
You can remove text from a string using the String.Remove method. This method removes a number of characters starting at a specific index.
using Equals method.
Exporting data to Excel in C# can be accomplished using libraries such as EPPlus, ClosedXML, or Microsoft Interop.Excel.
In C#, you can create dynamic objects using the dynamic keyword, which allows for runtime binding instead of compile-time binding.
This is particularly useful when working with objects whose types are not known until runtime, or when you need to interact with data that doesn't adhere to a strict schema. (e.g., JSON data, COM objects, etc.).
Example
dynamic obj = new ExpandoObject();
obj.Name = "John Doe"; // Property added dynamically
obj.Age = 30; // Another dynamic property
Console.WriteLine($"{obj.Name} is {obj.Age} years old.");
In C#, variance in delegates refers to the ability to use more flexible types in generic delegate assignments.
Variance allows a delegate to be assigned to another delegate of a different type under specific conditions. Variance in C# is introduced with covariance and contravariance.
Covariance allows you to use a more derived type than originally specified. It applies to output parameters (return values)
Contravariance allows you to use a less derived type than originally specified. It applies to input parameters.
In C#, indexers allow objects to be indexed in a similar way to arrays. They are a syntactic convenience that enables you to use the square bracket notation ([]) to access data members of a class or struct.
An indexer is defined using the this keyword in a class or struct
Indexers have get and set accessors, just like properties.
The indexer can take multiple parameters, but commonly, it uses a single parameter.
Indexers can have multiple parameters, making them versatile for multidimensional access.
Indexers are similar to properties but are accessed using an index ([]) instead of a name.
When your class logically represents a collection of data (e.g., a list, dictionary, or matrix).
To make your class API more intuitive and familiar, resembling standard collection access patterns.
In C#, reference equality determines whether two object references point to the same instance in memory. This is different from value equality, which checks whether two objects have the same data or value.
there are some methods for this.
The static method Object.ReferenceEquals explicitly checks if two object references point to the same memory location.
By default, for reference types, the == operator checks for reference equality.
In C#, conversions refer to transforming a value from one data type to another. These conversions can be categorized into two types:
1. Implicit Conversions
Automatically performed by the compiler.
Safe and do not lead to data loss.
Typically occurs when converting from a smaller to a larger data type.
example
int intValue = 42;
double doubleValue = intValue; // Implicit conversion
2. Explicit Conversions (Casting)
Requires a cast operator to specify the conversion.
Used when there is potential for data loss or when converting between incompatible types
Example
double doubleValue = 42.5;
int intValue = (int)doubleValue; // Explicit conversion (casting)
Boxing
The process of converting a value type into a reference type.
Example
int number = 123; // Value type
object boxedNumber = number; // Boxing
Unboxing :
The reverse process of converting a reference type back into a value type.
Example
object boxedNumber = 123; // Boxing
int number = (int)boxedNumber; // Unboxing
Boxing and unboxing are computationally expensive because they involve memory allocation and copying between the stack and heap.
Use generic collections like List<T>, which eliminate the need for boxing and unboxing.
Use Nullable<T> for nullable value types instead of boxing.
Using int.Parse()
Convert.ToInt32()
Int.TryParse()
Declare a ToString method with the following modifiers and return type
Implement the method so that it returns a string.
Example
The following example returns the name of the class in addition to the data
specific to a particular instance of the class.
class Person
{
public string Name { get; set; }
public int Age { get; set; }
public override string ToString()
{
return "Person: " + Name + " " + Age;
}
}
Person person = new Person { Name = "John", Age = 12 };
Console.WriteLine(person);
// Output:
// Person: John 12
True
Instance fields are specific to an instance of a type.
a static field belongs to the type itself, and is shared among all instances of that type.
A read-only field can only be assigned a value during initialization or in a constructor.
A static readonly field is similar to a constant, except that the C# compiler doesn't have access to the value of a static read-only field at compile time, only at run time.
Constants are immutable values which are known at compile time and do not change for the life of the program. Constants are declared with the const modifier.
Only the C# built-in types may be declared as const.
Example
public const int Months = 12;
The get and set accessors are used to define how a property is accessed and modified. A property in C# is a member that provides a mechanism to read, write, or compute the values of private fields.
Example
public class MyClass
{
private int _myField; // Private field
public int MyProperty // Public property
{
get
{
return _myField; // This is the getter accessor
}
set
{
_myField = value; // This is the setter accessor
}
}
}
Getter (get): The get accessor retrieves the value of the property.
Setter (set): The set accessor assigns a value to the property.
You can write auto implemented property without defining get and set accessors.
Example
public class MyClass
{
public int MyProperty { get; set; } // Auto-implemented property
}
In C#, yield is used in conjunction with the yield return and yield break keywords to simplify the process of creating iterators for collections or sequences of data.
It is commonly used in methods that return IEnumerable or IEnumerator types, allowing for lazy evaluation of collections.
False
Named arguments enable you to specify an argument for a parameter by matching the argument with its name rather than with its position in the parameter list.
Example
public void DisplayPersonInfo(string name, int age, string city)
{
Console.WriteLine($"Name: {name}, Age: {age}, City: {city}");
}
// Calling method with named arguments
DisplayPersonInfo(name: "John", age: 30, city: "New York");
Optional arguments enable you to omit arguments for some parameters. Both techniques can be used with methods, indexers, constructors, and delegates.
Example for Optional arguments
public void MyMethod(int requiredParam, string optionalParam = "default value")
{
Console.WriteLine($"Required: {requiredParam}, Optional: {optionalParam}");
}
requiredParam is a regular parameter, and it must be provided when calling the method.
optionalParam has a default value of "default value", so it is optional and can be omitted when calling the method.
True
In C#, you can call a base class constructor using the base keyword. This is typically done in a derived class constructor to ensure that the base class is properly initialized.
Example
class BaseClass
{
public BaseClass(string name)
{
Console.WriteLine($"Base class constructor called with name: {name}");
}
}
class DerivedClass : BaseClass
{
public DerivedClass(string name) : base(name) // Passing argument to base constructor
{
Console.WriteLine("Derived class constructor called.");
}
}
class Program
{
static void Main()
{
DerivedClass derivedObj = new DerivedClass("John");
}
}
In C#, a copy constructor is a special constructor that creates a new object as a copy of an existing object of the same class.
This is useful for duplicating an object with the same values or properties.
A copy constructor is typically used when you want to perform a deep copy or simply clone an object.
Sample Code
using System;
class Person
{
public string Name { get; set; }
public int Age { get; set; }
// Default constructor
public Person() { }
// Parameterized constructor
public Person(string name, int age)
{
Name = name;
Age = age;
}
// Copy constructor
public Person(Person other)
{
Name = other.Name;
Age = other.Age;
}
public void Display()
{
Console.WriteLine($"Name: {Name}, Age: {Age}");
}
}
class Program
{
static void Main()
{
Person person1 = new Person("Alice", 30);
Person person2 = new Person(person1); // Using the copy constructor
person2.Name = "Bob"; // Modifying the copy
person1.Display(); // Original remains unchanged
person2.Display(); // Copy reflects the changes
}
}
Object initializers let you assign values to any accessible fields or properties of an object at creation time without having to invoke a constructor followed by lines of assignment statements.
227. What is Collection initializers ?
Collection initializers let you specify one or more element initializers when you initialize a collection type that implements IEnumerable and has Add with the appropriate signature as an instance method or an extension method.
Example :
List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
A type defined within a class, struct, or interface is called a nested type.
Regardless of whether the outer type is a class, interface, or struct, nested types default to private; they are accessible only from their containing type.
Example of nested class
public class Container
{
public class Nested
{
Nested() { }
}
}
The nested, or inner, type can access the containing, or outer, type. To access the containing type, pass it as an argument to the constructor of the nested type.
In C#, the string keyword is an alias for String; therefore, String and string are
equivalent.
To determine whether a string is a valid representation of a specified numeric type, use the static TryParse method that is implemented by all primitive numeric types and also by types such as DateTime and IPAddress.
Generic type parameters in C# allow you to create classes, methods, interfaces, or structures that can work with any data type, while maintaining strong typing. They enable code reusability and type safety.
Task
Task<TResult>
void.
The extern modifier is used to declare a method that is implemented externally.
A common use of the extern modifier is with the DllImport attribute when you are using Interop services to call into unmanaged code.
In this case, the method must also be declared as static
Example
If you want to use MessageBox in web application, you have to import User32.dll library.
//using System.Runtime.InteropServices;
class ExternTest
{
[DllImport("User32.dll", CharSet=CharSet.Unicode)]
public static extern int MessageBox(IntPtr h, string m, string c, int type);
static int Main()
{
string myString;
Console.Write("Enter your message: ");
myString = Console.ReadLine();
return MessageBox((IntPtr)0, myString, "My Message Box", 0);
}
}
In C#, ref and out are keywords used to pass arguments by reference to methods. While both allow a method to modify the value of the parameter passed, they differ in how they are initialized and used.
ref Keyword
Purpose: Passes a variable by reference, allowing the method to modify its value.
Initialization: The variable must be initialized before being passed to the method.
Use Case: Use ref when the value of the variable is expected to be both read and modified by the called method.
out Keyword
Purpose: Passes a variable by reference but is primarily used to output data from the method.
Initialization: The variable does not need to be initialized before being passed to the method. However, the method must assign a value to the out parameter before returning.
Use Case: Use out when the method is expected to return a value through the parameter.
The this keyword refers to the current instance of the class and is also used as a modifier of the first parameter of an extension method.
Arithmetic operators that perform arithmetic operations with numeric operands.
Comparison operators that compare numeric operands.
Boolean logical operators that perform logical operations with bool operands.
Bitwise and shift operators that perform bitwise or shift operations with operands of the integral types.
Equality operators that check if their operands are equal or not.
The var keyword in C# is used to declare a variable with an implicitly typed local variable. The compiler infers the type of the variable from the type of the value that is assigned to it.
The type of the variable is determined by the type of the value assigned during declaration.
A var variable must be initialized at the time of declaration
Accept default values
Field initializers
Constructor parameters
Object initializers
For number default value is 0 and for reference default value is null.
Stack allocation is faster and automatically cleaned up when the method ends.
Value types tend to have better cache locality because they are allocated contiguously on the stack or within arrays. This can lead to better performance in CPU-bound operations.
SOLID design principles in C# are basic design principles
These principles are often used to improve code structure and reduce dependencies.
1. Single Responsibility Principle (SRP)
A class should have one and only one reason to change. It should only do one thing.
2. Open/Closed Principle (OCP)
Definition: A class should be open for extension but closed for modification.
3. Liskov Substitution Principle (LSP)
Definition: Objects of a superclass should be replaceable with objects of a subclass without altering the correctness of the program.
4. Interface Segregation Principle (ISP)
Definition: A class should not be forced to implement interfaces it does not use.
5. Dependency Inversion Principle (DIP)
Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions.
Managed code runs on the managed runtime environment than the operating system itself.
Benefits: Provides various services like a garbage collector, exception handling, etc.
Unmanaged code is when the code doesn’t run on CLR, it is an unmanaged code that works outside the .NET framework.
These are used to compare objects, values, or references.
The == operator is used to check for equality. Its behavior depends on the type of the operands:
Late binding and early binding are examples of one of the primary concepts of OOPS: Polymorphism.
Early Binding
The method or property call is resolved at compile-time. and so it is faster.
The compiler determines the method or property to invoke based on the declared type of the object, not the actual type.
The compiler ensures that the method or property exists and the arguments are valid.
Late Binding
The method or property call is resolved at runtime and hence it is slow.
The runtime determines which method or property to invoke based on the actual type of the object.
To set the class to be inherited, it needs to be declared as public. The method needs to be sealed to prevent any overrides
An “is” operator can be used to check an object’s compatibility with respect to a given type, and the result is returned as a Boolean.
An “as” operator can be used for casting an object to either a type or a class.
A singleton in C# is a design pattern that ensures a class has only one instance throughout the lifetime of an application and provides a global access point to that instance.
It is commonly used when a single instance is required to coordinate actions, such as configuration managers, logging services, or database connection pools.
main features :
Only one instance of the class exists.
The instance is accessible globally within the application.
The class controls the creation of the instance to ensure there's only one.
A race condition in C# occurs when the behavior of a program depends on the relative timing of events, such as the execution order of threads or tasks, and this timing is not deterministic.
It often happens when multiple threads access shared resources (like variables or data structures) concurrently without proper synchronization, leading to unpredictable or incorrect results.
To avoid race conditions in C#, you can use synchronization techniques
The lock statement prevents multiple threads from entering a critical section of code simultaneously.
The Interlocked class provides atomic operations for variables.
The Monitor class allows fine-grained control over locking and synchronization.
In C#, pointers are a low-level construct used to directly work with memory addresses, similar to pointers in C or C++.
They allow you to manipulate memory locations directly, which can be useful in scenarios requiring high performance, such as interfacing with hardware or unmanaged code.
its features
Pointers can only be used in an unsafe context.
Pointers are often used when calling unmanaged code through P/Invoke or working with C-style APIs.
Function calling itself is called Recursion.
Recursion is a process in which a function calls itself repeatedly until some specified condition has been satisfied.
Reference or output parameters can be used to return multiple values from a function.
By default, the access level of interface is internal.
The default access level for all interface members is public.
Compile time polymorphism (method overloading)
Runtime polymorphism. (method overriding)
The access modifiers are used to define the visibility of classes, methods, properties, and fields..
In C#, tasks and threads are both used for managing asynchronous and parallel execution, but they are conceptually and functionally different.
Thread:
A thread is the smallest unit of execution in a process.
It provides low-level control over execution, typically using the System.Threading.Thread class.
Threads require explicit management for starting, stopping, synchronization, and resource handling.
Task:
A task is a higher-level abstraction over threads, part of the Task Parallel Library (TPL), using the System.Threading.Tasks.Task class.
It represents a unit of work that runs asynchronously and can return a result.
Tasks make it easier to work with asynchronous and parallel programming by abstracting the thread management.
In C#, a destructor is a special method used to clean up resources when an object is destroyed.
It is called automatically by the garbage collector when the object is no longer in use.
However, destructors are rarely used in C#, as the garbage collector usually handles resource cleanup efficiently.
Preprocessing: Directives are processed (#include, #define).
Compilation: Source code translated into intermediate language (IL).
Assembly: IL code packaged into assemblies (DLL or EXE).
Execution: Just-in-time (JIT) compiler translates IL to native code for specific platforms during runtime.
What is enum ?
An enum in C# is a value type that defines a set of named constants representing integral values.
It provides a way to create named numeric constants, making the code more readable and self-documenting.
Example
{
SelectBalance = 1,
Select = 2,
Selectall = 3,
tdsbalance=2,
RetensionBalance = 3
}
In C#, both Dispose and Finalize are mechanisms for resource cleanup, but they serve different purposes and are used in different contexts.
Dispose
Provides a way to explicitly release unmanaged resources like file handles, database connections, etc., without waiting for the garbage collector.
To implement a dispose, Implement the IDisposable interface and define the cleanup logic in the Dispose method.
Implementing IDisposable allows the using statement to manage cleanup automatically.
Use GC.SuppressFinalize in Dispose to prevent the garbage collector from calling the finalizer.
Finalize
Cleanup unmanaged resources if Dispose wasn't called explicitly. It's a safety net.
A class can define a finalizer (~ClassName()) that the garbage collector calls just before reclaiming the object's memory.
Finalizers are non-deterministic (you don't know when the garbage collector will call them).
Finalizers can negatively affect performance because they increase the workload of the garbage collector.
In C#, SortedList is a collection that stores key-value pairs, maintaining the keys in sorted order. It is part of the System.Collections namespace.
This makes it useful when you need quick lookups and automatic ordering of keys.
Features
Sorted Order: Keys are always kept in ascending order.
Key-Value Pair: Similar to a dictionary, but the order is maintained.
Index Access: Provides index-based access to keys and values, unlike a SortedDictionary.
Duplicates: No duplicate keys are allowed.
In C#, a generic method allows you to define a method with a placeholder for the data type, which provides flexibility by working with any data type specified at the call site.
This is often done with a type parameter T, where T represents the type that will be specified when the method is called.
You can apply constraints to T using a syntax like where T : constraint. This ensures that the generic type meets certain requirements (e.g., being a class, an interface, a specific type, etc.).
public void Print<T>(T item)
{
Console.WriteLine(item);
}
static void Main()
{
Print<int>(42); // Prints: 42
Print<string>("Hello, Generics!"); // Prints: Hello, Generics!
}
You can specify constraints on the generic type parameter:
where T : class – T must be a reference type.
where T : struct – T must be a value type.
where T : new() – T must have a parameterless constructor.
where T : SomeInterface – T must implement SomeInterface.
where T : SomeBaseClass – T must inherit from SomeBaseClass.
Multiple Constraints Example
public T CreateInstance<T>() where T : class, new()
{
return new T();
}
In this example, T must be a reference type (class) and have a parameterless constructor (new()).
static void Main()
{
CreateInstance<List<string>>(); // Creates a new List<string>
}
TransactionScopeAsyncFlowOption.Enabled is an option in .NET's TransactionScope class that ensures transaction flow across asynchronous code.
This option is essential when working with asynchronous methods (async/await) to maintain transaction consistency across different threads.
In asynchronous programming, each await can potentially switch to a different thread. By default, TransactionScope does not flow across asynchronous continuations, which could lead to inconsistent behavior.
Setting TransactionScopeAsyncFlowOption.Enabled ensures that the ambient transaction remains consistent, even when switching threads.
Sample Code
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
// Perform database operations asynchronously
await SomeDatabaseOperationAsync();
// Complete the transaction
scope.Complete();
}
In C#, Parse and TryParse are methods used to convert strings into specific data types (like int, double, DateTime, etc.). However, they handle errors differently
In parse method, If the conversion fails, it throws an exception (FormatException, OverflowException, etc.).
You can use Parse method When you're sure the string is in the correct format and want the program to stop if it's not.
Example
string invalidStr = "abc";
int invalidNumber = int.Parse(invalidStr); // Throws FormatException
In TryParse method, Attempts to convert a string to a specified type without throwing an exception.
In TryParse method, it Returns true if the conversion succeeds; otherwise, it returns false.
string invalidStr = "abc";
bool isInvalid = int.TryParse(invalidStr, out int invalidNumber); // isInvalid is false, invalidNumber is 0
The null-conditional operator in C# provides a concise and safe way to access members (like properties or methods) of an object that might be null. It helps avoid NullReferenceException by ensuring that the access only occurs if the object is not null.
Example
Accessing a Property:
Person person = null;
int? age = person?.Age; // Returns null without throwing an exception if person is null
Invoking a Method:
string result = person?.GetFullName(); // If person is null, result is null
You can chain multiple null-conditional operators:
string firstName = person?.Address?.City?.Name;
It allows to create an object and specify values in a single step.
For example
public class Product
{
public string Name {get;set;}
public int Price {get;set;}
}
Product sampleproduct = new {
Name = "Fan",
Price = 3000
};
It is used to create a collection and its contents to be specified in a single step.
Example in controller,
public ViewResult Index()
{
return View("Index",new string[] { "mary","jose","steve });
}