Top .NET Interview Questions [2024]

An experienced .NET developer should be able to identify the various .NET implementations and explain when each one is best suited.

.NET Core: Ideal for cross-platform needs, microservices, containers, and high-performance and scalable systems.

.NET Framework: This implementation is best suited for scenarios where third-party libraries or NuGet packages are not available for .NET, or when technologies not supported by .NET, such as WCF, ASP.NET Web Forms, or Web Pages, are required. This implementation may also be suitable if the targeted platform does not support .NET.

.NET Standard: This is a collection of fundamental APIs that can be called by all .NET implementations. By targeting .NET Standard, you can build libraries that can be used across all .NET implementations.

Xamarin: Ideal for building mobile apps for iOS and Android platforms.

This question aims to test the comprehension of LINQ (Language Integrated Query) as a feature that enhances the functionality of .NET. LINQ can be used on various types of data sources, such as collections, SQL Server databases, ADO.NET datasets, XML documents, and any collection that implements the generic IEnumerable<T>.

The purpose of this question is to evaluate an understanding of the fundamental architectural patterns in .NET. The MVC (Model-View-Controller) pattern separates server-side concerns, while MVVM (Model-View-ViewModel) uses two-way binding, primarily in client-side applications. MVVM is prevalent in WPF, while MVC is the standard in ASP .NET.

This question assesses your comprehension of managed and unmanaged code, as well as your understanding of how .NET distinguishes itself from other programming languages. .NET exclusively generates managed code, which compiles into either CIL (Common Intermediate Language) or MSIL (Microsoft Intermediate Language) and executes in the CLR (Common Language Runtime). On the other hand, unmanaged code compiles and runs directly on the host machine and is generated through programming languages such as C or C++. A strong answer should mention the advantages of using .NET, such as its built-in garbage collection.

This question assesses understanding of .NET implementations. A comprehensive answer will mention the use of .NET Standard to create a library that can be referenced by both .NET Core and .NET Framework applications. Additionally, a strong answer should touch upon the role of NuGet, as both applications can reference a .NET Standard package deployed there.

The Finalize() and Dispose() methods in .NET are both utilized by the CLR for garbage collection of runtime objects. The Finalize() method is invoked automatically by the runtime at an indeterminate time to release unmanaged resources before an object is discarded. On the other hand, the Dispose() method is called explicitly by the programmer and allows for immediate release of unmanaged resources. Note that Dispose() is more efficient as it does not affect performance, unlike Finalize() which can result in a decrease in performance.

In .NET, an interface defines a contract for class types to adhere to, specifying a set of properties, methods, and events that must be implemented. Interface members do not have access modifiers and all declared members must be implemented by classes that implement the interface. On the other hand, an abstract class can provide a partial implementation and can declare both abstract and virtual members that can be overridden by derived classes. Abstract classes allow for common functionalities to be shared among derived classes while still allowing for additional customizations.

In .NET, reference types store references to the memory location where their data (objects) reside, while value types store the data directly within the memory allocated for the variable. As a result, when two reference type variables reference the same data, any operations performed on one variable will affect the object referenced by the other. Conversely, when two value-type variables hold separate copies of data, operations performed on one will not affect the other variable.

public: type or member can be accessed by any other code in the same assembly or another

private: type or member can be accessed only by code in the same class or struct

protected: type or member can be accessed only code in the same class or class derived from that class

internal: type or member can be accessed only by code living in the same assembly

protected internal: type or member can be accessed by any code in that assembly which declared it or by code in derived class in another assembly

private protected: type or member can be accessed by classes that inherit the class where it was declared in the same assembly

Delegate is a type that can hold a reference to methods with a specific return type or parameter list. For example, it can store a reference to a callback method you might want to call when an event triggers your current code block (e.g. database change, API request, timer expiry).

public delegate void MyDelegate(string message);
public static void MyDelegateMethod(string message) 
{ 
Console.WriteLine(message);
 }
public static void Notify(int errorCount, MyDelegate callback) 
{ 
callback($"There are {errorCount} errors.");
}
Notify(10, handler);
//There are 10 errors

M represents the model and is the data layer where you access and store information.

V represents the view where you render and display your data

C represents the controller, which handles the user interaction and creates the bridge between model and view

Unboxing is when a reference type is converted back into a value type. For example, object x = 10 followed by int y = (int) x. Unboxing is explicit. Boxing is the reverse process when a value type is converted into a reference type. For example, int y = 10 followed by object x = y. Boxing is implicit.

<appSettings> section stores custom application information like database connections, file paths, API URLs or other important configuration information and can be accessed in code using the ConfigurationSettings class.

<configuration>
       <appSettings>
           <add key= "ConnectionString" value="server=local; pwd=password; database=default" />
       </appSettings>
   </configuration>

.NET supports two types of memory allocation: stack and heap. The stack is responsible for static memory allocation and stores value types, keeping track of each executing thread and its location. The heap, on the other hand, handles dynamic memory allocation for reference types and is responsible for managing complex objects and data. The garbage collector continuously checks the objects stored on the heap memory that are no longer used by the application and reclaims their memory.

In .NET, an assembly is a collection of types and resources that represent a logical unit of functionality necessary for building and deploying an application. Assemblies can be private or shared and consist of .exe and .dll files. They enable multiple developers to work on separate source code files, which can then be combined into a single assembly.

.NET heap memory is divided into three segments called generations:

Generation 0 stores short-lived objects. When a new object is instantiated, it's stored here by default unless its size exceeds 85,000 bytes.

Generation 1 stores objects moved from generation 0.

Generation 2 stores long-lived objects and generation 1 objects. GC process is less frequent at this level.

Generics allow developers to define methods, classes, interfaces, or structures to act on a specific data type, increasing code reusability, and type safety. The following code is an example of a generic class definition:

public class MyGeneric<T>
{
public T myField;
}
static void Main()
{
         MyGeneric<string> mygeneric = new MyGeneric<string>()
         mygeneric.myField = "Hello";
         Console.WriteLine($"myField is {mygeneric.myField}")
         MyGeneric<int> mygeneric = new MyGeneric<int>()
         mygeneric.myField = 3;
         Console.WriteLine($"myField is {mygeneric.myField}")
}

.NET supports three programming languages: C#, F#, and Visual Basic. C# is an object-oriented and type-safe language that is well-suited for any development task. F# is an open-source, cross-platform language that is used to write concise, robust, and efficient code while transforming data with functions. Visual Basic is a language that is closest to human language and is easy to learn. However, it is a stable language that does not receive new features regularly, unlike C# or F#. Additionally, Visual Basic is not well-suited for web application development.

Reflection objects in .NET are used to obtain information about loaded assemblies and types, to define and create type instances at runtime, and to invoke and access them. An example use case is when private fields and methods need to be invoked on an instance type.

using System;
using System.Reflection;
public class MyType
{
    private string GetResponse() => "Confirmed";
}
var myInstance = new MyType();
var privateMethod =
    typeof(MyType)
        .GetMethod("GetResponse",BindingFlags.Instance | BindingFlags.NonPublic);
Console.WriteLine(privateMethod.Invoke(myInstance, parameters:null));

In .NET, dynamic objects allow developers to define properties and methods at runtime instead of at compile-time, enabling the creation of objects that do not match a static type. An example of using dynamic objects is when processing an HTML, XML, or JSON document, where the combination of elements and attributes can only be determined at runtime and may vary.

dynamic MyDynamic = new System.Dynamic.ExpandoObject()
MyDynamic.header = "My Header";
MyDynamic.footer = "MyFooter";
MyDynamic.firstElement = "First Element";
MyDynamic.secondElement = "Second Element";
MyDynamic.GetCount = new Func<int>(() => { return 10;});