在Core Data中存储带关联值的枚举是否可行？求解决方案

当然可以实现，下面提供两种实用方案：

方案一：通过Transformable属性配合自定义转换器 #

这种方式适合不需要基于枚举关联值做查询的场景，代码简洁易维护：

1. 修改Core Data数据模型
   给目标实体添加一个类型为Transformable的属性（比如命名为activity），在属性检查器中设置「Value Transformer」为自定义的转换器名称（比如ActivityTransformer）。

2. 让枚举遵循Codable协议
   因为要做编码解码，先给你的枚举添加Codable实现：

enum Activity: Codable {
    case bored
    case running(destination: String)
    case talking(topic: String)
    case singing(volume: Int)
}

3. 实现自定义ValueTransformer
   编写转换器类，负责将枚举和可存储的Data类型互相转换：

import CoreData

class ActivityTransformer: ValueTransformer {
    override class func transformedValueClass() -> AnyClass {
        return Activity.self
    }
    
    override class func allowsReverseTransformation() -> Bool {
        return true
    }
    
    override func transformedValue(_ value: Any?) -> Any? {
        guard let activity = value as? Activity else { return nil }
        return try? JSONEncoder().encode(activity)
    }
    
    override func reverseTransformedValue(_ value: Any?) -> Any? {
        guard let data = value as? Data else { return nil }
        return try? JSONDecoder().decode(Activity.self, from: data)
    }
}

// 注册转换器的名称
extension ActivityTransformer {
    static let name = NSValueTransformerName(rawValue: "ActivityTransformer")
}

4. 注册转换器
   在App启动时（比如AppDelegate的didFinishLaunchingWithOptions方法里）注册转换器：

ValueTransformer.setValueTransformer(ActivityTransformer(), forName: ActivityTransformer.name)

之后你就可以像操作普通属性一样，给Core Data实体的activity属性赋值或读取枚举值了。

方案二：拆分字段存储（支持关联值查询） #

如果需要基于枚举的关联值做Core Data查询（比如查询所有running且目的地是"公园"的记录），Transformable方式无法满足，此时可以拆分字段存储：

1. 修改Core Data数据模型
   给目标实体添加两个字段：

• activityType：String类型，存储枚举case的标识（比如"bored"、"running"）
• activityValue：String类型（存储字符串关联值）或Int类型（存储数值关联值，这里统一用String适配多种类型），无关联值时设为nil

2. 在NSManagedObject子类中封装枚举属性
   通过计算属性将两个字段封装成枚举，对外暴露统一的activity接口：

import CoreData

// 假设你的Core Data实体名为Record
extension Record {
    var activity: Activity {
        get {
            guard let type = activityType else { return .bored }
            switch type {
            case "bored":
                return .bored
            case "running":
                return .running(destination: activityValue ?? "")
            case "talking":
                return .talking(topic: activityValue ?? "")
            case "singing":
                guard let volume = activityValue.flatMap(Int.init) else { return .bored }
                return .singing(volume: volume)
            default:
                return .bored
            }
        }
        set {
            switch newValue {
            case .bored:
                activityType = "bored"
                activityValue = nil
            case .running(let destination):
                activityType = "running"
                activityValue = destination
            case .talking(let topic):
                activityType = "talking"
                activityValue = topic
            case .singing(let volume):
                activityType = "singing"
                activityValue = String(volume)
            }
        }
    }
}

两种方案对比 #

• Transformable方案：代码简洁，无需手动维护字段映射，但无法基于关联值做Core Data查询，存储的是二进制数据，可读性差。
• 拆分字段方案：支持基于关联值的查询，存储内容直观，但需要手动维护枚举与字段的映射关系，代码量稍多。

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