Top Most Essential ASP.NET Core Interview Questions with Real-Time Examples for Developers

VINNER TECH April 29, 2025

Asp. Net Core Interview Questions and Answers:-



If you’re preparing for an ASP.NET Core interview, you’ve come to the right place! ASP.NET Core is one of the most widely used frameworks for building web applications and APIs. Whether you’re a beginner or an experienced developer, understanding ASP.NET Core’s key concepts and features is essential for acing your interview. In this blog post, we’ll walk through 50 common ASP.NET Core interview questions, providing detailed explanations and real-time examples to help you get a solid grasp of this framework.


1. What is ASP.NET Core?

ASP.NET Core is a cross-platform, high-performance web framework used to build modern web applications, APIs, and microservices. It’s an open-source version of ASP.NET, designed to work seamlessly on Windows, macOS, and Linux. ASP.NET Core is faster, more lightweight, and modular compared to its predecessor, ASP.NET MVC.

Real-Time Example: You can use ASP.NET Core to create a web application like an e-commerce site. You can build APIs for handling product listings, checkout processes, and customer data, all running efficiently across different operating systems.

2. What are the main differences between ASP.NET Core and ASP.NET MVC?

While both ASP.NET Core and ASP.NET MVC are used to build web applications, ASP.NET Core is the next generation framework, with significant improvements in performance, modularity, and flexibility.

  • Cross-Platform: ASP.NET Core can run on multiple operating systems (Windows, Linux, macOS), whereas ASP.NET MVC is primarily for Windows-based applications.
  • Performance: ASP.NET Core has better performance due to a lightweight and modular design.
  • Unified Framework: ASP.NET Core merges MVC and Web API into a single framework, making it easier to build APIs alongside web applications.

3. What are the benefits of using ASP.NET Core?

ASP.NET Core offers numerous benefits, making it a top choice for web development:

  • Cross-Platform: You can run your application on Windows, Linux, and macOS.
  • High Performance: ASP.NET Core outperforms other web frameworks due to its modular and lightweight design.
  • Open Source: It's free to use and constantly improved by a community of developers.
  • Security: It provides built-in features for authentication and authorization, including ASP.NET Core Identity.

Real-Time Example: For example, when building a mobile app backend, ASP.NET Core’s speed and cross-platform capabilities allow it to work seamlessly with both iOS and Android devices.

4. What is the .NET Core CLI?

The .NET Core CLI (Command Line Interface) is a tool used to develop, build, and publish .NET Core applications from the command line. It’s especially useful when you prefer working with text editors or need to automate tasks in a CI/CD pipeline.

Real-Time Example: You can use the .NET CLI to create a new web API by running dotnet new webapi, which generates a boilerplate API project ready for development.

5. What is Kestrel in ASP.NET Core?

Kestrel is the web server that comes with ASP.NET Core. It’s lightweight, fast, and cross-platform, capable of handling HTTP requests. Kestrel is typically used with a reverse proxy like Nginx or IIS for production environments.

Real-Time Example: When hosting your ASP.NET Core application in the cloud (e.g., on Azure or AWS), Kestrel handles the initial request routing, while a reverse proxy handles load balancing and SSL termination.

6. What is Middleware in ASP.NET Core?

Middleware is software that sits between the incoming HTTP request and the application's response. It can modify requests, perform logging, handle errors, and more. Each middleware component is executed in the order it is configured.

Real-Time Example: You might use middleware for tasks like logging request details (e.g., IP address, request type), or handling authentication before the request reaches the controller.

7. How is routing handled in ASP.NET Core?

Routing in ASP.NET Core is responsible for mapping an HTTP request to a specific controller action. It’s defined in the Startup.cs class and allows you to set up URL patterns that match incoming requests.

Real-Time Example: For a blog application, a route like /blog/{id} might map to the GetPost(int id) action in the BlogController, where {id} is a placeholder for the blog post ID.

8. What are the Startup.cs and Program.cs files?

  • Startup.cs: This file configures services and middleware for the application. It contains the ConfigureServices and Configure methods.
  • Program.cs: This file contains the entry point for the application and starts the web server.

Real-Time Example: In a simple API, Startup.cs will configure routing, logging, and authentication, while Program.cs starts the application and sets up Kestrel as the server.

9. How is dependency injection implemented in ASP.NET Core?

Dependency injection (DI) is a design pattern used in ASP.NET Core to manage the application's dependencies. It allows for better testability and separation of concerns. Services are registered in Startup.cs and injected into controllers or other services.

Real-Time Example: In a blogging app, the BlogService might depend on a database context (DbContext). You register BlogService in Startup.cs, and ASP.NET Core automatically injects it into the BlogController.

10. What is the purpose of the appsettings.json file?

appsettings.json is a configuration file where you can store application settings such as database connections, API keys, and other configurations. ASP.NET Core automatically loads it into the application at runtime.

Real-Time Example: You can store your database connection string in appsettings.json, and ASP.NET Core can read it during startup to connect to your database.

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=mydb;User Id=myuser;Password=mypassword;"
  }
}

Configuration & Dependency Injection


11. How do you configure services in ASP.NET Core?

In ASP.NET Core, services are configured in the Startup.cs file, which is the central place to set up application services and middleware. In the ConfigureServices method, you register various services (like database context, authentication, logging, etc.) that your application requires.

Example: Let’s say you want to configure an in-memory database for your application:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<MyDbContext>(options =>
        options.UseInMemoryDatabase("InMemoryDb"));
}

Here, AddDbContext registers the MyDbContext service to use an in-memory database. This allows the rest of the application to depend on MyDbContext via dependency injection.

12. What is the difference between AddSingleton, AddScoped, and AddTransient?

These are different lifetimes used in dependency injection to control how services are created and disposed of:

  • AddSingleton: This service is created once and shared throughout the application's lifetime. It is ideal for services that don’t need to be recreated and hold state across multiple requests.

    Example: A logging service that should be shared across requests would be a good candidate for Singleton.

    services.AddSingleton<ILoggingService, ConsoleLoggingService>();

  • AddScoped: This service is created once per request or per client connection. It’s useful for services that need to be created for each HTTP request but should be reused throughout that request.

    Example: A service that manages user sessions could be scoped to the duration of a user’s request.

    services.AddScoped<IUserSessionService, UserSessionService>();

  • AddTransient: This service is created each time it is requested. It’s used for lightweight, stateless services where a new instance is needed on every request.

    Example: A service that sends emails could be transient since it doesn’t hold any state between requests.

    services.AddTransient<IEmailService, EmailService>();

13. How do you inject configuration values?

In ASP.NET Core, configuration values are typically stored in files like appsettings.json, and you can inject these values into your services or controllers. To inject configuration values, you can use IConfiguration.

Example: Assume you have the following configuration in appsettings.json:

{
  "AppSettings": {
    "SiteTitle": "My Awesome Site"
  }
}

You can inject the configuration value into your class like this:

public class HomeController : Controller
{
    private readonly IConfiguration _configuration;

    public HomeController(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public IActionResult Index()
    {
        var siteTitle = _configuration["AppSettings:SiteTitle"];
        return View(model: siteTitle);
    }
}

Here, we inject IConfiguration into the controller and access the SiteTitle value from the appsettings.json file.

14. How do you bind configuration to a strongly typed class?

ASP.NET Core allows you to bind configuration values directly to a strongly typed class using the IConfiguration interface and the Bind method.

Example: Let’s say you have this class:

public class AppSettings
{
    public string SiteTitle { get; set; }
}

And the following configuration in appsettings.json:

{
  "AppSettings": {
    "SiteTitle": "My Awesome Site"
  }
}

To bind this configuration to a class:

public void ConfigureServices(IServiceCollection services)
{
    var appSettings = new AppSettings();
    Configuration.Bind("AppSettings", appSettings);
    services.AddSingleton(appSettings);
}

Here, we bind the configuration section to the AppSettings class and register it as a singleton service.

15. What is the IOptions pattern?

The IOptions pattern is a way to retrieve configuration settings in a strongly-typed manner. It is typically used for application settings that need to be injected into classes and accessed at runtime.

Example: Suppose you have the AppSettings class and configuration from the previous example, but you want to use the IOptions pattern instead of binding manually.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
}

Now, you can inject IOptions<AppSettings> into your classes:

public class HomeController : Controller
{
    private readonly IOptions<AppSettings> _appSettings;

    public HomeController(IOptions<AppSettings> appSettings)
    {
        _appSettings = appSettings;
    }

    public IActionResult Index()
    {
        var siteTitle = _appSettings.Value.SiteTitle;
        return View(model: siteTitle);
    }
}

This pattern is especially useful for managing application settings that may change between environments or deployments.

Controllers & APIs

16. What is the difference between MVC and Web API in ASP.NET Core?

The main difference lies in the response format:

  • MVC (Model-View-Controller): Used for building web applications where the response is typically HTML, and the controller returns a view.
  • Web API: Used for building APIs where the response is typically in JSON or XML format, and the controller returns data.

Real-Time Example: For a blogging platform, an MVC controller might return an HTML view to display blog posts, while a Web API controller would return a JSON response with a list of blog posts for a mobile app to consume.

17. How do you create a Web API in ASP.NET Core?

Creating a Web API in ASP.NET Core is straightforward. You define a controller that inherits from ControllerBase and return data in the form of JSON or XML.

Example:

[ApiController]
[Route("api/[controller]")]
public class BlogController : ControllerBase
{
    private readonly IPostService _postService;

    public BlogController(IPostService postService)
    {
        _postService = postService;
    }

    [HttpGet]
    public IActionResult GetPosts()
    {
        var posts = _postService.GetAllPosts();
        return Ok(posts);  // Returns JSON data
    }
}

18. How do you enable CORS in ASP.NET Core?

Cross-Origin Resource Sharing (CORS) allows your API to be accessed from different domains. In ASP.NET Core, CORS is enabled in the Startup.cs file.

Example: To allow all origins:

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy("AllowAll", builder =>
        {
            builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
        });
    });
}

Then, in the Configure method, you can apply the CORS policy:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseCors("AllowAll");
}

19. What are filters in ASP.NET Core?

Filters in ASP.NET Core allow you to run code before or after an action is executed. They can be used for things like logging, authorization, or exception handling.

  • Action filters: Run before and after an action executes.
  • Exception filters: Handle unhandled exceptions.
  • Authorization filters: Used to authorize requests before they hit the action.

20. What is Model Binding and Model Validation?

  • Model Binding: This is the process where ASP.NET Core automatically maps HTTP request data (like query strings, form data, or route data) to action method parameters.

  • Model Validation: This ensures that the data passed to an action method is valid. ASP.NET Core provides built-in attributes like [Required] and [StringLength] to enforce validation rules.

Example:

public IActionResult CreatePost([FromBody] Post post)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    // Logic to create the post
}

Entity Framework Core


21. What is Entity Framework Core?

Entity Framework Core (EF Core) is an open-source, lightweight, and cross-platform Object-Relational Mapping (ORM) framework for .NET. It allows you to interact with a database using .NET objects, eliminating the need for raw SQL queries. EF Core is highly versatile, supporting multiple database providers, such as SQL Server, SQLite, and PostgreSQL.

Example: Imagine you're developing a blog application. Instead of writing SQL queries to manage posts and users, you can use EF Core to query and manipulate your database using .NET objects:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }
}

public class ApplicationDbContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
}

22. What are the key differences between EF Core and EF 6?

EF Core is the latest version of Entity Framework, with significant improvements over EF 6. Here are the key differences:

  • Cross-Platform Support: EF Core is cross-platform and can run on Windows, macOS, and Linux, while EF 6 is only supported on Windows.
  • Performance: EF Core offers improved performance and better support for modern database features like batching and lazy loading.
  • API Changes: EF Core introduces several breaking changes, including a new API for handling relationships and migrations.
  • No Support for Database-First: EF Core no longer supports the Database-First approach; it focuses on Code-First and Model-First approaches.

23. How do you perform code-first migrations in EF Core?

Code-first migration allows you to create and update your database schema based on your C# classes. You can create migrations and apply them using the Entity Framework Core CLI or Package Manager Console.

Steps to perform migrations:

  1. First, define your model classes (like Blog and Post).

  2. Run the Add-Migration command to create a migration:

    dotnet ef migrations add InitialCreate

  3. Apply the migration to the database using the Update-Database command:

    dotnet ef database update

EF Core will automatically generate SQL scripts to create or update your database schema based on your models.

24. What is DbContext and how is it used?

DbContext is a class in EF Core that represents a session with the database. It provides methods to query and save data to the database and is responsible for managing the entity objects.

Example:

public class ApplicationDbContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }
}

In this example, ApplicationDbContext inherits from DbContext, and DbSet<Blog> represents the collection of Blog entities in the database. You can inject ApplicationDbContext into your controllers or services to perform database operations.

25. What are navigation properties in EF Core?

Navigation properties are properties that represent relationships between entities in EF Core. These properties enable you to navigate from one entity to another, such as from a Blog to its associated Posts.

Example:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }
    
    public ICollection<Post> Posts { get; set; }  // Navigation property
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public int BlogId { get; set; }
    
    public Blog Blog { get; set; }  // Navigation property
}

In this example, the Blog entity has a navigation property to Posts, and each Post has a navigation property back to Blog.

Authentication & Authorization

26. How do you implement authentication in ASP.NET Core?

Authentication is the process of verifying the identity of a user. In ASP.NET Core, authentication can be implemented using various methods, such as cookie-based authentication, JWT, or OAuth.

Example (Cookie-based Authentication):

  1. Configure services in Startup.cs:

    public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(options =>
        {
            options.LoginPath = "/Account/Login";
            options.AccessDeniedPath = "/Account/AccessDenied";
        });
}

  2. Apply authentication middleware in Configure method:

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseAuthentication();
}

  3. Use [Authorize] attribute in controllers or actions to restrict access:

    [Authorize]
public IActionResult Dashboard()
{
    return View();
}

27. What is the difference between authentication and authorization?

  • Authentication: Verifies who the user is. It ensures that the user is who they claim to be (e.g., login with username and password).
  • Authorization: Determines what the user is allowed to do. It defines the permissions a user has after they are authenticated.

Example: In a blogging platform, authentication ensures the user is logged in, while authorization controls what actions they can perform, such as editing or deleting their posts.

28. How does ASP.NET Core Identity work?

ASP.NET Core Identity is a membership system that provides functionality for managing users, roles, and authentication in your application. It includes features like password hashing, user registration, login, and role-based access control.

Example: To use Identity, you first install the Microsoft.AspNetCore.Identity.EntityFrameworkCore package, then configure it in Startup.cs:

services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

You can then use the UserManager and SignInManager to handle user login, registration, and role management.

29. What is JWT and how is it used in ASP.NET Core?

JSON Web Tokens (JWT) are an open standard for securely transmitting information between parties as a JSON object. JWT is commonly used for authentication in modern web applications because it is stateless and can be easily transmitted via HTTP headers.

Example:

  1. Configure JWT authentication in Startup.cs:

    public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
        .AddJwtBearer(options =>
        {
            options.TokenValidationParameters = new TokenValidationParameters
            {
                ValidateIssuer = true,
                ValidateAudience = true,
                ValidateLifetime = true,
                ValidIssuer = "yourIssuer",
                ValidAudience = "yourAudience",
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("yourSecretKey"))
            };
        });
}

  2. Use [Authorize] to secure endpoints:

    [Authorize]
public IActionResult GetUserData()
{
    return Ok(new { Data = "Sensitive data" });
}

30. How do you implement role-based authorization?

Role-based authorization is used to restrict access to certain actions or controllers based on the user's role. This can be done using the [Authorize] attribute with roles.

Example:

  1. Define roles in your Identity system:

    public class ApplicationUser : IdentityUser
{
    // Additional properties
}

  2. Use the [Authorize] attribute with roles:

    [Authorize(Roles = "Admin")]
public IActionResult AdminDashboard()
{
    return View();
}

In this example, only users with the Admin role can access the AdminDashboard action.

Middleware & Services

31. What is custom middleware and how do you create it?

Custom middleware allows you to insert your own logic in the request pipeline to handle things like logging, authentication, or custom processing. You can create custom middleware by implementing a class with an Invoke or InvokeAsync method.

Example:

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Custom logic here
        Console.WriteLine("Request intercepted");
        await _next(context);
    }
}

To use this middleware:

public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware<CustomMiddleware>();
}

32. How do you handle exceptions in ASP.NET Core?

You can handle exceptions in ASP.NET Core using exception middleware or by defining custom exception filters.

Example:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
}

33. What is the UseDeveloperExceptionPage method?

UseDeveloperExceptionPage is a middleware used during development to display detailed error pages when an exception occurs. It helps developers debug the application by providing stack traces and error details.

34. What are hosted services in ASP.NET Core?

Hosted services are background tasks that run independently of user requests. They are useful for long-running tasks, like processing jobs or sending emails.

35. How do you log in ASP.NET Core?

ASP.NET Core provides built-in logging functionality that can be configured in the Startup.cs file. You can log information, warnings, errors, and critical messages using ILogger.

Example:

public void Configure(IApplicationBuilder app, ILogger<Startup> logger)
{
    logger.LogInformation("Application started!");
}

Advanced Topics in ASP.NET Core


36. What is the Repository pattern and how do you implement it?

The Repository pattern is a design pattern that separates the logic for accessing data from the business logic of an application. It acts as an intermediary between the domain and data mapping layers, reducing duplication and simplifying unit testing.

Real-Time Example: In a blog application, instead of interacting directly with the database in controllers, you create a repository to handle all data operations.

public interface IBlogRepository
{
    Task<IEnumerable<Blog>> GetAllBlogs();
    Task<Blog> GetBlogById(int id);
    Task AddBlog(Blog blog);
}

Implementation:

public class BlogRepository : IBlogRepository
{
    private readonly ApplicationDbContext _context;

    public BlogRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<IEnumerable<Blog>> GetAllBlogs() =>
        await _context.Blogs.ToListAsync();

    public async Task<Blog> GetBlogById(int id) =>
        await _context.Blogs.FindAsync(id);

    public async Task AddBlog(Blog blog)
    {
        _context.Blogs.Add(blog);
        await _context.SaveChangesAsync();
    }
}

37. How do you implement the Unit of Work pattern?

The Unit of Work pattern ensures that all database operations are performed in a single transaction, maintaining consistency and reducing potential errors during operations like updates and deletes. It works by grouping multiple repository operations into a single transaction.

Example:

public class UnitOfWork : IUnitOfWork
{
    private readonly ApplicationDbContext _context;
    private IBlogRepository _blogRepository;

    public UnitOfWork(ApplicationDbContext context)
    {
        _context = context;
    }

    public IBlogRepository BlogRepository =>
        _blogRepository ??= new BlogRepository(_context);

    public async Task<int> CommitAsync() => await _context.SaveChangesAsync();

    public void Dispose() => _context.Dispose();
}

38. What are Razor Pages?

Razor Pages is a simpler, more lightweight alternative to MVC in ASP.NET Core for building web pages. It uses a page-centric model, where each page is a self-contained unit of logic, view, and action.

Real-Time Example: In a blog application, instead of defining multiple controllers and views, you create a Pages folder with .cshtml files for each page:

public class BlogPageModel : PageModel
{
    private readonly IBlogRepository _repository;

    public BlogPageModel(IBlogRepository repository)
    {
        _repository = repository;
    }

    public async Task<IActionResult> OnGetAsync(int id)
    {
        Blog = await _repository.GetBlogById(id);
        if (Blog == null) return NotFound();
        return Page();
    }

    public Blog Blog { get; set; }
}

39. What is Blazor and how is it different from Razor Pages?

Blazor is a framework for building interactive web applications using C# instead of JavaScript. It allows you to build rich, client-side web apps with .NET, either running directly in the browser (via WebAssembly) or on the server.

Key Differences from Razor Pages:

  • Blazor allows for client-side interactivity with full support for .NET, while Razor Pages is typically used for server-side rendering.
  • Blazor can run WebAssembly in the browser, enabling rich client-side logic, whereas Razor Pages handles rendering on the server.

Example:

@page "/counter"

<h3>Current count: @count</h3>

<button @onclick="IncrementCount">Click me</button>

@code {
    private int count = 0;

    private void IncrementCount() => count++;
}

40. What is SignalR and how is it used in ASP.NET Core?

SignalR is a real-time web functionality library in ASP.NET Core that allows for bi-directional communication between the server and client. It is used for apps that require constant updates, such as chat applications, live notifications, and real-time data streaming.

Real-Time Example: In a chat application, SignalR can push messages to all connected clients in real-time.

Implementation:

  1. Install SignalR:

    dotnet add package Microsoft.AspNetCore.SignalR

  2. Define a Hub:

    public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

  3. Configure SignalR in Startup.cs:

    public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
}

public void Configure(IApplicationBuilder app)
{
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapHub<ChatHub>("/chathub");
    });
}

Testing & Deployment

41. How do you write unit tests for ASP.NET Core applications?

Unit testing ensures that individual components of your application work as expected. In ASP.NET Core, you can use testing frameworks like xUnit, NUnit, or MSTest to write unit tests.

Example:

public class BlogServiceTests
{
    [Fact]
    public void AddBlog_ShouldAddBlogToRepository()
    {
        // Arrange
        var mockRepository = new Mock<IBlogRepository>();
        var service = new BlogService(mockRepository.Object);
        var newBlog = new Blog { Name = "New Blog" };

        // Act
        service.AddBlog(newBlog);

        // Assert
        mockRepository.Verify(r => r.AddBlog(It.IsAny<Blog>()), Times.Once);
    }
}

42. What is integration testing in ASP.NET Core?

Integration testing tests how different components of an application work together. It typically involves testing the entire application, including controllers, databases, and external services.

Example:

public class BlogApiTests : IClassFixture<WebApplicationFactory<Startup>>
{
    private readonly HttpClient _client;

    public BlogApiTests(WebApplicationFactory<Startup> factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task GetBlogs_ReturnsOkResponse()
    {
        var response = await _client.GetAsync("/api/blogs");
        response.EnsureSuccessStatusCode();
    }
}

43. How do you deploy an ASP.NET Core application?

You can deploy an ASP.NET Core application to various platforms, including IIS, Azure, or Docker.

Deployment to IIS:

  1. Publish the app using Visual Studio or the dotnet publish command.
  2. Set up an IIS server and configure it to point to the published files.
  3. Ensure that ASP.NET Core Hosting Bundle is installed on the server.

44. What is the purpose of the launchSettings.json file?

The launchSettings.json file is used in ASP.NET Core to define environment-specific settings, such as the application URL, environment variables, and which profile to use during development.

Example:

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:5000",
      "sslPort": 44300
    }
  },
  "profiles": {
    "IIS Express": {
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "ProjectName": {
      "commandName": "Project",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Production"
      }
    }
  }
}

45. How do you publish an ASP.NET Core app to IIS?

  1. Publish the app: Use dotnet publish or Visual Studio to generate the app’s files.
  2. Configure IIS: Add a site to IIS, pointing to the published directory and configure the ASP.NET Core Module to handle the requests.
  3. Start the application: Ensure the app is running on IIS with the correct bindings.

Miscellaneous

46. What are tag helpers in ASP.NET Core?

Tag helpers are server-side components that allow you to modify HTML elements in views, making them more dynamic and easier to work with.

Example:

<form asp-action="Create">
    <input asp-for="Name" />
    <button type="submit">Submit</button>
</form>


VINNER TECH

Posted by VINNER TECH

Post a Comment

0 Comments