Runtime Execution Comparison:

// .NET Core application assembly reference
// References are granular NuGet packages
{
  "dependencies": {
    "Microsoft.NETCore.App": {
      "version": "6.0.0",
      "type": "platform"
    },
    "Microsoft.AspNetCore.App": {
      "version": "6.0.0"
    }
  }
}

// .NET Framework assembly reference
// References the entire framework
<Reference Include="System" />
<Reference Include="System.Web" />
        

Platform-Specific Code Implementation:

// Platform-specific code with seamless fallbacks
public string GetOSSpecificTempPath()
{
    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        return Environment.GetEnvironmentVariable("TEMP");
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || 
             RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
    {
        return "/tmp";
    }
    
    // Generic fallback
    return Path.GetTempPath();
}
        

Docker Container Optimization:

# Multi-stage build pattern leveraging cross-platform capabilities
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]
        

Advanced Project Creation Examples:

# Create an ASP.NET Core Web API targeting .NET 6.0
dotnet new webapi -n MyApiProject -f net6.0

# Create a class library with a specific output directory
dotnet new classlib -n CoreLibrary -o ./src/Libraries/CoreLib

# Create a solution file
dotnet new sln -n MySolution

# Add projects to a solution
dotnet sln MySolution.sln add ./src/MyProject/MyProject.csproj

# Create a project with specific language version
dotnet new console -n ModernApp --langVersion 10.0
        

Modern Program.cs (NET 6+):

using Microsoft.AspNetCore.Builder;

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure middleware
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();
        

CI/CD Pipeline Example:

#!/bin/bash
# Example CI/CD build script with optimizations

# Restore with locked dependencies
dotnet restore --locked-mode

# Build with deterministic outputs for reproducibility
dotnet build -c Release /p:ContinuousIntegrationBuild=true /p:EmbedUntrackedSources=true

# Run tests with coverage
dotnet test --no-build -c Release --collect:"XPlat Code Coverage"

# Create optimized single-file deployment
dotnet publish -c Release -r linux-x64 --self-contained true /p:PublishTrimmed=true /p:PublishSingleFile=true
        

Project File Integration:

<Project Sdk="Microsoft.NET.Sdk.Web">
    <PropertyGroup>
        <TargetFramework>net6.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    
    <ItemGroup>
        <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.5" />
        <PackageReference Include="Serilog.AspNetCore" Version="5.0.0" />
    </ItemGroup>
</Project>
        

Central Package Management Example:

<!-- Directory.Packages.props -->
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="6.0.5" />
    <PackageVersion Include="Serilog.AspNetCore" Version="5.0.0" />
  </ItemGroup>
</Project>

<!-- Individual project file now just references package without version -->
<ItemGroup>
  <PackageReference Include="Microsoft.EntityFrameworkCore" />
</ItemGroup>
        

Advanced Package Addition:

# Adding with version constraints (floating versions)
dotnet add package Microsoft.EntityFrameworkCore --version "6.0.*"

# Adding to a specific project in a solution
dotnet add ./src/MyProject/MyProject.csproj package Serilog

# Adding from a specific source
dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer --source https://api.nuget.org/v3/index.json

# Adding prerelease versions
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 7.0.0-preview.5.22302.2

# Adding with framework-specific dependencies
dotnet add package Newtonsoft.Json --framework net6.0
        

Listing Packages:

# List installed packages
dotnet list package

# Check for outdated packages
dotnet list package --outdated

# Check for vulnerable packages
dotnet list package --vulnerable

# Format output as JSON for further processing
dotnet list package --outdated --format json
        

Package Removal:

# Remove from all target frameworks
dotnet remove package Newtonsoft.Json

# Remove from specific project
dotnet remove ./src/MyProject/MyProject.csproj package Microsoft.EntityFrameworkCore

# Remove from specific framework
dotnet remove package Serilog --framework net6.0
        

Package Management:

# Install package with specific version
Install-Package Microsoft.AspNetCore.Authentication.JwtBearer -Version 6.0.5

# Install prerelease package
Install-Package Microsoft.EntityFrameworkCore -Pre

# Update package
Update-Package Newtonsoft.Json

# Update all packages in solution
Update-Package

# Uninstall package
Uninstall-Package Serilog

# Installing to specific project in a solution
Install-Package Npgsql.EntityFrameworkCore.PostgreSQL -ProjectName MyProject.Data
        

Advanced PackageReference Options:

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
  </PropertyGroup>
  
  <ItemGroup>
    <!-- Basic package reference -->
    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    
    <!-- Floating version (latest minor/patch) -->
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.*" />
    
    <!-- Private assets (not exposed to dependent projects) -->
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" PrivateAssets="all" />
    
    <!-- Conditional package reference -->
    <PackageReference Include="Microsoft.Windows.Compatibility" Version="6.0.0" Condition="'$(OS)' == 'Windows_NT'" />
    
    <!-- Package with specific assets -->
    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
    
    <!-- Version range -->
    <PackageReference Include="Serilog" Version="[2.10.0,3.0.0)" />
  </ItemGroup>
</Project>
        

Package Locking:

# Generate lock file 
dotnet restore --use-lock-file

# Force update lock file even if packages seem up-to-date
dotnet restore --force-evaluate
        

Central Package Management:

<!-- Directory.Packages.props at solution root -->
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
    <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.5" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="6.0.5" />
    <PackageVersion Include="Serilog.AspNetCore" Version="5.0.0" />
  </ItemGroup>
</Project>
        

Manual Configuration Setup:

// Program.cs in a .NET Core application
var builder = WebApplication.CreateBuilder(args);

// Adding configuration sources manually
builder.Configuration.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true)
    .AddEnvironmentVariables()
    .AddCommandLine(args);

// The configuration is automatically added to the DI container
var app = builder.Build();
        

Explicitly Configuring Providers:

var builder = WebApplication.CreateBuilder(args);

// Configure the host with explicit configuration providers
builder.Configuration.Sources.Clear(); // Remove default sources if needed
builder.Configuration
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true, reloadOnChange: true)
    .AddXmlFile("settings.xml", optional: true)
    .AddIniFile("config.ini", optional: true)
    .AddEnvironmentVariables()
    .AddCommandLine(args);

// Custom prefix for environment variables
builder.Configuration.AddEnvironmentVariables(prefix: "MYAPP_");

// Add user secrets in development
if (builder.Environment.IsDevelopment())
{
    builder.Configuration.AddUserSecrets<Program>();
}
        

Implementation Example:

// Service interfaces
public interface IOrderRepository
{
    Task<bool> SaveOrder(Order order);
}

public interface INotificationService
{
    Task NotifyCustomer(string customerId, string message);
}

// Service implementation with injected dependencies
public class OrderService : IOrderService
{
    private readonly IOrderRepository _repository;
    private readonly INotificationService _notificationService;
    private readonly ILogger<OrderService> _logger;
    
    public OrderService(
        IOrderRepository repository,
        INotificationService notificationService,
        ILogger<OrderService> logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _notificationService = notificationService ?? throw new ArgumentNullException(nameof(notificationService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
    
    public async Task ProcessOrderAsync(Order order)
    {
        _logger.LogInformation("Processing order {OrderId}", order.Id);
        
        await _repository.SaveOrder(order);
        await _notificationService.NotifyCustomer(order.CustomerId, "Your order has been processed");
    }
}

// Registration in Program.cs (for .NET 6+)
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddSingleton<INotificationService, EmailNotificationService>();
builder.Services.AddScoped<IOrderService, OrderService>();
        

Basic Registration Patterns:

// Type-based registration
services.AddTransient<IService, ServiceImplementation>();
services.AddScoped<IRepository, SqlRepository>();
services.AddSingleton<ICacheProvider, RedisCacheProvider>();

// Instance-based registration
var instance = new SingletonService();
services.AddSingleton<ISingletonService>(instance);

// Factory-based registration
services.AddTransient<IConfiguredService>(sp => {
    var config = sp.GetRequiredService<IConfiguration>();
    return new ConfiguredService(config["ServiceKey"]);
});

// Open generic registrations
services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));

// Multiple implementations of the same interface
services.AddTransient<IValidator, CustomerValidator>();
services.AddTransient<IValidator, OrderValidator>();
// Inject as IEnumerable<IValidator> to get all implementations
        

Core Resolution Techniques:

// 1. Constructor Injection (preferred)
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly ILogger<OrderService> _logger;
    
    public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
}

// 2. Service Location (avoid when possible, use judiciously)
public void SomeMethod(IServiceProvider serviceProvider)
{
    var service = serviceProvider.GetService<IMyService>(); // May return null
    var requiredService = serviceProvider.GetRequiredService<IMyService>(); // Throws if not registered
}

// 3. Explicit Activation via ActivatorUtilities
public static T CreateInstance<T>(IServiceProvider provider, params object[] parameters)
{
    return ActivatorUtilities.CreateInstance<T>(provider, parameters);
}

// 4. Action Injection in ASP.NET Core
public IActionResult MyAction([FromServices] IMyService service)
{
    // Use the injected service
}
        

Registration Extensions and Options:

// With configuration options
services.AddDbContext<ApplicationDbContext>(options => 
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

// Try-Add pattern (only registers if not already registered)
services.TryAddSingleton<IEmailSender, SmtpEmailSender>();

// Replace existing registrations
services.Replace(ServiceDescriptor.Singleton<IEmailSender, MockEmailSender>());

// Decorators pattern
services.AddSingleton<IMailService, MailService>();
services.Decorate<IMailService, CachingMailServiceDecorator>();
services.Decorate<IMailService, LoggingMailServiceDecorator>();

// Register with key (requires third-party extensions)
services.AddKeyedSingleton<IEmailProvider, SmtpEmailProvider>("smtp");
services.AddKeyedSingleton<IEmailProvider, SendGridProvider>("sendgrid");
        

Working with DI Scopes:

// Creating a scope (for background services or singletons that need scoped services)
public class BackgroundWorker : BackgroundService
{
    private readonly IServiceProvider _services;
    
    public BackgroundWorker(IServiceProvider services)
    {
        _services = services;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Create scope to access scoped services from a singleton
            using (var scope = _services.CreateScope())
            {
                var scopedProcessor = scope.ServiceProvider.GetRequiredService<IScopedProcessor>();
                await scopedProcessor.ProcessAsync(stoppingToken);
            }
            
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
}
        

Architectural Evolution Example - Startup Configuration:

// ASP.NET 4.x - Global.asax.cs
public class Global : HttpApplication
{
    protected void Application_Start()
    {
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        // Other configurations
    }
}

// ASP.NET Core 3.x - Startup.cs
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        // Other service registrations
    }
    
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints => {
            endpoints.MapControllers();
        });
    }
}

// ASP.NET Core 6.0+ - Minimal API in Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

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

app.Run();
        

Technical Implementation Comparison:

// ASP.NET Web Forms - Page Code-behind
public partial class ProductPage : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            ProductGrid.DataSource = GetProducts();
            ProductGrid.DataBind();
        }
    }

    protected void SaveButton_Click(object sender, EventArgs e)
    {
        // Handle button click event
    }
}

// ASP.NET MVC - Controller
public class ProductController : Controller
{
    private readonly IProductRepository _repository;
    
    public ProductController(IProductRepository repository)
    {
        _repository = repository;
    }
    
    public ActionResult Index()
    {
        var products = _repository.GetAll();
        return View(products);
    }
    
    [HttpPost]
    public ActionResult Save(ProductViewModel model)
    {
        if (ModelState.IsValid)
        {
            // Save product
            return RedirectToAction("Index");
        }
        return View(model);
    }
}

// ASP.NET Core - Controller with Dependency Injection
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductService _productService;
    private readonly ILogger _logger;
    
    public ProductsController(
        IProductService productService,
        ILogger logger)
    {
        _productService = productService;
        _logger = logger;
    }
    
    [HttpGet]
    public async Task>> GetProducts()
    {
        _logger.LogInformation("Getting all products");
        return await _productService.GetAllAsync();
    }
    
    [HttpPost]
    public async Task> CreateProduct(ProductDto productDto)
    {
        var product = await _productService.CreateAsync(productDto);
        return CreatedAtAction(
            nameof(GetProduct),
            new { id = product.Id },
            product);
    }
}
        

Core Framework Components:

• Routing Engine: Maps URL patterns to controller actions through route templates defined in RouteConfig.cs or via attribute routing
• Controller Factory: Responsible for instantiating controller classes
• Action Invoker: Executes the appropriate action method on the controller
• Model Binder: Converts HTTP request data to strongly-typed parameters for action methods
• View Engine: Razor is the default view engine that processes .cshtml files
• Filter Pipeline: Provides hooks for cross-cutting concerns like authentication, authorization, and exception handling

Implementation Example:

A more comprehensive implementation example:

// Model
public class Product
{
    public int Id { get; set; }
    
    [Required]
    [StringLength(100)]
    public string Name { get; set; }
    
    [Range(0.01, 10000)]
    public decimal Price { get; set; }
}

// Controller
public class ProductsController : Controller
{
    private readonly IProductRepository _repository;
    
    public ProductsController(IProductRepository repository)
    {
        _repository = repository;
    }
    
    // GET: /Products/
    [HttpGet]
    public ActionResult Index()
    {
        var products = _repository.GetAll();
        return View(products);
    }
    
    // GET: /Products/Details/5
    [HttpGet]
    public ActionResult Details(int id)
    {
        var product = _repository.GetById(id);
        if (product == null)
            return NotFound();
            
        return View(product);
    }
    
    // POST: /Products/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public ActionResult Create(Product product)
    {
        if (ModelState.IsValid)
        {
            _repository.Add(product);
            return RedirectToAction(nameof(Index));
        }
        return View(product);
    }
}
        

Models:

Models in ASP.NET MVC serve multiple purposes within the application architecture:

• Domain Models: Represent the core business entities and encapsulate business rules and validation logic
• View Models: Specialized models designed specifically for view consumption that may combine multiple domain models
• Input Models: Models designed to capture and validate user input (often using Data Annotations)
• Repository/Service Layer: Often included as part of the broader model concept, handling data access and manipulation

// Domain Model with validation
public class Product
{
    public int Id { get; set; }
    
    [Required, StringLength(100)]
    public string Name { get; set; }
    
    [Range(0.01, 10000)]
    [DataType(DataType.Currency)]
    public decimal Price { get; set; }
    
    [Display(Name = "In Stock")]
    public bool IsAvailable { get; set; }
    
    public int CategoryId { get; set; }
    public virtual Category Category { get; set; }
    
    // Domain logic
    public bool IsOnSale()
    {
        // Business rule implementation
        return Price < Category.AveragePrice * 0.9m;
    }
}

// View Model
public class ProductDetailsViewModel
{
    public Product Product { get; set; }
    public List<Review> Reviews { get; set; }
    public List<Product> RelatedProducts { get; set; }
    public bool UserCanReview { get; set; }
}
        

Views:

Views in ASP.NET MVC handle presentation concerns through several key mechanisms:

• Razor Syntax: Combines C# and HTML in .cshtml files with a focus on view-specific code
• View Layouts: Master templates using _Layout.cshtml files to provide consistent UI structure
• Partial Views: Reusable UI components that can be rendered within other views
• View Components: Self-contained, reusable UI components with their own logic (in newer versions)
• HTML Helpers and Tag Helpers: Methods that generate HTML markup based on model properties

@model ProductDetailsViewModel

@{
    ViewBag.Title = $"Product: {@Model.Product.Name}";
    Layout = "~/Views/Shared/_Layout.cshtml";
}

<div class="product-detail">
    <h2>@Model.Product.Name</h2>
    
    <div class="price @(Model.Product.IsOnSale() ? "on-sale" : "")">
        @Model.Product.Price.ToString("C")
        @if (Model.Product.IsOnSale())
        {
            <span class="sale-badge">On Sale!</span>
        }
    </div>
    
    <div class="availability">
        @if (Model.Product.IsAvailable)
        {
            <span class="in-stock">In Stock</span>
        }
        else
        {
            <span class="out-of-stock">Out of Stock</span>
        }
    </div>
    
    @* Partial view for reviews *@
    @await Html.PartialAsync("_ProductReviews", Model.Reviews)
    
    @* View Component for related products *@
    @await Component.InvokeAsync("RelatedProducts", new { productId = Model.Product.Id })
    
    @if (Model.UserCanReview)
    {
        <a asp-action="AddReview" asp-route-id="@Model.Product.Id" class="btn btn-primary">
            Write a Review
        </a>
    }
</div>
        

Controllers:

Controllers in ASP.NET MVC orchestrate the application flow with several key responsibilities:

• Route Handling: Map URL patterns to specific action methods
• HTTP Method Handling: Process different HTTP verbs (GET, POST, etc.)
• Model Binding: Convert HTTP request data to strongly-typed parameters
• Action Filters: Apply cross-cutting concerns like authentication or logging
• Result Generation: Return appropriate ActionResult types (View, JsonResult, etc.)
• Error Handling: Manage exceptions and appropriate responses

[Authorize]
public class ProductsController : Controller
{
    private readonly IProductRepository _productRepository;
    private readonly IReviewRepository _reviewRepository;
    private readonly IUserService _userService;
    
    // Dependency injection
    public ProductsController(
        IProductRepository productRepository,
        IReviewRepository reviewRepository,
        IUserService userService)
    {
        _productRepository = productRepository;
        _reviewRepository = reviewRepository;
        _userService = userService;
    }
    
    // GET: /Products/Details/5
    [HttpGet]
    [Route("Products/{id:int}")]
    [OutputCache(Duration = 300, VaryByParam = "id")]
    public async Task<IActionResult> Details(int id)
    {
        try
        {
            var product = await _productRepository.GetByIdAsync(id);
            if (product == null)
            {
                return NotFound();
            }
            
            var viewModel = new ProductDetailsViewModel
            {
                Product = product,
                Reviews = await _reviewRepository.GetForProductAsync(id),
                RelatedProducts = await _productRepository.GetRelatedAsync(id),
                UserCanReview = await _userService.CanReviewProductAsync(User.Identity.Name, id)
            };
            
            return View(viewModel);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving product details for ID: {ProductId}", id);
            return StatusCode(500, "An error occurred while processing your request.");
        }
    }
    
    // POST: /Products/AddReview/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    [Route("Products/AddReview/{productId:int}")]
    public async Task<IActionResult> AddReview(int productId, ReviewInputModel reviewModel)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        
        try
        {
            // Map the input model to domain model
            var review = new Review
            {
                ProductId = productId,
                UserId = User.FindFirstValue(ClaimTypes.NameIdentifier),
                Rating = reviewModel.Rating,
                Comment = reviewModel.Comment,
                DateSubmitted = DateTime.UtcNow
            };
            
            await _reviewRepository.AddAsync(review);
            
            return RedirectToAction(nameof(Details), new { id = productId });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error adding review for product ID: {ProductId}", productId);
            ModelState.AddModelError("", "An error occurred while submitting your review.");
            return View(reviewModel);
        }
    }
}
        

// 1. Standard expression syntax
@Model.PropertyName

// 2. Implicit Razor expressions
@DateTime.Now

// 3. Explicit Razor expressions
@(Model.PropertyName + " - " + DateTime.Now.Year)

// 4. Code blocks
@{
    var greeting = "Hello";
    var name = Model.UserName ?? "Guest";
}

// 5. Conditional statements
@if (User.IsAuthenticated) {
    @Html.ActionLink("Logout", "Logout")
} else {
    @Html.ActionLink("Login", "Login")
}

// 6. Loops
@foreach (var product in Model.Products) {
    @await Html.PartialAsync("_ProductPartial", product)
}

// 7. Razor comments (not rendered to client)
@* This is a Razor comment *@

// 8. Tag Helpers (in newer ASP.NET versions)
<environment include="Development">
    <script src="~/lib/jquery/dist/jquery.js"></script>
</environment>
        

Detailed Route Configuration in ASP.NET MVC:

public class RouteConfig
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
        
        // Custom route with constraints
        routes.MapRoute(
            name: "ProductsRoute",
            url: "products/{category}/{id}",
            defaults: new { controller = "Products", action = "Details" },
            constraints: new { id = @"\d+", category = @"[a-z]+" }
        );
        
        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
        );
    }
}
        

ASP.NET Core Endpoint Configuration:

public void Configure(IApplicationBuilder app)
{
    app.UseRouting();
    
    // You can add middleware between routing and endpoint execution
    app.UseAuthentication();
    app.UseAuthorization();
    
    app.UseEndpoints(endpoints =>
    {
        // Attribute routing
        endpoints.MapControllers();
        
        // Convention-based routing
        endpoints.MapControllerRoute(
            name: "areas",
            pattern: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
            
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
            
        // Direct lambda routing
        endpoints.MapGet("/ping", async context => {
            await context.Response.WriteAsync("pong");
        });
    });
}
        

Route Template Parsing and Component Structure:

// ASP.NET Core route template parser internals (conceptual)
public class RouteTemplate
{
    public List<TemplatePart> Parts { get; }
    public List<TemplateParameter> Parameters { get; }
    
    // Internal structure generated when parsing a template like:
    // "api/products/{category}/{id:int?}"
    
    // Parts would contain:
    // - Literal: "api"
    // - Literal: "products"
    // - Parameter: "category"
    // - Parameter: "id" (with int constraint and optional flag)
    
    // Parameters collection would contain entries for "category" and "id"
}
        

Custom Constraint Implementation:

// Implementing a custom constraint in ASP.NET Core
public class EvenNumberConstraint : IRouteConstraint
{
    public bool Match(
        HttpContext httpContext, 
        IRouter route, 
        string routeKey, 
        RouteValueDictionary values, 
        RouteDirection routeDirection)
    {
        // Return false if value is missing or not an integer
        if (!values.TryGetValue(routeKey, out var value) || value == null)
            return false;
            
        // Parse the value to an integer
        if (int.TryParse(value.ToString(), out int intValue))
        {
            return intValue % 2 == 0; // Return true if even
        }
        
        return false; // Not an integer or not even
    }
}

// Registering the custom constraint
public void ConfigureServices(IServiceCollection services)
{
    services.AddRouting(options =>
    {
        options.ConstraintMap.Add("even", typeof(EvenNumberConstraint));
    });
}

// Using the custom constraint in a route
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "EvenProducts",
        pattern: "products/{id:even}",
        defaults: new { controller = "Products", action = "GetEven" }
    );
});
        

// Multiple constraints on a single parameter
"{id:int:min(1):max(100)}"

// Required parameter with regex constraint
"{code:required:regex(^[A-Z]{3}\\d{4}$)}"

// Custom constraint combined with built-in constraints
"{value:even:min(10)}"
        

// Custom parameter transformer for kebab-case URLs
public class KebabCaseParameterTransformer : IOutboundParameterTransformer
{
    public string TransformOutbound(object value)
    {
        if (value == null) return null;
        
        // Convert "ProductDetails" to "product-details"
        return Regex.Replace(
            value.ToString(),
            "([a-z])([A-Z])",
            "$1-$2").ToLower();
    }
}

// Applying the transformer globally
services.AddRouting(options =>
{
    options.ConstraintMap["kebab"] = typeof(KebabCaseParameterTransformer);
});
        

Custom Value Provider Implementation:

public class CookieValueProvider : IValueProvider
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    
    public CookieValueProvider(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }
    
    public bool ContainsPrefix(string prefix)
    {
        return _httpContextAccessor.HttpContext.Request.Cookies.Any(c => 
            c.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
    }
    
    public ValueProviderResult GetValue(string key)
    {
        if (_httpContextAccessor.HttpContext.Request.Cookies.TryGetValue(key, out string value))
        {
            return new ValueProviderResult(value);
        }
        return ValueProviderResult.None;
    }
}

// Registration in Startup.cs
services.AddControllers(options =>
{
    options.ValueProviderFactories.Add(new CookieValueProviderFactory());
});
        

Custom Model Binder Implementation:

public class DateTimeModelBinder : IModelBinder
{
    private readonly string _customFormat;
    
    public DateTimeModelBinder(string customFormat)
    {
        _customFormat = customFormat;
    }
    
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));
            
        // Get the value from the value provider
        var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (valueProviderResult == ValueProviderResult.None)
            return Task.CompletedTask;
            
        bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
        
        var value = valueProviderResult.FirstValue;
        if (string.IsNullOrEmpty(value))
            return Task.CompletedTask;
            
        if (!DateTime.TryParseExact(value, _customFormat, CultureInfo.InvariantCulture, 
                                   DateTimeStyles.None, out DateTime dateTimeValue))
        {
            bindingContext.ModelState.TryAddModelError(
                bindingContext.ModelName, 
                $"Could not parse {value} as a date time with format {_customFormat}");
            return Task.CompletedTask;
        }
        
        bindingContext.Result = ModelBindingResult.Success(dateTimeValue);
        return Task.CompletedTask;
    }
}

// Usage with attribute
public class EventViewModel
{
    public int Id { get; set; }
    
    [ModelBinder(BinderType = typeof(DateTimeModelBinder), BinderTypeArguments = new[] { "yyyy-MM-dd" })]
    public DateTime EventDate { get; set; }
}
        

Form Data Binding with Nested Properties:

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string ZipCode { get; set; }
}

public class CustomerViewModel
{
    public string Name { get; set; }
    public string Email { get; set; }
    public Address ShippingAddress { get; set; }
    public Address BillingAddress { get; set; }
}

// Action method
[HttpPost]
public IActionResult Create([FromForm] CustomerViewModel customer)
{
    // Form fields should be named:
    // Name, Email, 
    // ShippingAddress.Street, ShippingAddress.City, ShippingAddress.ZipCode
    // BillingAddress.Street, BillingAddress.City, BillingAddress.ZipCode
    
    return View(customer);
}
        

Binding Collections from Query Strings:

// URL: /products/filter?categories=1&categories=2&categories=3
public IActionResult Filter([FromQuery] int[] categories)
{
    // categories = [1, 2, 3]
    return View();
}

// For complex collections with indexing:
// URL: /order?items[0].ProductId=1&items[0].Quantity=2&items[1].ProductId=3&items[1].Quantity=1
public class OrderItem
{
    public int ProductId { get; set; }
    public int Quantity { get; set; }
}

public IActionResult Order([FromQuery] List items)
{
    // items contains two OrderItem objects
    return View();
}
        

public class CommaSeparatedArrayModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (valueProviderResult == ValueProviderResult.None)
        {
            return Task.CompletedTask;
        }

        bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
        
        var value = valueProviderResult.FirstValue;
        if (string.IsNullOrEmpty(value))
        {
            return Task.CompletedTask;
        }

        // Split the comma-separated string into an array
        var splitValues = value.Split(new[] { ',,' }, StringSplitOptions.RemoveEmptyEntries)
                              .Select(s => s.Trim())
                              .ToArray();
                              
        // Set the result
        bindingContext.Result = ModelBindingResult.Success(splitValues);
        return Task.CompletedTask;
    }
}

// Usage with provider
public class CommaSeparatedArrayModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType == typeof(string[]) && 
            context.BindingInfo.BinderMetadata is CommaSeparatedArrayAttribute)
        {
            return new CommaSeparatedArrayModelBinder();
        }
        
        return null;
    }
}

// Custom attribute to trigger the binder
public class CommaSeparatedArrayAttribute : Attribute, IBinderTypeProviderMetadata
{
    public Type BinderType => typeof(CommaSeparatedArrayModelBinder);
}

// In Startup.cs
services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new CommaSeparatedArrayModelBinderProvider());
});

// Usage in controller
public IActionResult Search([CommaSeparatedArray] string[] tags)
{
    // For URL: /search?tags=javascript,react,node
    // tags = ["javascript", "react", "node"]
    return View();
}
        

// From query string: /search?tag=javascript&tag=react&tag=node
public IActionResult Search([FromQuery(Name = "tag")] string[] tags)
{
    // tags = ["javascript", "react", "node"]
    return View();
}
        

File Upload Binding:

public class ProductViewModel
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public IFormFile ProductImage { get; set; }
    public List AdditionalImages { get; set; }
}

[HttpPost]
public async Task Create([FromForm] ProductViewModel product)
{
    if (product.ProductImage != null && product.ProductImage.Length > 0)
    {
        // Process the uploaded file
        var filePath = Path.Combine(_environment.WebRootPath, "uploads", 
                                   product.ProductImage.FileName);
                                   
        using (var stream = new FileStream(filePath, FileMode.Create))
        {
            await product.ProductImage.CopyToAsync(stream);
        }
    }
    
    return RedirectToAction("Index");
}
        

Preventing Over-posting with Explicit Binding:

// Explicit inclusion
[HttpPost]
public IActionResult Update([Bind("Id,Name,Email")] User user)
{
    // Only Id, Name, and Email will be bound, even if other fields are submitted
    _repository.Update(user);
    return RedirectToAction("Index");
}

// Or with BindNever attribute in the model
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    
    [BindNever] // This won't be bound from request data
    public bool IsAdmin { get; set; }
}
        

Advanced Implementation Example:

// Controller with specific action for partial views
public class ProductController : Controller
{
    private readonly IProductRepository _repository;
    
    public ProductController(IProductRepository repository)
    {
        _repository = repository;
    }
    
    // Action specifically for a partial view
    [ChildActionOnly] // This attribute restricts direct access to this action
    public ActionResult ProductSummary(int productId)
    {
        var product = _repository.GetById(productId);
        return PartialView("_ProductSummary", product);
    }
}
        

Using child actions to render a partial view (in a parent view):

@model IEnumerable<int>

<div class="products-container">
    @foreach (var productId in Model)
    {
        @Html.Action("ProductSummary", "Product", new { productId })
    }
</div>
        

Advanced Implementation with Parameters and Async:

using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

public class UserProfileViewComponent : ViewComponent
{
    private readonly IUserService _userService;
    private readonly IOptionsMonitor<UserProfileOptions> _options;
    
    public UserProfileViewComponent(
        IUserService userService,
        IOptionsMonitor<UserProfileOptions> options)
    {
        _userService = userService;
        _options = options;
    }
    
    // Example of async Invoke with parameters
    public async Task<IViewComponentResult> InvokeAsync(string userId, bool showDetailedView = false)
    {
        // Track component metrics if configured
        using var _ = _options.CurrentValue.MetricsEnabled 
            ? Activity.StartActivity("UserProfile.Render") 
            : null;
            
        var userProfile = await _userService.GetUserProfileAsync(userId);
        
        // View Component can select different views based on parameters
        var viewName = showDetailedView ? "Detailed" : "Default";
        
        // Can have its own view model
        var viewModel = new UserProfileViewModel
        {
            User = userProfile,
            DisplayOptions = new ProfileDisplayOptions
            {
                ShowContactInfo = User.Identity.IsAuthenticated,
                MaxDisplayItems = _options.CurrentValue.MaxItems
            }
        };
        
        return View(viewName, viewModel);
    }
}
        

Invocation Methods:

@* Method 1: Component helper with async *@
@await Component.InvokeAsync("UserProfile", new { userId = "user123", showDetailedView = true })

@* Method 2: Tag Helper syntax (requires registering tag helpers) *@
<vc:user-profile user-id="user123" show-detailed-view="true"></vc:user-profile>

@* Method 3: View Component as a service (ASP.NET Core 6.0+) *@
@inject IViewComponentHelper Vc
@await Vc.InvokeAsync(typeof(UserProfileViewComponent), new { userId = "user123" })
        

Unit Testing a View Component:

[Fact]
public async Task UserProfileViewComponent_Returns_CorrectModel()
{
    // Arrange
    var mockUserService = new Mock<IUserService>();
    mockUserService
        .Setup(s => s.GetUserProfileAsync("testUser"))
        .ReturnsAsync(new UserProfile { Name = "Test User" });
        
    var mockOptions = new Mock<IOptionsMonitor<UserProfileOptions>>();
    mockOptions
        .Setup(o => o.CurrentValue)
        .Returns(new UserProfileOptions { MaxItems = 5 });
        
    var component = new UserProfileViewComponent(
        mockUserService.Object,
        mockOptions.Object);
        
    // Provide HttpContext for ViewComponent
    component.ViewComponentContext = new ViewComponentContext
    {
        ViewContext = new ViewContext
        {
            HttpContext = new DefaultHttpContext 
            { 
                User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] 
                { 
                    new Claim(ClaimTypes.Name, "testUser") 
                }, "mock"))
            }
        }
    };
    
    // Act
    var result = await component.InvokeAsync("testUser") as ViewViewComponentResult;
    var model = result.ViewData.Model as UserProfileViewModel;
    
    // Assert
    Assert.NotNull(model);
    Assert.Equal("Test User", model.User.Name);
    Assert.True(model.DisplayOptions.ShowContactInfo);
    Assert.Equal(5, model.DisplayOptions.MaxDisplayItems);
}
        

Advanced C# Features Example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

// Records for immutable data
public record Person(string FirstName, string LastName, int Age);

class Program
{
    static async Task Main()
    {
        // LINQ and collection initializers
        var people = new List<Person> {
            new("John", "Doe", 30),
            new("Jane", "Smith", 25),
            new("Bob", "Johnson", 45)
        };
        
        // Pattern matching with switch expression
        string GetLifeStage(Person p) => p.Age switch {
            < 18 => "Child",
            < 65 => "Adult",
            _ => "Senior"
        };
        
        // Async/await pattern
        await Task.WhenAll(
            people.Select(async p => {
                await Task.Delay(100); // Simulating async work
                Console.WriteLine($"{p.FirstName} is a {GetLifeStage(p)}");
            })
        );
        
        // Extension methods and LINQ
        var adults = people.Where(p => p.Age >= 18)
                          .OrderBy(p => p.LastName)
                          .Select(p => $"{p.FirstName} {p.LastName}");
                          
        Console.WriteLine($"Adults: {string.Join(", ", adults)}");
    }
}
        

Technical Example - .NET Assembly Structure:

// C# source code
namespace Example {
    public class Demo {
        public string GetMessage() => "Hello from .NET";
    }
}

/* Compilation Process:
1. C# compiler (csc.exe) compiles to CIL in assembly (Example.dll)
2. Assembly contains:
   - PE (Portable Executable) header
   - CLR header
   - Metadata tables (TypeDef, MethodDef, etc.)
   - CIL bytecode
   - Resources (if any)
3. When executed, CLR:
   - Loads assembly
   - Verifies CIL
   - JIT compiles methods as needed
   - Executes resulting machine code
*/
        

Memory Usage and Aliasing:

// These types are aliases for .NET framework types
// int is an alias for System.Int32
int number = 42;  
System.Int32 sameNumber = 42;  // Identical to the above

// string is an alias for System.String
string text = "Hello";
System.String sameText = "Hello";  // Identical to the above
        

Default Values:

// Numeric types default to 0
int defaultInt = default;     // 0
double defaultDouble = default;  // 0.0

// Boolean defaults to false
bool defaultBool = default;   // false

// Char defaults to '\0' (the null character)
char defaultChar = default;   // '\0'

// Reference types default to null
string defaultString = default;  // null
object defaultObject = default;  // null
        

// Basic declaration with explicit type
int counter;            // Declared but uninitialized
int score = 100;        // Declaration with initialization
string firstName = "John", lastName = "Doe";  // Multiple variables of same type
        

// Implicitly typed local variables
var count = 10;             // Inferred as int
var name = "Jane";          // Inferred as string
var items = new List(); // Inferred as List
        

// Constants must be initialized at declaration
const double Pi = 3.14159;
const string AppName = "MyApplication";
        

// Class-level readonly field
public class ConfigManager
{
    // Can only be assigned in declaration or constructor
    private readonly string _configPath;
    
    public ConfigManager(string path)
    {
        _configPath = path;  // Legal assignment in constructor
    }
}
        

// Using default value expressions
int number = default;        // 0
bool flag = default;         // false
string text = default;       // null
List list = default;    // null

// With explicit type (C# 7.1+)
var defaultInt = default(int);     // 0
var defaultBool = default(bool);   // false
        

// Value types that can also be null
int? nullableInt = null;
int? anotherInt = 42;

// C# 8.0+ nullable reference types
string? nullableName = null;  // Explicitly indicates name can be null
        

// Object initializer syntax
var person = new Person { 
    FirstName = "John", 
    LastName = "Doe",
    Age = 30 
};

// Collection initializer syntax
var numbers = new List { 1, 2, 3, 4, 5 };

// Dictionary initializer
var capitals = new Dictionary {
    ["USA"] = "Washington D.C.",
    ["France"] = "Paris",
    ["Japan"] = "Tokyo"
};
        

// Declaration patterns (C# 7.0+)
if (someValue is int count)
{
    // count is declared and initialized inside the if condition
    Console.WriteLine($"The count is {count}");
}

// Switch expressions with declarations (C# 8.0+)
var description = obj switch {
    int n when n < 0 => "Negative number",
    int n => $"Positive number: {n}",
    string s => $"String of length {s.Length}",
    _ => "Unknown type"
};
        

// Resource declaration with automatic disposal
using var file = new StreamReader("data.txt");
// file is disposed at the end of the current block
        

// The type is inferred from the variable declaration
List numbers = new();   // Same as new List()
Dictionary> map = new();  // Type inferred from left side
        

if (condition) 
{
    // Executed when condition is true
}
        

if (condition) 
{
    // Executed when condition is true
} 
else 
{
    // Executed when condition is false
}
        

if (condition1) 
{
    // Code block 1
} 
else if (condition2) 
{
    // Code block 2
} 
else 
{
    // Default code block
}
        

switch (expression) 
{
    case constant1:
        // Code executed when expression equals constant1
        break;
    case constant2:
    case constant3: // Fall-through is allowed between cases
        // Code executed when expression equals constant2 or constant3
        break;
    default:
        // Code executed when no match is found
        break;
}
        

string greeting = dayOfWeek switch 
{
    DayOfWeek.Monday => "Starting the week",
    DayOfWeek.Friday => "TGIF",
    DayOfWeek.Saturday or DayOfWeek.Sunday => "Weekend!",
    _ => "Regular day"
};
        

switch (obj) 
{
    case int i when i > 0:
        Console.WriteLine($"Positive integer: {i}");
        break;
    case string s:
        Console.WriteLine($"String: {s}");
        break;
    case null:
        Console.WriteLine("Null value");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}
        

// Syntax: condition ? expression_if_true : expression_if_false
int abs = number < 0 ? -number : number;
        

for (int i = 0; i < collection.Length; i++)
{
    // Loop body
}
        

while (condition)
{
    // Loop body
}
        

do
{
    // Loop body
} while (condition);
        

foreach (var item in collection)
{
    // Process item
}
        

Approximate expansion of a foreach loop:

// This foreach:
foreach (var item in collection)
{
    Console.WriteLine(item);
}

// Expands to something like:
{
    using (var enumerator = collection.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            var item = enumerator.Current;
            Console.WriteLine(item);
        }
    }
}
        

// Instead of:
var result = new List<int>();
foreach (var item in collection)
{
    if (item.Value > 10)
        result.Add(item.Value * 2);
}

// Use:
var result = collection
    .Where(item => item.Value > 10)
    .Select(item => item.Value * 2)
    .ToList();
        

Parallel.For(0, items.Length, i =>
{
    ProcessItem(items[i]);
});

Parallel.ForEach(collection, item =>
{
    ProcessItem(item);
});
        

Array Declarations and Initialization Patterns

// Declaration patterns
int[] numbers;           // Declaration only (null reference)
numbers = new int[5];    // Allocation with default values

// Initialization patterns
int[] a = new int[5];               // Initialized with default values (all 0)
int[] b = new int[5] { 1, 2, 3, 4, 5 }; // Explicit size with initialization
int[] c = new int[] { 1, 2, 3, 4, 5 };  // Size inferred from initializer
int[] d = { 1, 2, 3, 4, 5 };           // Shorthand initialization

// Type inference with arrays (C# 3.0+)
var scores = new[] { 1, 2, 3, 4, 5 }; // Type inferred as int[]

// Array initialization with new expression
var students = new string[3] {
    "Alice",
    "Bob", 
    "Charlie"
};
        

Multi-dimensional vs Jagged Arrays

// Rectangular 2D array (elements stored in continuous memory block)
int[,] matrix = new int[3, 4]; // 3 rows, 4 columns
matrix[1, 2] = 10;

// Jagged array (array of arrays, allows rows of different lengths)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4];
jaggedArray[1] = new int[2];
jaggedArray[2] = new int[5];
jaggedArray[0][2] = 10;

// Performance comparison:
// - Rectangular arrays have less memory overhead
// - Jagged arrays often have better performance for larger arrays
// - Jagged arrays allow more flexibility in dimensions
        

System.Array Methods and LINQ Operations

int[] numbers = { 5, 3, 8, 1, 2, 9, 4 };

// Array methods
Array.Sort(numbers);                 // In-place sort
Array.Reverse(numbers);              // In-place reverse
int index = Array.BinarySearch(numbers, 5); // Binary search (requires sorted array)
Array.Clear(numbers, 0, 2);          // Clear first 2 elements (set to default)
int[] copy = new int[7];
Array.Copy(numbers, copy, numbers.Length); // Copy array
Array.ForEach(numbers, n => Console.WriteLine(n)); // Apply action to each element

// LINQ operations on arrays
using System.Linq;

int[] filtered = numbers.Where(n => n > 3).ToArray();
int[] doubled = numbers.Select(n => n * 2).ToArray();
int sum = numbers.Sum();
double average = numbers.Average();
int max = numbers.Max();
bool anyGreaterThan5 = numbers.Any(n => n > 5);
        

// Using Span for zero-allocation slicing
int[] data = new int[100];
Span slice = data.AsSpan(10, 20); // Points to elements 10-29
slice[5] = 42; // Modifies data[15]

// Efficient array manipulation without copying
void ProcessRange(Span buffer)
{
    for (int i = 0; i < buffer.Length; i++)
    {
        buffer[i] *= 2;
    }
}
ProcessRange(data.AsSpan(50, 10)); // Process elements 50-59 efficiently
        

// Array covariance example
object[] objects = new string[10]; // Legal due to covariance

// This will compile but throw ArrayTypeMismatchException at runtime:
// objects[0] = 42; // Cannot store int in string[]

// Proper way to avoid covariance issues - use generics:
List strings = new List();
// List