如何重写/扩展远程认证回调方法并支持多身份提供商？

你遇到的核心问题是C#不支持从泛型参数派生类，所以无法通过ExternalAuthenticationHandler<THandler, TOptions>这种泛型继承方式复用不同OAuth提供商的Handler逻辑。以下是几种可行的变通方案，按推荐优先级排序：

方案1：利用OAuth事件模型（推荐） #

ASP.NET Core认证框架提供了事件钩子，可以在认证流程的关键节点注入自定义逻辑，无需重写Handler。最适合你的场景是OnCreatingTicket事件——它会在OAuth提供商返回用户信息、生成ClaimsTicket时触发，此时你可以查询数据库并添加内部用户ID到Claims，最终由Cookie认证中间件自动存入Cookie。

步骤1：编写通用的事件处理方法 #

public static async Task HandleExternalAuthTicket(OAuthCreatingTicketContext context)
{
    // 从提供商的Claims中获取唯一标识（Google返回的是NameIdentifier类型）
    var externalUserId = context.Principal.FindFirstValue(ClaimTypes.NameIdentifier);
    if (string.IsNullOrEmpty(externalUserId)) return;

    // 查询数据库，获取关联的内部用户ID
    var internalUserId = await YourDbContext.Users
        .Where(u => u.GoogleId == externalUserId) // 不同提供商需调整字段，比如Facebook用FacebookId
        .Select(u => u.Id.ToString())
        .FirstOrDefaultAsync();

    if (!string.IsNullOrEmpty(internalUserId))
    {
        // 将内部用户ID添加到Claims，后续会自动存入Cookie
        context.Principal.AddClaim(new Claim("InternalUserId", internalUserId));
    }

    // 可选：如果用户不存在，可在此处自动创建内部用户
}

步骤2：配置OAuth提供商时绑定事件 #

builder.Services.AddAuthentication()
    .AddGoogle(options =>
    {
        options.ClientId = "你的Google客户端ID";
        options.ClientSecret = "你的Google客户端密钥";
        // 绑定事件
        options.Events = new OAuthEvents
        {
            OnCreatingTicket = HandleExternalAuthTicket
        };
    })
    .AddFacebook(options =>
    {
        options.AppId = "你的Facebook AppID";
        options.AppSecret = "你的Facebook AppSecret";
        // 复用同一个事件处理方法，只需在方法内调整数据库查询字段
        options.Events = new OAuthEvents
        {
            OnCreatingTicket = HandleExternalAuthTicket
        };
    })
    .AddCookie(options =>
    {
        // 配置Cookie过期时间、路径等参数
        options.ExpireTimeSpan = TimeSpan.FromDays(7);
    });

这种方式完全贴合框架设计，无需自定义Handler，配置简单且易于扩展到多提供商。

方案2：自定义抽象基类+子类实现 #

如果需要更深度的流程控制（比如修改HandleRemoteAuthenticateAsync的完整逻辑），可以创建一个抽象基类继承OAuthHandler<TOptions>，实现通用逻辑后，为每个OAuth提供商编写对应的子类。

步骤1：创建抽象基类 #

public abstract class BaseExternalOAuthHandler<TOptions> : OAuthHandler<TOptions>
    where TOptions : OAuthOptions, new()
{
    protected readonly YourDbContext _dbContext;

    protected BaseExternalOAuthHandler(
        IOptionsMonitor<TOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder,
        ISystemClock clock,
        YourDbContext dbContext)
        : base(options, logger, encoder, clock)
    {
        _dbContext = dbContext;
    }

    protected override async Task<HandleRequestResult> HandleRemoteAuthenticateAsync()
    {
        // 调用基类的认证逻辑
        var result = await base.HandleRemoteAuthenticateAsync();
        if (!result.Success) return result;

        // 获取提供商返回的用户唯一标识
        var externalUserId = result.Ticket.Principal.FindFirstValue(ClaimTypes.NameIdentifier);
        if (string.IsNullOrEmpty(externalUserId)) return result;

        // 由子类实现具体的数据库查询逻辑（适配不同提供商的字段）
        var internalUserId = await GetInternalUserId(externalUserId);
        if (!string.IsNullOrEmpty(internalUserId))
        {
            // 更新ClaimsTicket，添加内部用户ID
            var newIdentity = new ClaimsIdentity(result.Ticket.Principal.Identity);
            newIdentity.AddClaim(new Claim("InternalUserId", internalUserId));
            var newTicket = new AuthenticationTicket(new ClaimsPrincipal(newIdentity), result.Ticket.Properties);
            
            return HandleRequestResult.Success(newTicket);
        }

        return result;
    }

    // 抽象方法：子类需实现对应提供商的用户查询逻辑
    protected abstract Task<string> GetInternalUserId(string externalUserId);
}

步骤2：为Google编写子类 #

public class GoogleExternalHandler : BaseExternalOAuthHandler<GoogleOptions>
{
    public GoogleExternalHandler(
        IOptionsMonitor<GoogleOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder,
        ISystemClock clock,
        YourDbContext dbContext)
        : base(options, logger, encoder, clock, dbContext)
    {
    }

    protected override async Task<string> GetInternalUserId(string externalUserId)
    {
        return await _dbContext.Users
            .Where(u => u.GoogleId == externalUserId)
            .Select(u => u.Id.ToString())
            .FirstOrDefaultAsync();
    }
}

步骤3：替换默认的GoogleHandler #

builder.Services.AddAuthentication()
    .AddGoogle(options =>
    {
        options.ClientId = "你的Google客户端ID";
        options.ClientSecret = "你的Google客户端密钥";
    })
    .AddCookie();

// 注册自定义Handler，替换默认的GoogleHandler
builder.Services.AddTransient<GoogleHandler, GoogleExternalHandler>();

这种方式逻辑集中，扩展性强，但需要为每个提供商编写子类，适合需要深度定制认证流程的场景。

方案3：装饰器模式包装现有Handler #

通过装饰器模式包装原有的OAuthHandler，实现逻辑注入，无需继承泛型参数。这种方式灵活性最高，但需要实现IAuthenticationHandler的所有方法。

装饰器类实现 #

public class ExternalAuthDecorator<THandler, TOptions> : IAuthenticationHandler
    where TOptions : OAuthOptions, new()
    where THandler : OAuthHandler<TOptions>, IAuthenticationHandler
{
    private readonly THandler _innerHandler;
    private readonly YourDbContext _dbContext;

    public ExternalAuthDecorator(THandler innerHandler, YourDbContext dbContext)
    {
        _innerHandler = innerHandler;
        _dbContext = dbContext;
    }

    public async Task InitializeAsync(AuthenticationScheme scheme, HttpContext context)
    {
        await _innerHandler.InitializeAsync(scheme, context);
    }

    public async Task<AuthenticateResult> AuthenticateAsync()
    {
        var result = await _innerHandler.AuthenticateAsync();
        if (result.Succeeded)
        {
            var externalUserId = result.Principal.FindFirstValue(ClaimTypes.NameIdentifier);
            var internalUserId = await _dbContext.Users
                .Where(u => u.GoogleId == externalUserId)
                .Select(u => u.Id.ToString())
                .FirstOrDefaultAsync();

            if (!string.IsNullOrEmpty(internalUserId))
            {
                // 更新ClaimsPrincipal
                var newIdentity = new ClaimsIdentity(result.Principal.Identity);
                newIdentity.AddClaim(new Claim("InternalUserId", internalUserId));
                var newPrincipal = new ClaimsPrincipal(newIdentity);
                
                return AuthenticateResult.Success(new AuthenticationTicket(newPrincipal, result.Properties));
            }
        }
        return result;
    }

    public async Task ChallengeAsync(AuthenticationProperties properties)
    {
        await _innerHandler.ChallengeAsync(properties);
    }

    public async Task ForbidAsync(AuthenticationProperties properties)
    {
        await _innerHandler.ForbidAsync(properties);
    }
}

注册装饰器 #

builder.Services.AddAuthentication()
    .AddGoogle(options =>
    {
        options.ClientId = "你的Google客户端ID";
        options.ClientSecret = "你的Google客户端密钥";
    })
    .AddCookie();

// 替换原Handler为装饰器
builder.Services.AddTransient<GoogleHandler, ExternalAuthDecorator<GoogleHandler, GoogleOptions>>();

这种方式无需修改原Handler逻辑，适合快速扩展，但需要维护接口的所有方法实现。

内容的提问来源于stack exchange，提问作者Szyszka947