14 Essential ASP.NET Interview Questions

The current ASP.NET Core comes with various features that make it better than the existing ASP.NET framework. Some of these features include:

• Cross-Platform Support: This is the most significant advantage that .NET Core has to offer. It is not tied to a Windows operating system like the legacy .NET framework. With ASP.NET Core, you can develop and deploy production-ready apps on Linux or macOS. Moreover, using an open-source operating system like Linux results in significant cost savings because the cost for Windows licenses is omitted from the production cost.
• High Performance: The ASP.NET Core framework is designed from scratch while keeping performance in mind. This has made it one of the market's fastest and most robust web application frameworks.
• Open Source: The .NET Core framework is also open-source and has an active community. Moreover, the .NET Core framework is openly hosted on GitHub for anyone to see, change and contribute. This has resulted in a great customer experience and trust for Microsoft. Additionally, the patches and bug fixes created by and deployed by developers worldwide have made it significantly more stable than other competitive frameworks.
• New Technologies: With the latest version of ASP.NET Core, you can now develop and deploy an application using new technologies like Blazor and Razor Pages. You can also use the traditional MVC approach still available in the .NET Core framework.

The Startup class in .NET Core is primarily responsible for two main aspects of your applications: service registration and middleware pipeline.

Services are classes made in C# that provide your application with additional functionality. The classes can be used by both your application as well as the .NET Core framework, for example, logging, database, etc. For services to be registered in the framework or application, they must be instantiated, either when you start running your app or when it needs them.

As the name suggests, the middleware pipeline refers to the main sequence, which your application uses to process an HTTP request.

The Configure() method is used to specify the behavior of the .NET Core application to HTTP requests. The methods’ request pipeline can be configured by adding middleware components to an IApplicationBuilder instance (which is provided by dependency injection). In addition, some built-in middleware exists for error handling, authentication, routing, sessions, and diagnostics.

ConfigureServices() is an optional method used wherever you want to add services that the application needs. You can include this function, for instance, if you intend to use Entity Framework in your application. For Example:

public void ConfigureServices(IServiceCollection services)  
{
    services.Configure(Configuration.GetSubKey("AppSettings"));
    services.AddEntityFramework()
            .AddSqlServer()
            .AddDbContext();
    // Add MVC services to the services container.
    services.AddMvc();
}

The Inversion of Control (IoC) between classes and their dependencies is accomplished using the Design Pattern known as Dependency Injection.
A built-in Dependency Injection framework that makes configurable services accessible throughout the application is included with ASP.NET Core. The ConfigureServices function allows you to configure the services as you want.

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();
}
}

However, these direct dependencies can become problematic when

• The class must be modified if you want to replace MyDependency with a different implementation.
• When it is difficult to implement Unit Testing.
• When the MyDependency class has some dependencies which may require it to be configured by class, the code becomes disorganized if multiple classes depend on MyDependency.

The dependency injection (DI) framework aims to solve these problems by

• Using interfaces or base classes to abstract the dependent implementation.
• Within the Startup class ConfigureServices function, dependencies are registered in the Service Container that ASP.NET Core gives.
• Constructor injection is used to inject dependencies, and DI creates and destroys the object as needed.

With its stack and kernel resources, Thread simulates a true OS-level thread. The thread provides the highest level of control. With a thread, you can:

1. Abort(), Suspend(), or Resume() a thread
2. watch its progress and modify thread-level parameters like stack size, apartment state, or culture.
3. Use the CLR's ThreadPool as a wrapper around a pool of threads.

The Task class from the Task Parallel Library offers the best of both worlds. A job does not produce its OS thread, similar to the ThreadPool. However, instead of using the ThreadPool as the default scheduler, tasks are now executed by a TaskScheduler. Also, in contrast to the ThreadPool, Task lets you check its progress and returns results using a generic Task.

A request delegate handles each HTTP request, which is how a request pipeline is constructed. Run, Map, and Use extension methods can be used to customize it. In addition, an anonymous function (also known as in-line middleware) or reusable class can be used as a request delegate. These reusable classes and the anonymous, in-line methods are called middleware or the middleware components.

The Test class above is used to read values from appsettings.json. In the code above, the configuration provider first loads the data values from appsetting.json and then loads the values from the appsettings.Environment.json file.

The values from the appsettings.json file override the environment-specific values. Additionally, The values in the appsettings.Development.json file override those in the appsettings.json file in the development environment, as well as in the production environment.

An application is divided into three primary logical components using the Model-View-Controller (MVC) architectural pattern: the model, the view, and the controller. The MVC pattern is primarily used to control the software side of an application.

Each component's role is clearly defined in an MVC design application. Model classes, for instance, simply contain the data and the business logic. They do not handle HTTP requests. Views merely present data. The controllers take care of processing user input, responding to it, and choosing which model to transfer to which view. This is what is meant by division of duty. It makes an application simple to create and maintain as it evolves and becomes more complicated.

Web Pages, Web Forms, and MVC are the three main development formats that ASP.NET offers. The ASP.NET MVC framework integrates with the pre-existing ASP.NET capabilities, like master pages, authentication, etc. It is a compact, highly testable presentation framework. Additionally, the ASP.NET MVC framework is built on top of the ASP.NET framework, which means most of the features available in ASP.NET can also be used in MVC.

Thus, the best framework for many applications would be ASP.NET MVC.

A host is necessary for ASP.NET Core apps to execute. Moreover, it is also in charge of managing an application's lifecycle and startup. Another responsibility of the host is to guarantee the server's functionality and the availability of the application's services.

It is important not to confuse yourself with a Server. The host is in charge of launching and managing the application, whereas the server is in charge of responding to HTTP requests. The host is set up to utilize a specific server, but the server is blind to its host.

Typically, a WebHostBuilder instance, which constructs and delivers a WebHost instance, is used to create the host. The WebHost refers to the server that will handle requests.

The code above can be changed to run on ASP.NET Core 2.0. ASP.NET 2.0 makes it not only simple but also very intuitive compared to its predecessor:

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup()
            .Build();
}

The Application Domain commonly referred to as AppDomain, is a lightweight process that serves as both a container and a boundary. Like the operating system utilizes a process as a container for code and data, the .NET runtime uses an AppDomain. In addition, the .NET runtime employs an AppDomain to isolate code inside a secure border. Again, this is similar to how the operating system uses processes to isolate bad code.

The CreateDomain() method is used to generate an AppDomain. To load and run assemblies, AppDomain instances are needed. An AppDomain may be unloaded if it is no longer required. Here is the completed code that creates an AppDomain:

public class MyAppDomain: MarshalByRefObject
{
    public string GetInfo()
    {
        return AppDomain.CurrentDomain.FriendlyName;
    }
}
public class MyApp
{
    public static void Main()
    {
        AppDomain apd = AppDomain.CreateDomain("Rajendrs Domain");
        MyAppDomain apdinfo = (MyAppDomain) apd.CreateInstanceAndUnwrap(Assembly.GetCallingAssembly(
    )
            .GetName()
            .Name, "MyAppDomain");
        Console.WriteLine("Application Name = " + apdinfo.GetInfo());
    }
}

Static files like CSS, pictures, JavaScript, and HTML are provided directly to clients with ASP.NET Core. All of these static files are provided in a root folder named wwwroot by the ASP.NET Core template. Inside Startup.Configure, use the UseStaticFiles() function. The static files can now be provided to clients thanks to Configure.

You can serve files outside the root folder by configuring Static File Middleware. For example:

app.UseStaticFiles(new StaticFileOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(env.ContentRootPath, "MyStaticFiles")),
        RequestPath = "/StaticFiles"
    });

Whenever you create a new web app with Visual Studio or dotnet new, a Properties/launchSettings.json file is created. Among many things, the file specifies the ports available to the app for communication. The code above is hardwired to respond to a single port. However, using the app.Urls.Add() method; we can add any number of ports. Hence, we can change it to the code below to work on multiple ports:

var app = WebApplication.Create(args);

app.Urls.Add("http://localhost:3000");
app.Urls.Add("http://localhost:4000");

app.MapGet("/", () => "Hello World");

app.Run();

There are several different ways for bundling and minification in ASP.NET Core.

• Gulp - Up to beta releases, Gulp was the default option for ASP.NET Core. It was later replaced with BundlerMinifier owing to performance and speed issues.
• BundlerMinifier - is a Visual Studio extension that lets you configure bundling and minifying JS, CSS, and HTML files. BundlerMinifier has now become the default option in Visual Studio. It is also in your default template, in which you can see a bundleconfig.json file.
• ASP.NET Core Web Optimizer – The ASP.NET Core middleware is another way for bundling and minification. It can be used to bundle as well as minify JavaScript and CSS files at runtime.
• Grunt - The framework allows you to automate repetitive tasks like minification, compilation, unit testing, linting, etc, making your job easier.

• InProc: The web server's memory houses the session state. This is the default setting in .NET.
• Custom mode: You can choose your storage provider in custom mode.
• Off mode: The session state is disabled in off mode.
• OutProc: This mode can be handled in one of two ways:
  1. StateServer: The ASP.NET state service is a distinct process that stores the session state. The session state is retained even if the application server is restarted. Moreover, it is also accessible by many Web servers.
  2. SQLServer: Session state is kept even if the Web application is restarted because it is stored in a database. Multiple Web servers in a Web farm can access the session state.