Top 25 Advanced C# Interview Questions & Answers

1. Introduction

Navigating the world of software development interviews can be daunting, especially when it comes to the C# programming language. This article is designed to guide seasoned programmers through advanced C# interview questions, ensuring they’re well-prepared for the technical challenges that lie ahead. Whether you’re a candidate or an interviewer, these questions will help gauge mastery over complex C# topics and concepts.

2. Exploring the Depth of C# Expertise

When it comes to hiring for advanced C# roles, employers seek candidates who not only understand the syntax of the language but can also apply its features to solve complex problems creatively and efficiently. A deep understanding of C#’s advanced concepts, such as asynchronous programming, design patterns, memory management, and more, is crucial for success in these roles. Employers are looking for developers who can go beyond the basics and leverage the full power of C# to drive innovation and performance in their software projects. By exploring advanced concepts through these interview questions, candidates can demonstrate their technical proficiency and readiness to contribute meaningfully in a professional setting.

3. Advanced C# Interview Questions

Q1. Describe the usage of the ‘yield’ keyword in C#. (Asynchronous Programming & Iterators)

The yield keyword in C# plays a crucial role in the implementation of iterator methods. It allows a method to return an enumerable sequence, providing a value to the enumerator and then pausing its execution until the next element is requested. This stateful iteration over a collection is accomplished without the need to create a temporary collection to hold all elements, which can lead to more efficient memory usage, particularly when iterating over large datasets or collections that are generated on-the-fly.

Example Usage:

public static IEnumerable<int> GetPowersOfTwo(int n)
{
    for (int i = 0; i < n; i++)
    {
        yield return (int)Math.Pow(2, i);
    }
}

In the above example, each call to the iterator method will run until it hits the yield return statement, which provides the next power of two to the caller. The state of the method (including the current value of i) is preserved between calls.

Q2. Explain how you would implement dependency injection in C# without using a framework. (Design Patterns & Coding Practices)

Implementing dependency injection manually in C# can be done by following some key principles:

• Interfaces or abstract classes: Define an interface or an abstract class for the dependency to abstract the concrete implementation.
• Constructor injection: Pass the dependency through the class constructor.
• Property injection: Alternatively, provide a public property or method to set the dependency.

Example Implementation:

public interface IService
{
    void Serve();
}

public class ServiceImplementation : IService
{
    public void Serve()
    {
        // Implementation
    }
}

public class ClientClass
{
    private IService _service;

    // Constructor injection
    public ClientClass(IService service)
    {
        _service = service;
    }

    public void DoWork()
    {
        _service.Serve();
    }
}

// Usage
var service = new ServiceImplementation();
var client = new ClientClass(service);

In this example, ClientClass requires a service. Instead of creating an instance of ServiceImplementation directly within ClientClass, it is injected into the constructor, allowing for greater flexibility and easier testing.

Q3. In C#, what is the difference between ‘String’ and ‘StringBuilder’ in terms of performance, and when would you use each one? (Memory Management & Performance)

String and StringBuilder in C# are used for different scenarios based on their performance characteristics:

• String: Immutable – once created, it cannot be modified. Any operations that appear to modify a String actually result in the creation of a new String object.
• StringBuilder: Mutable – designed to be modified in place, which can lead to more efficient memory usage and performance when dealing with string manipulation operations that involve concatenation, insertion, deletion, or appending in loops.

Performance Table:

Operation	String	StringBuilder
Creation	Fast for single or few operations	Slower due to additional object overhead
Modification	Slow, creates a new string for each operation	Fast, modifies the existing object
Memory Overhead	Low for unchanged strings	Higher, but efficient for many changes
Readability	Better for simple assignments and manipulations	Worse due to method calls

When to use each:

• String: Use when dealing with immutable text, small or single modifications, or when readability and simplicity are important.
• StringBuilder: Prefer when performing numerous or complex string manipulations, such as in loops or large concatenations.

Q4. How can you handle circular references when serializing objects in C#? (Serialization & Data Handling)

To handle circular references during serialization in C#, you need to configure the serializer to handle such references appropriately. This is often done by maintaining a reference table or by configuring the serializer to preserve object references.

For example, when using Newtonsoft.Json (Json.NET), you can set the PreserveReferencesHandling setting to manage circular references:

JsonSerializerSettings settings = new JsonSerializerSettings
{
    PreserveReferencesHandling = PreserveReferencesHandling.Objects
};

string json = JsonConvert.SerializeObject(yourObject, settings);

With System.Text.Json available from .NET Core 3.0 onwards, you can use the ReferenceHandler option:

var options = new JsonSerializerOptions
{
    ReferenceHandler = ReferenceHandler.Preserve
};

string json = JsonSerializer.Serialize(yourObject, options);

Q5. Discuss the IDisposable interface and provide an example of how you would implement it in a class. (Memory Management & Resource Handling)

The IDisposable interface is used in C# to release unmanaged resources, such as file handles, database connections, or any other resources that are not handled by the garbage collector. Classes that use these resources should implement IDisposable to allow consumers of the class to explicitly release these resources when they are no longer needed.

Example Implementation:

public class ResourceHolder : IDisposable
{
    private bool _disposed = false;
    // Assume _resource is some type of unmanaged resource
    private UnmanagedResource _resource;

    public ResourceHolder()
    {
        _resource = new UnmanagedResource();
    }

    // Public implementation of Dispose pattern callable by consumers
    public void Dispose()
    {
        Dispose(true);
        // Suppress finalization if the object is being disposed of manually
        GC.SuppressFinalize(this);
    }

    // Protected implementation of Dispose pattern
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Dispose managed state (managed objects)
            }

            // Free any unmanaged resources here
            if (_resource != null)
            {
                _resource.Release();
                _resource = null;
            }

            _disposed = true;
        }
    }

    // Destructor/finalizer
    ~ResourceHolder()
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose(false);
    }
}

In the provided example, ResourceHolder implements IDisposable and follows the dispose pattern, which includes a finalizer for additional safety to ensure that resources are freed when the object is collected by the garbage collector if they were not released earlier.

Q6. What are extension methods in C# and how do they work? Give an example of when you might use them. (Language Features & Best Practices)

Answer:

Extension methods in C# allow you to add new methods to existing types without modifying the original type’s source code or creating a new derived type. They are static methods defined in static classes, but are called as if they were instance methods on the extended type. To create an extension method, the first parameter specifies which type the method operates on, and it is prefixed with the this keyword.

Example of when you might use extension methods:

You might use extension methods to add functionality to a third-party library where you do not have access to the source code. For instance, you could add a method to better format a string output from a type provided by a library, or to simplify operations on collections.

Here’s an example of an extension method that adds a method to the string type that converts a comma-separated string into a list of strings:

public static class StringExtensions
{
    public static List<string> ToList(this string str, char separator = ',')
    {
        if (string.IsNullOrEmpty(str)) return new List<string>();
        return str.Split(separator).ToList();
    }
}

// Usage:
string csv = "apple,banana,cherry";
List<string> fruits = csv.ToList();

This code defines an extension method ToList on the string type, allowing every string in the application to be easily converted to a List<string> based on a provided separator.

Q7. Explain the concept of LINQ and its benefits over traditional iteration methods. (Language Integrated Query & Data Manipulation)

Answer:

LINQ (Language Integrated Query) is a set of features in C# that allows writing queries directly within the C# language, commonly used to query and manipulate data from various sources such as collections, databases, XML documents, etc.

Benefits of LINQ over traditional iteration methods:

• Readable code: LINQ queries are often more readable and concise than equivalent for or foreach loops.
• Consistency: LINQ provides a consistent querying experience across different data sources.
• Compile-time checking: LINQ queries are checked at compile-time, which can help catch errors early.
• IntelliSense support: LINQ queries benefit from IDE features like IntelliSense, making it easier to write and maintain queries.
• Lazy execution: LINQ queries use deferred execution, meaning the data is not retrieved until it’s actually needed.

Example of LINQ vs. traditional iteration:

Consider the task of finding all even numbers in an array and then ordering them. Here’s how you might do it with traditional iteration methods:

int[] numbers = { 1, 6, 2, 9, 5, 8 };
List<int> evenNumbers = new List<int>();
foreach (var number in numbers)
{
    if (number % 2 == 0)
    {
        evenNumbers.Add(number);
    }
}
evenNumbers.Sort();

And here’s how you could accomplish the same task using LINQ:

int[] numbers = { 1, 6, 2, 9, 5, 8 };
var evenNumbers = numbers.Where(n => n % 2 == 0).OrderBy(n => n);

The LINQ version is not only more concise but also easier to understand at a glance.

Q8. Can you explain covariance and contravariance in C# and where you might use it? (Type System & Advanced Concepts)

Answer:

Covariance and contravariance are concepts that deal with the substitutability of types, specifically in the context of generics and delegate types.

• Covariance: Enables you to use a more derived type than originally specified. You can assign an instance of IEnumerable<Derived> to a variable of IEnumerable<Base>.
• Contravariance: Allows you to use a more general type than originally specified. You can assign an instance of Action<Base> to a variable of Action<Derived>.

These concepts are useful in situations where you want to preserve type safety while working with collections and methods that handle different types in a class hierarchy.

Where you might use them:

Covariance is often used with collections that are read-only, like IEnumerable<T>, where it’s safe to return a sequence of a more derived type than the one specified.

Contravariance is typically used with delegates or interfaces that have method arguments, allowing you to pass a delegate that works with a more general type than the one specified.

Example of covariance and contravariance in interfaces:

public class Animal { }
public class Dog : Animal { }

public interface ICovariant<out T> { T Get(); }
public interface IContravariant<in T> { void Put(T item); }

public class CovariantClass<T> : ICovariant<T>
{
    public T Get() { return default(T); }
}

public class ContravariantClass<T> : IContravariant<T>
{
    public void Put(T item) { /* ... */ }
}

// Covariance
ICovariant<Animal> animalGetter = new CovariantClass<Dog>();
// Contravariance
IContravariant<Dog> dogPutter = new ContravariantClass<Animal>();

Q9. How would you debug a memory leak in a C# application? (Debugging & Performance Tuning)

Answer:

To debug a memory leak in a C# application, you can follow these steps:

• Use diagnostic tools: Employ tools like the Visual Studio Diagnostic Tools, dotMemory, or the CLR Profiler to analyze memory usage and detect leaks.
• Analyze memory snapshots: Take snapshots of the memory at different times and compare them to see what objects are being retained.
• Review code for common causes: Look for event handlers that are not unregistered, static references, timers, and large objects held in memory.
• Check for proper IDisposable pattern implementation: Ensure that classes implementing IDisposable correctly dispose of unmanaged resources.
• Use Weak References: Where appropriate, use weak references to prevent strong reference cycles.

In addition to these technical steps, it’s important to:

• Seek patterns: Investigate if the memory leak is related to specific actions or modules within the application.
• Isolate the issue: Try to replicate the leak in a smaller test application, if possible, to isolate the cause.
• Monitor memory in production: Use Application Performance Management (APM) tools to monitor memory in production environments, as some leaks may only occur under real workload.

Q10. Describe how the ‘async’ and ‘await’ keywords work in C#. Provide a real-world scenario where they would be useful. (Asynchronous Programming & Threading)

Answer:

The async and await keywords in C# are used to write asynchronous code that operates without blocking the main thread. An async method runs synchronously until it reaches an await statement, at which point it yields control back to the caller until the awaited task is complete. This makes the method asynchronous without the need for complex callbacks or manual thread management.

Real-world scenario where async and await would be useful:

Consider a web application that serves data from a remote API. To prevent the UI from freezing while data is being fetched, you could use async and await to call the remote service without blocking the UI thread.

Here’s a simplified example:

public async Task<List<Product>> GetProductsAsync()
{
    using (var httpClient = new HttpClient())
    {
        string responseBody = await httpClient.GetStringAsync("http://example.com/api/products");
        var products = JsonConvert.DeserializeObject<List<Product>>(responseBody);
        return products;
    }
}

// Usage in an async method
public async Task ShowProductsAsync()
{
    var products = await GetProductsAsync();
    // Do something with the products, like displaying them in the UI
}

In this example, GetProductsAsync fetches product data asynchronously. The await keyword is used to await the completion of the HTTP request without blocking. This allows other operations, such as UI updates, to continue running smoothly.

Q11. What is the role of the ‘volatile’ keyword in C# and when would you use it? (Threading & Memory Visibility)

The volatile keyword in C# is used to indicate that a field might be modified by multiple threads that are executing at the same time. The compiler, runtime system, and even hardware are instructed not to cache the value of such fields and to always read the latest value from the main memory. This ensures that the most recent value is visible to all threads, providing a form of memory visibility guarantee.

Here are some scenarios in which you might use volatile:

• When you have a field that is accessed by multiple threads without using lock statements, Mutex, or other synchronization primitives.
• When you are dealing with low-level threading scenarios where performance is critical and you want to avoid the overhead of full synchronization primitives.
• When you are dealing with hardware that can update memory outside of the control of the current CPU, such as memory-mapped I/O ports.

Note: The use of the volatile keyword has become less common with the introduction of the System.Threading namespace and the memory model enhancements in the CLR. It’s recommended to use Interlocked class methods and other synchronization primitives like Monitor, Mutex, etc., for most threading scenarios.

Q12. Explain the differences between ‘ref’, ‘out’, and ‘in’ parameters in C#. Provide examples. (Method Signatures & Parameter Passing)

In C#, ref, out, and in are keywords used to specify different kinds of parameter passing to methods.

ref parameters:

• Allows passing arguments by reference.
• The caller is required to initialize the variable before passing.
• The method can read and modify the value of the argument.

Example:

void Increment(ref int number)
{
    number++;
}

out parameters:

• Also allows passing arguments by reference.
• The caller does not need to initialize the variable before passing.
• The method must assign a value before the method returns.

Example:

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

in parameters:

• Allows passing arguments by reference but the method cannot modify the value.
• It is used to pass large structures or objects without copying their values but with the guarantee that they will not be modified.

Example:

void PrintCoordinates(in Point point)
{
    Console.WriteLine($"X: {point.X}, Y: {point.Y}");
}

The following table summarizes the differences:

Keyword	Initialization Required	Can Modify Value	Introduced in Version
ref	Yes	Yes	C# 1.0
out	No	Yes	C# 1.0
in	Yes	No	C# 7.2

Q13. How would you implement a thread-safe singleton pattern in C#? (Design Patterns & Concurrency)

A thread-safe singleton pattern ensures that only one instance of the class is created, even in multithreaded environments. Here’s how you can implement it:

Lazy Initialization with Lazy<T>:

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());

    public static Singleton Instance => lazy.Value;

    private Singleton()
    {
    }
}

In the above example, Lazy<T> is thread-safe by default (when using LazyThreadSafetyMode.ExecutionAndPublication). It ensures that the Singleton instance is created only when it is first accessed.

Q14. Discuss how you would use Tasks and Parallel Library for asynchronous operations in C#. (Asynchronous Programming & Parallel Computing)

In C#, the Task Parallel Library (TPL) provides an easy-to-use model for asynchronous and parallel programming. Here’s how you might use Tasks and the Parallel class:

Using Tasks for Asynchronous Operations:

• You can create a task to run asynchronous operations using Task.Run() or Task.Factory.StartNew().
• Tasks can be awaited with the await keyword, which makes the code easier to read and understand as it appears sequential.
• Tasks can return results, which can be accessed through the Result property or via await.

Example:

async Task<int> CalculateSumAsync(int a, int b)
{
    return await Task.Run(() => a + b);
}

Using Parallel for Parallel Computing:

• The Parallel.For and Parallel.ForEach methods are used to parallelize loops.
• The Parallel.Invoke method is used to run a set of actions in parallel.

Example:

Parallel.ForEach(items, item =>
{
    Process(item);
});

Q15. Explain what Expression Trees are in C# and a scenario where you might use them. (Expression Trees & Dynamic Programming)

Expression Trees in C# are data structures that represent code in a tree-like format, where each node is an expression, such as a method call or a binary operation. They are used to represent and manipulate code as data at runtime.

You might use Expression Trees in the following scenarios:

• LINQ Providers: They are extensively used in LINQ to SQL or Entity Framework to translate code into SQL queries that can be executed by the database.
• Dynamic Query Generation: When you need to create dynamic queries based on user input or other runtime conditions.
• Runtime Compilation: When you need to compile and execute code dynamically at runtime.

Example:

Expression<Func<int, bool>> isEvenExpr = num => num % 2 == 0;

In the example, isEvenExpr is an expression tree that represents the lambda expression num => num % 2 == 0.

Q16. How can you apply the SOLID principles when designing a class library in C#? (Software Design Principles & Coding Practices)

SOLID is an acronym for a set of design principles intended to make software designs more understandable, flexible, and maintainable. It stands for:

• S: Single Responsibility Principle
• O: Open/Closed Principle
• L: Liskov Substitution Principle
• I: Interface Segregation Principle
• D: Dependency Inversion Principle

Applying these principles to a class library in C# involves several steps:

• Single Responsibility Principle: Ensure that each class has a single responsibility and a single reason to change. This means that a class should only have one job or functionality.

• Open/Closed Principle: Classes should be open for extension but closed for modification. You can achieve this by using abstraction and allowing behavior to be extended through the creation of new derived classes without changing existing code.

• Liskov Substitution Principle: Derived classes must be substitutable for their base classes without altering the correctness of the program. This means that the derived class should not break the expected behavior when used in place of its base class.

• Interface Segregation Principle: Clients should not be forced to depend upon interfaces that they do not use. Instead of one fat interface, numerous small interfaces are preferred based on groups of methods, each one serving one submodule.

• Dependency Inversion Principle: High-level modules should not depend on low-level modules; both should depend on abstractions. Abstractions should not depend on details; details should depend on abstractions. This can be implemented by using interfaces or abstract classes to invert the dependency.

Example Code Snippets Applying SOLID Principles:

// Single Responsibility Principle
public class OrderProcessor
{
    public void ProcessOrder(Order order)
    {
        // Code to process the order
    }
}

// Open/Closed Principle
public abstract class Shape
{
    public abstract double Area();
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public override double Area()
    {
        return Math.PI * Radius * Radius;
    }
}

// Liskov Substitution Principle
public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }

    public int Area() => Width * Height;
}

public class Square : Rectangle
{
    public override int Width
    {
        set { base.Width = base.Height = value; }
    }

    public override int Height
    {
        set { base.Width = base.Height = value; }
    }
}

// Interface Segregation Principle
public interface IPrinter
{
    void Print(Document d);
}

public interface IScanner
{
    void Scan(Document d);
}

public class MultiFunctionPrinter : IPrinter, IScanner
{
    public void Print(Document d)
    {
        // Code for printing
    }

    public void Scan(Document d)
    {
        // Code for scanning
    }
}

// Dependency Inversion Principle
public interface IRepository
{
    void Save(Order order);
}

public class OrderSaver
{
    private IRepository _repository;

    public OrderSaver(IRepository repository)
    {
        _repository = repository;
    }

    public void SaveOrder(Order order)
    {
        _repository.Save(order);
    }
}

Q17. What is the purpose of the ‘checked’ and ‘unchecked’ context in C#? (Exception Handling & Overflow Checking)

In C#, the checked and unchecked contexts are used to control whether the overflow checking is performed for arithmetic operations and conversions.

• In a checked context, arithmetic operations and conversions that exceed the storage capacity of the data type throw an OverflowException.
• In an unchecked context, these operations and conversions do not throw an exception and the result is truncated by discarding any high-order bits that do not fit in the destination type.

Example Code Snippets:

int a = int.MaxValue;

try
{
    // Checked context
    checked
    {
        int b = a + 1; // This will throw an OverflowException
    }
}
catch (OverflowException)
{
    Console.WriteLine("Overflow occurred in checked context!");
}

// Unchecked context - no exception is thrown, overflow is ignored
unchecked
{
    int c = a + 1; // Overflow is ignored, and c becomes int.MinValue
}

Q18. Describe the role of the Dynamic Language Runtime (DLR) in C#. (Dynamic Programming & Runtime Features)

The Dynamic Language Runtime (DLR) is a runtime environment that adds a set of services for dynamic languages to the Common Language Runtime (CLR). The DLR makes it easier to develop dynamic languages to run on .NET and to add dynamic features to statically typed languages like C#.

The DLR provides the following services:

• Dynamic type system: This allows operations on dynamic types to be performed at runtime.
• Dynamic method dispatch: This enables the invocation of methods at runtime on dynamic objects.
• Dynamic code generation: The DLR can generate code at runtime, which is necessary for features like dynamic method bodies.
• Interoperability: It allows dynamic languages and statically typed languages to interoperate more smoothly.

The dynamic type in C# is a feature that relies on the DLR. It bypasses compile-time type checking and resolves type information at runtime.

Example Code Snippet Using DLR:

dynamic expando = new ExpandoObject();
expando.Name = "John Doe";
expando.Age = 30;

// The following line is resolved at runtime, not at compile-time
Console.WriteLine($"{expando.Name} is {expando.Age} years old.");

Q19. How do you implement custom exception handling in C# and when should you create a custom exception class? (Exception Handling & Software Design)

To implement custom exception handling in C#, you create a new class that derives from System.Exception or one of its subclasses. This custom exception class can provide additional properties and constructors to pass extra information related to the error condition.

You should create a custom exception class when you need to distinguish an error condition from other exceptions or when you need to pass additional information about the exception to the catch block.

Example Code Snippet:

public class OrderProcessingException : Exception
{
    public int OrderId { get; }

    public OrderProcessingException() { }

    public OrderProcessingException(string message)
        : base(message) { }

    public OrderProcessingException(string message, Exception inner)
        : base(message, inner) { }

    public OrderProcessingException(string message, int orderId)
        : base(message)
    {
        OrderId = orderId;
    }
}

try
{
    // Code that may throw an exception
    throw new OrderProcessingException("Order cannot be processed", orderId);
}
catch (OrderProcessingException ex)
{
    Console.WriteLine($"An error occurred while processing order {ex.OrderId}: {ex.Message}");
}

Q20. Explain the concept of the Task Parallel Library and how it differs from traditional threading. (Concurrency & Parallel Computing)

The Task Parallel Library (TPL) is a set of APIs in the System.Threading.Tasks namespace that makes it easier to write concurrent and asynchronous code. The main difference between the TPL and traditional threading is the level of abstraction. The TPL provides a higher-level abstraction over threads, allowing developers to focus on the tasks they want to perform rather than thread management.

The TPL uses a pool of threads to execute tasks efficiently and provides constructs for parallel loops, parallel LINQ (PLINQ), and task continuations.

Key Differences:

• Abstraction: TPL tasks are a higher-level abstraction than threads. You deal with what needs to be done (tasks), rather than how it’s done (threads).
• Pooling: The TPL uses the thread pool to manage and recycle threads, which is more efficient than manually creating and destroying threads.
• Easier Exception Handling: TPL tasks encapsulate exceptions in an AggregateException object, making it easier to handle exceptions from multiple tasks.
• Richer Support for Synchronization: TPL includes synchronization primitives like TaskCompletionSource, Barrier, CountdownEvent, and SemaphoreSlim.
• Built-in Support for Cancellation: TPL tasks can be easily cancelled using the CancellationToken infrastructure.
• Task Continuations: TPL allows creating complex workflows by chaining tasks together with the ContinueWith method.

Example Code Snippet Using TPL:

using System.Threading.Tasks;

// Example of running a task
Task<int> task = Task.Run(() =>
{
    // Simulate work
    Thread.Sleep(1000);
    return 42;
});

// Continue with another task once the first task is completed
task.ContinueWith(antecedent =>
{
    Console.WriteLine($"The answer is {antecedent.Result}");
});

When designing concurrent applications, TPL should generally be preferred over direct thread management due to its simplicity, powerful features, and efficient use of system resources.

Q21. What is the difference between a ‘struct’ and a ‘class’ in C#? When would you choose one over the other? (Type System & Data Structures)

Answer:
In C#, both struct and class are constructs used to define types that can contain data and behavior. However, there are fundamental differences between them:

• Semantics: Classes are reference types, whereas structs are value types. This means that when a class object is assigned to a new variable, it is the reference to the object that is copied, not the object itself. Conversely, when a struct is assigned to a new variable, a full copy of the struct is made.
• Memory Allocation: Instances of classes are allocated on the heap, and the memory management is handled by the garbage collector. Structs, on the other hand, are usually allocated on the stack, which can offer performance benefits, particularly in scenarios involving high-volume, short-lived objects.
• Inheritance: Classes can inherit from other classes, allowing for object-oriented hierarchies and polymorphism. Structs cannot inherit from other structs or classes, although both structs and classes can implement interfaces.
• Default Constructor: Classes can declare a default constructor and have one provided implicitly by the compiler if none is declared. Structs always have an implicit default constructor provided by the compiler, and you cannot define a parameterless constructor yourself.
• Nullability: Reference types (classes) can be set to null, indicating that they do not reference any object. Value types (structs) cannot be null by default unless they are declared as nullable (with ? after the type, e.g., int?).

You would generally choose a class when:

• You need to leverage inheritance.
• Your objects are large or complex.
• You require reference semantics for assignments.
• You want the object to have a lifecycle managed by the garbage collector.

You would choose a struct when:

• You are creating small, simple objects that do not require inheritance.
• You want value-type semantics.
• You want to minimize the impact on the garbage collector and improve performance, especially if instances of the type are small and short-lived.

Example Code:

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

public class Circle
{
    public Point Center { get; set; }
    public double Radius { get; set; }
}

In this example, Point is defined as a struct because it’s a simple, lightweight object representing a coordinate pair. Circle is a class because it is more complex and might be part of a larger object hierarchy, such as shapes that can be drawn on a canvas.

Q22. Can you explain the use of the ‘nameof’ operator and provide a scenario where it’s useful? (Syntax & Code Readability)

Answer:
The nameof operator is used to obtain the simple (unqualified) string name of a variable, type, or member. This is particularly useful when you need the name of something as a string for things like notifying property changes, in exception messages, or for logging purposes. The main advantage is that it is refactor-friendly, meaning if you rename the variable, type, or member, the string output by nameof will automatically update.

Example Scenario:
nameof is useful in implementing the INotifyPropertyChanged interface, which is commonly used in data-binding scenarios like WPF or Xamarin Forms. When a property changes, you want to notify the UI by passing the name of the property that changed.

Example Code:

public class Person : INotifyPropertyChanged
{
    private string _name;

    public string Name
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                OnPropertyChanged(nameof(Name));
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

In this example, the nameof operator is used to pass the name of the Name property to the OnPropertyChanged method, ensuring that the string remains correct even if the property is renamed.

Q23. How does the Common Language Runtime (CLR) manage memory? Discuss the garbage collection process. (Memory Management & CLR Internals)

Answer:
The CLR manages memory through a process known as garbage collection (GC), which automates memory management and helps to prevent memory leaks. The GC process is as follows:

• Allocation: When an object is created, memory is allocated on the managed heap. As objects are allocated, a pointer called the "Next Object Pointer" is moved along the heap.
• Generation: The heap is divided into generations to optimize the garbage collection process. New objects are placed in Generation 0 (Gen 0). As they survive garbage collection cycles, they may be promoted to Generation 1 (Gen 1) and eventually Generation 2 (Gen 2).
• Mark Phase: When the GC runs, it first identifies which objects are still in use. It does this by walking the graph of objects starting from the "roots," which are static fields, local variables on the stack, and CPU registers that reference objects.
• Relocation and Compaction: The GC then compacts live objects to reclaim contiguous memory, updating references to the moved objects as needed.
• Finalization: Objects with a finalizer (an override of the Finalize method) are given a chance to clean up unmanaged resources before the memory is reclaimed.
• Collection: The memory of objects that are not in use anymore is reclaimed and made available for new allocations.

The garbage collection process is typically triggered automatically when there is insufficient free memory on the heap. However, it can also be manually invoked by calling GC.Collect().

Q24. Describe how you would implement a custom attribute in C# and a scenario where it could be applied. (Reflection & Custom Metadata)

Answer:
To implement a custom attribute in C#, you define a class that derives from System.Attribute. You can then specify its usage by decorating it with the AttributeUsage attribute, which defines where the attribute can be applied (e.g., class, method, property) and whether it can be specified multiple times for a single element.

Example Code:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
public class TableAttribute : Attribute
{
    public string Name { get; }

    public TableAttribute(string name)
    {
        Name = name;
    }
}

[Table("people")]
public class Person
{
    // ...
}

In this example, a TableAttribute custom attribute is defined and used to specify the database table name associated with a class.

Scenario:
A common scenario for using custom attributes is in Object-Relational Mapping (ORM) frameworks, where you might want to map a class to a database table. The TableAttribute can be used to specify the table name that the class should be mapped to, which can then be read via reflection at runtime by the ORM to understand how to store and retrieve instances of the class from the database.

Q25. What are the key differences between .NET Core and .NET Framework, and how do you determine which one to use for a project? (Frameworks & Project Planning)

Answer:
.NET Core and .NET Framework are two different implementations of the .NET platform. Here are key differences:

Feature	.NET Core	.NET Framework
Cross-platform	Yes (Windows, macOS, Linux)	No (Windows only)
Open-source	Yes	Partially
Support for Microservices	Designed for microservices architecture	Not specifically designed for microservices
Performance	Optimized for high performance and scalability	Good performance, but not as optimized as Core
Side-by-side installation	Multiple versions can coexist	In-place update; only one version per machine
Supported workloads	Web, cloud, IoT, and console apps	Web, desktop, cloud, and console apps
UI Frameworks	ASP.NET Core, Blazor, MAUI	ASP.NET, WPF, WinForms, UWP
API Compatibility	.NET Standard and .NET 5+	.NET Standard and legacy .NET Framework APIs
Command-line interface	Integrated CLI for all OS	Limited CLI support, mostly through Visual Studio

To determine which one to use for a project:

• Use .NET Core if:

  • You need cross-platform capabilities.
  • You are designing microservices or need high scalability.
  • You want to use the latest UI frameworks like Blazor or MAUI.
  • You want to benefit from the latest performance improvements.
  • You need to run multiple versions of .NET side by side.

• Use .NET Framework if:

  • You are maintaining a legacy application that already uses .NET Framework.
  • You depend on Windows-specific APIs or .NET Framework libraries that are not available or compatible with .NET Core.
  • Your application uses technology not supported by .NET Core, such as WebForms.

It’s worth noting that Microsoft is converging these two platforms under the .NET 5 and beyond, which combines the best of both worlds and is intended to be the future of .NET.

4. Tips for Preparation

To maximize your chances of success, dive deep into the specifics of C# and .NET framework. Review advanced concepts such as asynchronous programming, memory management, design patterns, and the SOLID principles. Sharpen your understanding of the C# language features like LINQ, lambda expressions, and dynamic typing.

Beyond technical expertise, work on your problem-solving skills and practice coding on a whiteboard or in an IDE-like environment. Rehearse explaining your thought process, as this can be as important as the solution itself. Don’t neglect soft skills—be ready to discuss past projects and how you’ve worked in a team, handled conflicts, or led a project.

5. During & After the Interview

During the interview, communicate clearly and confidently. Interviewers seek candidates who not only have technical prowess but can also articulate their ideas and solutions effectively. Be prepared to walk through your code and explain your decisions. Avoid jumping to a solution without fully understanding the question—ask for clarifications if needed.

After the interview, it’s prudent to analyze your performance. Which questions did you excel in, and which ones could have gone better? This reflection can be useful for future interviews. Consider sending a personalized thank-you email to express your appreciation for the opportunity and to reiterate your interest in the role.

Typically, companies will outline the next steps and when you can expect to hear back. If this timeline passes, it’s appropriate to send a polite follow-up email inquiring about the status of your application.