Top 61 ASP.NET Core Interview Questions and Answers

Question

1. Describe the ASP.NET Core.

Answer 1

ASP.NET Core is an open-source, cross-platform and high performance platform that allows you to build modern, fast, secure and cloud enabled applications. With ASP.NET Core you can

Answer 2

.NET Hot Reload is available for ASP.NET Core 6.0 and later versions applications. It applies the code changes, including stylesheet changes to an app that is already running without losing app state and restarting the app.
Not all code changes trigger browser refresh like startup middleware changes unless it's not an inline middleware, configured services, removing component parameter attribute in Razor etc.
For more refer Hot Reload in ASP.NET Core.

Answer 3

ASP.NET Core comes with the following benefits over ASP.NET.

Answer 4

Startup class is responsible for configuration related things as below.

Answer 5

ConfigureServices method is optional and defined inside startup class as mentioned in above code. It gets called by the host before the 'Configure' method to configure the app's services.
Configure method is used to add middleware components to the IApplicationBuilder instance that's available in Configure method. Configure method also specifies how the app responds to HTTP request and response. ApplicationBuilder instance's 'Use...' extension method is used to add one or more middleware components to request pipeline.
You can configure the services and middleware components without the Startup class and it's methods, by defining this configuration inside the Program class in CreateHostBuilder method.

Answer 6

Dependency Injection is a Design Pattern that's used as a technique to achieve the Inversion of Control (IoC) between the classes and their dependencies.
ASP.NET Core comes with a built-in Dependency Injection framework that makes configured services available throughout the application. You can configure the services inside the ConfigureServices method as below.

Answer 7

A request pipeline or middleware pipeline consists of a sequence of request delegates which are called one after another to perform operations before and after the next delegate. For more about request processing pipeline for ASP.NET MVC visit Request Processing Pipeline.

Answer 8

Generally, one delegate passes the request to the next delegate to perform some operations but when a delegate does not pass the request to the next delegate then it's known as short-circuiting the request pipeline. You can short-circuit the request pipeline by not using the 'next' parameter. Short-circuiting Request Pipeline in ASP.NET Core.

Answer 9

Let's understand Dependency Injection with this C# example. A class can use a direct dependency instance as below.

Public class A {
MyDependency dep = new MyDependency();

public void Test(){
dep.SomeMethod();
}
}

But these direct dependencies can be problematic for the following reasons.

If you want to replace 'MyDependency' with a different implementation then the class must be modified.
It's difficult to Unit Test.
If MyDependency class has dependencies then it must be configured by class. If Multiple classes have dependency on 'MyDependency', the code becomes scattered.

DI framework solves these problems as below.

Use Interfaces or base class to abstract the dependency implementation.
Dependencies are registered in the Service Container provided by ASP.NET Core inside Startup class 'ConfigureServices' method.
Dependencies are injected using constructor injection and the instance is created by DI and destroyed when no longer needed.

Answer 10

When Services are registered, there is a lifetime for every service. ASP.NET Core provides the following lifetimes.

Answer 11

The Request handling pipeline is a sequence of middleware components where each component performs the operation on request and either call the next middleware component or terminate the request. When a middleware component terminates the request, it's called Terminal Middleware as It prevents next middleware from processing the request. You can add a middleware component to the pipeline by calling .Use... extension method as below.


    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();

So Middleware component is program that's build into an app's pipeline to handle the request and response. Each middleware component can decide whether to pass the request to next component and to perform any operation before or after next component in pipeline.

Answer 12

Request delegates handle each HTTP request and are used to build request pipeline. It can configured using Run, Map and Use extension methods. An request delegate can be a in-line as an anonymous method (called in-line middleware) or a reusable class. These classes or in-line methods are called middleware components.

Answer 13

Host encapsulates all the resources for the app. On startup, ASP.NET Core application creates the host. The Resources which are encapsulated by the host include:

Answer 14

The host setup the server, request pipeline and responsible for app startup and lifetime management. There are two hosts:

.NET Generic Host
ASP.NET Core Web Host

.NET Generic Host is recommended and ASP.NET Core template builds a .NET Generic Host on app startup.
ASP.NET Core Web host is only used for backwards compatibility.


// Host creation
public class Program
{
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup();
}

Answer 15

Server is required to run any application. ASP.NET Core provides an in-process HTTP server implementation to run the app. This server implementation listen for HTTP requests and surface them to the application as a set of request features composed into an HttpContext.
ASP.NET Core use the Kestrel web server by default. ASP.NET Core comes with:

Answer 16

In ASP.NET Core, Configuration is implemented using various configuration providers. Configuration data is present in the form of key value pairs that can be read by configuration providers as key value from different configuration sources as below.

appsettings.json - settings file
Azure Key Vault
Environment variables
In-memory .Net objects
Command Line Arguments
Custom Providers

By default apps are configured to read the configuration data from appsettings.json, environment variables, command line arguments etc. While reading the data, values from environment variables override appsettings.json data values. 'CreateDefaultBuilder' method provide default configuration.

Answer 17

You can read values from appsettings.json using below code.

Answer 18

Default configuration provider first load the values from appsettings.json and then from appsettings.Environment.json file.
Environment specific values override the values from appsettings.json file. In development environment appsettings.Development.json file values override the appsettings.json file values, same apply to production environment.
You can also read the appsettings.json values using options pattern described Read values from appsettings.json file.

Answer 19

Options Pattern allow you to access related configuration settings in Strongly typed way using some classes. When you are accessing the configuration settings with the isolated classes, The app should adhere these two principles.

Answer 20

ASP.NET Core use environment variables to configure application behavior based on runtime environment. launchSettings.json file sets ASPNETCORE_ENVIRONMENT to Development on local Machine. For more visit How to use multiple environments in ASP.NET Core

Answer 21

By default, ASP.NET Core provides below logging providers as a part of WebApplication.CreateBuilder code in program.cs class.

Answer 22

Routing is used to handle incoming HTTP requests for the app. Routing find matching executable endpoint for incoming requests. These endpoints are registered when app starts. Matching process use values from incoming request url to process the requests. You can configure the routing in middleware pipeline of configure method in startup class.

Answer 23

ASP.NET Core provides a better way to handle the errors in Startup class as below.


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

For development environment, Developer exception page display detailed information about the exception. You should place this middleware before other middlewares for which you want to catch exceptions. For other environments UseExceptionHandler middleware loads the proper Error page.
You can configure error code specific pages in Startup class Configure method as below.


    app.Use(async (context, next) =>
    {
    await next();
    if (context.Response.StatusCode == 404)
    {
    context.Request.Path = "/not-found";
    await next();
    }
    if (context.Response.StatusCode == 403 || context.Response.StatusCode == 503 || context.Response.StatusCode == 500)
    {
    context.Request.Path = "/Home/Error";
    await next();
    }
    });

For more visit Error handling

Answer 24

In ASP.NET Core, Static files such as CSS, images, JavaScript files, HTML are the served directly to the clients. ASP.NET Core template provides a root folder called wwwroot which contains all these static files. UseStaticFiles() method inside Startup.Configure enables the static files to be served to client.
You can serve files outside of this webroot folder by configuring Static File Middleware as following.

Answer 25

As we know HTTP is a stateless protocol. HTTP requests are independent and does not retain user values. There are different ways to maintain user state between multiple HTTP requests.

Answer 26

Yes, you can run an ASP.NET application or .NET Core application in Docker containers.

Answer 27

Model binding provides the capability to map the data from HTTP requests to action method parameters in your controller. It simplifies handling incoming data by automatically converting it from various sources such as JSON, form values, query strings, route data etc., into .NET objects. Model binding helps in reducing manual parsing of data and binding that data to .NET types. Model binding happens after the routing system selects the action method. For more you can refer Model Binding in ASP.NET Core.

Answer 28

Custom Model Binding in ASP.NET Core is a mechanism that allows developers to create their own custom model binders to handle specific cases where the built-in model binders are not suitable or need additional processing. It provides flexibility and extensibility to the model binding process, which maps data from an HTTP request to an action method's parameters or a Razor Page's properties.
To create a Custom Model Binder in ASP.NET Core, you need to follow these steps:

Create a class that implements the IModelBinder interface or derives from the ModelBinder class.
Implement the BindModelAsync method, which is responsible for binding the data from the request to the target model.
Register the custom model binder either globally or at the action method level.

Answer 29

Model Validation in ASP.NET Core is the process of ensuring that the data submitted by the user meets certain rules and constraints before processing it further. It helps to maintain data integrity and prevent invalid or malicious data from being processed by the application.
ASP.NET Core provides built-in support for model validation using data annotations. These annotations are applied to the properties of the model class, and they define the validation rules that should be enforced. For example, the [Required] attribute specifies that a property must have a non-null value, and the [StringLength] attribute sets the minimum and maximum length for a string property.
When a request is made, ASP.NET Core automatically validates the model based on the defined validation rules. If any validation errors occur, they are added to the ModelState object, which can be accessed and displayed to the user.

Answer 30

ASP.NET Core middleware is a software component that can handle requests and responses in the request pipeline. It provides a way to add custom logic to the request processing pipeline, such as logging, authentication, caching, and more.
To write a custom ASP.NET Core middleware, you need to create a class that implements the IMiddleware interface or extends the MiddlewareBase class. The middleware class should have an Invoke or InvokeAsync method that handles the request and response.
Here's an example of a simple middleware that logs the request path:

public class RequestPathLoggerMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public RequestPathLoggerMiddleware(RequestDelegate next, ILoggerFactory loggerFactory)
    {
        _next = next;
        _logger = loggerFactory.CreateLogger();
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation($"Request path: {context.Request.Path}");
        await _next(context);
    }
}

After creating the middleware class, you need to register it in the Startup.cs file by calling the UseMiddleware extension method in the Configure method:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Other middleware registrations...

    app.UseMiddleware();

    // Other middleware registrations...
}

This way, your custom middleware will be executed for every request in the specified order within the request pipeline.

Answer 31

Caching significantly improves the performance of an application by reducing the number of calls to actual data source. It also improves the scalability. Response caching is best suited for data that changes infrequently. Caching makes the copy of data and store it instead of generating data from original source.
Response caching headers control the response caching. ResponseCache attribute sets these caching headers with additional properties. For more visit Caching in ASP.NET Core.

Answer 32

In-memory cache is the simplest way of caching by ASP.NET Core that stores the data in memory on web server.
Apps running on multiple server should ensure that sessions are sticky if they are using in-memory cache. Sticky Sessions responsible to redirect subsequent client requests to same server. In-memory cache can store any object but distributed cache only stores byte[].
IMemoryCache interface instance in the constructor enables the In-memory caching service via ASP.NET Core dependency Injection.

Answer 33

Applications running on multiple servers (Web Farm) should ensure that sessions are sticky. For Non-sticky sessions, cache consistency problems can occur. Distributed caching is implemented to avoid cache consistency issues. It offloads the memory to an external process. Distributed caching has certain advantages as below.

Answer 34

Cross-Site Request Forgery (XSRF/CSRF) is an attack where attacker that acts as a trusted source send some data to a website and perform some action. An attacker is considered a trusted source because it uses the authenticated cookie information stored in browser.
For example a user visits some site 'www.abc.com' then browser performs authentication successfully and stores the user information in cookie and perform some actions, In between user visits some other malicious site 'www.bad-user.com' and this site contains some code to make a request to vulnerable site (www.abc.com). It's called cross site part of CSRF.
How to prevent CSRF?

Answer 35

Area is used to divide large ASP.NET MVC application into multiple functional groups. In general, for a large application Models, Views and controllers are kept in separate folders to separate the functionality. But Area is a MVC structure that separate an application into multiple functional groupings. For example, for an e-commerce site Billing, Orders, search functionalities can be implemented using different areas.

Answer 36

Filters provide the capability to run the code before or after the specific stage in request processing pipeline, it could be either MVC app or Web API service. Filters performs the tasks like Authorization, Caching implementation, Exception handling etc. ASP.NET Core also provide the option to create custom filters. There are 5 types of filters supported in ASP.NET Core Web apps or services.

Answer 37

For more visit Bundling and Minification.

Answer 38

To improve the performance of an ASP.NET Core application, you can implement several strategies. Here are some clear and simple examples:

Answer 39

Visual Studio comes with default profiling and diagnostics tools, which you can use at development time from the visual studio. These are the built-in tools and allow the analysis of memory usage, CPU usage and performance events in ASP.NET Core applications.
For more visit Performance Diagnostic Tools.

Answer 40

ASP.NET Core MVC is a framework to build web applications and APIs. It's based on Model-View-Controller (MVC) Design Pattern. This design pattern separate an application into three main components known as Model, View and Controller. It also helps to achieve SoC (Separation of Concern) design principle.
ASP.NET Core MVC is light weight, open-source and testable framework to build web applications and services.

Answer 41

ASP.NET MVC has three main group of components Model, View and Controller, Each one has his own responsibilities as below.

Answer 42

ViewModel is used to pass a complex data from controller to view. ViewModel data is prepared from different models and passed to view to display that data. For example, A Complex data model can be passed with the help of ViewModel.

Answer 43

Strongly-typed views are tightly bound to a model. for example, In above question if you want to pass the author data to view then you need to write below code for type checking in your view. @model Author. Controller can pass strongly type model to view that enables type checking and intelliSense support in view.

Answer 44

Attribute Routing gives you more control over the URIs in your web application. MVC 5 supports this attribute based routing where attributes are used to define the routes. You can manage resource hierarchies in better way using attribute based routing. Attribute based routing is used to create routes which are difficult to create using convention-based routing. For example below routes.

Answer 45

Dependency Injection is a design pattern used to inject the object dependencies inside controllers. ASP.NET core supports built-in dependency injection, just you need to register those services in the startup file inside ConfigureServices method. You can add services as constructor parameters, ASP.NET Core runtime will resolve these dependencies from the service container.
You can perform dependency injection in two ways.

Constructor Injection
Action Injection using FromServices attribute.
You can access additional settings by using options pattern instead of directly injecting IConfiguration inside the controller.

For more refer Dependency injection into ASP.NET Core controllers.

Answer 46

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-3.1#middleware-order

Answer 47

When you attend an interview, Interviewer may ask you to rate yourself in a specific Technology like ASP.NET Core, So It's depend on your knowledge and work experience in ASP.NET Core. The interviewer expects a realistic self-evaluation aligned with your qualifications.

Answer 48

The challenges faced while working on ASP.NET Core projects are highly dependent on one's specific work experience and the technology involved. You should explain any relevant challenges you encountered related to ASP.NET Core during your previous projects.

Answer 49

This question is commonly asked in interviews to understand your specific responsibilities and the functionalities you implemented using ASP.NET Core in your previous projects. Your answer should highlight your role, the tasks you were assigned, and the ASP.NET Core features or techniques you utilized to accomplish those tasks.

Answer 50

Here you can tell about your overall work experience on ASP.NET Core.

Answer 51

Whether a candidate has completed any ASP.NET Core certification or training is optional. While certifications and training are not essential requirements, they can be advantageous to have.

Answer 52

We have covered some frequently asked ASP.NET Core Interview Questions and Answers to help you for your Interview. All these Essential ASP.NET Core Interview Questions are targeted for mid level of experienced Professionals and freshers.
While attending any ASP.NET Core Interview if you face any difficulty to answer any question please write to us at info@qfles.com. Our IT Expert team will find the best answer and will update on the portal. In case we find any new ASP.NET Core questions, we will update the same here.

Programming

AI/ML

Automation (RPA)

Software Design

JS Frameworks

.Net Stack

Java Stack

Django Stack

Database

DevOps

Testing

Cloud Computing

Mobile Development

SAP Modules

Salesforce

Networking

BIG Data

BI and Data Analytics

Web Technologies

Top 61 ASP.NET Core Interview Questions and Answers

ASP.NET Core Interview Questions and Answers

Other Interview Questions For .NET Developers:

ASP.NET Core MVC Interview Questions

Some General Interview Questions for ASP.NET Core

Conclusion