100+ C# Interview Questions & Answers

C# (pronounced “C-sharp”) is a modern, object-oriented programming language developed by Microsoft. It is part of the .NET framework and is used to build a variety of applications, including web, desktop, mobile, and cloud-based applications. C# is known for its strong type-safety, garbage collection, and features that support software development. It is widely used in enterprise environments and is one of the primary languages for developing applications on the Microsoft platform. Read more – C# Version History and features. Here, we will provide 100+ C# Interview Questions and Answers which are suitable for both freshers and experienced professionals with 2, 5, and 10 years of experience.

C# Interview Questions & Answers

Download all Questions as .PDF

How do you call a base class constructor from a derived class?

You can call a base class constructor from a derived class using the base keyword followed by the parameters required by the base class constructor. This is typically done in the derived class’s constructor.

// Base class
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    // Base class constructor
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

// Derived class
class Employee : Person
{
    public int EmployeeId { get; set; }

    // Derived class constructor calling the base class constructor
    public Employee(string name, int age, int employeeId) : base(name, age)
    {
        EmployeeId = employeeId;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creating an object of the derived class
        Employee employee = new Employee("Alice", 30, 12345);

        // Displaying the initialized values
        Console.WriteLine($"Name: {employee.Name}, Age: {employee.Age}, Employee ID: {employee.EmployeeId}");
    }
} 

Usage of Destructor in C#

In C#, the garbage collector manages memory automatically, so destructors are not often needed for basic memory management tasks. Instead, the IDisposable interface and the using statement are preferred for deterministic disposal of resources. It should be used only when necessary because it can add overhead to the garbage collection process.

When to Use Destructors:

• Unmanaged Resources: When your class uses unmanaged resources such as file handles, network connections, or database connections.
• Resource Management: When you need to ensure that resources are released when the object is no longer needed.
• Finalization Logic: When you need to perform specific finalization logic before an object is destroyed.

class ResourceHolder : IDisposable
{
    // Constructor
    public ResourceHolder()
    {
        // Acquire resources
        Console.WriteLine("Resource acquired.");
    }

    // Dispose method for releasing resources
    public void Dispose()
    {
        // Release resources
        Console.WriteLine("Resource released.");
    }

    public void DoWork()
    {
        Console.WriteLine("Working...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (ResourceHolder rh = new ResourceHolder())
        {
            rh.DoWork();
        } // ResourceHolder is disposed here
    }
} 

What are Static members in a class?

Static members in a class are members that belong to the class itself rather than to any specific instance of the class. This means that static members are shared among all instances of the class, and they can be accessed without creating an instance of the class.

Static members are typically stored in a separate area of memory reserved for the class, rather than in the heap where instance-specific data is stored.

Types of Static Members:

• Static Fields: Variables that are shared among all instances of the class.
• Static Methods: Functions that can be called on the class itself, rather than on instances of the class.
• Static Properties: Properties that provide access to class-level data.
• Static Constructors: Special constructors used to initialize static fields or perform actions that need to be done only once.

class MyClass
{
    // Static field
    public static int Counter = 0;

    // Static property
    public static string ClassName { get; } = "MyClass";

    // Instance field
    public int InstanceNumber;

    // Static method
    public static void IncrementCounter()
    {
        Counter++;
    }

    // Instance method
    public void SetInstanceNumber(int number)
    {
        InstanceNumber = number;
    }

    // Static constructor
    static MyClass()
    {
        Console.WriteLine("Static constructor called.");
    }

    // Instance constructor
    public MyClass()
    {
        Console.WriteLine("Instance constructor called.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Accessing static members without creating an instance
        Console.WriteLine($"Class name: {MyClass.ClassName}");
        MyClass.IncrementCounter();
        Console.WriteLine($"Counter: {MyClass.Counter}");

        // Creating instances and accessing instance members
        MyClass obj1 = new MyClass();
        obj1.SetInstanceNumber(1);
        Console.WriteLine($"Instance 1 number: {obj1.InstanceNumber}");

        MyClass obj2 = new MyClass();
        obj2.SetInstanceNumber(2);
        Console.WriteLine($"Instance 2 number: {obj2.InstanceNumber}");

        // Static members remain the same across all instances
        Console.WriteLine($"Counter: {MyClass.Counter}");
    }
} 

Does C# support multiple inheritance? (or) Can a class implement multiple interfaces in C#?

No, C# does not support multiple inheritance for classes to avoid complexities like the diamond problem, where it becomes unclear which parent class’s method should be called when methods with the same name exist in multiple parent classes. This means a class in C# cannot directly inherit from more than one base class. However, C# does support multiple inheritance through interfaces, which allows a class to implement multiple interfaces.

What is explicit Interface implementation?

Explicit interface implementation allows a class to implement interface members explicitly, providing a way to differentiate which interface’s method is being implemented when a class implements multiple interfaces that have members with the same signature. This helps avoid naming conflicts and ensures that interface methods are only accessible through an interface reference.

public interface IFirstInterface
{
    void Display();
}

public interface ISecondInterface
{
    void Display();
}

public class MyClass : IFirstInterface, ISecondInterface
{
    // Explicit implementation of IFirstInterface.Display
    void IFirstInterface.Display()
    {
        Console.WriteLine("Display method from IFirstInterface");
    }

    // Explicit implementation of ISecondInterface.Display
    void ISecondInterface.Display()
    {
        Console.WriteLine("Display method from ISecondInterface");
    }

    // Regular class method
    public void Display()
    {
        Console.WriteLine("Display method from MyClass");
    }
}

public class Program
{
    public static void Main()
    {
        MyClass obj = new MyClass();
        obj.Display(); // Calls the regular class method

        // Calls the explicit interface implementation of IFirstInterface.Display
        IFirstInterface first = obj;
        first.Display(); // Output: Display method from IFirstInterface

        // Calls the explicit interface implementation of ISecondInterface.Display
        ISecondInterface second = obj;
        second.Display(); // Output: Display method from ISecondInterface
    }
} 

What is the work of a constructor?

A constructor creates and initializes the objects in an application.

Can we declare a constructor to private?

Yes

What is a constructor initializer in C#?

A constructor initializer in C# is a way to specify that a constructor should call another constructor in the same class (using this) or a constructor in the base class (using base) before executing the rest of the constructor’s body. This is useful for reusing constructor logic and ensuring that base class constructors are properly called.

Types of Constructor Initializers:

1. ‘this’ Initializer is used to call another constructor in the same class. It helps to avoid code duplication by reusing constructor logic.
▼ Show example



Example 1:

public class Example {
    public int x;
    public Example() : this(10) {}
    public Example(int x) {
        this.x = x;
    }
} 




Example 2:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    // Constructor with two parameters
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    // Constructor with one parameter, calls the two-parameter constructor
    public Person(string fullName) : this(fullName.Split(' ')[0], fullName.Split(' ')[1])
    {
    }
} 

2. ‘base’ Initializer is used to call a constructor in the base class. Ensures that the base class is properly initialized.
▼ Show example

public class Employee : Person
{
    public int EmployeeId { get; set; }

    // Constructor for Employee, calls the base class constructor
    public Employee(string firstName, string lastName, int employeeId) : base(firstName, lastName)
    {
        EmployeeId = employeeId;
    }

    // Constructor for Employee with full name, calls the base class constructor with full name
    public Employee(string fullName, int employeeId) : base(fullName)
    {
        EmployeeId = employeeId;
    }
} 

How to prevent a public class method to be overridden in drive class?

Make method sealed by using sealed keyword.

How to stop a class being inherited by another class?

Make the class sealed by using sealed keyword.

How to prevent a class being instantiated?

Make class abstract or static

Can you derive a static method of base class in child class?

No, you cannot derive a static method of a base class in a child class. In C#, static methods belong to the class itself rather than to any instance of the class. This means they are not inherited by derived classes in the same way that instance methods are.

Can you override a normal public method of base class and make it static?

No , the method signature should be same to be overridden.

How to override a private virtual method?

You cannot override a private method.

What is the difference between ‘override’ and ‘new’ keywords in C#?

What is Early and Late Binding?

Early Binding: Methods or properties are determined at compile time, resulting in faster execution and early error detection.

Late Binding: Methods or properties are determined at run time, offering more flexibility but potentially slower execution and late error detection.

using System;
using System.Reflection;

public class BindingExample
{
    public void ShowMessage()
    {
        Console.WriteLine("Binding Example");
    }
}

class Program
{
    static void Main(string[] args)
    {
        BindingExample example = new BindingExample();
        example.ShowMessage(); // Early binding
		
		Type type = Type.GetType("BindingExample");
        object obj = Activator.CreateInstance(type);
        MethodInfo method = type.GetMethod("ShowMessage");
        method.Invoke(obj, null); // Late binding
    }
} 

Can namespace contain the private class?

No, having a single private class does not mean anything , it is applicable only in case of nested class.

Can we have Sealed Method in abstarct class ?

No, an abstract class cannot have a sealed method directly because abstract methods must be overridden in derived classes, and sealing is meant to prevent further overriding.

How to Work Around: ou can achieve a similar effect by providing a virtual method in the abstract class, then override and seal it in a derived class.

public abstract class BaseClass
{
    // Virtual method in the abstract class
    public virtual void DisplayMessage()
    {
        Console.WriteLine("Message from BaseClass");
    }
}

public class DerivedClass : BaseClass
{
    // Overriding and sealing the method in the derived class
    public sealed override void DisplayMessage()
    {
        Console.WriteLine("Message from DerivedClass");
    }
}

// The following class would cause a compilation error because DisplayMessage is sealed
// public class FurtherDerivedClass : DerivedClass
// {
//     public override void DisplayMessage()
//     {
//         Console.WriteLine("Message from FurtherDerivedClass");
//     }
// }

class Program
{
    static void Main(string[] args)
    {
        DerivedClass derivedClass = new DerivedClass();
        derivedClass.DisplayMessage(); // Output: Message from DerivedClass
    }
} 

Why cannot I have abstract static methods in C#?

You cannot have abstract static methods because the concepts of “abstract” and “static” are fundamentally incompatible.
Abstract Methods: Require overriding in derived classes.
Static Methods: Cannot be overridden and belong to the class itself.

Implementation Requirement: Abstract methods are intended to be overridden and given concrete implementations in derived classes. However, static methods cannot be overridden.

Instance Context: Abstract methods operate within the context of an instance of a class, whereas static methods operate without any instance context.

The need for overriding (abstract) and the inability to be overridden (static) make it logically impossible to have a method that is both abstract and static.

Can we have Multiple Main Methods in one .cs file?

Yes

Can you declare the override method static while the original method is non-static?

No, you can’t, the signature of the virtual method must remain the same, only the keyword virtual is changed to keyword override.

Can you override private virtual methods?

No, you cannot access private methods in inherited classes.

Static methods cannot use Non-Static members. True or False?

True

If the Function has same parameter but different return type (int and float), Is it a overloading?

No, having a function with the same parameter list but different return types is not considered overloading in C#. Function overloading requires the parameter lists to differ in number, type, or order of parameters, not just the return type.

public class Example
{
    // This method returns an integer
    public int Calculate(int number)
    {
        return number * 2;
    }

    // This method returns a float
    public float Calculate(int number)
    {
        return number * 2.0f;
    }
} 

public class Example
{
    // This method returns an integer and takes an int parameter
    public int Calculate(int number)
    {
        return number * 2;
    }

    // This method returns a float and takes a float parameter
    public float Calculate(float number)
    {
        return number * 2.0f;
    }

    // This method returns a double and takes two int parameters
    public double Calculate(int number1, int number2)
    {
        return number1 * number2;
    }
} 

Overloading is Static Polymorphism and Overriding is Dynamic Polymorphism? True or False?

True

What are the default access modifiers for various elements in C#?

Why is a const variable available within a static method?

const members are implicitly static. They belong to the class rather than a specific instance. Because they are static, const variables are accessible within static methods without needing an instance of the class.

A static method can only access other static members (fields, properties, methods) of the class. Since const variables are static, they can be accessed from within static methods.

public class Example
{
    // Const variable (implicitly static)
    public const int ConstValue = 10;

    // Static method
    public static void StaticMethod()
    {
        // Accessing the const variable
        Console.WriteLine(ConstValue);
    }

    // Instance method
    public void InstanceMethod()
    {
        // Accessing the const variable
        Console.WriteLine(ConstValue);
    }
}

public class Program
{
    public static void Main()
    {
        // Calling the static method
        Example.StaticMethod();

        // Creating an instance and calling the instance method
        Example example = new Example();
        example.InstanceMethod();
    }
} 

How does C# handle Method Hiding?

Method hiding is done using the new keyword. Method hiding occurs when a derived class defines a method with the same name as a method in its base class. The new method hides the base class method. (continue reading the next Question to see a sample example for Hiding Members).

Use of “New” keyword in C#

The new keyword in C# has multiple uses.

1. Creating Objects: The new keyword is used to create instances of types (objects). This is the most common use.

// Creating an instance of MyClass
MyClass obj = new MyClass(); 

2) Hiding Members: The new keyword can be used to hide a member inherited from a base class. This is known as member hiding.

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Display from BaseClass");
    }
}

public class DerivedClass : BaseClass
{
    // Hides the Display method in the base class
    public new void Display()
    {
        Console.WriteLine("Display from DerivedClass");
    }
}

public class Program
{
    public static void Main()
    {
        DerivedClass obj = new DerivedClass();
        obj.Display(); // Output: Display from DerivedClass

        BaseClass baseObj = obj;
        baseObj.Display(); // Output: Display from BaseClass
    }
} 

3) Creating Instances of Anonymous Types: The new keyword is also used to create instances of anonymous types.

var anonType = new { Name = "John", Age = 30 }; 

4) Creating Instances of Array: The new keyword is used to create instances of arrays.

int[] numbers = new int[5]; 

5) Creating Instances of Value Types: The new keyword can be used to create instances of value types.

public struct MyStruct
{
    public int X;
    public int Y;
}

public class Program
{
    public static void Main()
    {
        MyStruct point = new MyStruct();
        point.X = 5;
        point.Y = 10;
        Console.WriteLine($"X: {point.X}, Y: {point.Y}");
    }
} 

Boxing and Unboxing in C#

Boxing: Converting a value type to a reference type

object obj = 123; 

Unboxing: Converting a reference type back to a value type

int num = (int)obj; 

Boxing and unboxing involve additional overhead due to heap allocation and type conversion, which can affect performance. Useful when you need to treat value types as objects, such as when storing them in non-generic collections.

What do you mean by ‘Mutable’ in C#

In C#, an object is considered mutable if its state or fields can be changed after it is created. Mutable objects allow modification of their data members.

Difference between String Vs StringBuilder

string str = "Hello";
str += " World";  // Creates a new string instance
Console.WriteLine(str); // Output: Hello World / Output: Hello World 

StringBuilder sb = new StringBuilder("Hello");
sb.Append(" World");  // Modifies the existing instance
Console.WriteLine(sb.ToString()); // Output: Hello World / Output: Hello World 

Difference between ‘Const’ Vs ‘Read Only’

public class Example
{
    public const int MaxValue = 100;

    public void Display()
    {
        Console.WriteLine(MaxValue);
    }
} 

public class Example
{
    public readonly int MaxValue;

    public Example(int maxValue)
    {
        MaxValue = maxValue;
    }

    public void Display()
    {
        Console.WriteLine(MaxValue);
    }
} 

What is Virtual method?

A virtual method is a method in a base class that can be overridden by a derived class. This allows the derived class to provide a specific implementation of the method, which will be used instead of the base class implementation. The virtual keyword is used in the base class, and the override keyword is used in the derived class.

public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Display method in BaseClass.");
    }
} 

public class DerivedClass : BaseClass
{
    public override void Display()
    {
        Console.WriteLine("Display method in DerivedClass.");
    }
} 

What is Collection in C#?

A Collection refers to a data structure that is used to store, manage, and manipulate groups of related objects. Collections provide various ways to store, access, and iterate over data, making them fundamental in programming for handling multiple items.

Types of Collections:

1. Non-Generic Collections: These are collections that can store any type of object. They are part of the System.Collections namespace.
   Example: ArrayList, Hashtable, Queue, Stack, SortedList.
2. Generic Collections: These collections provide type safety by allowing you to specify the type of elements stored in the collection. They are part of the System.Collections.Generic namespace.
   Example: List, Dictionary, Queue, Stack, SortedList, HashSet, LinkedList
3. Concurrent Collections: These collections are designed for multi-threaded scenarios, providing thread-safe operations. They are part of the System.Collections.Concurrent namespace.
   Example: ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBag

How do you implement a custom collection class?

Implementing a custom collection class in C# involves creating a class that encapsulates a collection of items and provides methods for adding, removing, and manipulating these items. To integrate well with .NET, it’s often useful to implement standard collection interfaces like IEnumerable<T>, ICollection<T>, or IList<T>.

using System;
using System.Collections;
using System.Collections.Generic;

public class CustomCollection<T> : ICollection<T>
{
    private List<T> _items = new List<T>();

    // Add an item to the collection
    public void Add(T item)
    {
        _items.Add(item);
    }

    // Clear all items from the collection
    public void Clear()
    {
        _items.Clear();
    }

    // Check if the collection contains a specific item
    public bool Contains(T item)
    {
        return _items.Contains(item);
    }

    // Copy the collection to an array starting at a specific index
    public void CopyTo(T[] array, int arrayIndex)
    {
        _items.CopyTo(array, arrayIndex);
    }

    // Remove an item from the collection
    public bool Remove(T item)
    {
        return _items.Remove(item);
    }

    // Get the number of items in the collection
    public int Count
    {
        get { return _items.Count; }
    }

    // Get a value indicating whether the collection is read-only
    public bool IsReadOnly
    {
        get { return false; }
    }

    // Get an enumerator that iterates through the collection
    public IEnumerator<T> GetEnumerator()
    {
        return _items.GetEnumerator();
    }

    // Get an enumerator that iterates through the collection (non-generic version)
    IEnumerator IEnumerable.GetEnumerator()
    {
        return _items.GetEnumerator();
    }
} 

using System;

class Program
{
    static void Main()
    {
        // Create an instance of the custom collection
        CustomCollection<string> collection = new CustomCollection<string>();

        // Add items to the collection
        collection.Add("Apple");
        collection.Add("Banana");
        collection.Add("Cherry");

        // Check if the collection contains an item
        Console.WriteLine($"Contains 'Banana': {collection.Contains("Banana")}");

        // Remove an item from the collection
        collection.Remove("Banana");

        // Iterate through the collection
        foreach (var item in collection)
        {
            Console.WriteLine(item);
        }

        // Clear the collection
        collection.Clear();
        Console.WriteLine($"Count after clearing: {collection.Count}");
    }
} 

What is ArrayList? When to use?

An ArrayList is a non-generic collection in C# that can store elements of any type, including both value types and reference types. It is part of the System.Collections namespace. Unlike arrays, the size of an ArrayList can dynamically increase or decrease as elements are added or removed.

When to Use:

• When Type Safety is Not a Concern: Use ArrayList when you do not need type safety and are working with a collection of objects of different types.
• Legacy Code: ArrayList is useful when maintaining or working with legacy code that already uses this collection.
• Quick Prototyping: For quick prototyping or small scripts where performance and type safety are not critical, ArrayList can be convenient.

Considerations:

• Type Safety: ArrayList does not provide compile-time type checking. This can lead to runtime errors if incorrect types are added or accessed.
• Performance: ArrayList can be less efficient than generic collections, such as List<T>, due to boxing and unboxing of value types and the lack of type safety.

Note: It is generally recommended to use generic collections, such as List<T>, which provide type safety and better performance.

using System;
using System.Collections;

public class Example
{
    public static void Main()
    {
        ArrayList arrayList = new ArrayList();

        // Adding elements
        arrayList.Add(1);
        arrayList.Add("Hello");
        arrayList.Add(3.14);

        // Accessing elements
        Console.WriteLine(arrayList[0]); // Output: 1
        Console.WriteLine(arrayList[1]); // Output: Hello
        Console.WriteLine(arrayList[2]); // Output: 3.14

        // Removing elements
        arrayList.Remove(1);

        // Iterating through the ArrayList
        foreach (var item in arrayList)
        {
            Console.WriteLine(item);
        }
    }
} 

What is List? When to use?

A List in C# is a generic collection that can store elements of a specific type, providing type safety & preventing runtime type errors, and providing dynamic resizing. It is part of the System.Collections.Generic namespace

When to Use:

• Use List<T> when you need to ensure that all elements in the collection are of the same type, providing compile-time type checking and reducing runtime errors.
• When you need efficient random access to elements, as well as efficient resizing and insertion/removal operations.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Creating a list of integers
        List<int> list = new List<int>();

        // Adding elements
        list.Add(1);
        list.Add(2);
        list.Add(3);

        // Accessing elements
        Console.WriteLine(list[0]); // Output: 1
        Console.WriteLine(list[1]); // Output: 2
        Console.WriteLine(list[2]); // Output: 3

        // Removing elements
        list.Remove(1);

        // Iterating through the List
        foreach (var item in list)
        {
            Console.WriteLine(item);
        }
    }
} 

Difference between ArrayList and List.

Difference between Array and List<T>.

Array example:

int[] numbers = new int[5] { 1, 2, 3, 4, 5 };
// Fixed size, can't add or remove elements

List<T> example:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6); // Can add more elements dynamically

What is HashTable? When to use?

A Hashtable in C# is a collection that stores key-value pairs. It is part of the System.Collections namespace and allows for fast retrieval of values (Fast Lookups) based on their keys. The keys in a Hashtable must be unique, and each key is associated with exactly one value. Can store keys and values of any type, but does not provide type safety at compile time. Dynamically resizes to accommodate the number of elements.

When to Use:

• When you need to store data as key-value pairs for quick retrieval based on the key.
• When maintaining or working with legacy code that uses Hashtable.
• When dealing with relatively small collections where the non-generic nature and potential boxing/unboxing overhead are not significant issues.

Note: It is generally recommended to use the generic Dictionary<TKey, TValue> collection, which provides type safety and better performance.

using System;
using System.Collections;

public class Example
{
    public static void Main()
    {
        // Creating a Hashtable
        Hashtable hashtable = new Hashtable();

        // Adding key-value pairs
        hashtable.Add("one", 1);
        hashtable.Add("two", 2);
        hashtable.Add("three", 3);

        // Accessing elements by key
        Console.WriteLine(hashtable["one"]);   // Output: 1
        Console.WriteLine(hashtable["two"]);   // Output: 2

        // Iterating through the Hashtable
        foreach (DictionaryEntry entry in hashtable)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }

        // Checking if a key exists
        if (hashtable.ContainsKey("three"))
        {
            Console.WriteLine("Key 'three' exists.");
        }

        // Removing a key-value pair
        hashtable.Remove("two");
    }
} 

What is Dictionary? When to use?

A Dictionary in C# is a generic collection that stores key-value pairs. It is part of the System.Collections.Generic namespace and provides a fast way to look up values based on their keys. The keys in a Dictionary must be unique, and each key is associated with exactly one value.

When to Use: When you want to ensure that all keys and values are of specific types, providing compile-time type checking and need to store data as key-value pairs for quick retrieval based on the key.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Creating a Dictionary
        Dictionary<string, int> dictionary = new Dictionary<string, int>();

        // Adding key-value pairs
        dictionary.Add("one", 1);
        dictionary.Add("two", 2);
        dictionary.Add("three", 3);

        // Accessing elements by key
        Console.WriteLine(dictionary["one"]);   // Output: 1
        Console.WriteLine(dictionary["two"]);   // Output: 2

        // Iterating through the Dictionary
        foreach (var kvp in dictionary)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }

        // Checking if a key exists
        if (dictionary.ContainsKey("three"))
        {
            Console.WriteLine("Key 'three' exists.");
        }

        // Removing a key-value pair
        dictionary.Remove("two");
    }
} 

Difference between HashTable and Dictionary.

How do you implement a ConcurrentDictionary in C#?

ConcurrentDictionary provides a thread-safe collection that allows multiple threads to concurrently add, update, or remove items from the dictionary without requiring manual synchronization, such as using locks.

ConcurrentDictionary<int, string> dictionary = new ConcurrentDictionary<int, string>();

using System;
using System.Collections.Concurrent;

class Program
{
    static void Main()
    {
        // Create a ConcurrentDictionary
        ConcurrentDictionary<int, string> dictionary = new ConcurrentDictionary<int, string>();

        // Add elements
        dictionary.TryAdd(1, "One");
        dictionary.TryAdd(2, "Two");

        // Access and update elements
        string value = dictionary.GetOrAdd(3, "Three");
        dictionary.AddOrUpdate(2, "Two", (key, oldValue) => "UpdatedTwo");

        // Remove an element
        bool removed = dictionary.TryRemove(1, out string removedValue);

        // Output the dictionary contents
        foreach (var kvp in dictionary)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
} 

What is Enum in C#?

An enum (short for “enumeration”) in C# is a value type that allows you to define a group of named constants. Enums are useful for representing a collection/group of related values, making your code more readable and maintainable by providing meaningful names to those values instead of using random numeric values.

The default type of enum is int. Enums are strongly typed, ensuring compile-time type safety. You cannot create an instance of an enum using the new keyword (Cannot Be Instantiated).

The members of an enum are accessed in a static-like manner, meaning you do not create an instance of the enum to access its values.

When to Use: When you need to define a group of related constants, such as days of the week, error codes, or status codes.

public enum DaysOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
} 

using System;

public class Example
{
    public static void Main()
    {
        // Assigning an enum value to a variable
        DaysOfWeek today = DaysOfWeek.Monday;

        // Checking an enum value
        if (today == DaysOfWeek.Monday)
        {
            Console.WriteLine("Today is Monday.");
        }

        // Using an enum in a switch statement
        switch (today)
        {
            case DaysOfWeek.Sunday:
                Console.WriteLine("Today is Sunday.");
                break;
            case DaysOfWeek.Monday:
                Console.WriteLine("Today is Monday.");
                break;
            // Other cases...
            default:
                Console.WriteLine("Today is another day.");
                break;
        }

        // Getting the underlying value of an enum
        int dayValue = (int)today;
        Console.WriteLine($"The numeric value of {today} is {dayValue}.");
    }
} 

public enum HttpStatusCode : short
{
    OK = 200,
    Created = 201,
    Accepted = 202,
    NoContent = 204,
    BadRequest = 400,
    Unauthorized = 401,
    Forbidden = 403,
    NotFound = 404
} 

What are partial classes in C#?

Partial classes allow a class definition to be split across multiple files and each part must use the partial keyword. This can be particularly useful for organizing large classes or when working with auto-generated code, where you might want to separate the generated code from your custom code (Separation of Concerns).

All parts of the partial class must be defined in the same assembly and namespace.

All parts of the partial class are combined into a single class when the application is compiled.

public partial class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public void PrintFullName()
    {
        Console.WriteLine($"{FirstName} {LastName}");
    }
} 

public partial class Person
{
    public int Age { get; set; }

    public void PrintAge()
    {
        Console.WriteLine($"Age: {Age}");
    }
} 

using System;

public class Example
{
    public static void Main()
    {
        Person person = new Person
        {
            FirstName = "John",
            LastName = "Doe",
            Age = 30
        };

        person.PrintFullName();  // Output: John Doe
        person.PrintAge();       // Output: Age: 30
    }
} 

What is a partial method in C#?

A partial method in C# is a method that is declared in one part of a partial class or struct and optionally implemented in another part. Partial methods enable developers to define method signatures within a class, allowing other parts of the class to provide the implementation or leave it empty. If the method is not implemented, the compiler removes its declaration and calls, resulting in no performance penalty.

Restrictions or Limitations:

• Partial methods must return void.
• They cannot have access modifiers; they are implicitly private.
• They cannot be extern, virtual, abstract, override, or static.

using System;

public partial class MyClass
{
    // Declaration of a partial method
    partial void OnMessageLogged(string message);

    public void LogMessage(string message)
    {
        Console.WriteLine("Logging message: " + message);
		
        // Call to the partial method
        OnMessageLogged(message); 
    }
}

// Another part of the partial class
public partial class MyClass
{
    // Implementation of the partial method
    partial void OnMessageLogged(string message)
    {
        Console.WriteLine("Message logged: " + message);
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyClass myClass = new MyClass();
        myClass.LogMessage("Hello, World!");
    }
} 

Synchronous vs. Asynchronous Operations in C#

Synchronous operations are operations that run sequentially. Each operation must complete before the next one starts. The program execution waits for the current operation to finish before moving to the next operation.

Asynchronous operations allow a program to initiate an operation and then move on to other tasks without waiting for the operation to complete. The program can continue running other tasks, and the operation will complete at some point in the future.

public class SynchronousExample
{
    public static void Main()
    {
        Console.WriteLine("Starting synchronous operation...");
        PerformSynchronousOperation();
        Console.WriteLine("Synchronous operation completed.");
    }

    public static void PerformSynchronousOperation()
    {
        // Simulate a time-consuming operation
        System.Threading.Thread.Sleep(2000); // Sleep for 2 seconds
    }
} 

public class AsynchronousExample
{
    public static async Task Main()
    {
        Console.WriteLine("Starting asynchronous operation...");
        await PerformAsynchronousOperation();
        Console.WriteLine("Asynchronous operation completed.");
    }

    public static async Task PerformAsynchronousOperation()
    {
        // Simulate a time-consuming operation
        await Task.Delay(2000); // Delay for 2 seconds
    }
} 

What are Serialization and Deserialization in C#?

Serialization is the process of converting an object into a format that can be easily stored or transmitted, such as JSON, XML, or binary.

Deserialization is the process of converting the serialized data back into an object.

In C#, serialization and deserialization are commonly used when working with data exchange, file storage, or communication between applications. The .NET framework provides built-in classes such as JsonSerializer, XmlSerializer, and BinaryFormatter for these purposes.

What are extension methods in C#?

Extension methods are a special kind of static method in C# that allows you to add new methods to existing types without modifying the original type or creating a new derived type. Defined as static methods in static classes and called as if they were instance methods. It Improves readability, reusability, and maintainability of code. It Cannot access private members.

The first parameter specifies which type the method operates on, and it is preceded by the this keyword.

Best Practices:

• Use carefully: Don’t overuse extension methods. They should enhance readability and maintainability, not complicate the codebase.
• Naming: 1) Choose method names that clearly convey their purpose and match the naming conventions of the extended type. 2) If multiple extension methods with the same name and signature are available, it can cause naming conflicts.
• Namespaces: Place extension methods in appropriate namespaces and use using directives to include them only where needed.

public static class StringExtensions
{
    public static string CapitalizeFirstLetter(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return input;

        return char.ToUpper(input[0]) + input.Substring(1);
    }
} 

using System;

public class Example
{
    public static void Main()
    {
        string example = "hello world";
        string capitalized = example.CapitalizeFirstLetter(); // Using the extension method

        Console.WriteLine(capitalized); // Output: Hello world
    }
} 

What is the purpose of ‘using’ statement in C#?

The using statement ensures proper disposal of resources that implement IDisposable and when they are no longer needed, e.g., unmanaged resources like file handles, database connections, and network connections.

// 1) Namespaces
using System;
using System.IO;

public class Example
{
    public static void Main()
    {
        // 2) Ensure the StreamReader is disposed of correctly
        using (StreamReader reader = new StreamReader("example.txt"))
        {
            string content = reader.ReadToEnd();
            Console.WriteLine(content);
        } // StreamReader.Dispose is called automatically here
    }
} 

How do you use the ‘using’ directive to manage namespaces?

The using directive simplifies referencing types from namespaces. It allows you to avoid fully qualifying type names, manage scope, create aliases for namespaces or types, and import static members for direct access. It is typically placed at the top of a file.

1. Simplify Code: Avoids writing fully qualified names.
▼ Show example

using System;

namespace Example
{
    class Program
    {
        // ...
    }
} 

2. Aliases: Creates shortcuts for namespaces or types.
▼ Show example

using ProjectAlias = MyProject.LongNamespace;
using AliasExample = System.Collections.Generic.List<string> 

3. Static Using: Imports static members for easier access.
▼ Show example

using static System.Math;

namespace Example
{
    class Program
    {
        // ...
    }
} 

4. Scope Management: Can be placed at the file, namespace, or class level to control scope.
▼ Show example

namespace Example
{
    using System.Text;

    class Program
    {
        // ...
    }
} 

What is the purpose of the ‘default’ keyword in C#?

The default keyword is used in several contexts to provide a default value for a type or to specify a default case in a switch statement. Its purpose varies based on the context in which it is used.

// Syntax
T defaultValue = default(T); 

1) Default Value for a Type: Used to obtain the default value of a type, especially useful in generics.

int defaultInt = default(int); // 0 

2) Default Case in a Switch Statement: Specifies a case to execute when no other case matches.

switch (expression)
{
    case value1:
        // Code block
        break;
    default:
        // Code block
        break;
} 

3) Default Literal: A shorthand way to obtain the default value of a type (C# 7.1 and later).

int defaultInt = default; // 0 

What is the purpose of the ‘default’ literal in generic programming?

The default literal is used to provide a default value for generic types. It helps in initializing generic variables with a default value. Useful in generic methods to return default values for type parameters.

public class GenericClass<T>
{
    private T _value;

    public GenericClass()
    {
        // Initialize the value with the default value of type T
        _value = default;
    }

    public T GetValue()
    {
        return _value;
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of GenericClass for int
        var intInstance = new GenericClass<int>();
        Console.WriteLine(intInstance.GetValue()); // Output: 0

        // Create an instance of GenericClass for string
        var stringInstance = new GenericClass<string>();
        Console.WriteLine(stringInstance.GetValue() == null); // Output: True
    }
} 

public class Utility
{
    public static T GetDefaultValue<T>()
    {
        return default;
    }
}

class Program
{
    static void Main()
    {
        int defaultInt = Utility.GetDefaultValue<int>();
        Console.WriteLine(defaultInt); // Output: 0

        string defaultString = Utility.GetDefaultValue<string>();
        Console.WriteLine(defaultString == null); // Output: True
    }
} 

What is the use of the yield keyword in C#?

The yield keyword in C# is used in an iterator to provide a value to the enumerator object or to signal the end of the iteration. It simplifies the implementation of custom iteration over collections.

Uses of the ‘yield’ Keyword:

1. yield return: Provides the next value in the iteration.
2. yield break: Ends the iteration.

Benefits:

• Simplifies Code: Reduces the complexity of writing custom iterators.
• Lazy Evaluation: Values are generated on demand.
• Maintains State: Automatically maintains the state of the iteration across multiple calls.

using System;
using System.Collections.Generic;

public class Numbers
{
    public IEnumerable<int> GetNumbers(int max)
    {
        for (int i = 0; i <= max; i++)
        {
            if (i > 5)
                yield break; // Stop the iteration if i is greater than 5
            yield return i;
        }
    }
}

public class Program
{
    public static void Main()
    {
        var numbers = new Numbers();
        foreach (int number in numbers.GetNumbers(10))
        {
            Console.WriteLine(number);
        }
    }
} 

How do you implement an iterator in C#?

Iterators are methods, properties, or indexers that perform custom iteration over a collection. iterator is implemented using the yield return and yield break statements.

using System;
using System.Collections;
using System.Collections.Generic;

// Implements IEnumerable to allow iteration over the collection.
public class NumberCollection : IEnumerable<int>
{
    private int[] numbers = { 1, 2, 3, 4, 5 };

    public IEnumerator<int> GetEnumerator()
    {
        foreach (int number in numbers)
        {
            yield return number;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        NumberCollection collection = new NumberCollection();

        foreach (int number in collection)
        {
            Console.WriteLine(number);
        }
    }
} 

When to use iterator:

• Custom Collection: You have a custom collection that you want to iterate over in a specific way.
• Lazy Evaluation: You want to yield items one at a time as they are needed, rather than generating all items at once.
• Complex Iteration Logic: The iteration logic is complex and involves multiple steps or conditions.

Suppose you have a tree data structure, and you want to iterate over its nodes in a specific order (e.g., depth-first search).

using System;
using System.Collections;
using System.Collections.Generic;

public class TreeNode<T>
{
    public T Value { get; set; }
    public List<TreeNode<T>> Children { get; } = new List<TreeNode<T>>();

    public TreeNode(T value)
    {
        Value = value;
    }

    public IEnumerable<T> DepthFirstTraversal()
    {
        yield return Value;
        foreach (var child in Children)
        {
            foreach (var descendant in child.DepthFirstTraversal())
            {
                yield return descendant;
            }
        }
    }
}

public class Program
{
    public static void Main()
    {
        var root = new TreeNode<int>(1);
        root.Children.Add(new TreeNode<int>(2));
        root.Children.Add(new TreeNode<int>(3));
        root.Children[0].Children.Add(new TreeNode<int>(4));
        root.Children[0].Children.Add(new TreeNode<int>(5));
        root.Children[1].Children.Add(new TreeNode<int>(6));

        foreach (var value in root.DepthFirstTraversal())
        {
            Console.WriteLine(value);
        }
    }
} 

What is the ‘base’ keyword used for in C#?

The base keyword is used to access members of the base class from within a derived class. It allows derived classes to call methods, access properties, and invoke constructors of their base class.

Uses of ‘base’ Keyword:

1. Calling Base Class Constructors: You can call a constructor of the base class from a constructor of the derived class.
▼ Show example

public class BaseClass
{
    public BaseClass(int number)
    {
        Console.WriteLine($"Base class constructor called with number: {number}");
    }
}

public class DerivedClass : BaseClass
{
    public DerivedClass(int number) : base(number)
    {
        Console.WriteLine($"Derived class constructor called with number: {number}");
    }
}

public class Program
{
    public static void Main()
    {
        DerivedClass obj = new DerivedClass(10);
    }
} 




Output:
Base class constructor called with number: 10
Derived class constructor called with number: 10



2. Accessing Base Class Members: You can access a method, property, indexer, or field of the base class that has been overridden or hidden in the derived class.
▼ Show example

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Display method in BaseClass");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        base.Display(); // Calling the base class method
        Console.WriteLine("Display method in DerivedClass");
    }
}

public class Program
{
    public static void Main()
    {
        DerivedClass obj = new DerivedClass();
        obj.Display();
    }
} 




Output:
Display method in BaseClass
Display method in DerivedClass

How do you declare and raise an event in C#?

Events are a way to provide notifications when something occurs. They are commonly used in scenarios where you want to notify other parts of your application about state changes or actions.

Steps to declare and raise event:

• Define a Delegate
• Declare the Event
• Create a Method to Raise the Event
• Raise the Event

public delegate void MyEventHandler(object sender, EventArgs e); 

public class MyClass
{
    public event MyEventHandler MyEvent;

    protected virtual void OnMyEvent(EventArgs e)
    {
        if (MyEvent != null)
        {
            MyEvent(this, e);
        }
    }

    public void TriggerEvent()
    {
        // Raise the event
        OnMyEvent(EventArgs.Empty);
    }
} 

public class Program
{
    public static void Main()
    {
        MyClass myClass = new MyClass();
        myClass.MyEvent += new MyEventHandler(HandleMyEvent);
        myClass.TriggerEvent();
    }

    static void HandleMyEvent(object sender, EventArgs e)
    {
        Console.WriteLine("Event triggered!");
    }
} 

What is a lambda expression in C#?

Provide a concise way to define anonymous methods. It allows you to write inline functions that can be passed as arguments to methods. Uses => operator with parameters on the left and the expression or statements on the right. Commonly used with delegates, LINQ queries, and event handling to simplify code and improve readability.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        // Using a lambda expression in a foreach loop to print each number
        numbers.ForEach(number => Console.WriteLine(number));
    }
} 

How do you handle exceptions in C#?

Exceptions are handled using try, catch, finally, and throw keywords. This mechanism helps in managing and responding to runtime errors in a controlled way.

• try: Wraps code that might throw an exception.
• catch: Catches and handles exceptions thrown in the try block.
• finally: Contains code that runs after try and catch blocks, regardless of whether an exception was thrown.
• throw: Used to throw an exception manually.

public class Program
{
	public static void Main()
	{
		try
		{
			ValidateNumber(-1);
			DivideNumber(10, 0)
		}
		catch (ArgumentException ex)
		{
			Console.WriteLine("An error occurred: " + ex.Message);
		}
		catch (DivideByZeroException ex)
		{
			Console.WriteLine("Cannot divide by zero: " + ex.Message);
		}
		catch (Exception ex)
		{
			Console.WriteLine("An error occurred: " + ex.Message);
		}
		finally
		{
			Console.WriteLine("This will always execute.");
		}
	}
	
	public static void ValidateNumber(int number)
	{
		if (number < 0)
		{
			throw new ArgumentException("Number cannot be negative.");
		}
	}

	public static void DivideNumber(int a, int b)
	{
		// This will throw a DivideByZeroException
		Console.WriteLine(a / b); 
	}
} 

Can I have multiple ‘catch’ in exception handling?

Yes, you can have multiple catch blocks in exception handling. This allows you to handle different types of exceptions separately and provide specific logic for each exception type. The catch blocks are evaluated in the order they appear, so the most specific exceptions should be caught first, followed by more general exceptions.

public class Program
{
    public static void Main()
    {
        try
        {
            int[] numbers = { 1, 2, 3 };

            // This will throw an IndexOutOfRangeException
            Console.WriteLine(numbers[3]);

            int a = 10;
            int b = 0;

            // This will throw a DivideByZeroException
            Console.WriteLine(a / b);
        }
        catch (IndexOutOfRangeException ex)
        {
            Console.WriteLine("Index out of range: " + ex.Message);
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine("Cannot divide by zero: " + ex.Message);
        }
        catch (Exception ex)
        {
            Console.WriteLine("An error occurred: " + ex.Message);
        }
        finally
        {
            Console.WriteLine("This will always execute.");
        }
    }
} 

What is the difference between ‘throw’ and ‘throw ex’ in C#?

The difference between throw and throw ex in C# lies in how they affect the exception’s stack trace when rethrowing an exception.

throw – Preserves Stack Trace: Using throw inside a catch block rethrows the current exception while preserving the original stack trace. This is useful for debugging, as it allows you to see the original point where the exception was thrown.

throw ex – Resets Stack Trace: Using throw ex resets the stack trace to the current location in the catch block. This means the stack trace will start from the point where the exception is rethrown, losing the original context.

public class Program
{
    public static void Main()
    {
        try
        {
            CauseException();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Handling exception and rethrowing...");
			
            // Rethrows the exception preserving the original stack trace
            throw;
        }
    }

    public static void CauseException()
    {
        throw new InvalidOperationException("An error occurred.");
    }
} 

public class Program
{
    public static void Main()
    {
        try
        {
            CauseException();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Handling exception and rethrowing...");
			
            // Rethrows the exception but resets the stack trace
            throw ex;
        }
    }

    public static void CauseException()
    {
        throw new InvalidOperationException("An error occurred.");
    }
} 

How do you define a custom exception in C#?

A custom exception is a user-defined class that extends the Exception class. It allows you to create specific error types tailored to your application’s needs. Custom exceptions can include custom properties, methods, and constructors for more detailed error handling and messaging.

public class CustomInvalidAgeException : Exception
{
    // Default constructor
    public CustomInvalidAgeException()
    {
    }

    // Constructor that takes a message
    public CustomInvalidAgeException(string message)
        : base(message)
    {
    }

    // Constructor that takes a message and an inner exception
    public CustomInvalidAgeException(string message, Exception inner)
        : base(message, inner)
    {
    }
}

public class Program
{
    public static void Main()
    {
        try
        {
            ValidateAge(-1);
        }
        catch (CustomInvalidAgeException ex)
        {
            Console.WriteLine("Custom Exception Caught: " + ex.Message);
        }
    }

    public static void ValidateAge(int age)
    {
        if (age < 0)
        {
            throw new CustomInvalidAgeException("Age cannot be negative.");
        }
    }
} 

What is the difference between ref and out parameters in C#?

using System;

public class Program
{
    public static void Main()
    {
        int number = 10;
        Console.WriteLine("Before method call: " + number);
        ModifyRef(ref number);
        Console.WriteLine("After method call: " + number);
    }

    public static void ModifyRef(ref int num)
    {
        num = 20; // Modifying the value
    }
} 

using System;

public class Program
{
    public static void Main()
    {
        int number;
        InitializeOut(out number);
        Console.WriteLine("After method call: " + number);
    }

    public static void InitializeOut(out int num)
    {
        num = 30; // Assigning a value
    }
} 

What is the difference between ‘in’ and ‘out’ parameters?

The in and out keywords in C# are used to define how parameters are passed to methods. Both are special types of parameters, but they serve different purposes.

public void ProcessData(in int value)
{
    value = value + 1; // This will cause a compile-time error.
    Console.WriteLine(value);
}

int number = 10;
ProcessData(in number);  // Passes the number by reference, but it cannot be modified inside the method.

public void GetData(out int value)
{
    value = 42;  // Must assign a value before the method returns.
}

int number;
GetData(out number);  // Passes the number by reference, and the method assigns a value to it.
Console.WriteLine(number);  // Output: 42

What is the ‘params’ keyword?

The params keyword allows you to specify a method parameter that takes a variable number of arguments. It is used to specify a parameter that takes an array of arguments, making it possible to pass a variable number of arguments without explicitly creating an array. It

public class Program
{
    public static void Main()
    {
        PrintNumbers(1, 2, 3, 4, 5); // Passing multiple arguments
        PrintNumbers(10, 20);        // Passing fewer arguments
        PrintNumbers();              // No arguments
    }

    public static void PrintNumbers(params int[] numbers)
    {
        foreach (int number in numbers)
        {
            Console.WriteLine(number);
        }
    }
} 

How do you define and use Indexers in C#?

Indexers allow instances of a ‘class’ or ‘struct’ to be indexed just like arrays. They are defined using the this keyword followed by a parameter list inside square brackets. Indexers provide a way to access class or struct data in a similar way to accessing elements in an array.

public class SampleCollection<T>
{
    private T[] array = new T[100];

    public T this[int index]
    {
        get { return array[index]; }
        set { array[index] = value; }
    }
} 

using System;

public class Program
{
    public static void Main()
    {
        var collection = new SampleCollection<string>();
        collection[0] = "Hello";
        collection[1] = "World";

        Console.WriteLine(collection[0]); // Output: Hello
        Console.WriteLine(collection[1]); // Output: World
    }
} 

How do you implement Generic Classes and Methods in C#?

Generics allow you to define classes, methods, and other data structures without specifying the exact data type. This enables code reusability and type safety.

// Implementing a Generic Class
public class GenericClass<T>
{
    private T data;

    public T Data
    {
        get { return data; }
        set { data = value; }
    }

    public void DisplayData()
    {
        Console.WriteLine("Data: " + data);
    }
}

public class Program
{
    // Implementing a Generic Method
    public void PrintData<T>(T data)
    {
        Console.WriteLine("Data: " + data);
    }

    public static void Main()
    {
        // Using Generic Class
        var intInstance = new GenericClass<int>();
        intInstance.Data = 10;
        intInstance.DisplayData(); // Output: Data: 10

        var stringInstance = new GenericClass<string>();
        stringInstance.Data = "Hello";
        stringInstance.DisplayData(); // Output: Data: Hello

        // Using Generic Method
        var program = new Program();
        program.PrintData(123);      // Output: Data: 123
        program.PrintData("Hello");  // Output: Data: Hello
        program.PrintData(45.67);    // Output: Data: 45.67
    }
} 

What is the purpose of constraints in generic programming?

Constraints in generic programming allow developers to write more robust and versatile generic code by specifying the necessary conditions that type arguments must fulfill. It are used to enforce specific requirements on type parameters, ensuring type safety, enabling access to members, providing flexibility, and enhancing code clarity.

Types of Constraints:

1. where T : struct: The type argument must be a value type.
2. where T : class: The type argument must be a reference type.
3. where T : new(): The type argument must have a parameterless constructor.
4. where T : <base class name>: The type argument must be or derive from the specified base class.
5. where T : <interface name>: The type argument must implement the specified interface.
6. where T : U: The type argument must be or derive from the type argument U.

// Define a generic class with constraints
public class GenericClass<T> where T : IComparable, new()
{
    private T data;

    public T Data
    {
        get { return data; }
        set { data = value; }
    }

    // Method to compare the data with another instance of the same type
    public int Compare(T other)
    {
        return data.CompareTo(other);
    }

    // Constructor
    public GenericClass()
    {
        // Instantiate using the parameterless constructor constraint
        data = new T();
    }
}

public class Program
{
    public static void Main()
    {
        var instance = new GenericClass<int>();
        instance.Data = 10;

        Console.WriteLine(instance.Compare(20)); // Output: -1 (since 10 < 20)
    }
} 

What are anonymous types in C#?

Anonymous types provide a way to create simple, immutable object types without having to explicitly define a class. They are useful for encapsulating a set of read-only properties into a single object for convenience, typically when you want to return multiple values from a method or perform quick data processing operations without the overhead of defining a new class. Typically used within the scope they are defined, such as within a method. Anonymous types are created using the new keyword followed by an object initializer syntax.

syntax:

var anonymousObject = new { Property1 = "Hello", Property2 = 123 }; 

var person = new { Name = "John Doe", Age = 30, Occupation = "Developer" }; 

var people = new[]
{
	new { Name = "John Doe", Age = 30 },
	new { Name = "Jane Smith", Age = 25 },
	new { Name = "Sam Brown", Age = 35 }
}; 

What is the purpose of the var keyword?

The var keyword is used for implicitly typing local variables. It allows the compiler to infer the type of the variable from the right-hand side of the assignment at compile-time. The var keyword enhances code readability and reduces redundancy without sacrificing type safety.

example:

var number = 10; // The type of number is inferred as int

How do you use the dynamic keyword?

The dynamic keyword in C# provides a powerful mechanism for deferring type resolution until runtime, making it ideal for interacting with dynamic languages, COM objects, and scenarios where type information is not available at compile-time. While it offers significant flexibility, it should be used judiciously due to the performance overhead and potential for runtime errors.

Unlike var, which requires the type to be known at compile-time, dynamic variables are checked at runtime.

COM Interop Example:

// COM Interop Example
dynamic excelApp = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
excelApp.Visible = true;
excelApp.Workbooks.Add();
excelApp.Cells[1, 1].Value = "Hello, Excel!"; 

Disadvantages – Performance Overhead, Lack of IntelliSense, Potential for Runtime Errors.

What is ‘thread’ in C#?

A thread in C# is a basic unit of execution within a process, allowing concurrent operations. Each process can have multiple threads, which share the process’s resources but execute independently. Threads allow a program to perform multiple operations concurrently, making efficient use of CPU resources and improving application performance, especially for tasks that involve waiting or are computationally intensive. Creating a thread can be done using the Thread class in the System.Threading namespace. Provides Thread Safety, ensuring that multiple threads do not interfere with each other when accessing shared resources.

Multithreading: The ability to run multiple threads concurrently within the same process. It helps in performing complex or multiple tasks at the same time.

Thread Life Cycle:

• Unstarted: The thread is created but not yet started.
• Running: The thread is executing.
• Blocked/Waiting: The thread is blocked or waiting for a resource or event.
• Dead: The thread has finished execution or has been terminated.

using System;
using System.Threading;

public class Program
{
    public static void Main()
    {
        // Define a method that will run on the new thread
        void ThreadMethod()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine($"Thread Method: {i}");
                Thread.Sleep(1000); // Simulate some work
            }
        }

        // Create a thread, passing the method as a ThreadStart delegate
        Thread thread = new Thread(new ThreadStart(ThreadMethod));

        // Start the thread
        thread.Start();

        // Continue with the main thread
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"Main Method: {i}");
            Thread.Sleep(500);
        }

        // Wait for the thread to complete
        thread.Join();
    }
} 

What is asynchronous programming? (or) How do you use Task, async, await keywords in C#.

In C#, the Task, async, and await keywords are used for asynchronous programming. This approach is called “asynchronous programming” or “async/await programming.” It allows you to write code that performs tasks asynchronously, meaning the tasks run independently of the main application flow, without blocking it. This is especially useful for I/O-bound operations like file access, network calls, or database queries, as well as for CPU-bound operations that might take a long time to complete.

• Task: Represents an asynchronous operation. It’s part of the Task Parallel Library (TPL) in the System.Threading.Tasks namespace.
• async: Indicates that a method is asynchronous and can contain await expressions.
• await: Pauses the execution of the async method until the awaited task completes.

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        Console.WriteLine("Starting...");

        // Call the asynchronous method
        string result = await FetchDataAsync();

        Console.WriteLine($"Result: {result}");
        Console.WriteLine("Finished.");
    }

    public static async Task<string> FetchDataAsync()
    {
        using (HttpClient client = new HttpClient())
        {
            // Asynchronously fetch data from a URL
            HttpResponseMessage response = await client.GetAsync("https://api.github.com");
            
            // Ensure the response was successful
            response.EnsureSuccessStatusCode();
            
            // Asynchronously read the response content as a string
            string responseBody = await response.Content.ReadAsStringAsync();
            
            return responseBody;
        }
    }
} 

What is the purpose of the ‘lock’ statement in C#?

The lock statement ensures that a block of code runs to completion by only one thread at a time. This prevents multiple threads from accessing a shared resource simultaneously (Thread Safety), which can lead to race conditions and data corruption. The lock statement provides a mechanism for enforcing thread synchronization, ensuring that only one thread can enter the critical section of code at any given moment. Helps avoid deadlocks by locking on a private object instead of this or a type.

using System;
using System.Threading;

public class Program
{
    private static readonly object lockObject = new object();
    private static int sharedResource = 0;

    public static void Main()
    {
        Thread thread1 = new Thread(IncrementResource);
        Thread thread2 = new Thread(IncrementResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine($"Final value of sharedResource: {sharedResource}");
    }

    private static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            lock (lockObject)
            {
                sharedResource++;
            }
        }
    }
} 

Guidelines for using ‘lock’

• Use a private object: Always use a private object for locking. Never lock on publicly accessible objects, instances of this, or types, as this can lead to unexpected behavior and deadlocks.
• Keep the critical section small: Minimize the code inside the lock statement to reduce the chance of contention and improve performance.
• Avoid locking on strings: Strings are immutable and interned by the CLR, which means that locking on a string can inadvertently lock on the same string instance across different parts of the code.

What is the purpose of the ‘is’ and ‘as’ operators?

The is and as operators in C# are used for type checking and type casting, respectively. They are useful for working with objects when you need to verify or convert their types at runtime.

‘is’ Operator: The is operator checks if an object is compatible with a given type. It returns true if the object can be cast to the specified type without throwing an exception; otherwise, it returns false.

if (obj is string) { } 

‘as’ Operator: The as operator attempts to cast an object to a specified type. If the cast is successful, it returns the object as the new type. If the cast fails, it returns null instead of throwing an exception.

string str = obj as string; 

How do you use attributes in C#?

Attributes in C# provide a way to add metadata to your code. They can be applied to various code elements, such as classes, methods, properties, fields, and more. Attributes are used to store declarative information and can be accessed at runtime using reflection.

[Serializable]
public class SerializableClass
{
    // Class implementation
} 

[Obsolete("This method is obsolete. Use NewMethod instead.", true)]
public void OldMethod()
{
    // Method implementation
} 

[DllImport("user32.dll")]
public static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type); 

[Conditional("DEBUG")]
public void DebugOnlyMethod()
{
    // Method implementation
} 

What is the purpose of the ‘AttributeUsage’ attribute?

The AttributeUsage attribute is used to specify the kinds of program elements to which a custom attribute can be applied. It allows you to control where and how your custom attribute can be used, and to define additional settings such as whether the attribute can be applied multiple times or inherited by derived classes.

Key Properties of ‘AttributeUsage’:

1. ValidOn: Specifies the program elements (such as classes, methods, properties, etc.) to which the attribute can be applied using the AttributeTargets enum.
   example values: AttributeTargets.Class, AttributeTargets.Method, AttributeTargets.Property, etc.
2. AllowMultiple: If true, the attribute can be applied more than once to the same element. The default value is false.
3. Inherited: If true, the attribute can be inherited by derived classes or overriding members. The default value is false.

using System;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class MyCustomAttribute : Attribute
{
    public string Description { get; }

    public MyCustomAttribute(string description)
    {
        Description = description;
    }
}

[MyCustomAttribute("This is a custom attribute for the SampleClass.")]
public class SampleClass
{
    [MyCustomAttribute("This is a custom attribute for the SampleMethod.")]
    public void SampleMethod()
    {
        Console.WriteLine("SampleMethod executed.");
    }
}

public class DerivedClass : SampleClass
{
    // Inherits attributes from SampleClass if Inherited = true
    public override void SampleMethod()
    {
        Console.WriteLine("Overridden SampleMethod in DerivedClass executed.");
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        object[] classAttributes = type.GetCustomAttributes(typeof(MyCustomAttribute), false);

        foreach (MyCustomAttribute attr in classAttributes)
        {
            Console.WriteLine($"Class Attribute Description: {attr.Description}");
        }

        MethodInfo method = type.GetMethod("SampleMethod");
        object[] methodAttributes = method.GetCustomAttributes(typeof(MyCustomAttribute), false);

        foreach (MyCustomAttribute attr in methodAttributes)
        {
            Console.WriteLine($"Method Attribute Description: {attr.Description}");
        }
    }
} 

What is the difference between Shallow copy and Deep copy in C#?

Shallow Copy: Creates a new object but references the same objects as the original. In other words, it creates a new instance of the original object, but the fields of the new object still reference the same objects as the fields of the original object. Copies the top-level structure of the object.

Deep Copy: Creates a new object and recursively copies all objects it references. In other words, it creates a completely independent copy of the original object and all objects that the original object references. Copies the entire object graph.

public class Person
{
    public string Name { get; set; }
    public Address Address { get; set; }

    public Person ShallowCopy()
    {
        return (Person)this.MemberwiseClone();
    }
	
    public Person DeepCopy()
    {
        Person copy = (Person)this.MemberwiseClone();
        copy.Address = new Address { City = this.Address.City };
        return copy;
    }
}

public class Address
{
    public string City { get; set; }
}

public class Program
{
    public static void Main()
    {
        Person original = new Person
        {
            Name = "John",
            Address = new Address { City = "New York" }
        };

        Person shallowCopy = original.ShallowCopy();

        // Both original and copy point to the same Address object
        Console.WriteLine(ReferenceEquals(original.Address, shallowCopy.Address)); // True
		
		
        Person deepCopy = original.DeepCopy();

        // original and copy point to different Address objects
        Console.WriteLine(ReferenceEquals(original.Address, deepCopy.Address)); // False
    }
} 

How do you implement ICloneable interface in C#?

The ICloneable interface in C# is used to create a clone (a copy) of an object. To implement it you need to define the Clone method, which returns a copy of the current instance. you can implement either a shallow copy or a deep copy.

using System;

public class Person : ICloneable
{
    public string Name { get; set; }
    public Address Address { get; set; }

    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

public class Address
{
    public string City { get; set; }
}

public class Program
{
    public static void Main()
    {
        Person original = new Person
        {
            Name = "John",
            Address = new Address { City = "New York" }
        };

        Person copy = (Person)original.Clone();

        Console.WriteLine($"Original Name: {original.Name}, City: {original.Address.City}");
        Console.WriteLine($"Copy Name: {copy.Name}, City: {copy.Address.City}");

        // Modifying the copy's Address
        copy.Address.City = "Los Angeles";

        // The original's Address is also changed because it's a shallow copy
        Console.WriteLine($"Original City after modification: {original.Address.City}");
        Console.WriteLine($"Copy City after modification: {copy.Address.City}");
    }
} 

What are nullable types in C#?

Nullable types allow value types (such as int, double, bool, etc.) to represent null values. This is useful when you need to represent the absence of a value for value types, which normally cannot be null.

A nullable type is declared using the ? syntax or the Nullable<T> generic type. For example, int? and Nullable<int> both represent a nullable integer.

int? nullableInt = null;

// You can check if a nullable type has a value using the HasValue property or by comparing it to null.
if (nullableInt.HasValue) 
{
	// If you are sure that the nullable type has a value, you can access it using the Value property.
	int value = nullableInt.Value;
}

What is the purpose of the ?? operator?

The ?? operator in C# is known as the null-coalescing operator. Its primary purpose is to provide a default value for nullable types or reference types when they are null.

The ?? operator returns the left-hand operand if it is not null; otherwise, it returns the right-hand operand.

int? nullableInt = null;
int result = nullableInt ?? 10;
Console.WriteLine(result); // Output: 10

string str = null;
string result = str ?? "default string";
Console.WriteLine(result); // Output: default string

How do you handle null values with nullable types?

1. Using ‘HasValue’ Property: The HasValue property indicates whether a nullable type contains a non-null value.
   ▼ Show example

   int? nullableInt = null; 
   if (nullableInt.HasValue)  { }

2. Using ‘Value’ Property: The Value property retrieves the value of the nullable type if ‘HasValue’ is ‘true’. Be cautious, as accessing ‘Value’ when ‘HasValue’ is ‘false’ will throw an ‘InvalidOperationException’.
   ▼ Show example

   int? nullableInt = null; 
   if (nullableInt.HasValue)  
   { 
   	int value = nullableInt.Value; 
   }

3. Using Null-Coalescing Operator (??): The null-coalescing operator (??) provides a default value if the nullable type is ‘null’.
   ▼ Show example

   int? nullableInt = null;
   int value = nullableInt ?? 10; // value will be 10 if nullableInt is null
   Console.WriteLine("Value: " + value); // Output: 10

4. Using Null-Conditional Operator (?.): The null-conditional operator (?.) allows you to access members only if the operand is not ‘null’.
   ▼ Show example

   int? nullableInt = null;
   int? length = nullableInt?.ToString()?.Length; // length will be null
   Console.WriteLine("Length: " + (length ?? 0)); // Output: 0

5. Default Value with ‘GetValueOrDefault’: The GetValueOrDefault method returns the value if it is not ‘null’; otherwise, it returns the default value for the type.
   ▼ Show example

   int? nullableInt = null;
   int value = nullableInt.GetValueOrDefault(); // value will be 0 (default for int)
   Console.WriteLine("Value: " + value); // Output: 0
   
   int customDefaultValue = nullableInt.GetValueOrDefault(10); // value will be 10
   Console.WriteLine("Value with custom default: " + customDefaultValue); // Output: 10

6. Using ‘is’ and Pattern Matching: Pattern matching with is allows checking and accessing the value if it is not ‘null’.
   ▼ Show example

   int? nullableInt = 5;
   
   if (nullableInt is int value)
   {
       Console.WriteLine("Value: " + value); // Output: 5
   }
   else
   {
       Console.WriteLine("Value is null");
   } 

What is the difference between the == and Equals methods?

// Value type comparison
int a = 5;
int b = 5;
Console.WriteLine(a == b); // True

// Reference type comparison
object obj1 = new object();
object obj2 = new object();
Console.WriteLine(obj1 == obj2); // False (different references)

string str1 = "hello";
string str2 = "hello";
Console.WriteLine(str1 == str2); // True (string interning in C#)

// Value type comparison
int a = 5;
int b = 5;
Console.WriteLine(a.Equals(b)); // True

// Reference type comparison
object obj1 = new object();
object obj2 = new object();
Console.WriteLine(obj1.Equals(obj2)); // False (different references)

string str1 = "hello";
string str2 = "hello";
Console.WriteLine(str1.Equals(str2)); // True (compares the content of strings)

How do you override the Equals method in C#?

Overriding the Equals method involves providing a custom implementation that defines how instances of your class should be compared for equality.

Steps to Override Equals Method:

1. Override the Equals Method – Provide a custom implementation for the Equals method that compares the relevant fields of your object.
2. Override GetHashCode Method – When overriding Equals, it is also important to override GetHashCode to ensure that objects that are considered equal have the same hash code.
3. Implement IEquatable<T> Interface (Optional) – Implementing IEquatable<T> can improve performance and make your equality checks more explicit.

public class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    // Override the Equals method
    public override bool Equals(object obj)
    {
        // If the object is null or not of the same type, return false
        if (obj == null || this.GetType() != obj.GetType())
        {
            return false;
        }

        // Cast the object to Person and compare the properties
        Person other = (Person)obj;
        return this.Name == other.Name && this.Age == other.Age;
    }

    // Override GetHashCode method
    public override int GetHashCode()
    {
        // Combine the hash codes of the properties
        return (Name?.GetHashCode() ?? 0) ^ Age.GetHashCode();
    }

    // Implement IEquatable interface
    public bool Equals(Person other)
    {
        // If the other object is null, return false
        if (other == null)
        {
            return false;
        }

        // Compare the properties
        return this.Name == other.Name && this.Age == other.Age;
    }

    public static void Main(string[] args)
    {
        Person person1 = new Person { Name = "Alice", Age = 30 };
        Person person2 = new Person { Name = "Alice", Age = 30 };
        Person person3 = new Person { Name = "Bob", Age = 25 };

        Console.WriteLine(person1.Equals(person2)); // True
        Console.WriteLine(person1.Equals(person3)); // False
        Console.WriteLine(person1.GetHashCode() == person2.GetHashCode()); // True
    }
} 

How do you implement the IComparable<T> interface?

IComparable<T> is particularly useful for sorting and comparison operations. The interface requires you to implement the CompareTo method, which compares the current instance with another object of the same type.

using System;
using System.Collections.Generic;

public class Person : IComparable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    // Implement the CompareTo method
    public int CompareTo(Person other)
    {
        if (other == null)
        {
            return 1;
        }

        // Compare the Age properties
        return this.Age.CompareTo(other.Age);
    }

    public override string ToString()
    {
        return $"{Name}, Age: {Age}";
    }

    public static void Main(string[] args)
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        // Sort the list using the CompareTo method
        people.Sort();

        // Display the sorted list
        foreach (var person in people)
        {
            Console.WriteLine(person);
        }
    }
} 

What is the purpose of the ‘global’ keyword in namespace declarations?

The global keyword is used in namespace declarations to reference the global namespace, ensuring that the namespace reference is unambiguous and starts from the root. This is particularly useful in scenarios where you might have nested or conflicting namespaces and it makes the code clearer.

namespace MyCompany.Project
{
    class Program
    {
        static void Main(string[] args)
        {
            // Using global::System ensures the System namespace from the root
            global::System.Console.WriteLine("Hello, World!");
        }
    }
} 

What are ‘global using’ directives in C# 10.0?

Global using directives are a C# 10.0 feature that allows using directives to be declared once and applied globally to all files in a project. They simplify and clean up code by reducing the need for repetitive using statements.

global using System;
global using System.Collections.Generic;
global using System.Linq; 

What is Dependency Injection and How do you implement it in different ways in C#?

Dependency Injection (DI) is a design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. It allows the dependencies of a class to be injected at runtime, promoting decoupling and easier testing.

Key Components of Dependency Injection:

1. Service: The class that performs some specific service.
2. Client: The class that depends on the service.
3. Injector: The mechanism that injects the service into the client.

3 Ways to Implement Dependency Injection:

1. Constructor Injection: Dependencies are provided through a class constructor. This is the most commonly used type of dependency injection.
▼ Show example



Step 1: Define the Service Interface

public interface IMessageService
{
    void SendMessage(string message);
} 




Step 2: Implement the Service

public class EmailService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine("Email message: " + message);
    }
} 




Step 3: Define the Client

public class Notification
{
    private readonly IMessageService _messageService;

    // Constructor Injection
    public Notification(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public void Notify(string message)
    {
        _messageService.SendMessage(message);
    }
} 

‘Notification’ depends on ‘IMessageService’ and gets it through constructor injection.




Step 4: Set Up Dependency Injection
Using a DI container like Microsoft.Extensions.DependencyInjection

using Microsoft.Extensions.DependencyInjection;

class Program
{
    static void Main(string[] args)
    {
        // Set up the DI container
        var serviceProvider = new ServiceCollection()
            .AddTransient<IMessageService, EmailService>()
            .AddTransient<Notification>()
            .BuildServiceProvider();

        // Resolve the dependency
        var notification = serviceProvider.GetService<Notification>();
        notification.Notify("Hello, Dependency Injection!");
    }
} 

2. Property Injection: Dependencies are provided through public properties of the client class. This type is less commonly used and typically for optional dependencies.
▼ Show example

// Step 1:
public interface IService
{
    void Serve();
}


// Step 2:
public class Service : IService
{
    public void Serve()
    {
        Console.WriteLine("Service Called");
    }
}


// Step 3:
public class Client
{
    // Property Injection
    public IService Service { get; set; }

    public void Start()
    {
        Service?.Serve();
    }
}


// Step 4: Setting up the DI container
var serviceProvider = new ServiceCollection()
    .AddTransient<IService, Service>()
    .AddTransient<Client>()
    .BuildServiceProvider();

// Resolving the dependency
var client = serviceProvider.GetService<Client>();
client.Service = serviceProvider.GetService<IService>();
client.Start(); 

3. Method Injection: Dependencies are provided through method parameters. This type is used when the dependency is only needed for a specific method.
▼ Show example

// Step 1:
public interface IService
{
    void Serve();
}


// Step 2:
public class Service : IService
{
    public void Serve()
    {
        Console.WriteLine("Service Called");
    }
}


// Step 3:
public class Client
{
    // Method Injection
    public void Start(IService service)
    {
        service.Serve();
    }
}


// Step 4: Setting up the DI container
var serviceProvider = new ServiceCollection()
    .AddTransient<IService, Service>()
    .AddTransient<Client>()
    .BuildServiceProvider();

// Resolving the dependency
var client = serviceProvider.GetService<Client>();
var service = serviceProvider.GetService<IService>();
client.Start(service); 

Advantages:

• Decoupling: Reduces tight coupling between classes.
• Testability: Makes it easier to test by allowing mock implementations.
• Flexibility: Promotes flexible and maintainable code architecture.

How do you use the Activator.CreateInstance method?

Activator.CreateInstance allows you to create instances of types at runtime. This method is particularly useful when the type of the object to be created is not known at compile time but is determined at runtime. It provides several overloads to support different scenarios, such as creating instances with parameters or using generic type parameters.

public interface IMyInterface
{
    void Display();
}

public class MyClass : IMyInterface
{
    public void Display()
    {
        Console.WriteLine("MyClass instance created implementing IMyInterface!");
    }
}

public class MyClass2
{
    public MyClass2(string message)
    {
        Console.WriteLine(message);
    }
	
	public void Display2()
    {
        Console.WriteLine("MyClass2 instance created!");
    }
	
	
}

class Program
{
    static void Main()
    {
        // Method 1: Create an instance of MyClass (Basic Usage)
        var myClassInstance1 = (MyClass2)Activator.CreateInstance(typeof(MyClass2));
        myClassInstance1.Display2();
		
		
        // Method 2: Create an instance of MyClass using generic overload
        var myClassInstance2 = Activator.CreateInstance<MyClass2>();
        myClassInstance2.Display2();
		
		
        // Method 3: Create an instance of MyClass with parameter
        var myClassInstance3 = (MyClass2)Activator.CreateInstance(typeof(MyClass2), "Hello, MyClass!");
		
		
        // Method 4: Create an instance of MyClass type implementing Interfaces
        var myClassInstance4 = (IMyInterface)Activator.CreateInstance(typeof(MyClass));
        myClassInstance4.Display();
		
    }
} 

How do you use pattern matching in C#?

Pattern matching can be used with switch statements, if statements, and expressions. Pattern matching enhances type safety and readability, making code more expressive and easier to maintain.

object obj = "Hello, World!";
if (obj is string s)
{
    Console.WriteLine($"The string is: {s}");
} 

object obj = 42;

switch (obj)
{
    case int i:
        Console.WriteLine($"The integer is: {i}");
        break;
    case string s:
        Console.WriteLine($"The string is: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
} 

int number = 42;

string description = number switch
{
    < 0 => "Negative",
    0 => "Zero",
    > 0 and <= 10 => "Small positive number",
    > 10 => "Large positive number",
    _ => "Unknown"
};

Console.WriteLine(description); // Output: Large positive number

(int x, int y) point = (1, 2);

string quadrant = point switch
{
    (0, 0) => "Origin",
    var (x, y) when x > 0 && y > 0 => "Quadrant I",
    var (x, y) when x < 0 && y > 0 => "Quadrant II",
    var (x, y) when x < 0 && y < 0 => "Quadrant III",
    var (x, y) when x > 0 && y < 0 => "Quadrant IV",
    _ => "On axis"
};

Console.WriteLine(quadrant); // Output: Quadrant I

public class Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) => (X, Y) = (x, y);
    public void Deconstruct(out int x, out int y) => (x, y) = (X, Y);
}

var point = new Point(1, 2);

string location = point switch
{
    (0, 0) => "Origin",
    var (x, y) when x > 0 && y > 0 => "Quadrant I",
    var (x, y) when x < 0 && y > 0 => "Quadrant II",
    var (x, y) when x < 0 && y < 0 => "Quadrant III",
    var (x, y) when x > 0 && y < 0 => "Quadrant IV",
    _ => "On axis"
};

Console.WriteLine(location); // Output: Quadrant I

What is the purpose of tuples in C#?

Tuples provide a way to store multiple values in a single object without creating a custom class or struct. They are useful for returning multiple values from a method, grouping related data, and making code more readable and concise.

public void GetCoordinates(out int x, out int y)
{
    x = 10;
    y = 20;
}

int x, y;
GetCoordinates(out x, out y);
Console.WriteLine($"x: {x}, y: {y}");

public (int, int) GetCoordinates()
{
    return (10, 20);
}

var coordinates = GetCoordinates();
Console.WriteLine($"x: {coordinates.Item1}, y: {coordinates.Item2}");

public (int X, int Y) GetCoordinates()
{
    return (10, 20);
}

var coordinates = GetCoordinates();
Console.WriteLine($"x: {coordinates.X}, y: {coordinates.Y}");

var person = ("John", "Doe", 30);

Console.WriteLine($"First Name: {person.Item1}");
Console.WriteLine($"Last Name: {person.Item2}");
Console.WriteLine($"Age: {person.Item3}");

var person = (FirstName: "John", LastName: "Doe", Age: 30);

Console.WriteLine($"First Name: {person.FirstName}");
Console.WriteLine($"Last Name: {person.LastName}");
Console.WriteLine($"Age: {person.Age}");

How do you deconstruct a tuple in C#?

Deconstruction extracts the elements of the tuple into individual variables. You can deconstruct a tuple into separate variables to make it easier to work with the individual elements.

// Creating a tuple
var person = ("John", "Doe", 30);

// Deconstructing the tuple into individual variables
(string firstName, string lastName, int age) = person;

Console.WriteLine($"First Name: {firstName}");
Console.WriteLine($"Last Name: {lastName}");
Console.WriteLine($"Age: {age}"); 

// Creating a named tuple
var person = (FirstName: "John", LastName: "Doe", Age: 30);

// Deconstructing the named tuple into individual variables
(string firstName, string lastName, int age) = person; 

// Method returning a tuple
public (string FirstName, string LastName, int Age) GetPerson()
{
    return ("John", "Doe", 30);
}

// Deconstructing the tuple returned by the method
var (firstName, lastName, age) = GetPerson(); 

var person = ("John", "Doe", 30);

// Deconstructing and discarding the last name
(string firstName, _, int age) = person;

Console.WriteLine($"First Name: {firstName}");
Console.WriteLine($"Age: {age}"); 

What happens if a constructor throws an exception in C#?

When a constructor throws an exception, the object construction fails and the following things happen:

• Object Creation Fails: The partially created object is discarded, and the reference to the object becomes null (if the constructor was called with the new keyword).
• Exception Propagation: The exception propagates up the call stack to the point where the constructor was called. If not caught, it continues to propagate until it is either caught by a catch block or the application terminates.
• No Finalizers Called: Finalizers (destructors) are not called on the partially constructed object because it was never fully constructed. The garbage collector will eventually clean up any resources associated with the object.

What is an anonymous method in C#?

An anonymous method in C# is a method without a name, defined using the delegate keyword. It allows you to define inline methods that can be passed as parameters, used in event handling, or assigned to delegates without needing to declare a separate method.

using System;

delegate void MyDelegate(string message);

class Program
{
    static void Main(string[] args)
    {
        // Anonymous method assigned to a delegate
        MyDelegate myDelegate = delegate (string msg)
        {
            Console.WriteLine(msg);
        };

        // Invoke the delegate
        myDelegate("Hello, this is an anonymous method!");
    }
} 

What is the purpose of the ‘nameof’ operator in C#?

The nameof operator is used to obtain the name of a variable, type, or member as a string. It is useful for refactoring, code readability, and avoiding hardcoded strings, especially when dealing with exceptions, logging, or argument validation.

string propertyName = nameof(Example.PropertyName); 

What are expression-bodied members in C#?

Expression-bodied members in C# provide a concise syntax for defining methods, properties, constructors, destructors, and other members that can be implemented with a single expression. Expression-bodied members use the => (lambda expression) syntax to directly return or assign a value.

Traditional method syntax:

public int Add(int x, int y)
{
	return x + y;
}

Expression-bodied method:

public int AddExpressionBodied(int x, int y) => x + y; 

What is the purpose of the Span<T> type in C#?

The Span<T> type provides a safe and efficient way to work with contiguous memory regions. It is a stack-allocated type, meaning it’s a lightweight, value type that helps avoid heap allocations. Span<T> is particularly useful in scenarios requiring high performance and low memory overhead, such as processing large data streams or performing operations on buffers, systems programming, game development, or processing large datasets.

Allows for creating sub-spans (slices) of the original span without copying data, providing a view over a portion of the memory.

ReadOnlySpan<T> is a read-only counterpart, used when you need a non-modifiable view of the data.

using System;

class Program
{
    static void Main()
    {
        // Example with an array
        int[] numbers = { 1, 2, 3, 4, 5 };

        // Create a Span over the array
        Span<int> span = numbers;

        // Modify the span (and thus the array)
        span[2] = 100;

        // Print the modified array
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }

        // Output: 1, 2, 100, 4, 5

        // Slicing a Span
        Span<int> slice = span.Slice(1, 3);

        // Print the sliced span
        foreach (var item in slice)
        {
            Console.WriteLine(item);
        }

        // Output: 2, 100, 4
    }
} 

What is the purpose of the ‘stackalloc’ keyword in C#?

The stackalloc keyword is used to allocate memory on the stack for temporary arrays or spans. It improves performance by avoiding heap allocations (which is faster and more efficient) and reducing garbage collection overhead.

Span<int> numbers = stackalloc int[5];
// or
Span<int> numbers = stackalloc int[3] { 10, 20, 30 }; 

What is the purpose of Memory<T> and ReadOnlyMemory<T>?

Memory<T> and ReadOnlyMemory<T> are types designed to represent a contiguous region of memory in a safe and efficient manner. They allow for working with large data buffers, slices of arrays, or other memory blocks without the need for copying data. They are especially useful in performance-critical applications where minimizing memory allocations and copying is important.

Purpose of Memory<T>:

• Writable Memory: Memory<T> represents a block of memory that can be read from and written to. It is similar to Span<T>, but Memory<T> can be stored on the heap, while Span<T> is restricted to stack-only scenarios.
• Slicing: Allows you to create sub-slices of the memory without copying the underlying data.
• Asynchronous (Async/Await) Operations: Unlike Span<T>, Memory<T> can be used in async methods. Efficiently manage buffers in scenarios like network I/O, file I/O, or data processing where copying data would be costly.

Purpose of ReadOnlyMemory<T>:

• Read-Only Memory: ReadOnlyMemory<T> is similar to Memory<T>, but it only allows reading from the memory. It ensures that the underlying data cannot be modified, which is useful for enforcing immutability.
• Data Security: Provides a way to pass around slices of data safely, ensuring that the original data cannot be altered by the recipient.
• Immutable Data: Use ReadOnlyMemory<T> when you want to ensure that a section of data remains unchanged when passed to other parts of the code.

Memory<int> memory = new int[] { 1, 2, 3 };
ReadOnlyMemory<int> readOnlyMemory = new int[] { 1, 2, 3 }; 

public void ProcessData(Memory<byte> buffer)
{
    var slice = buffer.Slice(0, 10); // Slice the first 10 bytes
    // Modify the slice
    slice.Span[0] = 255;
}

byte[] data = new byte[100];

ProcessData(data); // Memory can implicitly be created from arrays

public void DisplayData(ReadOnlyMemory<byte> buffer)
{
    var slice = buffer.Slice(0, 10); // Slice the first 10 bytes
    // Process the slice without modifying it
    foreach (var b in slice.Span)
    {
        Console.WriteLine(b);
    }
}

byte[] data = new byte[100];

DisplayData(data); // ReadOnlyMemory can implicitly be created from arrays

What is the difference between ‘Task’ and ‘ValueTask’ in C#?

Task and ValueTask are both used in C# for representing asynchronous operations, but they serve slightly different purposes and are optimized for different scenarios.

public async Task<int> GetDataAsync()
{
    await Task.Delay(1000);
    return 42;
} 

public ValueTask<int> GetDataAsync(bool quickResult)
{
    if (quickResult)
    {
        // Synchronous, no allocation
        return new ValueTask<int>(42); 
    }
    else
    {
        // Asynchronous
        return new ValueTask<int>(Task.Delay(1000).ContinueWith(t => 42)); 
    }
} 

How do you use the ‘record’ feature in C# 9.0?

The record feature in C# 9.0 introduces a new reference type that provides built-in functionality for immutable data models with value-based equality, making it easier to create data-centric classes.

Key Features of ‘record’:

1. Immutability: By default, records are immutable, meaning once created, their properties cannot be changed.
2. Value-Based Equality: Records compare objects based on their values, not their references, making them ideal for data structures where the value matters more than the identity.
3. Readability: Use when you need concise and readable code for defining types that primarily store data.
4. Concise Syntax: Records can be declared with a much simpler syntax compared to traditional classes.

public record Person(string FirstName, string LastName); 

public class Person
{
    public string FirstName { get; }
    public string LastName { get; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    public override bool Equals(object obj) =>
        obj is Person person &&
        FirstName == person.FirstName &&
        LastName == person.LastName;

    public override int GetHashCode() => 
        HashCode.Combine(FirstName, LastName);
} 

var person1 = new Person("John", "Doe");
var person2 = new Person("John", "Doe");

// Value-based equality
Console.WriteLine(person1 == person2); // True
Console.WriteLine(person1.Equals(person2)); // True

var (firstName, lastName) = person1;
Console.WriteLine(firstName); // John
Console.WriteLine(lastName);  // Doe

var person3 = person1 with { LastName = "Smith" };
Console.WriteLine(person3); // Person { FirstName = John, LastName = Smith }

public record Employee(string FirstName, string LastName, string Position)
    : Person(FirstName, LastName);

var employee = new Employee("Jane", "Doe", "Manager");
Console.WriteLine(employee); // Employee { FirstName = Jane, LastName = Doe, Position = Manager }

How do you implement ‘with’ expressions in C# 9.0 records?

In C# 9.0, records provide a simple way to create immutable objects with value-based equality. The with expression allows you to create a copy of an existing record object with some properties changed, while the original object remains unchanged.

public record Person(string FirstName, string LastName, int Age); 

var originalPerson = new Person("John", "Doe", 30); 

// create a new record based on an existing one with some modifications.
var updatedPerson = originalPerson with { Age = 31 }; 

What is a ‘Record Struct‘ in C# 10.0?

Unlike regular records, which are reference types, a record struct is a value type. This means that it is stored on the stack and passed by value rather than by reference. By default, record structs are designed to be immutable. This makes them useful for defining small, lightweight data structures that should not change after creation.

public record struct Point(int X, int Y); 

What is a target-typed ‘new’ expression in C# 9.0?

A target-typed new expression in C# 9.0 allows you to create an instance of an object without explicitly specifying the type when the type can be inferred from the context. This feature simplifies the syntax, making the code cleaner and more concise. The compiler infers the type of the object being created based on the context, so you don’t need to repeat the type on the right-hand side of the assignment.

List<int> numbers = new(); // List<int> is inferred

What is the ‘init’ accessor in C# 9.0?

The init accessor in C# 9.0 is a new way to set properties during object initialization, making them immutable after the object is created. This means once an object is created, properties with init accessors cannot be modified afterward.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

var person = new Person { FirstName = "John", LastName = "Doe" };
person.FirstName = "Jane"; // This is allowed, but changes the original object

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

var person = new Person { FirstName = "John", LastName = "Doe" };
person.FirstName = "Jane"; // Error: Cannot modify because of init

How do you use the ‘range’ and ‘index’ operators

The range and index operators in C# are used to easily access specific elements or ranges of elements within arrays, strings, or other indexable collections.

1) Range Operator (..): The range operator (..) allows you to specify a range of elements. The syntax start..end extracts elements from the start index to the end index (exclusive). You can omit the start or end to take elements from the beginning or up to the end of the collection.

int[] numbers = { 10, 20, 30, 40, 50 };

// Extract elements from index 1 to 3 (20, 30, 40)
int[] middle = numbers[1..4];

// Extract the first three elements (10, 20, 30)
int[] firstThree = numbers[..3];

// Extract the last two elements (40, 50)
int[] lastTwo = numbers[^2..]; 

2) Index Operator (^): The index operator ^ allows you to access elements from the end of a collection. The syntax ^n refers to the element at the n-th position from the end.

int[] numbers = { 10, 20, 30, 40, 50 };

// Accesses the last element: 50
int lastElement = numbers[^1];   

// Accesses the second-to-last element: 40
int secondLastElement = numbers[^2]; 

What is the purpose of the ‘checked’ and ‘unchecked’ keywords in C#?

The checked and unchecked keywords in C# are used to control the behavior of arithmetic operations and conversions with respect to overflow.

1) ‘checked’ Keyword: Enforces overflow checking and throws an exception if overflow occurs. Ensures data integrity by detecting overflows, particularly in critical calculations where overflow could lead to incorrect results. Often used in scenarios where arithmetic operations involve user input or data that could reach extreme values.

// This will throw an OverflowException
int result = checked(max + 1); 

2) ‘unchecked’ Keyword: Disables overflow checking, allowing arithmetic operations to wrap around without throwing an exception. Improves performance by avoiding the overhead of overflow checking.
Useful in scenarios where you are confident that overflow is either impossible or acceptable (e.g., when working with bitwise operations).

int max = int.MaxValue;

// This will not throw an exception; it will wrap around
int result = unchecked(max + 1); 

// Output: -2147483648 (wrapped around value)
Console.WriteLine(result); 

What is the purpose of the ‘volatile’ keyword in C#?

The volatile keyword in C# is used to indicate that a field may be modified by multiple threads simultaneously. It ensures that the most up-to-date value of the field is always read from memory, not from a CPU register or cache. Use the volatile keyword for fields that are shared between multiple threads and where simple atomic reads and writes (like int, bool, float, etc.) are required.

public class Example
{
    private volatile bool _isRunning;

    public void Start()
    {
        _isRunning = true;
        new Thread(Run).Start();
    }

    public void Stop()
    {
        _isRunning = false;
    }

    private void Run()
    {
        while (_isRunning)
        {
            // Perform work
        }
    }
} 

It’s not suitable for more complex thread synchronization scenarios (like incrementing a value or checking and setting a value simultaneously); for those, you should use lock, Monitor, Mutex, etc.

How do you use ‘string interpolation’ in C#?

String interpolation allows you to embed expressions directly within string literals, making it easier and more readable to format strings. Use the $ symbol before the string and place expressions inside curly braces {} within the string.

string name = "John";
int age = 30;
string message = $"My name is {name} and I am {age} years old.";