ASP.NET Interview Questions with Answers

// Dynamic web API endpoint in ASP.NET Core (Minimal APIs)
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Welcome to ASP.NET Core API!");

app.Run();

// Architectural ecosystem framework selection
// 1. ASP.NET Web Forms (Legacy event-driven)
// 2. ASP.NET MVC (Structured separation)
// 3. ASP.NET Web API (RESTful endpoint interfaces)
// 4. ASP.NET Core (Modern, high performance, cross-platform)

<!-- ASP.NET Web Forms Event-Driven server side control markup -->
<asp:Button ID="btnSubmit" runat="server" Text="Click Me" OnClick="btnSubmit_Click" />

// Model-View-Controller design architecture pattern
public class HomeController : Controller {
    public IActionResult Index() {
        return View(); // Routes control flow directly to the layout view
    }
}

// Program entry startup bootstrapping in ASP.NET Core
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

var app = builder.Build();
app.UseStaticFiles();
app.UseRouting();

app.MapDefaultControllerRoute();
app.Run();

// Code-behind mechanism: separation of layout and business processing logic
// Page.aspx markup binds to class code-behind file dynamically
public partial class UserDashboard : System.Web.UI.Page {
    protected void Page_Load(object sender, EventArgs e) {
        lblMessage.Text = "Welcome to Server Control logic!";
    }
}

<!-- Hidden structural system state tracking payload inside generated browser DOM -->
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUKMjg0Nzc0MD..." />

// Handling user postbacks safely inside page transaction sequences
protected void Page_Load(object sender, EventArgs e) {
    if (!IsPostBack) {
        // Runs exclusively on the initial client landing request
        PopulateDropdowns();
    }
}

<!-- Server-side UI tag rendering elements inside dynamic engine compiler -->
<asp:TextBox ID="txtEmail" runat="server" CssClass="form-input" Required="true" />

<!-- Master layout structure containing shared template content boxes -->
<%@ Master Language="C#" AutoEventWireup="true" CodeBehind="Site.Master.cs" %>
<div class="header">Main Application Layout Header</div>
<asp:ContentPlaceHolder ID="MainBodyContent" runat="server">
    <!-- Child page unique body elements are injected directly here -->
</asp:ContentPlaceHolder>

<!-- XML application-level settings configuration parameters inside web.config -->
<configuration>
  <appSettings>
    <add key="ApplicationMode" value="Production" />
  </appSettings>
  <connectionStrings>
    <add name="DbConn" connectionString="Server=SQLServer;Database=MyDB;Trusted_Connection=True;" />
  </connectionStrings>
</configuration>

// Application-level lifecycle events inside global.asax
public class Global : System.Web.HttpApplication {
    protected void Application_Start(object sender, EventArgs e) {
        // Runs on initial web app pool initiation sequences
        RegisterRoutes(RouteTable.Routes);
    }
}

// Saving user session state payload buffers across server steps
HttpContext.Session.SetString("UserEmail", "akash@example.com");

// Reading data dynamically from session storage buffers
var email = HttpContext.Session.GetString("UserEmail");

// Output caching strategy configurations on actions
[ResponseCache(Duration = 60, Location = ResponseCacheLocation.Any)]
public IActionResult GetCachedData() {
    return Ok(new { Timestamp = DateTime.UtcNow });
}

// Implementing cookie authentication configuration mechanisms
builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options => {
        options.LoginPath = "/Account/Login";
        options.AccessDeniedPath = "/Account/AccessDenied";
    });

// Managing user resource accessibility via role controls
[Authorize(Roles = "Admin, Manager")]
public class AdminController : Controller {
    public IActionResult Dashboard() => View();
}

// Mapping routing patterns dynamically in the startup configuration
app.MapControllerRoute(
    name: "products",
    pattern: "store/{category}/{id?}",
    defaults: new { controller = "Products", action = "Details" });

// Registering and injecting constructor services via native DI containers
builder.Services.AddScoped<IUserRepository, UserRepository>();

public class UserController : Controller {
    private readonly IUserRepository _repo;
    public UserController(IUserRepository repo) {
        _repo = repo; // Loose coupling architecture
    }
}

// Dynamic pipeline middleware processing step delegates
app.Use(async (context, next) => {
    // Process request operations prior to passing up pipeline
    await next();
    // Post-processing execution tasks before returning output
});

<!-- Structured Razor view layout programming loops -->
@model List<string>
<ul>
    @foreach(var name in Model) {
        <li class="user-item">User: @name</li>
    }
</ul>

<!-- Reusable isolated layout component injection -->
<div class="sidebar">
    <partial name="_UserCard" model="Model.CurrentUser" />
</div>

// Temporary storage passing patterns surviving exactly one redirection step
public IActionResult UpdateSettings() {
    TempData["AlertMessage"] = "System settings modified successfully!";
    return RedirectToAction("Dashboard");
}

// Passing un-typed dynamic parameters cleanly from controller contexts down to views
public IActionResult Index() {
    ViewBag.PageTitle = "System Administration Panel";
    return View();
}

// Binding incoming query string payloads directly inside API methods
[HttpGet("search")]
public IActionResult FindProducts([FromQuery] string query, [FromQuery] int limit) {
    return Ok($"Searching for: {query}, Limit: {limit}");
}

// Base controller return results managing REST protocols
public IActionResult GetSystemStatus(int id) {
    if (id <= 0) return BadRequest("Invalid target ID specified.");
    return Ok(new { Status = "Online", Code = 200 });
}

// Building custom action filters handling horizontal security concerns
public class LogActionFilter : IActionFilter {
    public void OnActionExecuting(ActionExecutingContext context) {
        Console.WriteLine($"Initiating Action: {context.ActionDescriptor.DisplayName}");
    }
    public void OnActionExecuted(ActionExecutedContext context) {}
}

// Bundle dynamic assets to reduce browser HTTP handshake limits
// ScriptBundle consolidates files while minimizing Whitespace and Comments
var scriptBundle = new ScriptBundle("~/bundles/corejs")
    .Include("~/Scripts/jquery-{version}.js", "~/Scripts/bootstrap.js");

// Fully fledged REST API controller configurations
[ApiController]
[Route("api/[controller]")]
public class InventoryController : ControllerBase {
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id) => Ok(new { ProductId = id });
}

// Dynamic server push real-time client sync hubs using SignalR
public class SystemAlertHub : Hub {
    public async Task BroadcastAlert(string message) {
        await Clients.All.SendAsync("ReceiveAlert", message);
    }
}

// Complete secure user database schema handling using Microsoft Identity
builder.Services.AddDefaultIdentity<IdentityUser>(options => {
    options.Password.RequiredLength = 8;
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
}).AddEntityFrameworkStores<ApplicationDbContext>();

// Sequence order of middleware layers inside the pipeline
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseCors("AllowAll");
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();

// Configuring Kestrel microserver listening sockets in Program.cs
builder.WebHost.ConfigureKestrel(serverOptions => {
    serverOptions.ListenAnyIP(5001, listenOptions => {
        listenOptions.UseHttps(); // Secure SSL bindings
    });
});

// Standard REST structural mappings matching standard CRUD verbs
// GET    -> api/users      (Retrieve collections)
// POST   -> api/users      (Create record payload)
// PUT    -> api/users/{id} (Update record parameters)
// DELETE -> api/users/{id} (Destroy targeted key)

// Creating structural JSON Web Tokens (JWT) inside backend authentication servers
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes("SuperSecretSecureKey123_DoNotDisclose");
var tokenDescriptor = new SecurityTokenDescriptor {
    Subject = new ClaimsIdentity(new[] { new Claim("id", "101") }),
    Expires = DateTime.UtcNow.AddHours(2),
    SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);

// Centralized HTTP client configurations interfacing internal microservice APIs
builder.Services.AddHttpClient("BillingService", client => {
    client.BaseAddress = new Uri("https://billing.internal.local/");
    client.DefaultRequestHeaders.Add("Accept", "application/json");
});

// Handling I/O operations non-blockingly via asynchronous threads
public async Task<IActionResult> FetchRecordsAsync() {
    var data = await _dbContext.Users.ToListAsync(); // Releases work process thread during database wait
    return Ok(data);
}

// Explicit service registration lifetimes in DI container builds
builder.Services.AddSingleton<ICacheService, MemoryCacheService>(); // Single global instance
builder.Services.AddScoped<IOrderService, OrderService>();         // Recreated per HTTP request context
builder.Services.AddTransient<ITransactionId, GuidGenerator>();     // Recreated on every injection point

// Configuring dynamic Cross-Origin Resource Sharing (CORS) rules securely
builder.Services.AddCors(options => {
    options.AddPolicy("AllowSpecificApp", policy => {
        policy.WithOrigins("https://dashboard.company.com")
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

// Automated interactive API endpoint schema generators (Swagger)
builder.Services.AddSwaggerGen();
// ...
if (app.Environment.IsDevelopment()) {
    app.UseSwagger();
    app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "Core API v1"));
}

// Centralized logging infrastructure configurations in controllers
private readonly ILogger<PaymentController> _logger;
public PaymentController(ILogger<PaymentController> logger) {
    _logger = logger;
}
public IActionResult ProcessPayment() {
    _logger.LogInformation("Payment sequence initiated dynamically.");
    return Ok();
}

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase {
    [HttpGet]
    public IActionResult GetUser() {
        return Ok(new { Name = "Akash", Role = "Administrator" });
    }
}

@model WebApp.Models.UserModel

<div className="profile-wrapper">
    <h1>Welcome, @Model.Name!</h1>
    <p>Account Status: @(Model.IsActive ? "Active" : "Suspended")</p>
</div>

// Configuring attribute route configurations within standard controllers
[HttpGet("api/v1/departments/{deptId:int}/employees")]
public IActionResult GetEmployeesByDepartment(int deptId) {
    return Ok($"Returning employees matching dept: {deptId}");
}

public interface IService {
    string GetServiceData();
}

public class BusinessController : ControllerBase {
    private readonly IService _service;
    
    // Dependency Injection resolves the service instance automatically on initialization
    public BusinessController(IService service) {
        _service = service;
    }
}

[HttpGet("{id}")]
public async Task<ActionResult<Product>> GetProductById(int id) {
    var product = await _dbContext.Products.FindAsync(id);
    if (product == null) {
        return NotFound(new { Message = "Target item not registered." });
    }
    return Ok(product);
}

// Writing and retrieving operational session properties
HttpContext.Session.SetString("name", "AK");
var cachedSessionUser = HttpContext.Session.GetString("name");

try {
    var result = _paymentService.ProcessTransaction(payload);
}
catch (PaymentDeclinedException ex) {
    _logger.LogWarning(ex, "Declined transaction processing sequence.");
    return BadRequest(ex.Message);
}
catch (Exception ex) {
    _logger.LogError(ex, "Unexpected crash inside the transaction processor.");
    throw;
}

public class SimpleCustomMiddleware {
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context) {
        // Run logic prior to executing down nested steps
        context.Response.Headers.Add("X-Execution-Engine", "ASP.NET Core");
        await _next(context);
    }
}

// Programmatic configurations mappings inside core app pipelines
var databaseConnectionString = Configuration.GetConnectionString("DefaultConnection");
var thirdPartyApiKey = Configuration["ApiKeys:ExternalProvider"];

// Program.cs setup configuration settings
builder.Services.AddCors(options => {
    options.AddPolicy("AllowDashboard", p => p.WithOrigins("https://dash.com").AllowAnyMethod());
});

var app = builder.Build();
app.UseCors("AllowDashboard");

// Entity Framework Core – Code First approach
public class AppDbContext : DbContext {
    public DbSet<Product> Products { get; set; }
    public DbSet<Order> Orders { get; set; }
}

// Using DbContext in a controller
public class ProductsController : ControllerBase {
    private readonly AppDbContext _db;
    public ProductsController(AppDbContext db) => _db = db;

    [HttpGet]
    public async Task<IActionResult> Get() {
        return Ok(await _db.Products.ToListAsync());
    }
}

// Dapper – lightweight micro-ORM
using Dapper;
public class ProductRepo {
    private readonly IDbConnection _conn;
    public ProductRepo(IConfiguration config) {
        _conn = new SqlConnection(config.GetConnectionString("Default"));
    }
    public async Task<IEnumerable<Product>> GetProducts() {
        return await _conn.QueryAsync<Product>("SELECT * FROM Products");
    }
}

// Background service using IHostedService
public class TimedBackgroundService : IHostedService, IDisposable {
    private Timer _timer;
    public Task StartAsync(CancellationToken cancellationToken) {
        _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromMinutes(5));
        return Task.CompletedTask;
    }
    private void DoWork(object state) {
        // Background logic
    }
    public Task StopAsync(CancellationToken cancellationToken) {
        _timer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }
    public void Dispose() => _timer?.Dispose();
}

// Health Checks – /health endpoint
builder.Services.AddHealthChecks()
    .AddDbContextCheck<AppDbContext>()
    .AddUrlGroup(new Uri("https://api.external.com"), "External API");

app.MapHealthChecks("/health", new HealthCheckOptions {
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

// Response Compression – reduce payload size
builder.Services.AddResponseCompression(options => {
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
    options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
        new[] { "image/svg+xml" });
});

app.UseResponseCompression();

// Distributed Caching with Redis
builder.Services.AddStackExchangeRedisCache(options => {
    options.Configuration = "localhost:6379";
    options.InstanceName = "SampleInstance";
});

// In a controller
public class CacheController : ControllerBase {
    private readonly IDistributedCache _cache;
    public CacheController(IDistributedCache cache) => _cache = cache;

    public async Task SetAsync(string key, string value) {
        await _cache.SetStringAsync(key, value);
    }
}

// Rate Limiting (using AspNetCoreRateLimit)
builder.Services.AddMemoryCache();
builder.Services.AddInMemoryRateLimiting();
builder.Services.Configure<IpRateLimitOptions>(options => {
    options.GeneralRules = new List<RateLimitRule> {
        new RateLimitRule {
            Endpoint = "*",
            Limit = 100,
            Period = "1m"
        }
    };
});
builder.Services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();

// API Versioning
builder.Services.AddApiVersioning(options => {
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ReportApiVersions = true;
});

[ApiVersion("1.0")]
[ApiController]
[Route("api/v{version:apiVersion}/[controller]")]
public class ProductsController : ControllerBase { }

// Globalization and Localization
builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");
builder.Services.Configure<RequestLocalizationOptions>(options => {
    var supportedCultures = new[] { new CultureInfo("en"), new CultureInfo("es") };
    options.DefaultRequestCulture = new RequestCulture("en");
    options.SupportedCultures = supportedCultures;
    options.SupportedUICultures = supportedCultures;
});

app.UseRequestLocalization();

// SignalR Advanced – Groups
public class ChatHub : Hub {
    public async Task JoinGroup(string groupName) {
        await Groups.AddToGroupAsync(Context.ConnectionId, groupName);
    }
    public async Task SendToGroup(string groupName, string message) {
        await Clients.Group(groupName).SendAsync("ReceiveMessage", message);
    }
}

// Blazor WebAssembly – Program.cs
builder.RootComponents.Add<App>("#app");
builder.RootComponents.Add<HeadOutlet>("head::after");

builder.Services.AddScoped(sp => new HttpClient {
    BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});

await builder.Build().RunAsync();

// Blazor Server – Startup configuration
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();

app.MapBlazorHub();
app.MapFallbackToPage("/_Host");

// Razor Pages – Page Model
public class ContactModel : PageModel {
    [BindProperty]
    public ContactForm Input { get; set; }
    public void OnGet() { }
    public async Task<IActionResult> OnPostAsync() {
        if (!ModelState.IsValid) return Page();
        // Process form
        return RedirectToPage("Success");
    }
}

// Tag Helpers – built-in and custom
<input asp-for="User.Email" class="form-control" />
<label asp-for="User.Email"></label>

// Custom Tag Helper
[HtmlTargetElement("email")]
public class EmailTagHelper : TagHelper {
    public override void Process(TagHelperContext context, TagHelperOutput output) {
        output.TagName = "a";
        output.Attributes.SetAttribute("href", "mailto:test@example.com");
    }
}

// View Components
public class UserListViewComponent : ViewComponent {
    private readonly AppDbContext _db;
    public UserListViewComponent(AppDbContext db) => _db = db;
    public async Task<IViewComponentResult> InvokeAsync(int count) {
        var users = await _db.Users.Take(count).ToListAsync();
        return View(users);
    }
}

// In View
@await Component.InvokeAsync("UserList", new { count = 5 })

// Custom Model Binder
public class CustomModelBinder : IModelBinder {
    public Task BindModelAsync(ModelBindingContext bindingContext) {
        var value = bindingContext.ValueProvider.GetValue("id").FirstValue;
        // Custom logic
        bindingContext.Result = ModelBindingResult.Success(int.Parse(value));
        return Task.CompletedTask;
    }
}

// Usage
public IActionResult Get([ModelBinder(BinderType = typeof(CustomModelBinder))] int id)

// Custom Validator
public class CustomValidator : ValidationAttribute {
    protected override ValidationResult IsValid(object value, ValidationContext context) {
        if (value == null) return new ValidationResult("Field is required");
        // Custom logic
        return ValidationResult.Success;
    }
}

// Model property
[CustomValidator]
public string Name { get; set; }

// Exception Filter
public class CustomExceptionFilter : IExceptionFilter {
    private readonly ILogger<CustomExceptionFilter> _logger;
    public CustomExceptionFilter(ILogger<CustomExceptionFilter> logger) => _logger = logger;

    public void OnException(ExceptionContext context) {
        _logger.LogError(context.Exception, "Unhandled exception");
        context.Result = new ObjectResult("Internal Server Error") {
            StatusCode = 500
        };
        context.ExceptionHandled = true;
    }
}

// Register globally
builder.Services.AddControllers(options => {
    options.Filters.Add<CustomExceptionFilter>();
});

// Result Filter – modify response after execution
public class CustomResultFilter : IResultFilter {
    public void OnResultExecuting(ResultExecutingContext context) {
        // Before result executed
    }
    public void OnResultExecuted(ResultExecutedContext context) {
        // After result executed
    }
}

// Authorization Filter – check permissions
public class CustomAuthFilter : IAuthorizationFilter {
    public void OnAuthorization(AuthorizationFilterContext context) {
        if (!context.HttpContext.User.Identity.IsAuthenticated) {
            context.Result = new UnauthorizedResult();
        }
    }
}

// Action Filter – before/after action method
public class CustomActionFilter : IActionFilter {
    public void OnActionExecuting(ActionExecutingContext context) {
        // Before action executes
    }
    public void OnActionExecuted(ActionExecutedContext context) {
        // After action executes
    }
}

// Resource Filter – wraps everything (model binding, action, result)
public class CustomResourceFilter : IResourceFilter {
    public void OnResourceExecuting(ResourceExecutingContext context) { }
    public void OnResourceExecuted(ResourceExecutedContext context) { }
}

// Middleware vs Filters – conceptual difference
// Middleware: global pipeline, runs for every request
// Filters: scoped to controllers/actions, have access to MVC context
// Use middleware for cross-cutting concerns (auth, logging, compression)
// Use filters for action-specific logic (validation, caching, exception handling)

// HTTPS enforcement
app.UseHttpsRedirection();

// Or globally in Program.cs
builder.Services.AddHttpsRedirection(options => {
    options.RedirectStatusCode = StatusCodes.Status307TemporaryRedirect;
    options.HttpsPort = 5001;
});

// Anti-CSRF protection in Razor
@Html.AntiForgeryToken()

// In controller
[ValidateAntiForgeryToken]
[HttpPost]
public IActionResult Submit(FormModel model) { }

// XSS Prevention – automatic encoding in Razor
@Html.Raw("<script>alert('XSS')</script>") // Danger – avoid
// Use @ for automatic encoding
@Model.UserInput // Encoded by default

// In code
var encoded = System.Text.Encodings.Web.HtmlEncoder.Default.Encode(userInput);

// Advanced CORS – with credentials and preflight
builder.Services.AddCors(options => {
    options.AddPolicy("AllowCredentials", policy => {
        policy.WithOrigins("https://client.com")
              .AllowCredentials()
              .AllowAnyHeader()
              .AllowAnyMethod()
              .SetPreflightMaxAge(TimeSpan.FromMinutes(10));
    });
});

// JWT Authentication – validation setup
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => {
        options.TokenValidationParameters = new TokenValidationParameters {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("MySecretKey")),
            ValidateIssuer = false,
            ValidateAudience = false
        };
    });

// OAuth 2.0 / OpenID Connect
builder.Services.AddAuthentication(options => {
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
})
.AddCookie()
.AddOpenIdConnect(options => {
    options.Authority = "https://identity.example.com";
    options.ClientId = "aspnet_client";
    options.ClientSecret = "secret";
    options.ResponseType = "code";
    options.Scope.Add("openid");
    options.Scope.Add("profile");
});

// Multi-Factor Authentication (MFA) – two-factor with TOTP
// In Identity configuration
builder.Services.Configure<IdentityOptions>(options => {
    options.Tokens.AuthenticatorTokenProvider = "Authenticator";
});

// Enable 2FA in login flow
var user = await _userManager.FindByNameAsync(username);
if (await _userManager.GetTwoFactorEnabledAsync(user)) {
    // Redirect to MFA verification
}

// Logging with Serilog
builder.Host.UseSerilog((context, config) => {
    config.ReadFrom.Configuration(context.Configuration);
});

// In appsettings.json
{
  "Serilog": {
    "MinimumLevel": "Information",
    "WriteTo": [
      { "Name": "File", "Args": { "path": "logs/log.txt" } }
    ]
  }
}

// Application Insights – telemetry
builder.Services.AddApplicationInsightsTelemetry();

// In controller
public IActionResult Get() {
    var telemetry = new TelemetryClient(new TelemetryConfiguration());
    telemetry.TrackEvent("Get called");
    return Ok();
}

// Unit Testing with xUnit
public class ProductServiceTests {
    [Fact]
    public void Add_ShouldReturnTrue_WhenProductIsValid() {
        // Arrange
        var service = new ProductService();
        // Act
        var result = service.Add(new Product());
        // Assert
        Assert.True(result);
    }
}

// Integration Testing – WebApplicationFactory
public class IntegrationTests : IClassFixture<WebApplicationFactory<Program>> {
    private readonly WebApplicationFactory<Program> _factory;
    public IntegrationTests(WebApplicationFactory<Program> factory) => _factory = factory;

    [Fact]
    public async Task GetProducts_ReturnsOk() {
        var client = _factory.CreateClient();
        var response = await client.GetAsync("/api/products");
        response.EnsureSuccessStatusCode();
    }
}

// Mocking with Moq
public class MockTest {
    [Fact]
    public void Service_ShouldUseRepository() {
        var mockRepo = new Mock<IProductRepository>();
        mockRepo.Setup(r => r.GetAll()).Returns(new List<Product>());
        var service = new ProductService(mockRepo.Object);
        var result = service.GetAll();
        Assert.Empty(result);
    }
}

// In-Memory Database Testing (EF Core)
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseInMemoryDatabase("TestDb"));

// In tests
[Fact]
public void AddProduct_SavesToDatabase() {
    var options = new DbContextOptionsBuilder<AppDbContext>()
        .UseInMemoryDatabase(databaseName: "TestDb")
        .Options;
    using var context = new AppDbContext(options);
    context.Products.Add(new Product { Name = "Test" });
    context.SaveChanges();
    Assert.Equal(1, context.Products.Count());
}

// Docker Deployment – Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

// Azure App Service Deployment – using az CLI
az webapp up --name myapp --resource-group myrg --plan myplan --runtime "DOTNET|8.0"

// Using Azure DevOps YAML
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    arguments: '--configuration Release --output $(Build.ArtifactStagingDirectory)'
- task: AzureWebApp@1
  inputs:
    azureSubscription: 'my-connection'
    appName: 'myapp'
    package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

// IIS Deployment – web.config for IIS
<configuration>
  <system.webServer>
    <handlers>
      <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" resourceType="Unspecified" />
    </handlers>
    <aspNetCore processPath="dotnet" arguments=".MyApp.dll" stdoutLogEnabled="true" stdoutLogFile=".logsstdout" />
  </system.webServer>
</configuration>

// Performance Profiling – using BenchmarkDotNet
[MemoryDiagnoser]
public class MyBenchmark {
    [Benchmark]
    public void MethodA() { }

    [Benchmark]
    public void MethodB() { }
}

// Run: dotnet run -c Release --filter *MyBenchmark*

// Memory Management – dispose pattern
public class ResourceHolder : IDisposable {
    private bool _disposed;
    private Stream _stream;

    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    protected virtual void Dispose(bool disposing) {
        if (!_disposed) {
            if (disposing) {
                _stream?.Dispose();
            }
            _disposed = true;
        }
    }
}

// Connection Pooling – default in ADO.NET
// Use standard patterns
using (var conn = new SqlConnection(connectionString)) {
    await conn.OpenAsync();
    // Operations
}

// Pool size can be adjusted in connection string:
// "Server=.;Database=MyDb;Pooling=True;Min Pool Size=5;Max Pool Size=100;"

// gRPC Services – setup
builder.Services.AddGrpc();

app.MapGrpcService<GreeterService>();

public class GreeterService : Greeter.GreeterBase {
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context) {
        return Task.FromResult(new HelloReply { Message = "Hello " + request.Name });
    }
}

// GraphQL with Hot Chocolate – schema
builder.Services.AddGraphQLServer()
    .AddQueryType<Query>();

public class Query {
    public IQueryable<Product> GetProducts([Service] AppDbContext db) => db.Products;
}

// Endpoint: /graphql

// WebSockets – using WebSocketManager
app.UseWebSockets();
app.Map("/ws", async context => {
    if (context.WebSockets.IsWebSocketRequest) {
        var socket = await context.WebSockets.AcceptWebSocketAsync();
        // Handle WebSocket
    }
});

// Real-Time Dashboards – using SignalR
public class DashboardHub : Hub {
    public async Task SubscribeToUpdates(string dashboardId) {
        await Groups.AddToGroupAsync(Context.ConnectionId, dashboardId);
    }
}

// Server-side push
await _hubContext.Clients.Group(dashboardId).SendAsync("UpdateData", data);

// Background Task Scheduling – using Quartz.NET
builder.Services.AddQuartz(q => {
    q.ScheduleJob<MyJob>(trigger => trigger
        .WithIdentity("MyJob")
        .WithCronSchedule("0 0/5 * * * ?")
    );
});
builder.Services.AddQuartzHostedService();

public class MyJob : IJob {
    public Task Execute(IJobExecutionContext context) { /* work */ }
}

// Environment Configuration
var env = builder.Environment;

if (env.IsDevelopment()) { /* dev settings */ }
if (env.IsProduction()) { /* prod settings */ }

// appsettings.Development.json will override default values
var config = builder.Configuration;
var dbConn = config.GetConnectionString("Default");

// Feature Flags – using Microsoft.FeatureManagement
builder.Services.AddFeatureManagement();

// In controller
[FeatureGate("NewFeature")]
public IActionResult NewFeature() { return View(); }

// In view
<feature name="NewFeature">
    <p>New feature content</p>
</feature>

// Minimal APIs – simplified endpoint
var app = builder.Build();

app.MapGet("/", () => "Hello Minimal API");
app.MapPost("/products", (Product product) => Results.Created($"/products/{product.Id}", product));

app.Run();