.NET Core 跨平台之路：从 Windows 到全平台的演进

// 1. 编译模型 - 启动性能提升
public class MyDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer("连接字符串")
                  .EnableSensitiveDataLogging()
                  .EnableDetailedErrors();

    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }
}

// 2. 临时表 - SQL Server 支持
await context.Database.ExecuteSqlRawAsync(
    "CREATE TABLE #TempUsers (Id INT, Name NVARCHAR(50))");

// 3. 迁移包 - 部署优化
dotnet ef migrations add InitialCreate
dotnet ef migrations bundle --self-contained

// 4. JSON 列 - 更好的文档数据库支持
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<User>()
        .Property(e => e.Metadata)
        .HasJsonConversion();
}

// SQL Server - Windows/Linux
options.UseSqlServer("连接字符串");

// PostgreSQL - 全平台
options.UseNpgsql("连接字符串");

// MySQL - 全平台
options.UseMySQL("连接字符串");

// SQLite - 嵌入式，全平台
options.UseSqlite("Data Source=app.db");

// Cosmos DB - 云原生
options.UseCosmos("endpoint", "key", "database");

public class UserService
{
    private readonly MyDbContext _context;

    public UserService(MyDbContext context)
    {
        _context = context;
    }

    // 创建
    public async Task<User> CreateUserAsync(string name, string email)
    {
        var user = new User { Name = name, Email = email };
        _context.Users.Add(user);
        await _context.SaveChangesAsync();
        return user;
    }

    // 查询
    public async Task<User> GetUserAsync(int id)
    {
        return await _context.Users
            .Include(u => u.Orders)
            .FirstOrDefaultAsync(u => u.Id == id);
    }

    // 更新
    public async Task UpdateUserAsync(User user)
    {
        _context.Users.Update(user);
        await _context.SaveChangesAsync();
    }

    // 删除
    public async Task DeleteUserAsync(int id)
    {
        var user = await _context.Users.FindAsync(id);
        if (user != null)
        {
            _context.Users.Remove(user);
            await _context.SaveChangesAsync();
        }
    }

    // 复杂查询
    public async Task<List<User>> GetActiveUsersWithOrdersAsync()
    {
        return await _context.Users
            .Where(u => u.IsActive)
            .Include(u => u.Orders)
            .Where(u => u.Orders.Any(o => o.Status == "Completed"))
            .OrderByDescending(u => u.CreatedAt)
            .Take(100)
            .ToListAsync();
    }
}

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddDiscoveryClient(Configuration);
    services.AddMvc();
}

public void Configure(IApplicationBuilder app)
{
    app.UseMvc();
    app.UseDiscoveryClient();
}

// appsettings.json
{
  "spring": {
    "application": {
      "name": "order-service"
    }
  },
  "eureka": {
    "client": {
      "serviceUrl": "http://localhost:8761/eureka/",
      "shouldRegisterWithEureka": true
    },
    "instance": {
      "port": 8010
    }
  }
}

services.AddConsulClient(options =>
{
    options.Address = new Uri("http://localhost:8500");
});

services.AddConsulServiceRegistration(options =>
{
    options.ID = "order-service-1";
    options.Name = "order-service";
    options.Address = "localhost";
    options.Port = 8010;
});

// Program.cs
builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.AllowAnyOrigin()
              .AllowAnyMethod()
              .AllowAnyHeader();
    });
});

var app = builder.Build();

app.MapReverseProxy();

app.Run();

// Consul 配置读取
services.AddConsulConfig(options =>
{
    options.Options =
    {
        Address = new Uri("http://localhost:8500"),
        Token = "consul-token"
    };
});

services.Configure<MyOptions>(
    Configuration.GetSection("MyOptions")
);

// OpenTelemetry 集成
builder.Services.AddOpenTelemetryTracing(tracing =>
{
    tracing.AddAspNetCoreInstrumentation()
           .AddHttpClientInstrumentation()
           .AddSource("MyService")
           .SetResourceBuilder(
               ResourceBuilder.CreateDefault()
                   .AddService("my-service"))
           .AddZipkinExporter(options =>
           {
               options.Endpoint = new Uri("http://localhost:9411/api/v2/spans");
           });
});

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

// Program.cs
app.MapGrpcService<GreeterService>();

// Client 端
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);

var reply = await client.SayHelloAsync(
    new HelloRequest { Name = "World" });

// Program.cs
builder.Services.AddHealthChecks()
    .AddDbContextCheck<MyDbContext>()
    .AddSqlServer(connectionString)
    .AddUrlGroup(new Uri("https://api.external.com"), "external-api")
    .AddCheck("memory", new MemoryHealthCheck(1024));

var app = builder.Build();

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

app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("ready")
});

app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = _ => false
});

// C# 示例：现代语言特性
public record User(int Id, string Name, string Email);

public async Task<Result<User>> GetUserAsync(int id)
{
    return await _context.Users
        .Where(u => u.Id == id)
        .Select(u => new User(u.Id, u.Name, u.Email))
        .FirstOrDefaultAsync()
        is User user
            ? Result.Success(user)
            : Result.NotFound<User>();
}

// Startup.cs
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 添加服务发现客户端
        services.AddDiscoveryClient(Configuration);
        services.AddControllers();

        // 添加 HttpClient 工厂
        services.AddHttpClient("UserService")
            .AddServiceDiscovery();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });

        // 启动服务发现客户端
        app.UseDiscoveryClient();
    }
}

[ApiController]
[Route("/")]
public class HealthController : ControllerBase
{
    [HttpGet("health")]
    public IActionResult Health()
    {
        return Ok(new { status = "UP" });
    }

    [HttpGet("status")]
    public IActionResult Status()
    {
        return Ok(new
        {
            app = "order-service",
            status = "UP",
            version = "1.0.0"
        });
    }
}

public class OrderController : ControllerBase
{
    private readonly DiscoveryHttpClientHandler _handler;
    private readonly ILogger<OrderController> _logger;

    public OrderController(IDiscoveryClient client, ILogger<OrderController> logger)
    {
        _handler = new DiscoveryHttpClientHandler(client);
        _logger = logger;
    }

    [HttpGet("{id}/user")]
    public async Task<ActionResult<UserDto>> GetUserForOrder(int id)
    {
        // 创建使用服务发现的 HttpClient
        var client = new HttpClient(_handler);

        try
        {
            // 通过服务名调用，自动负载均衡
            var response = await client.GetStringAsync("http://user-service/api/users/current");
            var user = JsonSerializer.Deserialize<UserDto>(response);

            return Ok(user);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "调用 user-service 失败");
            return StatusCode(503, "服务暂时不可用");
        }
    }
}

// Startup.cs
services.AddHttpClient("UserService", client =>
{
    client.BaseAddress = new Uri("http://user-service/");
})
.AddServiceDiscovery()
.AddRoundRobinLoadBalancer()
.AddPolicyHandler(GetRetryPolicy());

static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
{
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.ServiceUnavailable)
        .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
}

// Controller
public class OrderController : ControllerBase
{
    private readonly IHttpClientFactory _httpClientFactory;

    public OrderController(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    [HttpGet("{id}/user")]
    public async Task<ActionResult<UserDto>> GetUserForOrder(int id)
    {
        var client = _httpClientFactory.CreateClient("UserService");

        var response = await client.GetAsync("api/users/current");
        response.EnsureSuccessStatusCode();

        var user = await response.Content.ReadFromJsonAsync<UserDto>();
        return Ok(user);
    }
}

// Program.cs
builder.Configuration.AddConfigServer(options =>
{
    options.Environment = "Development";
    options.Name = "order-service";
    options.Label = "master";
    options.Uri = "http://localhost:8888";
});

var app = builder.Build();