Preparing for an interview on .NET Core Web API

Preparing for an interview on .NET Core Web API involves understanding various concepts and demonstrating practical skills. Here are some commonly asked interview questions, along with answers and explanations, that can help you prepare effectively.

1. What is .NET Core?

Answer: .NET Core is an open-source, cross-platform framework for building modern, high-performance, and scalable applications. It is a modular and lightweight version of the .NET Framework, designed to run on Windows, macOS, and Linux. It includes libraries and APIs for building web applications, APIs, microservices, and more.

Explanation: .NET Core allows developers to write applications that can run on multiple operating systems and platforms, making it suitable for a wide range of environments.

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

Answer:

• Platform: ASP.NET Core is cross-platform and runs on Windows, macOS, and Linux. ASP.NET Framework runs only on Windows.
• Performance: ASP.NET Core is optimized for high performance and can handle more requests per second compared to ASP.NET Framework.
• Modularity: ASP.NET Core is designed to be modular with a lightweight runtime, whereas ASP.NET Framework is monolithic.
• Dependency Injection: ASP.NET Core has built-in support for dependency injection, while ASP.NET Framework requires third-party libraries for DI.
• Hosting: ASP.NET Core can be hosted on Kestrel, IIS, or any other web server, while ASP.NET Framework is primarily hosted on IIS.

Explanation: These differences impact how applications are developed, deployed, and maintained across different environments.

3. How do you define a route in ASP.NET Core Web API?

Answer: Routes in ASP.NET Core Web API can be defined using attribute routing or conventional routing.

Attribute Routing: Define routes directly on controller actions using attributes:

[ApiController]

[Route("api/[controller]")]

public class ProductsController : ControllerBase

{

    [HttpGet("{id}")]

    public IActionResult GetProductById(int id)

    {

        // Implementation

    }

}

Conventional Routing: Define routes in Startup.cs using UseEndpoints:

app.UseEndpoints(endpoints =>

{

    endpoints.MapControllers();

});

Explanation: Attribute routing offers more flexibility and clarity by placing route definitions close to the action methods they correspond to.

4. What is Dependency Injection (DI) and how is it used in ASP.NET Core?

Answer: Dependency Injection (DI) is a design pattern used to achieve Inversion of Control (IoC) by injecting dependencies (services) into classes, rather than creating them within the class. In ASP.NET Core, DI is built-in and configured in Startup.cs:

public void ConfigureServices(IServiceCollection services)

{

    services.AddControllers();

    services.AddScoped<IMyService, MyService>();

}

Explanation: DI helps manage dependencies in a decoupled manner, making the application more maintainable and testable.

5. What is Middleware in ASP.NET Core?

Answer: Middleware is software that is assembled into an application pipeline to handle requests and responses. Each component (middleware) in the pipeline can process requests, perform tasks, or modify the request/response before passing it to the next component.

Example of adding middleware in Startup.cs:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)

{

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>

    {

        endpoints.MapControllers();

    });

}

Explanation: Middleware components are executed in the order they are added to the pipeline, allowing for tasks like logging, authentication, and response handling.

6. What are Entity Framework Core and its advantages?

Answer: Entity Framework Core (EF Core) is an Object-Relational Mapper (ORM) for .NET Core that simplifies data access by allowing developers to work with a database using .NET objects. Advantages include:

• Cross-Platform: Works with .NET Core on Windows, macOS, and Linux.
• Code-First and Database-First Approaches: Supports different development workflows.
• LINQ Queries: Allows for querying databases using LINQ.
• Migrations: Supports schema changes and database evolution.

Explanation: EF Core abstracts the database interactions, making data access more intuitive and integrated into the .NET ecosystem.

7. How do you handle error handling in ASP.NET Core Web API?

Answer: Error handling in ASP.NET Core Web API can be managed using several methods:

Exception Handling Middleware: Configure global exception handling in Startup.cs:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)

{

    app.UseExceptionHandler("/Home/Error");

    app.UseHsts();

    // Other middleware

}

Custom Exception Filters: Create custom exception filters to handle exceptions at the action or controller level:

public class CustomExceptionFilter : ExceptionFilterAttribute

{

    public override void OnException(ExceptionContext context)

    {

        context.Result = new StatusCodeResult(500); // Internal Server Error

        // Log exception

    }

}

Try-Catch Blocks: Handle specific exceptions in code where they might occur:

try

{

    // Code that might throw an exception

}

catch (Exception ex)

{

    // Handle exception

}

Explanation: Effective error handling ensures that your API can gracefully handle and log errors, providing a better user experience and easier debugging.

8. How can you implement versioning in an ASP.NET Core Web API?

Answer: Versioning can be implemented using URL path versioning, query string versioning, or header versioning. Here’s an example of URL path versioning:

1.Install the Microsoft.AspNetCore.Mvc.Versioning NuGet package.

2. Configure versioning in Startup.cs:

public void ConfigureServices(IServiceCollection services)

{

    services.AddApiVersioning(options =>

    {

        options.AssumeDefaultVersionWhenUnspecified = true;

        options.DefaultApiVersion = new ApiVersion(1, 0);

        options.ReportApiVersions = true;

    });

}

3. Use versioning in controllers:

[ApiController]

[Route("api/v{version:apiVersion}/[controller]")]

[ApiVersion("1.0")]

public class ProductsController : ControllerBase

{

    [HttpGet]

    public IActionResult GetAllProducts()

    {

        // Implementation

    }

}

Explanation: API versioning allows you to manage changes and updates to your API without breaking existing clients.

9. What is a Controller in ASP.NET Core Web API?

Answer: A Controller in ASP.NET Core Web API is a class that handles HTTP requests. It is responsible for processing requests, interacting with the data layer, and returning responses. Controllers inherit from ControllerBase and typically use attributes to map HTTP methods to actions.

Example:

[ApiController]

[Route("api/[controller]")]

public class ProductsController : ControllerBase

{

    [HttpGet]

    public IActionResult GetAllProducts()

    {

        // Implementation

    }

    [HttpPost]

    public IActionResult CreateProduct([FromBody] Product product)

    {

        // Implementation

    }

}

Explanation: Controllers are the core components that handle request routing, perform actions based on the request, and return responses.

10. How can you secure an ASP.NET Core Web API?

Answer: Securing an ASP.NET Core Web API can be done using various techniques:

Authentication: Use JWT tokens or OAuth2 to authenticate users. Configure authentication in Startup.cs:

public void ConfigureServices(IServiceCollection services)

{

    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)

            .AddJwtBearer(options =>

            {

                options.TokenValidationParameters = new TokenValidationParameters

                {

                    // Token validation parameters

                };

            });

}

Authorization: Implement role-based or policy-based authorization:

[Authorize(Roles = "Admin")]

[HttpGet]

public IActionResult GetAdminData()

{

    // Implementation

}

HTTPS: Enforce HTTPS to secure data in transit.

Explanation: Securing your API involves implementing proper authentication and authorization mechanisms, ensuring data is encrypted in transit, and following best security practices.

11. What is the purpose of Startup.cs in a .NET Core Web API application?

Answer: Startup.cs is a class that configures the services and the application's request pipeline. It contains two key methods:

• ConfigureServices: Configures services used by the application, such as dependency injection, MVC, and Entity Framework.

• Configure: Defines how the application responds to HTTP requests, setting up the middleware pipeline.

Explanation: Startup.cs centralizes the configuration of services and middleware, making it the entry point for setting up the application's behavior.

12. What are some best practices for designing a RESTful API?

Answer:

Use HTTP Methods Correctly: Utilize GET, POST, PUT, DELETE, PATCH appropriately.

Design Resource-Based URIs: Use nouns for resources and keep URLs simple.

Use Standard HTTP Status Codes: Return appropriate status codes (e.g., 200 OK, 404 Not Found, 500 Internal Server Error)

Implement Pagination: For large datasets, use pagination to manage the amount of data returned in a single request.

Include Error Handling: Provide meaningful error messages and status codes.

Secure the API: Implement authentication and authorization, and enforce HTTPS.

13. What are the HTTP methods used in RESTful APIs and their purposes?

Answer:

• GET: Retrieve data from the server. It should be idempotent (calling it multiple times should have the same effect as calling it once).
• POST: Create a new resource on the server. It is not idempotent.
• PUT: Update an existing resource or create a new one if it does not exist. It is idempotent.
• DELETE: Remove a resource from the server. It is idempotent.
• PATCH: Apply partial modifications to a resource. It is not necessarily idempotent.

Explanation: Understanding these methods helps in designing APIs that align with HTTP standards and provide clear and predictable behavior.