如何实现适配多.NET运行时的NuGet包配置兼容构造函数？

由于你的类库编译为.NET Standard 2.0程序集，编译时条件编译无法区分最终运行环境，因此需要结合运行时检测和构造函数限制策略来实现需求，同时无需多版本编译。

1. 运行时环境检测 #

通过RuntimeInformation.FrameworkDescription可以精准判断当前运行的框架类型：

using System.Runtime.InteropServices;

private static bool IsRunningOnNetFramework()
{
    return RuntimeInformation.FrameworkDescription
        .StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);
}

2. 构造函数的条件限制与提示 #

方案一：运行时校验+错误拦截 #

同时定义两个构造函数，在运行时校验环境并阻止错误调用，配合XML注释让开发者在IDE中提前感知：

using Microsoft.Extensions.Configuration;
using System.Configuration;

public class YourTargetClass
{
    /// <summary>
    /// .NET（Core/5+）环境专用构造函数
    /// </summary>
    /// <param name="configuration">.NET配置对象</param>
    public YourTargetClass(IConfiguration configuration)
    {
        if (IsRunningOnNetFramework())
        {
            throw new InvalidOperationException(
                "该构造函数仅适用于.NET环境，请使用接受ConfigurationManager的重载");
        }
        // .NET环境初始化逻辑
    }

    /// <summary>
    /// .NET Framework环境专用构造函数
    /// </summary>
    /// <param name="configurationManager">Framework配置对象</param>
    public YourTargetClass(ConfigurationManager configurationManager)
    {
        if (!IsRunningOnNetFramework())
        {
            throw new InvalidOperationException(
                "该构造函数仅适用于.NET Framework环境，请使用接受IConfiguration的重载");
        }
        // .NET Framework环境初始化逻辑
    }

    private static bool IsRunningOnNetFramework()
    {
        return RuntimeInformation.FrameworkDescription
            .StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);
    }
}

方案二：编译符号隐藏无用构造函数 #

利用引用项目自动生成的框架符号，让不同环境的开发者仅能看到对应构造函数。需要在类库的csproj中添加符号定义：

<PropertyGroup>
  <TargetFramework>netstandard2.0</TargetFramework>
  <DefineConstants>NETSTANDARD2_0;$(DefineConstants)</DefineConstants>
</PropertyGroup>

然后编写构造函数：

using Microsoft.Extensions.Configuration;
using System.Configuration;

public class YourTargetClass
{
#if !NETFRAMEWORK
    // 仅.NET环境可见
    public YourTargetClass(IConfiguration configuration)
    {
        // .NET环境初始化逻辑
    }
#endif

#if NETFRAMEWORK
    // 仅.NET Framework环境可见
    public YourTargetClass(ConfigurationManager configurationManager)
    {
        // .NET Framework环境初始化逻辑
    }
#endif
}

引用该类库的项目会根据自身框架自动过滤构造函数，从根源避免误用。

3. 更优雅的替代：抽象配置访问层 #

如果不想暴露多个构造函数，可以通过抽象接口统一配置访问逻辑，用工厂方法封装环境判断：

public interface IConfigAccessor
{
    string GetValue(string key);
}

public class YourTargetClass
{
    public YourTargetClass(IConfigAccessor configAccessor)
    {
        // 统一初始化逻辑，依赖抽象接口
    }
}

public static class YourTargetClassFactory
{
    public static YourTargetClass Create()
    {
        if (IsRunningOnNetFramework())
        {
            return new YourTargetClass(
                new NetFrameworkConfigAccessor(ConfigurationManager.AppSettings));
        }
        throw new InvalidOperationException(
            ".NET环境下请使用Create(IConfiguration)方法");
    }

    public static YourTargetClass Create(IConfiguration configuration)
    {
        if (IsRunningOnNetFramework())
        {
            throw new InvalidOperationException(
                ".NET Framework环境下请使用无参数Create方法");
        }
        return new YourTargetClass(new NetCoreConfigAccessor(configuration));
    }

    private static bool IsRunningOnNetFramework()
    {
        return RuntimeInformation.FrameworkDescription
            .StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);
    }
}

// 内部实现类，对外隐藏细节
internal class NetFrameworkConfigAccessor : IConfigAccessor
{
    private readonly NameValueCollection _appSettings;
    public NetFrameworkConfigAccessor(NameValueCollection appSettings) => _appSettings = appSettings;
    public string GetValue(string key) => _appSettings[key];
}

internal class NetCoreConfigAccessor : IConfigAccessor
{
    private readonly IConfiguration _configuration;
    public NetCoreConfigAccessor(IConfiguration configuration) => _configuration = configuration;
    public string GetValue(string key) => _configuration[key];
}

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