.NET Modernization with Autohand Code

# Analyze .NET Framework codebase
autohand analyze --framework dotnet --version 4.8 \
  --target-version 8.0 \
  --output dotnet-analysis.json

# Analysis includes:
# - Framework compatibility issues
# - Third-party library support
# - Windows-specific dependencies
# - Migration complexity assessment

# Migrate to .NET 8
autohand migrate-dotnet --from framework --to 8.0 \
  --target-platform linux \
  --container-support

# Key transformations:
# - Project file format conversion
# - Package reference updates
# - API compatibility fixes
# - Configuration modernization

<Project ToolsVersion="15.0" DefaultTargets="Build">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
  </PropertyGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

# Migrate ASP.NET Web Forms/MVC
autohand migrate-aspnet --from webforms --to core \
  --target-version 8.0 \
  --razor-pages

# Migrate Web API
autohand migrate-aspnet --from webapi --to core \
  --minimal-apis \
  --swagger-integration

// Before (ASP.NET MVC 5)
public class ProductsController : Controller
{
    private readonly ProductService _service;
    
    public ProductsController()
    {
        _service = new ProductService();
    }
    
    [HttpGet]
    public ActionResult Index()
    {
        var products = _service.GetAll();
        return View(products);
    }
    
    [HttpPost]
    public ActionResult Create(Product product)
    {
        if (ModelState.IsValid)
        {
            _service.Create(product);
            return RedirectToAction("Index");
        }
        return View(product);
    }
}

// After (ASP.NET Core 8)
public class ProductsController : ControllerBase
{
    private readonly ProductService _service;
    
    public ProductsController(ProductService service)
    {
        _service = service;
    }
    
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Product>>> GetAll()
    {
        var products = await _service.GetAllAsync();
        return Ok(products);
    }
    
    [HttpPost]
    public async Task<ActionResult<Product>> Create(Product product)
    {
        await _service.CreateAsync(product);
        return CreatedAtAction(nameof(GetById), new { id = product.Id }, product);
    }
}

// Before (manual DI or custom containers)
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly IEmailService _emailService;
    
    public OrderService()
    {
        _repository = new OrderRepository();
        _emailService = new EmailService();
    }
}

// After (built-in DI)
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly IEmailService _emailService;
    
    public OrderService(IOrderRepository repository, IEmailService emailService)
    {
        _repository = repository;
        _emailService = emailService;
    }
}

// Program.cs registration
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddScoped<OrderService>();

<configuration>
  <appSettings>
    <add key="ConnectionString" value="Server=...;Database=..." />
    <add key="ApiKey" value="..." />
  </appSettings>
  <connectionStrings>
    <add name="DefaultConnection" connectionString="..." />
  </connectionStrings>
</configuration>

// After (appsettings.json)
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=...;Database=..."
  },
  "AppSettings": {
    "ApiKey": "..."
  }
}

// Program.cs
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
var apiKey = builder.Configuration["AppSettings:ApiKey"];

# Generate migration tests
autohand generate-tests --framework dotnet \
  --target-version 8.0 \
  --test-framework xunit

# Run migration validation
autohand validate-migration --from framework --to 8.0 \
  --run-tests \
  --performance-benchmark

# Compare behavior
autohand compare --before framework-output \
  --after dotnet8-output \
  --tolerance 0.01

# Generate Docker files
autohand containerize --framework dotnet --target 8.0 \
  --base-image mcr.microsoft.com/dotnet/aspnet:8.0 \
  --runtime-alpine

# Generate Kubernetes manifests
autohand generate-k8s --framework dotnet \
  --service-type webapi \
  --ingress-enabled

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

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