如何处理第三方API中不可修改的设计糟糕模型？

我太懂这种每次强转还要翻数据库查类型的糟心感了——第三方API这种把属性都设成object的设计，简直是开发路上的绊脚石。针对你的问题，我分享几个实际用过的可行方案，你可以根据自己的项目情况挑：

这个思路和你预想的一致，先定义一个符合预期的强类型类：

public class StronglyTypedPlayer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

然后用AutoMapper配置一次映射规则，把所有类型转换逻辑集中处理：

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Player, StronglyTypedPlayer>()
        .ForMember(dest => dest.Id, opt => opt.MapFrom(src => (int)src.Id))
        .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Name?.ToString() ?? string.Empty));
});

IMapper mapper = config.CreateMapper();

// 后续使用时直接映射，再也不用手动强转
var typedPlayer = mapper.Map<StronglyTypedPlayer>(originalPlayer);
var id = typedPlayer.Id; // 直接是int类型
var name = typedPlayer.Name; // 直接是string类型

好处：一劳永逸，后续业务代码只用自定义类即可；如果API属性有小变动，只需要修改映射配置，不用改所有业务代码。
注意点：一定要处理null场景，比如上面的src.Name?.ToString() ?? string.Empty，避免空引用异常。

如果不想引入AutoMapper的依赖，写个包装类或者扩展方法更直接：

包装类版本 #

把原始Player实例包起来，对外暴露强类型属性：

public class PlayerWrapper
{
    private readonly Player _innerPlayer;

    public PlayerWrapper(Player player)
    {
        _innerPlayer = player ?? throw new ArgumentNullException(nameof(player));
    }

    public int Id => (int)_innerPlayer.Id;
    public string Name => _innerPlayer.Name?.ToString() ?? string.Empty;

    // 要是需要访问原始Player的其他方法，也可以按需暴露
    public Player GetOriginalPlayer() => _innerPlayer;
}

使用时：

var wrappedPlayer = new PlayerWrapper(originalPlayer);
var id = wrappedPlayer.Id;
var name = wrappedPlayer.Name;

扩展方法版本（更灵活） #

如果只是想快速获取强类型属性，扩展方法可以让你直接在原始实例上调用：

public static class PlayerExtensions
{
    public static int GetId(this Player player)
    {
        if (player?.Id == null)
            throw new InvalidOperationException("Player Id为空或类型无效");
        return (int)player.Id;
    }

    public static string GetName(this Player player)
    {
        return player?.Name?.ToString() ?? string.Empty;
    }
}

使用时：

var id = originalPlayer.GetId();
var name = originalPlayer.GetName();

好处：不需要额外的类实例，也不用依赖第三方库，代码轻量；扩展方法可以在任何地方直接调用，侵入性极低。
注意点：如果API属性类型发生变化，需要同步修改对应的扩展方法或包装类属性。

如果想让类型转换的语法更自然，可以给自定义类重载explicit运算符：

public class StronglyTypedPlayer
{
    public int Id { get; set; }
    public string Name { get; set; }

    public static explicit operator StronglyTypedPlayer(Player player)
    {
        if (player == null)
            return null;

        return new StronglyTypedPlayer
        {
            Id = (int)player.Id,
            Name = player.Name?.ToString() ?? string.Empty
        };
    }
}

使用时直接强转，看起来和原始强转类似，但逻辑是我们自己控制的：

var typedPlayer = (StronglyTypedPlayer)originalPlayer;

• 要是项目里已经在用AutoMapper，方案1是最省心的选择；
• 不想加依赖，方案2的包装类或扩展方法完全能解决问题；
• 追求代码简洁优雅，方案3的运算符重载会让代码看起来更清爽。

不管选哪个，核心都是把重复的类型转换逻辑抽离出来，避免每次手动强转还要查类型，既能减少出错概率，也能提升开发效率。

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