C#中如何封装枚举以避免跨类库依赖？

方案1：镜像枚举+内部映射 #

在Words类库中定义一个和Letters里enum1完全一致的公开枚举，内部做值的转换，对外只暴露这个镜像枚举。这样应用只需要引用Words，完全不用感知Letters的存在。

示例代码：

// Words类库中的公开枚举
public enum PublicEnum1
{
    A,
    B,
    C
}

// Words里的业务类，负责内部转换
public class WordHandler
{
    // 对外接收PublicEnum1，内部转成Letters的enum1处理
    public void Process(PublicEnum1 input)
    {
        Letters.enum1 internalEnum = (Letters.enum1)Enum.Parse(typeof(Letters.enum1), input.ToString());
        Letters.SomeService.DoBusiness(internalEnum);
    }

    // 如果需要返回枚举值，同样转换后返回PublicEnum1
    public PublicEnum1 GetSelectedValue()
    {
        Letters.enum1 internalValue = Letters.SomeService.GetCurrent();
        return (PublicEnum1)Enum.Parse(typeof(PublicEnum1), internalValue.ToString());
    }
}

方案2：常量替代（轻量无类型安全版） #

如果场景简单，不需要枚举的类型校验，可以在Words里定义对应常量，直接映射enum1的数值：

// Words类库中的常量类
public static class EnumConsts
{
    public const int A = (int)Letters.enum1.A;
    public const int B = (int)Letters.enum1.B;
    public const int C = (int)Letters.enum1.C;
}

// 业务方法使用示例
public void Handle(int enumVal)
{
    Letters.enum1 internalVal = (Letters.enum1)enumVal;
    // 执行Letters类库的逻辑
}

这种方式代码最少，但失去了枚举的类型约束，适合对类型安全要求不高的场景。

方案3：抽象接口封装（高扩展性版） #

如果后续可能替换底层枚举或扩展功能，可以用抽象接口封装，内部用包装类适配Letters的enum1：

// Words类库中的抽象接口
public interface IEnum1
{
    int Value { get; }
    string Name { get; }
}

// 内部包装类，隐藏Letters的枚举实现
internal class Enum1Wrapper : IEnum1
{
    private readonly Letters.enum1 _innerEnum;

    public Enum1Wrapper(Letters.enum1 innerEnum)
    {
        _innerEnum = innerEnum;
    }

    public int Value => (int)_innerEnum;
    public string Name => _innerEnum.ToString();
}

// 对外提供访问入口
public static class Enum1Factory
{
    public static IEnum1 A => new Enum1Wrapper(Letters.enum1.A);
    public static IEnum1 B => new Enum1Wrapper(Letters.enum1.B);
    public static IEnum1 C => new Enum1Wrapper(Letters.enum1.C);
}

应用端通过Enum1Factory.A等方式获取实例，完全隔离底层的Letters类库，同时保留了类型安全，还方便后续替换底层实现。

内容的提问来源于stack exchange，提问作者altaaf.hussein