Dot NET Core Interview Questions PDF By ScholarHat

Dot NET Core Interview Questions PDF By ScholarHat

1. Top 50 .NET Core Interview Questions and
Answers 2025
.NET Core Interview Questions: An Overview
Are you a .NET enthusiast? Do you want to take a step further in the .NET developer roadmap? If
yes, you have come to the right place. In this .NET Core tutorial on .NET Core Interview Questions,
we have tried our best to provide you with some of the top .NET Core Interview Questions and
Answers. After going through these questions, you can check your knowledge through our .NET
Core Certification Training. 
Basic .NET Core Interview Questions for Freshers
1. What do you understand by .NET Core Framework?
.NET Core is a cross-platform, open-source framework that is the successor of .NET for
building various types of applications, including web, desktop, and console applications.
It provides runtime, libraries, and development tools for building and running .NET
applications on different platforms.

2. .NET Core supports multiple programming languages, including C#, F#, and Visual Basic.
Looking for a 50% Salary Hike? Enroll in Our ASP.Net Core Certification Training and Make
Your Job Change Count!
Cross-Platform Compatibility: .NET Core is designed to be cross-platform, allowing
developers to build and run applications on various operating systems such as Windows,
Linux, and macOS.
Open-Source: .NET Core is an open-source framework, with its source code available on
GitHub. This openness encourages community contributions, fosters transparency, and
enables developers to explore and understand the inner workings of the framework.
Modular Architecture: .NET Core follows a modular architecture, where features are
organized into separate packages (NuGet packages).
High Performance: .NET Core is optimized for performance, with features such as just-in-
time (JIT) compilation, runtime optimizations, and support for asynchronous programming
patterns.
Side-by-Side Versioning: .NET Core supports side-by-side versioning, allowing multiple
versions of the runtime and framework to be installed on the same machine.
Cloud-Native Support: .NET Core is well-suited for cloud-native development, with support
for microservices architecture, containerization (e.g., Docker), and cloud platforms such as
Microsoft Azure.
Modern Language Features: .NET Core supports modern language features and
programming paradigms, including asynchronous programming with async/await, functional
programming concepts, language enhancements (e.g., pattern matching, nullable reference
types in C# 8.0), and more.
Tooling and Ecosystem: .NET Core comes with a rich set of development tools, including the
cross-platform .NET CLI (Command-Line Interface), Visual Studio IDE (Integrated
Development Environment), Visual Studio Code, and various third-party tools and extensions.
2. State some important characteristics of .NET Core.

3. Installation
Application
Models
Features
Compatibility
Training Name 
ASP.NET Core Certification Training
.Net Certification Training
Get Free Demo!! Book a
FREE Live Demo! Book a
FREE Live Demo!
.NET Core
It works based on the principle of “build
.NET framework This framework is compatible
once, run anywhere”. It is cross-platform,with the Windows operating
so it is compatible with different operating system only. Even though, it
systems such as Linux, Windows, andwas developed to support
Mac OS.software and applications on
all operating systems.
It is installed in the form of a
single package for Windows
OS.
It is used for developing both
desktop and web applications,
on the Windows mobile, web, andalong with this it also supports
Since it is cross-platform, it is packaged
and installed independently of the OS.
It
desktop application and it focuses mainly
does not support developing the
Windows store. Windows Forms and WPF
applications.
3. Differentiate between .NET and .NET Core.

4. Performance
and Scalability
It
scalability.
provides high performance and It is less effective compared to
.Net
performance
Core in terms of
as
as well
scalability of applications.
Support
Micro-Services
for It supports developing and implementing
the micro-services and the user is
required to create a REST API for its
implementation.
It is shipped as a collection of Nugget
packages.
It
microservices’
does not support the
development
and implementation, but it
supports REST API services.
All the libraries that belong to
and
Services
Packaging
Shipping
REST
and
the .Net Framework are
packaged and shipped all at
once.
Android
Development
It is compatible with open-source mobile
app platforms like Xamarin, via .NET
Standard Library. Developers can make
use of tools of Xamarin for configuring the
mobile application for particular mobile
devices like Android, iOS, and Windows
phones. For all supported platforms, it
provides
lightweight editors along with command-
line tools.
It
development
applications.
does not support the
mobile
of
CLI Tools .NET is heavy for
CLI(Command Line Interface)
and developers usually prefer
to work on the lightweight CLI.
Deployment
Model
The updated version of the .NET Core getsWhen the updated version is
initiated on one machine at a time, which released, it is deployed only on
the Internet Information Server
at first.means
folders/directories
it gets updated in new
existing
application without affecting it. Thus, we
can say that .NET Core has a very good
flexible deployment model.
in the
4. What is CoreCLR?

5. Garbage collector
JIT compiler
Low-level classes
Primitive data types
CLS and CTS
The Common Language Runtime (CLR) performs the garbage collection and code compilation
functions etc.
The CLR is the execution/ run-time engine in .NET Core, that is, it is responsible for the execution
and running of programs in different programming languages. It consists of the following major
components:
Kestrel is an event-driven, I/O-based, open-source, cross-platform, and asynchronous server that
hosts .NET applications. It is provided as a default server for .NET Core therefore, it is compatible
with all the platforms and their versions that .NET Core supports.
5. What is Kestrel?

6. Kestrel supports both HTTP/1.x and HTTP/2 protocols, providing flexibility and performance
improvements for modern web applications.
1. Common Language Runtime (CLR): It is the runtime environment that manages the
execution of .NET Core applications. It provides features such as memory management,
6. Describe the components of .NET Core.

7. Yes, garbage collection (GC) is an ongoing process in managed memory environments like those
provided by .NET. It occurs automatically in the background to reclaim memory occupied by
objects no longer used by the application, thus freeing up memory for future allocations.
Garbage collection can occur at different times, including:
NuGet packages are parts of the package management system for .NET which are essential to
carry on any development on the platform. These packages contain libraries and other
descriptive metadata and are managed by NuGet.
In other words, a NuGet package is a single zip file with a .nupkg extension. The file contains
compiled codes, files related to the code, and descriptions. Developers can create and share
these packages by publishing them to either private or public hosts. They can also use the
packages available and add to projects on an as-needed basis.
exception handling, garbage collection, and type safety.
2. Base Class Library (BCL): It is a collection of reusable classes, types, and APIs that provide
fundamental functionality for building .NET Core applications.
3. CoreFX: CoreFX is a foundational set of libraries that complement the Base Class Library and
provide additional functionality for building .NET Core applications.
4. ASP.NET Core: It is a cross-platform web framework for building modern web applications
and services. It includes features for building web APIs, MVC web applications, real-time web
applications using SignalR, and more.
5. Entity Framework Core: It is an object-relational mapping (ORM) framework that enables
developers to work with databases using .NET objects. It provides a powerful set of APIs for
querying, updating, and managing database data using .NET Core applications.
 . CLI (Command-Line Interface): The .NET Core CLI provides a command-line interface for
creating, building, running, and managing .NET Core applications.
7. .NET Standard: .NET Standard is a formal specification that defines a set of APIs that must
be available on all .NET implementations, including .NET Core, .NET Framework, and
Xamarin.
 . Tooling: .NET Core includes a set of development tools, including Visual Studio, Visual Studio
Code, and various command-line tools, that help developers build, debug, and deploy .NET
Core applications efficiently.
7. What are NuGet packages?
8. Is Garbage collection an ongoing process? When does it occur?

8. Best
application
Parameters
Definition
.Net Core A part of .NET framework
which is
specially optimized for designing
Mono
It is also part of .NET family
frameworks, but this framework is
optimized for iOS, macOS, Android, and
Windows devices by the Xamarin
platform
Mobile app development, Designing
games, Code compilation within the
modern
developer workflows
apps and supporting
To
applications
design command line
application
web
1. During memory allocation: When an application requests memory allocation and the system
detects insufficient memory, it may trigger a garbage collection cycle to free up memory before
allocating more.
2. When a certain threshold is reached: The garbage collector monitors memory usage and
triggers a collection when certain thresholds, such as generation sizes or memory pressure,
are met or exceeded.
3. Explicitly: Developers can request garbage collection explicitly by calling GC.Collect()
method. However, this is typically not recommended in most scenarios because the garbage
collector is usually efficient at managing memory automatically.
4. During idle periods or low system activity: The garbage collector may take advantage of idle
periods or low system activity to perform more intensive garbage collection cycles without
impacting application performance.
9. State the differences between .Net Core and Mono.

9. Area
Specific
features
App Models
Base library
development,
background service apps, Desktop
application
Designing browser, Designing multi-platform
desktop applications
Natural
framework
acquisition
Smaller
Modular
deployment
Native User Interface Native API Access
Native Performance Productivity
footprint Fast release cycles
UWP (Universal Windows Platform),Xamarin iOS, Xamarin Android, Xamarin
ASP.NET Core Forms, Xamarin Mac
CoreFX Class Library Mono Class Library
In .NET Core, service lifetimes define how long instances of services managed by the built-in
dependency injection container (DI container) should live within the application. The choice of
service lifetime affects how instances are created, reused, and disposed of by the DI
container.
There are three types of service lifetimes supported by .NET Core:
10. What are service lifetimes in .NET Core?

10. To specify the service lifetime when registering services with the DI container in .NET Core, you
use the appropriate extension methods:
AddTransient: Registers a transient service.
AddScoped: Registers a scoped service.
AddSingleton: Registers a singleton service.
Suppose you have a Razor Page named Index.cshtml located in the Pages directory of your
ASP.NET Core project. This page will display a greeting message to the user.
Razor Pages is a comparatively newer and more simplified web app development/ programming
model. The Razor Pages follow a file-based routing approach thus simplifying the "Model-View-
Controller" architectural model of ASP.NET. The code and the HTML are both in a single file
which eliminates the need for separate view models, controllers, action methods, etc.
11. What is meant by Razor Pages?
Example
services.AddTransient<imytransientservice, mytransientservice="">();
services.AddScoped<imyscopedservice, myscopedservice="">();
services.AddSingleton<imysingletonservice, mysingletonservice="">();

11. @page @model
IndexModel
<!DOCTYPE html>
<html>
<head>
<title>Welcome</title>
</head>
<body>


<h1>Welcome to My Razor Page!</h1>
<p>@Model.GreetingMessage</p>
</body>
</html>





}
public void OnGet()
{
// Set the greeting message
GreetingMessage = "Hello, World!";
}
using Microsoft.AspNetCore.Mvc.RazorPages;
public class IndexModel : PageModel
{
public string GreetingMessage { get; set; }

12. The Index.cshtml file represents the Razor Page itself. It contains HTML markup along with
Razor syntax, such as @page and @model, to define the page and its associated model. The
Index.cshtml.cs file is the code-behind file for the Razor Page. It contains the C# code that
defines the behavior and logic for the page. In this case, it's a PageModel class with a
property GreetingMessage and a method OnGet() that sets the greeting message.
When you want to add migrations without making any changes in the model it might lead to the
creation of code files with empty classes. These can be customized to perform operations not
related to the core Entity Framework (EF) model.
A middleware is a component of an application pipeline that handles requests and responses.
That is, the middleware component chooses whether or not to pass an incoming request to the
next component of the pipeline. It is also responsible for giving responses or processing the
request before and after it passes the pipeline.
The below diagram shows a middleware request pipeline consisting of many delegates called
one after another. Where black arrows mark the direction of execution. Each delegate in the
diagram performs some operations before or after the next delegate.
12. What are Empty migrations?
13. What do you know about .NET Core middleware?

13. 14. What languages can you use on .NET Core?
Developers can use multiple programming languages including C++, C#, F#, Visual Basic, etc to
work in the framework and develop .NET Core applications. The Microsoft Intermediate
Language (MSIL) and Common Language Infrastructure (CLI) make it possible to transform any
programming language into CPU-independent instructions.
15. Are ASP.NET Core and .NET Framework compatible?
Yes, ASP.NET Core works with both the .NET framework and the .NET Core framework and is
managed by Microsoft.
16. Explain the concept of dependency injection in .NET Core. How
does it differ from other dependency injection frameworks you have
used?
Dependency injection (DI) in .NET Core is a technique for achieving Inversion of Control (IoC)
between classes and their dependencies. It promotes loose coupling, testability, and
maintainability by allowing the runtime to provide required dependencies instead of
hardcoding them within classes.
.NET Core’s built-in DI container differs from other frameworks like Autofac or Ninject in its
simplicity and lightweight nature. While it provides basic features such as constructor, property,
and method injection, it lacks advanced capabilities like interception or auto-registration.
However, it can be easily replaced with third-party containers if needed.
In .NET Core, services are registered in the ConfigureServices method of the Startup class using
IServiceCollection extension methods like AddTransient, AddScoped, and AddSingleton. These
methods define the lifetime of the service instances.
public class MyClass
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient();
}

14. 19. What is Transfer-encoding?
Transfer-encoding is used for transferring the payload body(information part of the data sent in
the HTTP message body) to the user. It is a hop-by-hop header, that is applied not to a resource
itself, but to a message between two nodes. Each multi-node connection segment can make use
of various Transfer-encoding values.
17. What is the IGCToCLR interface?
IGCToCLR interface will be passed as an argument to the InitializeGarbageCollector() function
and it is used for runtime communication. It consists of a lot of built-in methods such as
RestartEE(), SuspendEE(), etc.
20. What is the use of generating SQL scripts in the .NET core?
18. In what situations .NET Core and .NET Standard Class Library
project types will be used?
.NET Core library is used if there is a requirement to increase the surface area of the .NET API
which your library will access, and permit only applications of .NET Core to be compatible with
your library if you are okay with it.
Most modern web servers and clients support Transfer-Encoding and can handle chunked
transfer encoding transparently. It's defined in the HTTP/1.1 specification (RFC 7230) and is
widely used in practice.
.NET Standard library will be used in case you need to increase the count of applications that are
compatible with your library and reduce the surface area(a piece of code that a user can interact
with) of the .NET API which your library can access if you are okay with it.




}
public MyClass(IMyService myService)
{
_myService = myService;
}
{
private readonly IMyService _myService;

15. 1. Prepare the Application for Publishing: This includes building the application and verifying
that it runs correctly on your development machine.
2. Determine the Target Runtime: Determine the target runtime and operating system for which
you want to publish the self-contained application.
3. Choose the Publishing Command: In the .NET Core CLI (Command-Line Interface), you have
several options for publishing a self-contained application:
dotnet publish: This command publishes the application for a specified target runtime
and configuration.
dotnet publish -r: Use this command to specify the target runtime identifier explicitly.
dotnet publish -c Release: Specify the configuration (e.g., Release) for publishing the
application.
4. Publish the Application: Run the appropriate dotnet publish command from the terminal or
command prompt.
1. Database Schema Management: Generating SQL scripts allows developers to manage
database schema changes efficiently. By using tools like Entity Framework Core Migrations or
other ORM (Object-Relational Mapping) frameworks, developers can generate SQL scripts to
create, update, or rollback database schema changes based on changes made to the
application's data model.
2. Database Deployment: SQL scripts can be used to deploy database schema changes across
different environments, such as development, testing, staging, and production.
3. Database Versioning and Source Control: Generating SQL scripts allows developers to
version control database schema changes along with application code.
4. Database Backup and Recovery: By generating SQL scripts that include backup commands
or data migration statements, developers can automate backup and recovery processes,
ensuring data integrity and disaster recovery preparedness.
5. Database Migration and Integration: By generating SQL scripts that contain data migration
logic or integration routines, developers can automate data transfer tasks and ensure data
consistency across different systems.
 . Database Maintenance and Optimization: SQL scripts can be used to perform database
maintenance tasks, such as indexing, data cleaning, or performance tuning.
Intermediate .NET Core Interview Questions
1. Explain the process of publishing a self-contained .NET Core
application.
Example

16. The .NET Core CLI is a powerful tool for developing, building, and deploying applications. To
utilize it effectively:
1. Install the .NET Core SDK to access the CLI commands.
2. Use “dotnet new” to create a project template (e.g., console app, web app).
3. Navigate to the project directory and use “dotnet restore” to install dependencies.
4. Develop your application using your preferred IDE or text editor.
5. Build the application with “dotnet build”, which compiles source code into executable files.
 . Run the application locally using “dotnet run”.
7. Deploy the application by publishing it with “dotnet publish”, generating a self-contained
deployment or framework-dependent deployment.
5. Verify the Published Output: After completing the publishing process, verify that the
application has been published successfully. Navigate to the publish directory specified in the
output of the dotnet publish command.
 . Run the Published Application: Test the published application on the target system to ensure
that it runs correctly. You can execute the application directly from the publish directory or
distribute it to other systems.
7. Deploy and Distribute the Application: Once you have verified that the self-contained
application runs correctly, you can deploy and distribute it to users or deploy it to production
environments as necessary.
In .NET Core, CoreRT has been used as a native toolchain that performs compilation to
translation. In other words, it compiles CIL byte code to machine code. The CoreRT uses ahead-
of-complier, RyuJIT for compilation. You can also use it with other compilers to perform native
compilation for UWP apps.
The type system of the CoreRT is designed in such a way that metadata for reflection is not at all
required. This feature enables to have an AOT toolchain that can link away unused metadata and
identify unused application code.
3. Explain CoreRT.
2. How can you utilize the .NET Core CLI for developing, building,
and deploying applications?
dotnet publish -c Release -r win-x64

17. 5. How do you implement exception handling and logging in .NET
Core applications?
In .NET Core applications, exception handling and logging are implemented using middleware
components. Middleware is a chain of components that handle requests and responses in the
application pipeline.
4. How do you secure your .NET Core applications? Discuss the
different authentication and authorization mechanisms available.
To secure .NET Core applications, implement authentication and authorization mechanisms.
Authentication verifies user identity, while authorization determines access rights.
1. Cookie-based: Use ASP.NET Core Identity for storing user information and managing
authentication via cookies.
2. Token-based: Utilize JSON Web Tokens (JWT) to authenticate users without server-side
sessions.
3. OAuth 2.0/OpenID Connect: Integrate with external providers like Google or Facebook using
these protocols.
4. Windows Authentication: Employ this mechanism in intranet scenarios where Active
Directory is available.
5. Certificate Authentication: Authenticate clients based on X.509 certificates, suitable for
mutual TLS scenarios.
For authorization:
1. Role-based: Grant access based on predefined roles assigned to users.
2. Claims-based: Evaluate claims within a user’s identity to determine permissions.
3. Policy-based: Define custom policies with specific requirements, evaluated by the
Authorization Middleware.

18. Log messages with different severity levels: Trace, Debug, Information, Warning, Error, Critical:
For exception handling, use the built-in “UseExceptionHandler” middleware to catch exceptions
and provide custom error pages or responses. Configure it in the “Startup.cs” file within the
“Configure” method:
For logging, utilize the ILogger interface provided by Microsoft.Extensions.Logging namespace.
Inject ILogger into classes via dependency injection:
The hosting environment contains application-specific details such as application functions,
where it is stored, services for app management, etc. A HostingEnvironment is created in the
application domain, before the ASP's creation. In other words, a hosting environment is
responsible for application management and app-specific functions.
6. What is the hosting environment?




}
public MyClass(ILogger logger)
{
_logger = logger;
}
public class MyClass
{
private readonly ILogger _logger;
app.UseExceptionHandler(options =>
{
options.Run(async context =>
{



});
// Custom error response logic here
});
_logger.LogInformation("This is an information log message.");

19. In this example, response caching middleware is added to the request pipeline, and the Index
action in the controller is decorated with the ResponseCache attribute, specifying a cache
duration of 60 seconds.
Response caching is when the .NET Core MVC's HTTP responses are pre-specified in cache-
related headers. These headers describe how intermediate or client machines should cache
responses to requests. This hence reduces the volume of requests the client or proxy
machine
makes to the web server.
This feature of .NET Core makes it possible for the developer to work with multiple environments,
without creating any friction.
8. What is meant by state management?
7. Explain response caching in .NET Core.
// Configure method in Startup.cs
public void Configure(IApplicationBuilder app)
{
app.UseResponseCaching();
app.UseMiddleware();

}
// Controller action with ResponseCache attribute
[ResponseCache(Duration = 60)]
public IActionResult Index()
{
// Action logic here
}
// ConfigureServices method in Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
}

20. Approach Name
Cookies
Session state
Temp Data
Query Strings
Hidden Fields
HTTPContext.Items
Cache
Storage Mechanism HTTP Cookies,
Server-side app code HTTP Cookies,
Server-side app code HTTP Cookies,
Session State
HTTP Query Strings
HTTP Form Fields
Server-side app code
Server-side app code
Docker is an open-source platform for the development of applications, and also for shipping
and running them. It allows for separating the application from the infrastructure using
containers so that software can be delivered quickly. With Docker, you will be able to manage
the infrastructure in the same ways you used to manage your applications.
It supports shipping, testing, and deploying application code quickly, thus reducing the delay
between code writing and running it in production.
The Docker platform provides the ability to package and application execution in a loosely
isolated environment namely a container. The isolation and security permit you to run
multiple containers at the same time on a given host. Containers are lightweight and they
include every necessary thing required for running an application, so you need not depend on
what is currently installed within the host.
Roslyn is a .NET Core compiler that compiles VB or C# code to the intermediate language (IL).
Whereas, RyuJIT as the name suggests is a Just-In-Time compiler that works the other way
around i.e. compiles the IL to native code.
Regarding .NET Core frameworks, state management is a kind of state control object to control
the states of the object during different processes. Since stateless protocol, HTTP has been
used, which is unable to retain user values; thus, different methods have been used to store and
preserve the user data between requests.
9. What is Docker?
10. What's the difference between RyuJIT and Roslyn?

21. 11. What is MEF?
The MEF(Managed Extensibility Framework) is a library that is useful for developing extensible
and lightweight applications. It permits application developers to use extensions without the
need for configuration. It also allows extension developers for easier code encapsulation thus
avoiding fragile hard dependencies. MEF will let you reuse the extensions within applications, as
well as across the applications. It is an integral part of the .NET Framework 4. It improves the
maintainability, flexibility, and testability of large applications.
13. What is Hosting Environment Management?
In .NET Core, the hosting environment represents the context in which the application is running.
It provides information about the environment, such as whether the application is running in
12. What are the benefits of using SignalR in .NET Core applications,
and how does it differ from traditional AJAX-based communication?
SignalR in .NET Core offers real-time communication, enabling server-side code to push content
updates instantly to connected clients. This contrasts with traditional AJAX-based
communication, which relies on client-initiated requests and periodic polling for updates.
Key benefits of SignalR include:
Real-time functionality: Instantly update clients without requiring user interaction or page
refreshes.
Automatic connection management: Handles connection persistence, reconnection, and
scaling seamlessly.
Broad compatibility: Supports various platforms (web, mobile, desktop) and fallback
mechanisms for older browsers.
High-level abstraction: Simplifies complex tasks like managing connections, groups, and
message handling.
Extensibility: Customizable components allow adapting to specific requirements.
SignalR’s main difference from AJAX is its push-based approach, using WebSockets when
available and falling back to other techniques (e.g., Server-Sent Events, Long Polling) if
necessary. AJAX, conversely, employs a pull-based model where the client must request data
explicitly.

22. There are mainly four ways to manage errors in .NET Core for web APIs.
1. Developer Exception Page
2. Exception Handler Page
3. Exception Handle Lambda
4. UseStatusCodePages
If you compare these four methods, the best way is "Developer Exception Page" as it provides
detailed information (stacks, query string parameters, headers, cookies) about unhandled
request exceptions. You can easily enable this page by running your applications in the
development, staging, or production mode.
1. Environment Name: .NET Core applications define an environment name that indicates the
current deployment environment. Common environment names include Development,
Staging, Production, and others.
2. IHostingEnvironment Interface: In ASP.NET Core, the IHostingEnvironment interface
provides access to information about the hosting environment. It exposes properties such as
EnvironmentName, ContentRootPath, and WebRootPath, which allow the application to
determine its current environment and file system paths.
3. WebHostBuilder: The ConfigureAppConfiguration method of the WebHostBuilder allows you
to set up configuration sources and specify environment variables or command-line
arguments that influence the hosting environment.
4. AppSettings Configuration: By using separate appsettings files (e.g.,
appsettings.Development.json, appsettings.Production.json), you can define environment-
specific configuration settings that are loaded based on the current environment.
5. Environment-specific Middleware: ASP.NET Core allows you to register middleware based
on the hosting environment conditionally. This enables you to add or remove middleware
components depending on the deployment environment.
 . Development vs. Production Mode: In Development mode, the application may have features
enabled that aid in debugging and development, such as detailed error messages, developer
exception pages, and automatic browser refresh (in client-side development).
7. Integration with Dependency Injection: The hosting environment is often used in conjunction
with dependency injection to configure services and components based on the current
environment.
14. What are the various ways to manage errors in .NET Core for
web APIs?

23. In .NET Core, the IConfiguration interface plays a central role in managing application
configuration settings. It provides a unified way to access configuration values from various
configuration sources, such as appsettings.json files, environment variables, command-line
arguments, user secrets, Azure Key Vault, and custom configuration providers.
To read configuration values, first install the required NuGet packages for the desired
configuration providers (e.g., Microsoft.Extensions.Configuration.Json). Then, create a
ConfigurationBuilder instance, add the necessary providers, and build the configuration object.
development environment. This page runs early in the middleware pipeline, so you can easily
catch the exception in middleware.
1. .NET Core Class Library
Use .NET Core class library projects when you need to create reusable components or
libraries specifically targeting the .NET Core runtime.
.NET Core class libraries are typically used to build components that will be used within
.NET Core applications, ASP.NET Core web applications, or other .NET Core projects.
.NET Core class libraries can take advantage of the features, performance optimizations,
and APIs provided by the .NET Core runtime.
2. .NET Standard Class Library
Use .NET Standard class library projects when you want to create reusable components
or libraries that can be shared across different .NET implementations and runtimes.
.NET Standard class libraries are designed to provide a common API surface across
multiple .NET platforms, including .NET Core, .NET Framework, Xamarin, and others.
.NET Standard class libraries are suitable for building libraries that need to target multiple
.NET platforms or runtimes, ensuring compatibility and portability across different
environments.
15. How to figure out when to use .NET Core and .NET Standard
Class Library project types?
1. Describe the role of the IConfiguration interface in .NET Core and
provide examples of how to read configuration values from
different sources.
Advanced .NET Core Interview Questions for
Experienced

24. 1. appsettings.json Files
2. Environment Variables
3. Command-Line Arguments
Blazor WebAssembly
Web app with client-side execution loaded fromEvery
Blazor Server
interaction handled on server
web server can work offline via a service worker. prerendered HTML
The Main() method determines the basic
components of the application the components
are in the App.razor file It's run in the browser
using WebAssembly Single Page Application
The Main() method calls the
CreateHostBuilder method which sets the
ASP.Net Core hosts.
It's run on the server
Use SignalIR to update the client.
2. Differentiate between Blazor Server and Blazor WebAssembly.
How do you decide which one to use for a particular project?
var builder = new ConfigurationBuilder()


.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
IConfiguration configuration = builder.Build();
string value = configuration["MySetting"];
string[] args = { "--mysetting=value" };
var builder = new ConfigurationBuilder().AddCommandLine(args);
IConfiguration configuration = builder.Build();
string value = configuration["mysetting"];
var builder = new ConfigurationBuilder().AddEnvironmentVariables();
IConfiguration configuration = builder.Build();
string value = configuration["MY_ENVIRONMENT_VARIABLE"];

25. Progressive Web App(PWA)
To decide which model to use, consider these factors:
Fast processing large amounts of data
In .NET Core, the Generic Host is a new hosting model for building lightweight and cross-platform
console applications, background services, and microservices. It provides a simplified and
consistent way to configure, start, and run .NET Core applications outside of the ASP.NET Core
framework.
The Generic Host is built on top of the HostBuilder API, which is part of
Microsoft.Extensions.Hosting namespace. It allows developers to configure application
services, logging, configuration, and other components using a fluent and builder-style syntax.
Let's see how to create and configure a Generic Host in a .NET Core console application:
1. Latency: If low latency is crucial, choose Blazor WebAssembly.
2. Offline capability: For offline functionality, opt for Blazor WebAssembly.
3. Client resources: If targeting less powerful devices or slow networks, Blazor Server may be
preferable.
4. Server load: Blazor Server increases server load; if minimizing this is important, select Blazor
WebAssembly.
5. Compatibility: Blazor WebAssembly requires modern browsers; for broader compatibility,
use Blazor Server.
 . Code sharing: Both models allow code sharing between client and server, but Blazor
WebAssembly enables greater flexibility.
3. What is Generic Host in .NET Core?
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Threading;
using System.Threading.Tasks;

26. public MyBackgroundService(ILogger logger)
{
_logger = logger;
}
public class MyBackgroundService : BackgroundService
{
private readonly ILogger _logger;
class Program
{
static async Task Main(string[] args)
{












}
await new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService();
})
.ConfigureLogging(logging =>
{
logging.AddConsole();
})
.RunConsoleAsync();
}








}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Background service is running...");
await Task.Delay(1000, stoppingToken);
}
}

27. 4. What about MVC in .NET Core?
MVC (Model-View-Controller) is a popular architectural pattern for building web applications, and
it's also a key component of ASP.NET Core. MVC in ASP.NET Core follows the same principles as
traditional MVC frameworks but with some enhancements and features tailored for modern web
development.
5. Explain the types of deployment for .NET Core applications.
.NET Core applications can be deployed in various ways, depending on factors such as
application complexity, infrastructure requirements, and deployment preferences. Two common
ASP.NET Core MVC Features
Routing: ASP.NET Core MVC includes a flexible routing system that maps incoming HTTP
requests to controller actions based on URL patterns.
Model Binding: Model binding automatically maps incoming request data (e.g., form values,
query string parameters) to action method parameters or model properties.
Views and Razor Syntax: Views in ASP.NET Core MVC use the Razor view engine, which
allows developers to write HTML with embedded C# code to generate dynamic content.
Tag Helpers: Tag Helpers are a feature in ASP.NET Core MVC that enables developers to
create and use HTML-friendly syntax to generate and work with HTML elements and
attributes within Razor views.
Filters: Filters are used to add pre-action or post-action behavior to controller actions.
Examples include authorization filters, exception filters, action filters, and result filters.
Middleware Pipeline Integration: ASP.NET Core MVC integrates seamlessly with the
ASP.NET Core middleware pipeline, allowing you to combine MVC with other middleware
components for features such as authentication, authorization, logging, and error handling.
Dependency Injection: ASP.NET Core MVC fully embraces dependency injection, making it
easy to inject services and dependencies into controllers, views, filters, and other
components.
Testing Support: ASP.NET Core MVC provides support for unit testing controllers and actions
using testing frameworks like xUnit or NUnit.
The Startup class is the entry point for configuring services and middleware in an ASP.NET Core
application. In the ConfigureServices method, you can register services with the dependency
injection container, including MVC services.

28. types of deployment for .NET Core applications are:
In .NET Core, there isn't a direct replacement for Windows Communication Foundation (WCF) as
a single, unified communication framework. Instead, .NET Core offers several alternatives and
technologies.
ASP.NET Core Web API: It is a lightweight and modern framework for building HTTP-based
APIs using RESTful principles. ASP.NET Core Web API supports various features such as
model binding, routing, middleware, content negotiation, and JSON serialization.
gRPC: A high-performance RPC (Remote Procedure Call) framework developed by Google. It
uses protocol buffers (protobuf) as the interface definition language and provides features
1. Self-Contained Deployment (SCD)
In this, the .NET Core runtime and all application dependencies are included with the
application package.
The application is bundled with the specific version of the .NET Core runtime required to
run it, ensuring that the application can run on systems where the runtime is not installed.
Self-contained deployments are typically larger compared to framework-dependent
deployments because they include runtime and dependencies.
Self-contained deployments are useful when targeting platforms where the .NET Core
runtime may not be available or when you want to isolate the application's runtime
environment from other applications on the system.
You can create self-contained deployments using the dotnet publish command with the
appropriate runtime identifier (RID) specified.
2. Framework-Dependent Deployment (FDD)
Here, the .NET Core runtime is installed separately on the target system, and the
application relies on the installed runtime to execute.
The application package contains only the application binaries and dependencies,
without including the .NET Core runtime.
Framework-dependent deployments are smaller in size compared to self-contained
deployments because they do not include the runtime. Framework-dependent
deployments are suitable for environments where the .NET Core runtime is already
installed, such as development machines, build servers, or containerized environments.
You can create framework-dependent deployments using the dotnet publish command
without specifying a runtime identifier (RID), which defaults to the host system's platform.
6. What officially replaces WCF in .NET Core?

29. In .NET Core, the implicit compilation process refers to the automatic compilation of C# source
code files into executable code without the need for explicit compilation commands. This
process is facilitated by the .NET Core SDK and the underlying build system.
Here's an overview of the working of the implicit compilation process in .NET Core:
1. Project Structure: In a typical .NET Core project, C# source code files (*.cs) are organized
within a project directory structure. The project also contains a project file (usually with a
.csproj extension) that defines project metadata, dependencies, and build configurations.
2. dotnet CLI: The .NET Core command-line interface (CLI) provides commands for managing
.NET Core projects, including building, running, testing, and publishing applications. The
dotnet CLI is used to perform various development and build tasks from the command line.
3. Project File: The project file (e.g., MyProject.csproj) contains XML-based configurations that
specify project settings, dependencies, target frameworks, and build instructions. It defines
the structure and behavior of the project and provides instructions to the build system on
how to compile the project.
4. Dependency Resolution: Before compilation, the .NET Core SDK resolves project
dependencies and ensures that all required packages and libraries are available. It
downloads missing packages from package repositories such as NuGet.org and restores
dependencies as necessary.
5. Build Process: When you build a .NET Core project using the dotnet CLI (e.g., dotnet build
command), the SDK invokes the build system to compile the project's source code files into
executable code. The build system uses MSBuild, the Microsoft Build Engine, to orchestrate
the compilation process.
such as bi-directional streaming, authentication, and cancellation. ASP.NET Core gRPC: It
includes built-in support for creating gRPC services using ASP.NET Core middleware.
ASP.NET Core gRPC allows you to define and implement gRPC services using C# and
integrates seamlessly with ASP.NET Core features such as middleware,
dependency injection, and routing.
ASP.NET Core SignalR: It enables bi-directional communication between clients and servers
over a single, persistent connection. It is suitable for scenarios requiring real-time updates,
such as chat applications, live dashboards, and multiplayer games. Azure Communication
Services: It is a suite of cloud-based communication APIs provided by Microsoft Azure. It
offers APIs for building voice calling, video calling, SMS messaging, and chat functionality
into applications.
7. Explain the implicit compilation process in .NET Core.

30. ASP.NET Core doesn't serve static files like images, HTML, or CSS by default. Instead, it relies
on the UseStaticFiles middleware to handle this task.
You configure this middleware to point to your static file folder, typically wwwroot.
Then, the middleware intercepts requests for these files and delivers them directly to the
client, bypassing the entire ASP.NET Core pipeline.
This keeps things fast and efficient. Additionally, you can control caching and authorization
for static files to further optimize your application.
Universal Windows Platform(UWP) is one of the methods used to create client applications for
Windows. UWP apps will make use of WinRT APIs for providing powerful UI as well as features
of advanced asynchronous that are ideal for devices with internet connections.
Scaffolding in ASP.NET MVC is a code generation technique used to quickly create basic CRUD
(Create, Read, Update, Delete) functionality for database entities. It automates the process of
generating controller, views, and data access code based on the model classes representing the
database entities.
Additionally, the framework includes multiple templates, including page templates, field
templates, entity page templates, and filter templates. You can call them Scaffold templates.
These templates permit you to design and build a fully functional website.
 . Compilation Tasks: During the compilation process, the build system performs various tasks,
including parsing C# source code files, resolving references, compiling source code into
Intermediate Language (IL) bytecode, and generating executable binaries (e.g., DLLs, EXEs).
7. Incremental Builds: The .NET Core build system supports incremental builds, which means
that only modified source code files and their dependencies are recompiled during
subsequent builds. This improves build performance by avoiding unnecessary recompilation
of unchanged files.
 . Output Artifacts: After successful compilation, the build system produces output artifacts
such as DLLs, EXEs, and other files specified in the project configuration. These artifacts
represent the compiled application or library and can be executed, tested, or published for
distribution.
8. What is Scaffolding in ASP.NET MVC?
9. How does ASP.NET Core handle static file serving?
10. What are Universal Windows Platform(UWP) Apps in .Net Core?

31. MSBuild is a free and open-source development platform for Visual Studio and Microsoft. It is a
build tool that helps automate the software product creation process, along with source code
compilation, packaging, testing, deployment, and documentation creation. Using MSBuild, we can
build Visual Studio projects and solutions without the need to install the Visual Studio IDE.
Features of UWP apps:
Cross-Device Compatibility: UWP apps are designed to run on a variety of Windows 10
devices, including PCs, tablets, smartphones, Xbox consoles, Surface Hub, and HoloLens
devices.
Responsive Design: UWP apps support responsive design principles, allowing developers to
create adaptive user interfaces that scale and adjust layout dynamically based on screen
size, orientation, and resolution.
Modern UI Controls: UWP provides a rich set of modern UI controls and components that
enable developers to create visually appealing and interactive user interfaces.
Live Tiles and Notifications: UWP apps can utilize Live Tiles on the Start menu to display
dynamic content, updates, and notifications to users.
Background Tasks and Services: UWP apps support background tasks and services that
allow applications to perform tasks and process data even when they're not in the
foreground.
App Services and APIs: UWP apps can leverage platform APIs and app services to access
system features, device hardware, and platform capabilities. This includes accessing
sensors, cameras, location services, contacts, calendars, and other device-specific
functionality through secure and sandboxed APIs.
Security and App Containerization: UWP apps run in a secure and isolated app container
environment that protects against malicious code, unauthorized access to system resources,
and data breaches.
App Distribution and Store Integration: UWP apps can be distributed and installed through
the Microsoft Store, providing a centralized marketplace for users to discover, download, and
install applications.
Single Codebase and Deployment: UWP apps can be built using a single codebase and
deployed to multiple device types without requiring separate versions or modifications.
Integration with Windows Features: UWP apps seamlessly integrate with various Windows
features and services, including Cortana, Windows Ink, etc.
12. What is Xamarin?
11. What is MSBuild in the .NET Core?

32. The Startup is a critical class in the application. The following points make it imperative:
It describes the pipeline of the web applications.
You can use individual startups for each environment.
It helps to perform the registration of all required middleware components.
Reading and checking thousands of lines in different environments is tough, but you can use
various startup classes to resolve it.
Xamarin is an open-source platform useful in developing a modern and efficient application
for iOS, Android, and Windows with .NET. It is an abstraction layer used to manage the
communication of shared code with fundamental platform code. Xamarin runs in a managed
environment that gives benefits like garbage collection and
memory allocation.
Developers can share about 90% of their applications over platforms using Xamarin. This
pattern permits developers to write entire business logic in a single language (or reuse
existing app code) but accomplishes native performance, look, and feel on each platform.
The Xamarin applications can be written on Mac or PC and then they will be compiled into
native application packages, like a .ipa file on iOS, or .apk file on Android.
In .NET Core, CTS stands for Common Type System. The Common Type System is a fundamental
component of the .NET runtime environment that defines how types are declared, used, and
managed across different programming languages supported by the .NET platform.
CTS is a single-rooted object hierarchy where the System object is the base type for the
derivation of all other types. Two major kinds of types it supports are:
1. Value Types: These types are either allocated within the structure inline or are stored directly
in the stack. This includes built-in value types (standard primitive types), types defined in
source code, user-defined value types, enumerations, etc.
2. Reference Types: These store value memory address references and are allocated on the
heap. They may be any of the interface types, pointer types, or self-describing types. For
example- class types and arrays like boxed value types, delegates, user-defined classes, etc.
14. What is CTS in .NET Core?
13. Why is Startup Class important?
15. How is .NET Core SDK different from .NET Core Runtime?

33. .NET Core SDK builds applications, whereas .NET Core Runtime runs the application. Consider
SDK is a collection of all tools and libraries you need to develop .NET Core applications quickly
like a compiler, and CLI. Consider Runtime as a virtual machine consisting of runtimes libraries
that help you run those applications.
Read more:
.NET8 Developer Roadmap for 2025
What is the difference between .NET 7 and 8?
What's new in .NET 8? Discover ALL .NET 8 Features
Why a Tech Stack .NET Developer Should Upskill?
.NET Developer Should Learn Azure or AWS?
How to Become a .NET Developer in 2025?
.Net Developer: Roles & Responsibilities, Salary & Career Path
Is .Net Worth Learning in 2025? Your Roadmap to Career in .Net