Asp.net Core Interview Questions Answers

• Cross-Platform webserver "Kestrel" & Container Support
• Single programming model for MVC and Web API
• Dependency Injection is heavily used in asp.net core framework, We can extend it with other popular DI containers
• We have built-in and extensible structured logging in Asp.Net Core, also can use third party logging utility
• "WWWROOT" folder for static files
• fully async pipeline easily configured via middleware
• Razor page, specially designed for small size application, supports cross platform deployment
• Provide protection against CSRF (Cross-Site Request Forgery)
• Support WebSocket and SignalR
• Command-line supports to create, build, run an application
• Tags Helpers in Asp.net Core helps in rapid Development.
• There is no web.config, We now use appsettings.json file to store configuration information
• There is no Global.asax, We have Startup.cs, to setup new Middleware and services for DI Container.

Learn more about asp.net core middleware.

• It supports cross-platform application building, so it can be run on Windows, Linux and Mac.
• Now no framework installation required, because all the required dependencies are packaged with asp.net core application
• Asp.Net Core has in-built logging capabilities
• ASP.NET Core can handle request more efficiently than the ASP.NET

It defines the HTTP pipeline, how the application will respond to request. We can change the sequence of middleware configuration, it accepts IApplicationBuilder as a parameter and two optional parameters: IHostingEnvironment and ILoggerFactory.

Using this method, we can configure built-in middleware such as authentication, error handling and also any custom middleware or third-party middleware.

Both methods are used to add middleware delegate to the application request pipeline.

Run method never calls the subsequent ore next middleware, After IApplicationBuilder.Run method, system stops adding middleware in pipeline

• Conventional routing
• Attribute routing

The middleware for the session is provided by Microsoft.AspNetCore.Session. To use the session in ASP.NET Core application we need to add the middleware in pipeline

public class Startup
 {
     public void ConfigureServices(IServiceCollection services)
     {  
         services.AddSession();
         services.AddMvc();
     }
     public void Configure(IApplicationBuilder app, IHostingEnvironment env)
     {
        app.UseSession();
     }
 }

• appsettings.json
• bundleconfig.json
• global.json
• npm-shrinkwrap.json
• launchsettings.json
• bower.json
• package.json

When we create a razor page, it provides the option to have model binging or not, in model binding there is a model created with the razor page, the model is inherited from : PageModel we need to use [BindProperty] attribute to bind any property to model

public class ContactModel : PageModel
 {
     [BindProperty]
     public string StudentName { get; set; }
 }

• ViewResult

  Represents HTML and markup.

• JsonResult

  Represent JSON that can be used in AJAX, like a JSON object

• JavaScriptResult

  Represent a JavaScript script.

• ContentResult

  Represents string literal.

• RedirectResult

  Represents a redirection to a new URL

• RedirectToRouteResult

  Represent another action of same or other controller

• PartialViewResult

  Returns HTML from Partial view

• HttpUnauthorizedResult

  Returns HTTP 403 status

• FileContentResult / FileStreamResult / FilePathResult

  Represents the content of a file

We can write following code in Startup.cs file.

Here are some sample two Middleware pipeline, we want to map them for different path.

private static void ExecuteMiddleware1(IApplicationBuilder app)
{
app.Run(async context =>
{
await context.Response.WriteAsync("Execute Middleware 1");
});
}
private static void ExecuteMiddleware2(IApplicationBuilder app)
{
app.Run(async context =>
    {
        await context.Response.WriteAsync("Execute Middleware 2");
    });
}

Here is how you can Map Middleware in Configure method

public void Configure(IApplicationBuilder app)
{
app.Map("/mapPath1", ExecuteMiddleware1);
app.Map("/mapPath2", ExecuteMiddleware2);
app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from No Match.");
        });
    }