init

Avalonia-Services/Avalonia-Services.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <RootNamespace>Avalonia_Services</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.7" />
+    <PackageReference Include="Serilog" Version="4.2.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+    <PackageReference Include="Serilog.Enrichers.Environment" Version="3.0.1" />
+    <PackageReference Include="Serilog.Enrichers.Thread" Version="4.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Avalonia-Common\Avalonia-Common.csproj" />
+    <ProjectReference Include="..\Avalonia-EFCore\Avalonia-EFCore.csproj" />
+  </ItemGroup>
+
+</Project>

Avalonia-Services/Core/EndpointPrinter.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Linq;
+
+namespace Avalonia_Services.Core
+{
+    /// <summary>
+    /// 端点列表打印工具 —— 在应用启动时输出所有已注册的拦截接口。
+    /// 类似 Swagger 的接口清单效果。
+    /// </summary>
+    public static class EndpointPrinter
+    {
+        /// <summary>
+        /// 打印所有已注册端点到控制台。
+        /// </summary>
+        public static void PrintEndpoints(
+            ServiceEndpointCollection collection,
+            string? title = null,
+            EndpointHostTarget host = EndpointHostTarget.All)
+        {
+            title ??= "API Endpoints";
+            var endpoints = collection.ForHost(host).ToList();
+
+            var maxMethodLen = endpoints.Count > 0
+                ? endpoints.Max(e => e.HttpMethod.Length)
+                : 4;
+            var maxPathLen = endpoints.Count > 0
+                ? endpoints.Max(e => e.Pattern.Length)
+                : 8;
+
+            var totalWidth = maxMethodLen + maxPathLen + 5;
+            var separator = new string('─', Math.Max(totalWidth, 50));
+
+            Console.WriteLine();
+            Console.WriteLine($"╔═ {title} ═{new string('═', Math.Max(0, totalWidth - title.Length - 3))}╗");
+            Console.WriteLine($"║ {"Method".PadRight(maxMethodLen)} │ {"Path".PadRight(maxPathLen)} │ Auth ║");
+            Console.WriteLine($"╟{separator}╢");
+
+            foreach (var ep in endpoints.OrderBy(e => e.Pattern))
+            {
+                var auth = ep.RequireAuthorization
+                    ? (ep.Roles.Count > 0 ? string.Join(",", ep.Roles) : ep.Policy ?? "✓")
+                    : "—";
+                var methodColor = ep.HttpMethod switch
+                {
+                    "GET" => ConsoleColor.Green,
+                    "POST" => ConsoleColor.Blue,
+                    "PUT" => ConsoleColor.Yellow,
+                    "DELETE" => ConsoleColor.Red,
+                    _ => ConsoleColor.Gray,
+                };
+
+                var savedColor = Console.ForegroundColor;
+
+                Console.Write("║ ");
+                Console.ForegroundColor = methodColor;
+                Console.Write(ep.HttpMethod.PadRight(maxMethodLen));
+                Console.ForegroundColor = savedColor;
+                Console.Write(" │ ");
+                Console.Write(ep.Pattern.PadRight(maxPathLen));
+                Console.Write(" │ ");
+                Console.Write(auth.PadRight(4));
+                Console.WriteLine(" ║");
+            }
+
+            Console.WriteLine($"╚{separator}╝");
+            Console.WriteLine($"  Total: {endpoints.Count} endpoint(s)");
+            Console.WriteLine();
+        }
+    }
+}

Avalonia-Services/Core/GlobalExceptionFilter.cs

@@ -0,0 +1,107 @@
+using Avalonia_Common.Core;
+using System;
+using System.Threading.Tasks;
+
+namespace Avalonia_Services.Core
+{
+    /// <summary>
+    /// 全局异常拦截过滤器 —— 自动包裹所有端点处理器，无需在每个方法中写 try-catch。
+    /// 所有未捕获异常会被转为统一的 ApiResponse 错误格式。
+    /// </summary>
+    public sealed class GlobalExceptionFilter : IEndpointFilter
+    {
+        /// <summary>
+        /// 是否在错误响应中包含异常详情。
+        /// </summary>
+        private readonly bool _includeDetails;
+
+        /// <summary>
+        /// 初始化全局异常过滤器。
+        /// </summary>
+        /// <param name="includeDetails">是否在响应中包含异常详情（开发环境建议 true，生产环境 false）</param>
+        public GlobalExceptionFilter(bool includeDetails = false)
+        {
+            _includeDetails = includeDetails;
+        }
+
+        /// <summary>
+        /// 执行过滤器逻辑：包裹下一个委托，捕获所有未处理异常并转换为统一错误响应。
+        /// </summary>
+        /// <param name="context">请求上下文。</param>
+        /// <param name="next">管道中的下一个委托。</param>
+        public async Task InvokeAsync(ServiceEndpointContext context, EndpointFilterDelegate next)
+        {
+            try
+            {
+                await next(context);
+            }
+            catch (OperationCanceledException)
+            {
+                // 取消操作不视为错误
+                context.StatusCode = 499;
+                context.StatusMessage = "Client Closed Request";
+                context.ResponseBody = ApiResponse<object>.Fail(499, "请求已取消");
+            }
+            catch (UnauthorizedAccessException ex)
+            {
+                context.StatusCode = 401;
+                context.StatusMessage = "Unauthorized";
+                context.ResponseBody = ApiResponse<object>.Unauthorized(
+                    _includeDetails ? ex.Message : "未授权访问");
+            }
+            catch (InvalidOperationException ex) when (ex.Message.Contains("not found", StringComparison.OrdinalIgnoreCase))
+            {
+                context.StatusCode = 404;
+                context.StatusMessage = "Not Found";
+                context.ResponseBody = ApiResponse<object>.NotFound(
+                    _includeDetails ? ex.Message : "资源不存在");
+            }
+            catch (ArgumentException ex)
+            {
+                context.StatusCode = 400;
+                context.StatusMessage = "Bad Request";
+                context.ResponseBody = ApiResponse<object>.BadRequest(
+                    _includeDetails ? ex.Message : "参数错误");
+            }
+            catch (Exception ex)
+            {
+                // 记录完整日志（无论是否返回详情）
+                LogException(context, ex);
+
+                context.StatusCode = 500;
+                context.StatusMessage = "Internal Server Error";
+                context.ResponseBody = ApiResponse<object>.ServerError(
+                    _includeDetails ? ex.Message : "服务器内部错误，请联系管理员");
+
+                // 可选：在开发环境附加堆栈信息
+                if (_includeDetails)
+                {
+                    // 通过 Items 传递额外调试信息
+                    context.Items["ExceptionDetail"] = ex.ToString();
+                }
+            }
+        }
+
+        /// <summary>
+        /// 记录异常日志，优先使用 Serilog，不可用时回退到 Console。
+        /// </summary>
+        /// <param name="context">请求上下文。</param>
+        /// <param name="ex">异常对象。</param>
+        private static void LogException(ServiceEndpointContext context, Exception ex)
+        {
+            try
+            {
+                // 使用 Serilog（如果已配置）
+                Serilog.Log.Error(ex,
+                    "全局异常拦截 | {Method} {Path} | {ExceptionType}: {Message}",
+                    context.Method, context.Path, ex.GetType().Name, ex.Message);
+            }
+            catch
+            {
+                // Serilog 不可用时回退到 Console
+                Console.Error.WriteLine(
+                    $"[ERROR] {context.Method} {context.Path} | {ex.GetType().Name}: {ex.Message}");
+            }
+        }
+    }
+}

Avalonia-Services/Core/IAuthService.cs

@@ -0,0 +1,39 @@
+using System.Security.Claims;
+
+namespace Avalonia_Services.Core
+{
+    /// <summary>
+    /// 鉴权服务抽象 —— 各宿主按自己的方式实现（JWT / Cookie / Token 等）。
+    /// </summary>
+    public interface IAuthService
+    {
+        /// <summary>
+        /// 验证请求并返回用户主体；返回 null 表示未授权。
+        /// </summary>
+        Task<ClaimsPrincipal?> AuthenticateAsync(ServiceEndpointContext context);
+
+        /// <summary>
+        /// 检查当前用户是否有指定权限。
+        /// </summary>
+        Task<bool> AuthorizeAsync(ClaimsPrincipal user, string policy);
+    }
+
+    /// <summary>
+    /// 无需鉴权的默认实现（开发/公开 API 场景）。
+    /// </summary>
+    public sealed class AnonymousAuthService : IAuthService
+    {
+        /// <inheritdoc />
+        public Task<ClaimsPrincipal?> AuthenticateAsync(ServiceEndpointContext context)
+        {
+            // 匿名用户，始终通过
+            var identity = new ClaimsIdentity("anonymous");
+            return Task.FromResult<ClaimsPrincipal?>(new ClaimsPrincipal(identity));
+        }
+        /// <inheritdoc />
+        public Task<bool> AuthorizeAsync(ClaimsPrincipal user, string policy)
+        {
+            return Task.FromResult(true);
+        }
+    }
+}

Avalonia-Services/Core/IEndpointFilter.cs

@@ -0,0 +1,48 @@
+using System.Threading.Tasks;
+
+namespace Avalonia_Services.Core
+{
+    /// <summary>
+    /// 端点过滤器抽象 —— 在请求处理前后执行逻辑。
+    /// 类似于 ASP.NET Core 的 IEndpointFilter，但可在任何宿主中使用。
+    /// </summary>
+    public interface IEndpointFilter
+    {
+        /// <summary>
+        /// 过滤器执行方法。
+        /// 调用 next(ctx) 继续管道；不调用则短路。
+        /// </summary>
+        Task InvokeAsync(ServiceEndpointContext context, EndpointFilterDelegate next);
+    }
+
+    /// <summary>
+    /// 过滤器管道中的下一个委托。
+    /// </summary>
+    public delegate Task EndpointFilterDelegate(ServiceEndpointContext context);
+
+    /// <summary>
+    /// 用于包装匿名过滤器的简单实现。
+    /// </summary>
+    internal sealed class AnonymousEndpointFilter : IEndpointFilter
+    {
+        /// <summary>
+        /// 匿名过滤器的委托实现。
+        /// </summary>
+        private readonly Func<ServiceEndpointContext, EndpointFilterDelegate, Task> _filter;
+
+        /// <summary>
+        /// 使用匿名函数创建过滤器。
+        /// </summary>
+        /// <param name="filter">过滤器委托。</param>
+        public AnonymousEndpointFilter(Func<ServiceEndpointContext, EndpointFilterDelegate, Task> filter)
+        {
+            _filter = filter;
+        }
+
+        /// <inheritdoc />
+        public Task InvokeAsync(ServiceEndpointContext context, EndpointFilterDelegate next)
+        {
+            return _filter(context, next);
+        }
+    }
+}

Avalonia-Services/Core/ServiceEndpointCollection.cs

@@ -0,0 +1,364 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Avalonia_Services.Core
+{
+    /// <summary>
+    /// 端点挂载的宿主目标。
+    /// </summary>
+    [Flags]
+    public enum EndpointHostTarget
+    {
+        /// <summary>挂载到 Avalonia-API（ASP.NET Core Web API）。</summary>
+        Api = 1,
+        /// <summary>挂载到 Avalonia-PC（桌面 WebView）。</summary>
+        Pc = 2,
+        /// <summary>同时挂载到 API 和 PC。</summary>
+        All = Api | Pc,
+    }
+
+    /// <summary>
+    /// 单个端点定义。
+    /// </summary>
+    public class ServiceEndpoint
+    {
+        /// <summary>路由路径，如 "api/wData"</summary>
+        public string Pattern { get; init; } = string.Empty;
+
+        /// <summary>HTTP 方法（GET/POST/PUT/DELETE）</summary>
+        public string HttpMethod { get; init; } = "GET";
+
+        /// <summary>端点名称（用于 OpenAPI / 日志）</summary>
+        public string? Name { get; set; }
+
+        /// <summary>OpenAPI 分组标签。</summary>
+        public string? OpenApiTag { get; set; }
+
+        /// <summary>OpenAPI 摘要。</summary>
+        public string? OpenApiSummary { get; set; }
+
+        /// <summary>OpenAPI 描述。</summary>
+        public string? OpenApiDescription { get; set; }
+
+        /// <summary>OpenAPI 请求体类型。</summary>
+        public Type? OpenApiRequestType { get; set; }
+
+        /// <summary>OpenAPI 200 响应数据类型。</summary>
+        public Type? OpenApiResponseType { get; set; }
+
+        /// <summary>端点处理器</summary>
+        public Func<ServiceEndpointContext, Task<object?>> Handler { get; init; } = _ => Task.FromResult<object?>(null);
+
+        /// <summary>该端点专属的过滤器（按顺序执行）</summary>
+        public List<IEndpointFilter> Filters { get; init; } = new();
+
+        /// <summary>是否需要鉴权</summary>
+        public bool RequireAuthorization { get; set; }
+
+        /// <summary>鉴权策略名</summary>
+        public string? Policy { get; set; }
+
+        /// <summary>允许访问该端点的角色。多个角色满足任意一个即可。</summary>
+        public List<string> Roles { get; } = new();
+
+        /// <summary>端点挂载的宿主。默认 API 和 PC 都挂载。</summary>
+        public EndpointHostTarget HostTarget { get; set; } = EndpointHostTarget.All;
+
+        /// <summary>
+        /// 设置端点名称（Fluent API）。
+        /// </summary>
+        public ServiceEndpoint WithName(string name)
+        {
+            Name = name;
+            return this;
+        }
+
+        /// <summary>
+        /// 设置端点的 OpenAPI 元数据（标签、摘要、描述、请求/响应类型）。
+        /// </summary>
+        /// <param name="tag">OpenAPI 分组标签。</param>
+        /// <param name="summary">简要摘要。</param>
+        /// <param name="description">详细描述。</param>
+        /// <param name="requestType">请求体类型。</param>
+        /// <param name="responseType">成功响应类型。</param>
+        /// <returns>当前端点实例（Fluent API）。</returns>
+        public ServiceEndpoint WithOpenApi(
+            string tag,
+            string summary,
+            string? description = null,
+            Type? requestType = null,
+            Type? responseType = null)
+        {
+            OpenApiTag = tag;
+            OpenApiSummary = summary;
+            OpenApiDescription = description;
+            OpenApiRequestType = requestType;
+            OpenApiResponseType = responseType;
+            return this;
+        }
+
+        /// <summary>
+        /// 标记端点需要登录。
+        /// </summary>
+        public ServiceEndpoint RequireAuth()
+        {
+            RequireAuthorization = true;
+            return this;
+        }
+
+        /// <summary>
+        /// 标记端点需要指定角色。多个角色满足任意一个即可。
+        /// </summary>
+        public ServiceEndpoint RequireRoles(params string[] roles)
+        {
+            RequireAuthorization = true;
+            Roles.Clear();
+            Roles.AddRange(roles.Where(role => !string.IsNullOrWhiteSpace(role)).Select(role => role.Trim()));
+            return this;
+        }
+
+        /// <summary>
+        /// 只挂载到 Avalonia-API。
+        /// </summary>
+        public ServiceEndpoint ApiOnly()
+        {
+            HostTarget = EndpointHostTarget.Api;
+            return this;
+        }
+
+        /// <summary>
+        /// 只挂载到 Avalonia-PC。
+        /// </summary>
+        public ServiceEndpoint PcOnly()
+        {
+            HostTarget = EndpointHostTarget.Pc;
+            return this;
+        }
+
+        /// <summary>
+        /// 判断端点是否支持指定的宿主目标。
+        /// </summary>
+        /// <param name="host">要检查的宿主目标。</param>
+        /// <returns>是否支持。</returns>
+        public bool SupportsHost(EndpointHostTarget host)
+        {
+            return (HostTarget & host) != 0;
+        }
+    }
+
+    /// <summary>
+    /// 端点集合 —— 所有端点的注册中心。在 Avalonia-Services 中统一配置。
+    /// </summary>
+    public class ServiceEndpointCollection
+    {
+        /// <summary>所有已注册的端点</summary>
+        public List<ServiceEndpoint> Endpoints { get; } = new();
+
+        /// <summary>
+        /// 获取指定宿主目标的所有端点。
+        /// </summary>
+        /// <param name="host">宿主目标。</param>
+        /// <returns>匹配的端点集合。</returns>
+        public IEnumerable<ServiceEndpoint> ForHost(EndpointHostTarget host)
+        {
+            return Endpoints.Where(endpoint => endpoint.SupportsHost(host));
+        }
+
+        /// <summary>作用于所有端点的全局过滤器</summary>
+        public List<IEndpointFilter> GlobalFilters { get; } = new();
+
+        /// <summary>
+        /// 注册一个端点。
+        /// </summary>
+        public ServiceEndpoint MapGet(string pattern, Func<ServiceEndpointContext, Task<object?>> handler)
+        {
+            return AddEndpoint(pattern, "GET", handler);
+        }
+
+        /// <summary>
+        /// 注册一个带服务依赖注入的 GET 端点。
+        /// </summary>
+        /// <typeparam name="TService">服务类型。</typeparam>
+        /// <param name="pattern">路由路径。</param>
+        /// <param name="handler">接受服务实例和上下文的处理器。</param>
+        /// <returns>已注册的端点实例。</returns>
+        public ServiceEndpoint MapGet<TService>(
+            string pattern,
+            Func<TService, ServiceEndpointContext, Task<object?>> handler)
+            where TService : notnull
+        {
+            return MapGet(pattern, CreateServiceHandler(handler));
+        }
+
+        /// <summary>
+        /// 注册一个 POST 端点。
+        /// </summary>
+        public ServiceEndpoint MapPost(string pattern, Func<ServiceEndpointContext, Task<object?>> handler)
+        {
+            return AddEndpoint(pattern, "POST", handler);
+        }
+
+        /// <summary>
+        /// 注册一个带服务依赖注入的 POST 端点。
+        /// </summary>
+        /// <typeparam name="TService">服务类型。</typeparam>
+        /// <param name="pattern">路由路径。</param>
+        /// <param name="handler">接受服务实例和上下文的处理器。</param>
+        /// <returns>已注册的端点实例。</returns>
+        public ServiceEndpoint MapPost<TService>(
+            string pattern,
+            Func<TService, ServiceEndpointContext, Task<object?>> handler)
+            where TService : notnull
+        {
+            return MapPost(pattern, CreateServiceHandler(handler));
+        }
+
+        /// <summary>
+        /// 注册一个 PUT 端点。
+        /// </summary>
+        public ServiceEndpoint MapPut(string pattern, Func<ServiceEndpointContext, Task<object?>> handler)
+        {
+            return AddEndpoint(pattern, "PUT", handler);
+        }
+
+        /// <summary>
+        /// 注册一个带服务依赖注入的 PUT 端点。
+        /// </summary>
+        /// <typeparam name="TService">服务类型。</typeparam>
+        /// <param name="pattern">路由路径。</param>
+        /// <param name="handler">接受服务实例和上下文的处理器。</param>
+        /// <returns>已注册的端点实例。</returns>
+        public ServiceEndpoint MapPut<TService>(
+            string pattern,
+            Func<TService, ServiceEndpointContext, Task<object?>> handler)
+            where TService : notnull
+        {
+            return MapPut(pattern, CreateServiceHandler(handler));
+        }
+
+        /// <summary>
+        /// 注册一个 DELETE 端点。
+        /// </summary>
+        public ServiceEndpoint MapDelete(string pattern, Func<ServiceEndpointContext, Task<object?>> handler)
+        {
+            return AddEndpoint(pattern, "DELETE", handler);
+        }
+
+        /// <summary>
+        /// 注册一个带服务依赖注入的 DELETE 端点。
+        /// </summary>
+        /// <typeparam name="TService">服务类型。</typeparam>
+        /// <param name="pattern">路由路径。</param>
+        /// <param name="handler">接受服务实例和上下文的处理器。</param>
+        /// <returns>已注册的端点实例。</returns>
+        public ServiceEndpoint MapDelete<TService>(
+            string pattern,
+            Func<TService, ServiceEndpointContext, Task<object?>> handler)
+            where TService : notnull
+        {
+            return MapDelete(pattern, CreateServiceHandler(handler));
+        }
+
+        /// <summary>
+        /// 添加全局过滤器（作用于所有端点）。
+        /// </summary>
+        public ServiceEndpointCollection AddGlobalFilter(IEndpointFilter filter)
+        {
+            GlobalFilters.Add(filter);
+            return this;
+        }
+
+        /// <summary>
+        /// 通过匿名函数添加全局过滤器。
+        /// </summary>
+        public ServiceEndpointCollection AddGlobalFilter(Func<ServiceEndpointContext, EndpointFilterDelegate, Task> filter)
+        {
+            GlobalFilters.Add(new AnonymousEndpointFilter(filter));
+            return this;
+        }
+
+        /// <summary>
+        /// 内部方法，创建端点并添加到集合。
+        /// </summary>
+        /// <param name="pattern">路由路径。</param>
+        /// <param name="method">HTTP 方法。</param>
+        /// <param name="handler">端点处理器。</param>
+        /// <returns>已创建的端点实例。</returns>
+        private ServiceEndpoint AddEndpoint(string pattern, string method, Func<ServiceEndpointContext, Task<object?>> handler)
+        {
+            var endpoint = new ServiceEndpoint
+            {
+                Pattern = pattern,
+                HttpMethod = method,
+                Handler = handler,
+            };
+            Endpoints.Add(endpoint);
+            return endpoint;
+        }
+
+        /// <summary>
+        /// 创建自动从 DI 解析服务实例并调用处理器的委托包装。
+        /// </summary>
+        /// <typeparam name="TService">服务类型。</typeparam>
+        /// <param name="handler">接受服务实例和上下文的处理器。</param>
+        /// <returns>包装后的处理器委托。</returns>
+        private static Func<ServiceEndpointContext, Task<object?>> CreateServiceHandler<TService>(
+            Func<TService, ServiceEndpointContext, Task<object?>> handler)
+            where TService : notnull
+        {
+            return async ctx =>
+            {
+                var serviceProvider = ctx.Items["ServiceProvider"] as IServiceProvider
+                    ?? throw new InvalidOperationException("ServiceProvider 未注入。");
+
+                await using var scope = serviceProvider.CreateAsyncScope();
+                var service = scope.ServiceProvider.GetRequiredService<TService>();
+                return await handler(service, ctx);
+            };
+        }
+    }
+
+    /// <summary>
+    /// 构建器 —— 提供 Fluent API 来配置所有端点。
+    /// </summary>
+    public class ServiceEndpointBuilder
+    {
+        /// <summary>
+        /// 端点集合
+        /// </summary>
+        public ServiceEndpointCollection Endpoints { get; } = new();
+
+        /// <summary>
+        /// 鉴权服务（默认匿名）
+        /// </summary>
+        public IAuthService AuthService { get; set; } = new AnonymousAuthService();
+
+        /// <summary>
+        /// 配置端点（在此方法中调用 endpoints.MapGet 等）。
+        /// </summary>
+        public ServiceEndpointBuilder ConfigureEndpoints(Action<ServiceEndpointCollection> configure)
+        {
+            configure(Endpoints);
+            return this;
+        }
+
+        /// <summary>
+        /// 设置鉴权服务。
+        /// </summary>
+        public ServiceEndpointBuilder UseAuthService(IAuthService authService)
+        {
+            AuthService = authService;
+            return this;
+        }
+
+        /// <summary>
+        /// 构建最终的端点集合。
+        /// </summary>
+        public ServiceEndpointCollection Build()
+        {
+            return Endpoints;
+        }
+    }
+}

Avalonia-Services/Core/ServiceEndpointContext.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+
+namespace Avalonia_Services.Core
+{
+    /// <summary>
+    /// 抽象的请求上下文，屏蔽不同宿主（ASP.NET Core / Desktop WebView）的差异。
+    /// </summary>
+    public class ServiceEndpointContext
+    {
+        /// <summary>
+        /// 请求路径，例如 "api/wData"
+        /// </summary>
+        public string Path { get; init; } = string.Empty;
+
+        /// <summary>
+        /// HTTP 方法（GET, POST, PUT, DELETE 等）
+        /// </summary>
+        public string Method { get; init; } = "GET";
+
+        /// <summary>
+        /// 请求头
+        /// </summary>
+        public Dictionary<string, string> Headers { get; init; } = new(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// 请求体（原始字符串）
+        /// </summary>
+        public string? Body { get; set; }
+
+        /// <summary>
+        /// 查询参数
+        /// </summary>
+        public Dictionary<string, string> Query { get; init; } = new(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// 响应状态码
+        /// </summary>
+        public int StatusCode { get; set; } = 200;
+
+        /// <summary>
+        /// 响应状态描述
+        /// </summary>
+        public string StatusMessage { get; set; } = "OK";
+
+        /// <summary>
+        /// 响应头
+        /// </summary>
+        public Dictionary<string, string> ResponseHeaders { get; set; } = new(StringComparer.OrdinalIgnoreCase)
+        {
+            ["Content-Type"] = "application/json; charset=utf-8"
+        };
+
+        /// <summary>
+        /// 响应体
+        /// </summary>
+        public object? ResponseBody { get; set; }
+
+        /// <summary>
+        /// 存储在请求生命周期中的任意数据（由中间件/过滤器使用）
+        /// </summary>
+        public Dictionary<string, object?> Items { get; init; } = new();
+
+        /// <summary>
+        /// 获取请求头值
+        /// </summary>
+        public string? GetHeader(string key)
+        {
+            return Headers.TryGetValue(key, out var value) ? value : null;
+        }
+
+        /// <summary>
+        /// 设置响应头
+        /// </summary>
+        public void SetResponseHeader(string key, string value)
+        {
+            ResponseHeaders[key] = value;
+        }
+    }
+}

Avalonia-Services/Endpoints/AppEndpoints.cs

@@ -0,0 +1,147 @@
+using Avalonia_Common.Core;
+using Avalonia_EFCore.Database;
+using Avalonia_EFCore.Models;
+using Avalonia_Services.Core;
+using Avalonia_Services.Services;
+using Microsoft.EntityFrameworkCore;
+
+namespace Avalonia_Services.Endpoints
+{
+    /// <summary>
+    /// 统一端点配置 —— 所有业务端点在此定义一次。
+    /// 这是 Avalonia-API 和 Avalonia-PC 的唯一入口。
+    /// </summary>
+    public static class AppEndpoints
+    {
+        /// <summary>
+        /// 配置所有业务端点。调用方传入 builder，按需叠加鉴权、过滤器等。
+        /// </summary>
+        /// <param name="builder">端点构建器</param>
+        /// <param name="includeDetails">是否在错误响应中包含异常详情（开发环境 true）</param>
+        public static ServiceEndpointBuilder Configure(ServiceEndpointBuilder builder, bool includeDetails = false)
+        {
+            // ---- 全局异常拦截（自动捕获所有端点中未处理的异常） ----
+            builder.Endpoints.AddGlobalFilter(new GlobalExceptionFilter(includeDetails));
+
+            builder.ConfigureEndpoints(endpoints =>
+            {
+                // ---- 全局日志过滤器（记录每个请求） ----
+                endpoints.AddGlobalFilter(async (ctx, next) =>
+                {
+                    Serilog.Log.Debug("→ {Method} {Path}", ctx.Method, ctx.Path);
+                    await next(ctx);
+                    Serilog.Log.Debug("← {Method} {Path} | {StatusCode}", ctx.Method, ctx.Path, ctx.StatusCode);
+                });
+
+                // ---- 业务端点注册 ----
+                // 天气预报（从数据库读取）
+                endpoints.MapGet("api/wData", GetWeatherForecastsAsync)
+                    .WithOpenApi("Weather", "获取天气预报信息。")
+                    .WithName("GetWeatherForecast");
+
+                // 获取用户（演示从数据库查询）
+                endpoints.MapGet("api/getUser", GetUserFromDatabaseAsync)
+                    .WithName("GetUser");
+
+                // 处理数据（POST — 演示参数处理）
+                endpoints.MapPost("api/processData", ProcessDataAsync)
+                    .WithName("ProcessData");
+
+                // ---- 需要鉴权的端点示例 ----
+                // endpoints.MapGet("api/admin/dashboard", AdminDashboardAsync)
+                //     .WithName("AdminDashboard")
+                //     .RequireAuthorization = true
+                //     .Policy = "AdminOnly";
+
+            });
+
+            return builder;
+        }
+
+        #region 业务处理方法
+
+        /// <summary>
+        /// 从数据库查询天气预报（优先数据库，回退到内存生成）。
+        /// </summary>
+        private static async Task<object?> GetWeatherForecastsAsync(ServiceEndpointContext ctx)
+        {
+            var sp = ctx.Items["ServiceProvider"] as IServiceProvider;
+
+            // 尝试从数据库读取
+            if (sp?.GetService(typeof(AppDataContext)) is AppDataContext db)
+            {
+                var dbForecasts = await db.WeatherForecasts
+                    .OrderByDescending(f => f.Date)
+                    .Take(5)
+                    .ToListAsync();
+
+                if (dbForecasts.Count > 0)
+                {
+                    return ResponseHelper.Ok(dbForecasts, "获取天气预报成功（来自数据库）");
+                }
+            }
+
+            // 回退：内存生成（数据库为空时）
+            var service = sp?.GetService(typeof(WeatherForecastService)) as WeatherForecastService
+                ?? new WeatherForecastService();
+
+            var forecasts = service.GetWeatherForecasts();
+            return ResponseHelper.Ok(forecasts, "获取天气预报成功（内存生成）");
+        }
+
+        /// <summary>
+        /// 从数据库获取用户信息（演示数据库查询），若无数据则返回演示用户。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>用户信息。</returns>
+        private static async Task<object?> GetUserFromDatabaseAsync(ServiceEndpointContext ctx)
+        {
+            var sp = ctx.Items["ServiceProvider"] as IServiceProvider;
+
+            // 尝试从数据库读取用户
+            if (sp?.GetService(typeof(AppDataContext)) is AppDataContext db)
+            {
+                var users = await db.Set<UserEntity>().Take(1).ToListAsync();
+                if (users.Count > 0)
+                {
+                    return ResponseHelper.Ok(users[0], "获取用户成功（来自数据库）");
+                }
+            }
+
+            // 回退：演示数据
+            await Task.Delay(100);
+            var user = new { id = 1, name = "张三", email = "zhangsan@example.com" };
+            return ResponseHelper.Ok(user);
+        }
+
+        /// <summary>
+        /// 处理前端发送的数据（POST 演示），将数据存入数据库或转为大写返回。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>处理结果。</returns>
+        private static async Task<object?> ProcessDataAsync(ServiceEndpointContext ctx)
+        {
+            var sp = ctx.Items["ServiceProvider"] as IServiceProvider;
+
+            // 演示：将收到的数据存入数据库
+            var input = ctx.Body ?? string.Empty;
+            if (sp?.GetService(typeof(AppDataContext)) is AppDataContext db && !string.IsNullOrWhiteSpace(input))
+            {
+                var forecast = new WeatherForecastEntity
+                {
+                    Date = DateOnly.FromDateTime(DateTime.Now),
+                    TemperatureC = 20,
+                    Summary = input,
+                };
+                db.WeatherForecasts.Add(forecast);
+                await db.SaveChangesAsync();
+                return ResponseHelper.Ok(forecast, "数据已存入数据库");
+            }
+
+            await Task.Delay(200);
+            return ResponseHelper.Ok(new { input, processed = input.ToUpperInvariant() });
+        }
+
+        #endregion
+    }
+}

Avalonia-Services/Endpoints/AuthEndpoints.cs

@@ -0,0 +1,61 @@
+using Avalonia_Services.Core;
+using Avalonia_Services.Services.AuthService;
+
+namespace Avalonia_Services.Endpoints
+{
+    /// <summary>
+    /// 认证端点统一入口。端点定义在这里，宿主项目只提供对应实现。
+    /// </summary>
+    public static class AuthEndpoints
+    {
+        /// <summary>
+        /// 配置 API 端鉴权端点（登录、刷新、登出）。
+        /// </summary>
+        /// <param name="builder">端点构建器。</param>
+        public static void ConfigureApi(ServiceEndpointBuilder builder)
+        {
+            builder.ConfigureEndpoints(endpoints =>
+            {
+                endpoints.MapPost<IApiAuthEndpointService>("api/auth/login", (service, ctx) => service.LoginAsync(ctx))
+                    .WithName("ApiLogin")
+                    .WithOpenApi("Auth", "API 登录，返回 access token 和 refresh token。", "", typeof(ApiLoginRequest), typeof(AuthTokenResponse))
+                    .ApiOnly();
+
+                endpoints.MapPost<IApiAuthEndpointService>("api/auth/refresh", (service, ctx) => service.RefreshAsync(ctx))
+                    .WithName("ApiRefresh")
+                    .WithOpenApi("Auth", "API refresh token 轮换。", "", typeof(ApiRefreshTokenRequest), typeof(AuthTokenResponse))
+                    .ApiOnly();
+
+                endpoints.MapPost<IApiAuthEndpointService>("api/auth/logout", (service, ctx) => service.LogoutAsync(ctx))
+                    .WithName("ApiLogout")
+                    .WithOpenApi("Auth", "API 退出登录并吊销 refresh token。", "", typeof(ApiLogoutRequest))
+                    .ApiOnly();
+            });
+        }
+
+        /// <summary>
+        /// 配置 PC 端鉴权端点（授权码登录、刷新、登出）。
+        /// </summary>
+        /// <param name="builder">端点构建器。</param>
+        public static void ConfigurePc(ServiceEndpointBuilder builder)
+        {
+            builder.ConfigureEndpoints(endpoints =>
+            {
+                endpoints.MapPost<IPcAuthEndpointService>("api/pc/auth/authorize", (service, ctx) => service.AuthorizeAsync(ctx))
+                    .WithName("PcAuthorize")
+                    .WithOpenApi("Auth", "PC 授权码登录，生成本地全局 token。", "", typeof(PcAuthorizeRequest), typeof(PcTokenResponse))
+                    .PcOnly();
+
+                endpoints.MapPost<IPcAuthEndpointService>("api/pc/auth/refresh", (service, ctx) => service.RefreshAsync(ctx))
+                    .WithName("PcRefresh")
+                    .WithOpenApi("Auth", "PC 全局 token 刷新。", "", typeof(PcRefreshRequest), typeof(PcTokenResponse))
+                    .PcOnly();
+
+                endpoints.MapPost<IPcAuthEndpointService>("api/pc/auth/logout", (service, ctx) => service.LogoutAsync(ctx))
+                    .WithName("PcLogout")
+                    .WithOpenApi("Auth", "PC 退出登录。", "", typeof(PcLogoutRequest))
+                    .PcOnly();
+            });
+        }
+    }
+}

Avalonia-Services/Extensions/DesktopEndpointAdapter.cs

@@ -0,0 +1,233 @@
+using Avalonia_Services.Core;
+
+namespace Avalonia_Services.Extensions
+{
+    /// <summary>
+    /// Desktop (Avalonia-PC) 端点适配器。
+    /// 将统一端点转换为桌面端可用的路由处理器，支持过滤器和鉴权管道。
+    /// </summary>
+    public class DesktopEndpointAdapter
+    {
+        /// <summary>
+        /// 统一端点集合。
+        /// </summary>
+        private readonly ServiceEndpointCollection _endpoints;
+        /// <summary>
+        /// 鉴权服务。
+        /// </summary>
+        private readonly IAuthService _authService;
+        /// <summary>
+        /// DI 服务提供程序。
+        /// </summary>
+        private readonly IServiceProvider _serviceProvider;
+
+        /// <summary>
+        /// 匹配后的路由结果（与原有 RouteDispatchResult 兼容）。
+        /// </summary>
+        public class RouteResult
+        {
+            /// <summary>
+            /// 获取是否匹配到路由。
+            /// </summary>
+            public bool IsMatched { get; init; }
+            /// <summary>
+            /// 获取 HTTP 状态码。
+            /// </summary>
+            public int StatusCode { get; init; } = 200;
+            /// <summary>
+            /// 获取状态描述文本。
+            /// </summary>
+            public string StatusMessage { get; init; } = "";
+            /// <summary>
+            /// 获取响应数据。
+            /// </summary>
+            public object? Data { get; init; }
+            /// <summary>
+            /// 获取响应头字典。
+            /// </summary>
+            public Dictionary<string, string> ResponseHeaders { get; init; } = new();
+
+            /// <summary>
+            /// 创建成功响应结果。
+            /// </summary>
+            /// <param name="data">响应数据。</param>
+            /// <param name="ctx">端点上下文。</param>
+            /// <returns>路由结果。</returns>
+            public static RouteResult Success(object? data, ServiceEndpointContext ctx)
+            {
+                return new RouteResult
+                {
+                    IsMatched = true,
+                    StatusCode = ctx.StatusCode,
+                    StatusMessage = ctx.StatusMessage,
+                    Data = data,
+                    ResponseHeaders = new Dictionary<string, string>(ctx.ResponseHeaders, StringComparer.OrdinalIgnoreCase),
+                };
+            }
+
+            /// <summary>
+            /// 创建 404 未找到响应。
+            /// </summary>
+            /// <returns>表示未匹配的路由结果。</returns>
+            public static RouteResult NotFound() => new()
+            {
+                IsMatched = false,
+                StatusCode = 404,
+                StatusMessage = "Not Found",
+            };
+        }
+
+        /// <summary>
+        /// 初始化桌面端点适配器。
+        /// </summary>
+        /// <param name="endpoints">端点集合。</param>
+        /// <param name="authService">鉴权服务。</param>
+        /// <param name="serviceProvider">DI 服务提供程序。</param>
+        public DesktopEndpointAdapter(
+            ServiceEndpointCollection endpoints,
+            IAuthService authService,
+            IServiceProvider serviceProvider)
+        {
+            _endpoints = endpoints;
+            _authService = authService;
+            _serviceProvider = serviceProvider;
+        }
+
+        /// <summary>
+        /// 处理来自前端（WebView2 Bridge）的请求。
+        /// </summary>
+        /// <param name="path">规范化路径，如 "api/wData"</param>
+        /// <param name="method">HTTP 方法</param>
+        /// <param name="body">请求体字符串</param>
+        /// <param name="headers">请求头字典</param>
+        /// <param name="query">查询参数字典</param>
+        public async Task<RouteResult> HandleRequestAsync(
+            string path,
+            string method,
+            string? body,
+            Dictionary<string, string>? headers = null,
+            Dictionary<string, string>? query = null)
+        {
+            // 查找匹配的端点（忽略大小写 + 方法匹配）
+            var endpoint = _endpoints.Endpoints.FirstOrDefault(e =>
+                e.SupportsHost(EndpointHostTarget.Pc) &&
+                string.Equals(e.Pattern, path, StringComparison.OrdinalIgnoreCase) &&
+                string.Equals(e.HttpMethod, method, StringComparison.OrdinalIgnoreCase));
+
+            if (endpoint is null)
+            {
+                return RouteResult.NotFound();
+            }
+
+            // 构建上下文
+            var ctx = new ServiceEndpointContext
+            {
+                Path = path,
+                Method = method,
+                Body = body,
+                Headers = headers ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase),
+                Query = query ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase),
+                Items = { ["ServiceProvider"] = _serviceProvider },
+            };
+
+            try
+            {
+                // 1. 鉴权检查
+                if (endpoint.RequireAuthorization)
+                {
+                    var user = await _authService.AuthenticateAsync(ctx);
+                    if (user is null)
+                    {
+                        ctx.StatusCode = 401;
+                        ctx.StatusMessage = "Unauthorized";
+                        ctx.ResponseBody = new { success = false, error = "Unauthorized" };
+                        return RouteResult.Success(ctx.ResponseBody, ctx);
+                    }
+
+                    if (endpoint.Roles.Count > 0)
+                    {
+                        var authorized = await _authService.AuthorizeAsync(user, $"roles:{string.Join(',', endpoint.Roles)}");
+                        if (!authorized)
+                        {
+                            ctx.StatusCode = 403;
+                            ctx.StatusMessage = "Forbidden";
+                            ctx.ResponseBody = new { success = false, error = "Forbidden" };
+                            return RouteResult.Success(ctx.ResponseBody, ctx);
+                        }
+                    }
+                    else if (!string.IsNullOrEmpty(endpoint.Policy))
+                    {
+                        var authorized = await _authService.AuthorizeAsync(user, endpoint.Policy);
+                        if (!authorized)
+                        {
+                            ctx.StatusCode = 403;
+                            ctx.StatusMessage = "Forbidden";
+                            ctx.ResponseBody = new { success = false, error = "Forbidden" };
+                            return RouteResult.Success(ctx.ResponseBody, ctx);
+                        }
+                    }
+
+                    ctx.Items["User"] = user;
+                }
+
+                // 2. 构建过滤管道：全局过滤器 → 端点过滤器 → 处理器
+                var pipeline = BuildPipeline(endpoint);
+
+                // 3. 执行管道
+                await pipeline(ctx);
+
+                return RouteResult.Success(ctx.ResponseBody, ctx);
+            }
+            catch (Exception ex)
+            {
+                ctx.StatusCode = 500;
+                ctx.StatusMessage = "Internal Server Error";
+                ctx.ResponseBody = new { success = false, error = ex.Message };
+                return RouteResult.Success(ctx.ResponseBody, ctx);
+            }
+        }
+
+        /// <summary>
+        /// 构建过滤管道（全局过滤器 + 端点过滤器 → 端点处理器）。
+        /// </summary>
+        private EndpointFilterDelegate BuildPipeline(ServiceEndpoint endpoint)
+        {
+            // 最内层：端点处理器
+            EndpointFilterDelegate handler = async (ctx) =>
+            {
+                ctx.ResponseBody = await endpoint.Handler(ctx);
+            };
+
+            // 先包裹端点专属过滤器（后注册的先执行）
+            var filters = new List<IEndpointFilter>();
+            filters.AddRange(_endpoints.GlobalFilters);
+            filters.AddRange(endpoint.Filters);
+
+            for (int i = filters.Count - 1; i >= 0; i--)
+            {
+                var filter = filters[i];
+                var next = handler;
+                handler = (ctx) => filter.InvokeAsync(ctx, next);
+            }
+
+            return handler;
+        }
+    }
+
+    /// <summary>
+    /// Desktop 端的辅助扩展。不依赖 IServiceCollection（由宿主项目自行完成 DI 注册）。
+    /// </summary>
+    public static class DesktopServiceExtensions
+    {
+        /// <summary>
+        /// 快速构建 DesktopEndpointAdapter（用于非 DI 场景如 MainWindow）。
+        /// </summary>
+        public static DesktopEndpointAdapter CreateAdapter(
+            this ServiceEndpointCollection endpoints,
+            IServiceProvider serviceProvider)
+        {
+            var auth = (serviceProvider.GetService(typeof(IAuthService)) as IAuthService) ?? new AnonymousAuthService();
+            return new DesktopEndpointAdapter(endpoints, auth, serviceProvider);
+        }
+    }
+}

Avalonia-Services/Services/AuthService/AuthContracts.cs

@@ -0,0 +1,98 @@
+namespace Avalonia_Services.Services.AuthService
+{
+    /// <summary>
+    /// API 登录请求。
+    /// </summary>
+    /// <param name="Account">账号（邮箱或用户名）。</param>
+    /// <param name="Password">密码。</param>
+    /// <param name="Roles">请求的角色列表。</param>
+    public sealed record ApiLoginRequest(string? Account, string? Password, string[]? Roles = null);
+
+    /// <summary>
+    /// API Refresh Token 请求。
+    /// </summary>
+    /// <param name="RefreshToken">刷新令牌。</param>
+    public sealed record ApiRefreshTokenRequest(string? RefreshToken);
+
+    /// <summary>
+    /// API 登出请求。
+    /// </summary>
+    /// <param name="RefreshToken">要撤销的刷新令牌。</param>
+    public sealed record ApiLogoutRequest(string? RefreshToken);
+
+    /// <summary>
+    /// 认证 Token 响应，包含 Access Token 和 Refresh Token 及其过期时间。
+    /// </summary>
+    /// <param name="AccessToken">访问令牌。</param>
+    /// <param name="RefreshToken">刷新令牌。</param>
+    /// <param name="AccessTokenExpiresAt">访问令牌过期时间。</param>
+    /// <param name="RefreshTokenExpiresAt">刷新令牌过期时间。</param>
+    /// <param name="Roles">用户角色列表。</param>
+    public sealed record AuthTokenResponse(
+        string AccessToken,
+        string RefreshToken,
+        DateTime AccessTokenExpiresAt,
+        DateTime RefreshTokenExpiresAt,
+        string[] Roles);
+
+    /// <summary>
+    /// PC 端授权码登录请求。
+    /// </summary>
+    /// <param name="AuthorizationCode">第三方授权码。</param>
+    public sealed record PcAuthorizeRequest(string? AuthorizationCode);
+
+    /// <summary>
+    /// PC 端 Token 刷新请求。
+    /// </summary>
+    /// <param name="Token">当前 Token。</param>
+    public sealed record PcRefreshRequest(string? Token);
+
+    /// <summary>
+    /// PC 端登出请求。
+    /// </summary>
+    /// <param name="Token">要清除的 Token。</param>
+    public sealed record PcLogoutRequest(string? Token);
+
+    /// <summary>
+    /// PC 端 Token 响应。
+    /// </summary>
+    /// <param name="Token">访问令牌。</param>
+    /// <param name="ExpiresAt">过期时间。</param>
+    /// <param name="Roles">用户角色列表。</param>
+    public sealed record PcTokenResponse(string Token, DateTime ExpiresAt, string[] Roles);
+
+    /// <summary>
+    /// 第三方授权检查结果。
+    /// </summary>
+    public enum ThirdPartyAuthCheckResult
+    {
+        /// <summary>授权有效。</summary>
+        Valid,
+        /// <summary>授权已丢失。</summary>
+        AuthorizationLost,
+        /// <summary>暂时性失败。</summary>
+        TemporaryFailure,
+    }
+
+    /// <summary>
+    /// 第三方授权客户端接口，用于验证和刷新第三方授权。
+    /// </summary>
+    public interface IPcThirdPartyAuthorizationClient
+    {
+        /// <summary>
+        /// 验证第三方授权码是否有效。
+        /// </summary>
+        /// <param name="authorizationCode">第三方授权码。</param>
+        /// <param name="cancellationToken">取消令牌。</param>
+        /// <returns>授权检查结果。</returns>
+        Task<ThirdPartyAuthCheckResult> ValidateAuthorizationCodeAsync(string authorizationCode, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 刷新第三方授权。
+        /// </summary>
+        /// <param name="authorizationReference">授权引用标识。</param>
+        /// <param name="cancellationToken">取消令牌。</param>
+        /// <returns>授权检查结果。</returns>
+        Task<ThirdPartyAuthCheckResult> RefreshAuthorizationAsync(string authorizationReference, CancellationToken cancellationToken = default);
+    }
+}

Avalonia-Services/Services/AuthService/AuthEndpointServices.cs

@@ -0,0 +1,59 @@
+using Avalonia_Services.Core;
+using System.Threading.Tasks;
+
+namespace Avalonia_Services.Services.AuthService
+{
+    /// <summary>
+    /// API 鉴权端点服务接口，定义登录、刷新 Token 和登出操作。
+    /// </summary>
+    public interface IApiAuthEndpointService
+    {
+        /// <summary>
+        /// 处理用户登录请求。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>包含 Token 的认证响应。</returns>
+        Task<object?> LoginAsync(ServiceEndpointContext ctx);
+
+        /// <summary>
+        /// 使用 Refresh Token 刷新 Access Token。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>新的 Token 对。</returns>
+        Task<object?> RefreshAsync(ServiceEndpointContext ctx);
+
+        /// <summary>
+        /// 处理用户登出请求。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>登出结果。</returns>
+        Task<object?> LogoutAsync(ServiceEndpointContext ctx);
+    }
+
+    /// <summary>
+    /// PC 端鉴权端点服务接口，定义授权码登录、Token 刷新和登出操作。
+    /// </summary>
+    public interface IPcAuthEndpointService
+    {
+        /// <summary>
+        /// 使用授权码进行登录授权。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>包含 Token 的认证响应。</returns>
+        Task<object?> AuthorizeAsync(ServiceEndpointContext ctx);
+
+        /// <summary>
+        /// 刷新当前 Token。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>新的 Token 响应。</returns>
+        Task<object?> RefreshAsync(ServiceEndpointContext ctx);
+
+        /// <summary>
+        /// 处理用户登出请求。
+        /// </summary>
+        /// <param name="ctx">服务端点上下文。</param>
+        /// <returns>登出结果。</returns>
+        Task<object?> LogoutAsync(ServiceEndpointContext ctx);
+    }
+}

Avalonia-Services/Services/WeatherForecastService.cs

@@ -0,0 +1,30 @@
+using Avalonia_EFCore.Models;
+
+namespace Avalonia_Services.Services
+{
+    /// <summary>
+    /// 天气预报服务，随机生成未来 5 天的天气预报数据。
+    /// </summary>
+    public class WeatherForecastService
+    {
+        private static readonly string[] Summaries =
+        [
+            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+        ];
+
+        /// <summary>
+        /// 生成未来 5 天的随机天气预报数据。
+        /// </summary>
+        /// <returns>天气预报数据集合。</returns>
+        public IEnumerable<WeatherForecast> GetWeatherForecasts()
+        {
+            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+            {
+                Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
+                TemperatureC = Random.Shared.Next(-20, 55),
+                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
+            })
+            .ToArray();
+        }
+    }
+}