C# Interview Q&A | Try Hands-On Practice & Personalised AI Support

Access modifiers in C# are keywords used to specify the accessibility of a class and its members. The main access modifiers are:

• public: The member is accessible from any other code.
• private: The member is accessible only within the class or struct in which it is declared.
• protected: The member is accessible within its class and by derived class instances.
• internal: The member is accessible only within files in the same assembly.
• protected internal: The member is accessible within its assembly and by derived class instances.

public class MyClass
{
    private int privateField;
    public int publicField;
    protected int protectedField;
    internal int internalField;
    protected internal int protectedInternalField;
}

Both abstract classes and interfaces can be used to define methods that must be implemented by derived classes. However, there are key differences:

• Abstract Classes: Can include implementation of methods, fields, properties, and constructors. A class can inherit from only one abstract class.
• Interfaces: Cannot include any implementation. They can only contain method, property, event, or indexer declarations. A class can implement multiple interfaces.

// Abstract class
public abstract class Animal
{
    public abstract void MakeSound();
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

// Interface
public interface IAnimal
{
    void MakeSound();
}

// Implementing an abstract class
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Barking...");
    }
}

// Implementing an interface
public class Cat : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Meowing...");
    }
}

Polymorphism is a core concept in object-oriented programming that allows methods to have different implementations based on the object they are acting upon. There are two types of polymorphism in C#:

• Compile-time polymorphism (Method Overloading): Methods in a class with the same name but different parameters.
• Runtime polymorphism (Method Overriding): Derived class provides a specific implementation of a method that is already defined in its base class using the virtual and override keywords.

// Method Overloading
public class MathOperations
{
    public int Add(int a, int b)
    {
        return a + b;
    }
    public double Add(double a, double b)
    {
        return a + b;
    }
}

// Method Overriding
public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Base class display method");
    }
}

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

A delegate in C# is a type that represents references to methods with a particular parameter list and return type. Delegates are used to pass methods as arguments to other methods. They are similar to function pointers in C++ but are type-safe and secure.

public delegate void DisplayMessage(string message);

public class MessageHandler
{
    public void ShowMessage(string message)
    {
        Console.WriteLine(message);
    }
}

public class Program
{
    static void Main()
    {
        MessageHandler handler = new MessageHandler();
        DisplayMessage del = new DisplayMessage(handler.ShowMessage);
        del("Hello, World!");
    }
}

Events in C# are a way for a class to notify other classes or objects when something of interest happens. Events are based on delegates. A class that raises an event is called a publisher , and a class that receives the event notification is called a subscriber .

public class Publisher
{
    public delegate void Notify();  // Delegate
    public event Notify OnNotify;   // Event

    public void DoSomething()
    {
        // Some code...
        OnNotify?.Invoke();
    }
}

public class Subscriber
{
    public void Subscribe(Publisher publisher)
    {
        publisher.OnNotify += OnNotified;
    }

    private void OnNotified()
    {
        Console.WriteLine("Subscriber notified.");
    }
}

class Program
{
    static void Main()
    {
        Publisher publisher = new Publisher();
        Subscriber subscriber = new Subscriber();
        subscriber.Subscribe(publisher);

        publisher.DoSomething(); // This will trigger the event
    }
}

In C#, String and string are essentially the same. string is an alias for System.String . They both represent a sequence of characters. The use of one over the other is a matter of style or convention. However, string is more commonly used in C# code, while String is used when referencing the .NET class directly.

Properties in C# are members that provide a flexible mechanism to read, write, or compute the values of private fields. Properties can have logic implemented in their get and set accessors, providing control over how values are accessed or modified. Fields, on the other hand, are simple variables that store data directly.

public class Person
{
    private string name; // Field

    public string Name   // Property
    {
        get { return name; }
        set { name = value; }
    }
}

Method overloading in C# is the ability to create multiple methods with the same name in the same class but with different parameters (different type, number, or both). It allows methods to handle different types of input in a flexible and readable way.

public class MathOperations
{
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
}

A struct in C# is a value type that can contain fields, methods, constructors, properties, and other members. Unlike classes, structs are value types and are typically used for small data structures that contain primarily data. Key differences:

• Structs are value types, while classes are reference types.
• Structs are stored on the stack, whereas classes are stored on the heap.
• Structs do not support inheritance but can implement interfaces.
• Structs cannot have a default constructor (parameterless).

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

The using statement in C# is used to ensure that IDisposable objects are properly disposed of once they are no longer needed. This is particularly important for managing unmanaged resources like file handles, database connections, or network connections. The using statement ensures that the Dispose method is called even if an exception occurs.

using (StreamReader reader = new StreamReader("file.txt"))
{
    string content = reader.ReadToEnd();
}

Both const and readonly are used to define fields whose values cannot be modified, but they have different use cases and behaviors:

• const: The value is set at compile-time and cannot be changed. It must be initialized at the time of declaration. const is implicitly static.
• readonly: The value is set at runtime, either during declaration or in the constructor. It can be different for each instance of the class.

public class Example
{
    public const int ConstValue = 10; // Compile-time constant
    public readonly int ReadOnlyValue; // Runtime constant

    public Example(int value)
    {
        ReadOnlyValue = value; // Can only be set in the constructor
    }
}

C# provides several types of collections, categorized mainly into the following:

• Arrays: Fixed-size collections of elements of the same type.
• List<T>: A dynamic array that can grow in size.
• Dictionary<TKey, TValue>: A collection of key-value pairs.
• Queue<T>: A first-in, first-out (FIFO) collection.
• Stack<T>: A last-in, first-out (LIFO) collection.
• HashSet<T>: A collection of unique elements.
• LinkedList<T>: A doubly linked list.

Exception handling in C# is a mechanism to handle runtime errors in a controlled and graceful manner using try , catch , finally , and throw keywords.

• try: Block of code where exceptions may occur.
• catch: Block of code that handles the exception.
• finally: Block of code that executes regardless of whether an exception is thrown or not.
• throw: Used to explicitly throw an exception.

try
{
    int divisor = 0;
    int result = 10 / divisor;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Cannot divide by zero.");
}
finally
{
    Console.WriteLine("Execution completed.");
}

LINQ (Language Integrated Query) is a set of features in C# that provides query capabilities directly within the C# language. It allows querying various data sources, such as collections, SQL databases, XML documents, etc., using a consistent syntax. LINQ queries can be written using query syntax or method syntax.

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

Both override and new are used to redefine a method in a derived class, but they have different implications:

• override: Used to provide a new implementation of a virtual method defined in the base class. It requires the method in the base class to be marked as virtual, abstract, or override.
• new: Hides a method from the base class. It is used when the derived class wants to define a new implementation that is not related to the base class method.

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

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

public class AnotherDerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Another derived class display method");
    }
}