Dart中如何通过类变量访问枚举成员以实现封装？

你可以通过简化中间私有类的实现，或者利用Dart的静态特性优化代码，既保留DesignSystem.colors.white的调用方式，又避免繁琐的重复代码。以下是几种可行的优化方案：

方案一：用Getter替代私有类的成员变量 #

将原来的私有类改为通过getter直接返回枚举成员，无需存储实例变量，同时将枚举设为私有防止客户端直接访问：

// 私有枚举，客户端无法直接导入
enum _Color {
  black(value: '#000000'),
  white(value: '#FFFFFF');

  final String value;
  
  const _Color({required this.value});
}

enum _Spacing {
  xs(value: 5),
  sm(value: 10);

  final int value;
  
  const _Spacing({required this.value});
}

class DesignSystem {
  static const colors = _Colors();
  static const spacings = _Spacings();
}

// 私有类通过getter直接返回枚举成员，无需存储变量
class _Colors {
  const _Colors();
  
  _Color get black => _Color.black;
  _Color get white => _Color.white;
}

class _Spacings {
  const _Spacings();
  
  _Spacing get xs => _Spacing.xs;
  _Spacing get sm => _Spacing.sm;
}

这种方式减少了冗余的成员变量声明，同时私有类可以使用const构造，避免不必要的实例创建，性能更优。

方案二：直接在DesignSystem中封装分组对象 #

通过静态getter直接返回封装了枚举成员的对象，省去单独定义私有类的步骤：

enum _Color {
  black(value: '#000000'),
  white(value: '#FFFFFF');

  final String value;
  
  const _Color({required this.value});
}

enum _Spacing {
  xs(value: 5),
  sm(value: 10);

  final int value;
  
  const _Spacing({required this.value});
}

class DesignSystem {
  // 颜色分组：返回包含枚举成员的私有对象
  static get colors => const _(
    black: _Color.black,
    white: _Color.white,
  );
  
  // 间距分组同理
  static get spacings => const __(
    xs: _Spacing.xs,
    sm: _Spacing.sm,
  );
}

// 仅用于封装枚举成员的私有数据类
class _ {
  final _Color black;
  final _Color white;
  
  const _({required this.black, required this.white});
}

class __ {
  final _Spacing xs;
  final _Spacing sm;
  
  const __({required this.xs, required this.sm});
}

这种方式将私有类的定义和初始化合并，进一步减少代码行数，同时保持你期望的调用结构。

方案三：Dart 3.0+ 密封类替代枚举（可选） #

如果你的项目使用Dart 3.0及以上版本，密封类可以提供更灵活的封装方式，适合需要扩展行为的场景：

sealed class _Color {
  const _Color();
  String get value;
}

class _Black extends _Color {
  const _Black();
  @override
  String get value => '#000000';
}

class _White extends _Color {
  const _White();
  @override
  String get value => '#FFFFFF';
}

sealed class _Spacing {
  const _Spacing();
  int get value;
}

class _Xs extends _Spacing {
  const _Xs();
  @override
  int get value => 5;
}

class _Sm extends _Spacing {
  const _Sm();
  @override
  int get value => 10;
}

class DesignSystem {
  static const colors = _Colors();
  static const spacings = _Spacings();
}

class _Colors {
  const _Colors();
  
  _Color get black => const _Black();
  _Color get white => const _White();
}

class _Spacings {
  const _Spacings();
  
  _Spacing get xs => const _Xs();
  _Spacing get sm => const _Sm();
}

以上方案都能实现你想要的封装效果：客户端无需导入枚举，直接通过DesignSystem访问目标成员，同时代码结构更简洁。

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