🎄🎁 Christmas Offer! Exclusive Shield Enterprise discount.

Grab Your Discount!

Ends in: 8d 0h 20m 5s

.NET Core Interview Question & Answers

October 10, 2023 19 minutes read

Index

Dive into the world of contemporary programming as we untangle some of the most
commonly asked dotnet core interview questions and answers!
Staying up-to-date with the evolution of technology can be a demanding task, but not
if you’re provided with clear explanations and useful insights. In this chunk of
knowledge, we’ll delve deeply into the key aspects of .NET Core, allowing you to
showcase your expertise and ace your next interview.

Whether you’re an aspiring programmer or an experienced developer revisiting your

core dotnet interview know-how, this right here is your invaluable resource!

How does Dependency Injection work in

.NET Core?

Answer

In .NET Core, Dependency Injection (DI) is a technique whereby one class (or module)
outsources the creation of its dependencies to an external framework instead of
handling them itself.

Built-in DI is a significant aspect of .NET Core. It comes with integrated support for
dependency injection, unlike the previous versions, where we had to rely on external
libraries like AutoFac, Ninject, Unity, etc.

Here is a simple example:

public class SampleClassA: ISampleClassA

{
private readonly ISampleClassB _sampleClassB;
public SampleClassA(ISampleClassB sampleClassB)
{
_sampleClassB = sampleClassB;
}
}

In this case, SampleClassA depends on ISampleClassB. To inject ISampleClassB

into SampleClassA, you need to register these classes in your Startup.cs file:
 public void ConfigureServices(IServiceCollection services)
{
services.AddTransient<ISampleClassA, SampleClassA>();
services.AddTransient<ISampleClassB, SampleClassB>();
}

When SampleClassA is created, .NET Core automatically creates an instance of

SampleClassB and injects it into the constructor.

Can you explain how .NET Core’s

performance compares to Node.js?

Answer

In terms of performance, both .NET Core and Node.js have their strengths and
weaknesses. Performance can also be relative based on the specific workload and
requirements of the application, but here are some general insights:

Response Time: .NET Core generally holds an edge over Node.js in raw response
time. .NET Core has been designed to deal with high-performance servers and
optimized accordingly.
Concurrent Request Handling: Node.js uses a single-threaded, event-driven
architecture that is efficient for handling high volumes of concurrent, IO-intensive
workloads. In contrast, .NET Core uses a multi-threaded approach, which can lead
to higher resource consumption under heavy loads but can handle CPU-intensive
workloads more efficiently.
Throughput: In most cases, .NET Core exhibits high throughput rates compared
to Node.js due to its inherent design and the optimization done by the JIT
compiler.

Remember, while these are some of the general observations, the real-life
performance of an application will depend on various factors, including how well the
code is written and optimized.
How do you manage cross-platform
targeting in a .NET Core project?

Answer

.NET Core projects are capable of targeting multiple platforms including Windows,
Linux, and macOS. This can be managed through the project file (*.csproj).

First, the Target Framework Moniker (TFM) determines the APIs that you have access
to. It is possible to specify multiple target frameworks and libraries depending on your
application needs. The selected framework will dictate which APIs your code can call.

Here is an example where the project targets .NET Core 3.1 and .NET Standard 2.0:

<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
<TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
</PropertyGroup>

</Project>

You need to be aware of any breaking changes or incompatible APIs when targeting
multiple platforms. It is also possible to handle divergent code with the help of
preprocessor directives.

What are the main advantages of using

Entity Framework Core over Entity
Framework 6.x in a .NET Core application?

Answer
Entity Framework Core (EF Core) is a lightweight, extensible, open-source, and cross-
platform version of the popular Entity Framework data access technology. Here are
the main advantages of using EF Core:

Cross-Platform: EF Core works with .NET Core, which makes it possible to run on
any platform that .NET Core supports.
Improved Performance: Compared to EF 6.x, EF Core provides better
performance because of its optimized query generation and processing.
Modular Design: EF Core is more modular, which means you can include only
the necessary packages your application needs, leading to less clutter and
overhead.
Built-In Dependency Injection: EF Core supports the new .NET Core
dependency injection feature out of the box.
Flexibility and Extensibility: EF Core is designed to be flexible and extensible,
allowing developers to adapt the framework to their specific needs.

How does Kestrel server work in the .NET

Core environment and how does it differ
from other web servers?

Answer

Kestrel is a cross-platform web server built for .NET Core based applications. It is
based on a libuv library, an asynchronous I/O-based model used by Node.js. Kestrel
can also be used in combination with a reverse proxy server such as Apache, Nginx, or
IIS, which provides an additional layer of configuration, security, and load balancing.

Here are the key differences between Kestrel and other web servers such as IIS and
Http.sys:

Cross-Platform: Unlike IIS and Http.sys, which are Windows-specific, Kestrel can
run on multiple operating systems thanks to its integration with .NET Core.
Performance: Kestrel is designed to be fast and has been heavily optimized for
performance. It demonstrates high throughput and has a lower request latency
 than traditional IIS.
Stand-Alone or with Reverse Proxy: Kestrel can be used as a stand-alone web
server or with a reverse proxy. Using it with a reverse proxy can help protect the
application from potential vulnerabilities.
In-Process or Out-Of-Process Models: With the advent of .NET Core 2.2 and 3.0,
Kestrel can be used in both in-process and out-of-process hosting models,
providing flexibility in how your application is hosted.

Overall, when considering a web server for hosting .NET Core applications, Kestrel
provides a high-performance, cross-platform, and flexible option that aligns well with
the objectives of .NET Core.

Moving smoothly from servers to application patterns, let’s discuss another

fundamental topic that often spices up net core questions for interviews – the
Repository pattern.

Certainly, transitioning from the way Kestrel servers operate in .NET Core to the
application of patterns in Entity Framework Core might seem like a leap. But don’t fret,
as we’ll guide you through the interconnected world of .NET Core with simple
explanations and concise examples.

How would you implement the Repository

pattern in a .NET Core application using
Entity Framework Core?

Answer

To implement the Repository pattern in a .NET Core application using Entity

Framework Core, you could follow these general steps:
 Create an interface for repositories: Each repository should have its unique
interface defining the operations it supports. For example, in a student
management system, a typical IRepository interface might include methods for
GetAll, GetById, Insert, Update, and Delete.
Implement repository interfaces: Write a class that implements each interface,
providing the logic for the defined operations. Entity Framework Core’s
DbContext provides the functionality to handle these operations.
Create a UnitOfWork class: Unit of Work is another pattern that’s often used
with Repository. It groups one or more operations (like reading, insertion, or
deletion) into a single transaction. In the context of Entity Framework Core, your
DbContext class would act as your unit of work.
Use dependency injection to provide instances of your repositories to
controllers: .NET Core has built-in support for dependency injection. You can
provide your DbContext and repository classes in ConfigureServices method of
your Startup class.

Here is a simple example of what the repository class might look like:

public class Repository<T> : IRepository<T> where T : class{

private readonly DbContext _dbContext;
public Repository(DbContext dbContext){
_dbContext = dbContext;
}
public IEnumerable<T> GetAll(){
return _dbContext.Set<T>().ToList();
}
//... other methods
}

How do you handle exceptions globally in

an ASP.NET Core Web API project?

Answer
Global exception handling in ASP.NET Core can be achieved using middleware. The
ideal place to handle exceptions is in the middleware pipeline so that it is separate
from your application logic, and can trap any unhandled exceptions.

One of the most effective ways is to use the built-in UseExceptionHandler

middleware which captures synchronous and asynchronous exceptions. With this
middleware, you can redirect to an error handling route or render an error response
directly.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)

{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/api/Error");
}

//... rest of the middleware

}

In the above code, when an exception is raised it is handled by the “/api/Error” route.

Another method of handling global exceptions is using

UseDeveloperExceptionPage middleware which provides detailed exception
information in the local development environment.

What are the significant differences

between .NET Core 2.x and .NET Core 3.x?

Answer

There are a number of significant differences between .NET Core 2.x and .NET Core 3.x:
Desktop Development: .NET Core 3 introduced support for Windows Desktop
Applications (Windows Forms and WPF). This feature was not available in .NET Core 2.

New JSON APIs: .NET Core 3.0 introduced new built-in JSON APIs that are high-
performance and low allocation, making them significantly faster than JSON.NET.

HTTP/2 Support: In .NET Core 3, built-in support for HTTP/2 was added.

Improved performance: Continuous enhancements were made to improve the

performance of .NET Core including less memory consumption and faster application
startup times.

gRPC Services: .NET Core 3.x introduced support for gRPC, a modern open-source
high-performance RPC framework.

Support for ARM64: .NET Core 3.0 added support for ARM64-based processors.

Can you explain the steps involved in

configuring and working with Azure Active
Directory in .NET core?

Answer

Azure Active Directory (Azure AD) provides an easy way for businesses to manage
identity and access, both in the cloud and on-premises. You can use it to add sign-in
functionality and regulate access to your .NET Core applications. Here are the essential
steps to configure and work with Azure AD in a .NET Core application:

Register your application with your Azure AD tenant:

Log in to the Azure portal.

Click Azure Active Directory, and then click App registrations to open the list of
registered applications.
 Click New registration, and provide a suitable name for your application.
In the Redirect URI field, enter the base URL for your application.

Configure your .NET Core application to use Azure AD:

Open your application settings in the Azure portal, copy the Directory (tenant) ID and
Application (client) ID, and then use them to configure the authentication in your .NET
Core application.

public void ConfigureServices(IServiceCollection services)

{
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.Authority = "<Directory (tenant) ID>";
options.Audience = "<Application (client) ID>";
});

services.AddControllers();
}

Protect your application’s routes:

[Authorize]
public class SecureController : Controller
{
//... controller logic here
}

Use Azure AD as user store:

You can use Azure AD to store and manage users for your .NET Core application.

How to do database migrations in Entity

Framework Core?
Answer

Entity Framework Core (EF Core) includes a feature called Migrations that allows you
to make changes to your model and then propagate those changes to your database
schema. Here’s a basic overview of performing a migration:

1. Install the necessary packages: EF Core requires certain NuGet packages to

perform migrations. Make sure you have the basic Entity Framework Core and EF Core
tools packages installed in your project.

2. Create a new Migration: Use the Add-Migration command and provide a name
for your migration. This creates a new class in your Migrations folder that contains the
changes to be made to the database schema.

Add-Migration MyFirstMigration

3. Update the database: Use the Update-Database command. This applies any
pending migrations on the database. EF Core creates the database if it does not exist.

Update-Database

You may opt to provide a specific migration name if you want to update the database
to a specific migration rather than the latest.

Remember to treat migrations as a part of your codebase. They need to be kept under
source control and applied as part of your deployment process. Well-managed
migrations are key to dealing with evolving database schemas.

We’ve had a comprehensive understanding of how to conduct database migrations in

Entity Framework Core so far. But what about real-time communication in web
applications?
As the terrain of dotnet core interview questions and answers is vast and varied,
let’s shift our sails and explore the realm of SignalR and its indispensable role in the
.NET Core universe.

Real-time communication is a crucial cog in the wheel of interactive and highly

responsive applications, so stick around as we dive deeper!

How can you explain SignalR’s role in .NET

Core and how it enhances real-time
communication in web applications?

Answer

SignalR is a library in .NET Core used to facilitate real-time communication between

server and client. It uses several techniques under the hood to maintain a persistent
connection between the client and the server. This connection allows real-time
communication with high-frequency updates.

SignalR uses WebSockets, Long Polling, Server-Sent Events, and others to maintain
this connection, choosing the best available transport method based on the client and
server capabilities.

In effect, SignalR simplifies the process of creating real-time, responsive web

applications. It’s widely used in applications where high frequency updates are
required, such as live chat, gaming, real-time dashboards, and others.

How do you secure .NET Core Web API

using IdentityServer4?

Answer
IdentityServer4 is an OpenID Connect and OAuth 2.0 framework for .NET Core, which
can be used to secure your .NET Core Web API.

To do this, you would need to install and configure IdentityServer4 in your application.
This will involve creating the necessary client configurations, defining scopes, and
securing your API endpoints.

Here is a basic overview of the steps:

Install the IdentityServer4 package in your application

Create an IdentityServer service and configure its options in your Startup class.
This includes setting up your resources, clients, and scopes.
Add the authentication middleware to your application pipeline, specifying the
IdentityServer authentication handler.
Decorate your API actions or controllers with the [Authorize] attribute to
ensure they are secured.

It’s important to remember that securing your API requires a clear understanding of
authentication and authorization concepts, as well as the protocols used by
IdentityServer4 (OpenID Connect and OAuth 2.0).

How would you manage configurations in

a .NET Core application when moving from
development to production?

Answer

.NET Core provides an elegant solution to managing configurations across different

environments through the use of configuration providers.

For managing configuration, you can use the appsettings.json file, which is the default
file read by .NET Core application. Moreover, you can have dedicated configuration
files for each environment, such as appsettings.Development.json or
appsettings.Production.json, giving you the chance to override the default settings.

Here are some steps you could take:

Use different appsettings.{Environment}.json files to store environment-specific

configurations.
Use the environment variable configuration provider to set environment-specific
settings. The settings set by this provider take precedence over those set in the
appsettings.json.
Use the IConfiguration interface in your classes to access configured settings.

Remember to exclude sensitive data like connection strings and application secrets
from source control by using secure methods like user secrets or Azure Key Vault.

How does the out-of-the-box logging

framework in .NET Core work?

Answer

With .NET Core, you get an in-built, easy-to-use logging API which supports a variety
of built-in and third-party logging providers. It provides various logging levels like
Trace, Debug, Information, Warning, Error, and Critical.

The steps to add logs to a .NET Core application using this framework are as follows:

Inject the ILogger<T> dependency in your class, where T is the class into which
ILogger<T> is injected.
Use the provided methods (LogDebug, LogInformation, LogWarning,
LogError, LogCritical) to log messages at different levels.

You can configure these log levels and logging output targets in the appsettings.json
or in your code. The framework automatically reads from the configuration settings at
runtime.

How would you implement CQRS in a .NET

Core application?

Answer

Command Query Responsibility Segregation (CQRS) is a pattern in which read

operations (queries) and write operations (commands) are separated, improving
performance, scalability, and security.

To implement this in .NET Core:

Create two separate models: a write model (for commands) and a read model
(for queries).
Define distinct interfaces/classes for your commands and queries.
Use the MediatR library, which provides a straightforward way to implement the
CQRS pattern. You define your queries and commands as Request/Notification
handlers.
For the read operations, you can design the models according to the needs of
the client application, while the write model can be closer to the
business/domain model.

Remember, while CQRS can provide performance and scalability benefits, it adds
complexity to the application and should be used wisely, preferentially in more
complex scenarios where these benefits are significant.

Having understood how to implement Command Query Responsibility Segregation

(CQRS) in a .NET Core application, it’s time to transition towards microservices. The
jump may seem wide, but it’s all threads in the same vast tapestry of core dotnet
interview questions.
In the complex world of .NET Core ecosystems, knowledge of microservices becomes
incredibly pertinent. So, let’s delve into the support provided by .NET Core for the
development of microservices and how they efficiently manage a large application’s
complex business requirements.

How does .NET Core support the

development of microservices?

Answer

.NET Core supports the development of microservices by several ways:

Cross-platform support – .NET Core supports the development and deployment

of applications on several operating systems including Windows, Linux, and
macOS. This flexibility is crucial for microservices architecture as it allows services
to be deployed on a variety of platforms.
Easily integrated with Docker – Docker is a popular platform used to deploy
applications, and .NET Core has excellent support for Docker. It is possible to
create a Dockerfile for an application, which makes it easy to build and run the
application inside a Docker container.
Independent Deployment – Each microservice can be developed, tested and
deployed independently of others. Microservices can also have their own
databases and develop their own individual business capabilities.
Scalability – Microservices developed with .NET Core can be easily scaled out or
in, depending on the demand. They don’t have to share server resources and can
be scaled independently.
Resiliency – .NET Core and the use of microservices provide for each service to
be able to handle and respond to failure. If a microservice fails, it won’t crash the
whole system.

How is routing implemented in ASP.NET

Core MVC compared to ASP.NET MVC?
Answer

There are several differences in how routing is handled in ASP.NET Core MVC
compared to ASP.NET MVC.

In ASP.NET MVC, routing was handled through a central RouteConfig file that
includes rules for each controller and action method. These routing rules can be
either attribute-based or convention-based.
On the other hand, ASP.NET Core MVC uses middleware for routing. It provides
two types of routing methodologies – convention-based routing and attribute
routing. All the routing information is configured in the Startup.cs file.
In ASP.NET Core MVC, we also have a new feature, Routing to Razor Pages. Razor
Pages are a new aspect of ASP.NET Core MVC that allow you to create page-
based programming model.
Additionally, ASP.NET Core MVC supports route constraints, which weren’t
available in ASP.NET MVC. Route constraints let you restrict how the parameters
in the route template are matched.

What are some of the best techniques for

optimizing performance in .NET Core
applications?

Answer

Optimizing performance in .NET Core applications could involve several techniques:

Caching: It’s about storing data somewhere for future use to speed up the
application. .NET Core provides support for several different types of caching
including in-memory caching, distributed caching, and response caching.
Asynchronous Programming: Use the async and await keywords to write
asynchronous code that’s easier to read, write and manage.
Pooling: Techniques such as Object Pooling or Connection Pooling can be used
to recycle objects or connections instead of creating and destroying them
frequently.
 Optimization of Data Access: Minimize the amount of data that you send over
the network and reduce the number of server round trips.
Use of Middleware: Middleware components are used to handle requests and
responses. Ensure that unnecessary middleware components are not registered.

Can you explain some possible strategies

for managing session state in a distributed
.NET Core application?
Categories

Answer

Managing session state in a distributed .NET Core application generally involves either
a server-side or client-side session management approach.

Server-side session management: It store session data on the server. This

strategy involves storing the session state in a database or in-memory data store
like Redis. This allows applications running on multiple servers to have access to
the shared session data.
Client-side session management: In this strategy, the session state is stored in a
client side, usually in cookies or in local storage. This strategy eliminates the need
to store session data on the server, which can be especially useful in applications
with a large number of users.
Distributed Cache Session Management: ASP.NET Core provides
IDistributedCache interface that you can use to store your session state.

Remember to always secure session data, especially when incorporating client-side

session management strategies.

How would you approach error handling

and debugging in a distributed .NET Core
application with multiple microservices?
Answer

Handling errors and debugging in a distributed .NET Core application with multiple
microservices can be challenging. Some of the strategies include:

Centralized Logging: All microservices should send their logs to a centralized

place where they are collated and indexed. This allows you to search and visualize
logs from all services at one place.
Use of Correlation IDs: Correlation IDs are unique identifiers that are assigned
to a request. This ID is then passed to all the services that are involved in
handling that request. This allows you to trace the entire chain of requests and
responses.
Health Check APIs: Health check APIs can be implemented to monitor the status
of the microservices. They can report metrics like uptime, CPU usage, memory
usage etc.
Exception Handling Middleware: You can create a middleware that wraps
around every microservice request. If an exception occurs during the execution of
the request, this middleware will catch the exception and respond with a
meaningful error message.
Use a Distributed Tracing System: It collects data and metrics from each
microservice, then collates that data into a comprehensive, visual overview of
your system’s performance.

Remember that in a microservices architecture errors should be handled at the service

level. Each service should handle its own exceptions and return a suitable error
message or response code.

Wrapping up our deep dive into net core questions for interviews, we hope you
found the thorough explanations and code examples enlightening.

Remember, the journey of a thousand miles begins with a single step, and every
complex problem can be broken down into simple, easy-to-understand blocks. And
that’s precisely what our exploration of the .NET Core environment aimed to do.

So whether you’re preparing for your next interview or simply seeking to solidify your
.NET Core understanding, keep this guide in your arsenal!