Unityでのenumシリアライズ

using System;
using UnityEngine;
using UnityEngine.Assertions;
 
public class EnumStringPropertyAttribute : PropertyAttribute
{
    public Type type { get { return _type; } }
 
    public EnumStringPropertyAttribute(Type type)
    {
        Assert.IsNotNull(type);
        Assert.IsTrue(type.IsEnum, "Type must be enum: " + type.Name);
        _type = type;
    }
 
    private Type _type = null;
}

using UnityEngine;
using UnityEditor;
using System;
 
[CustomPropertyDrawer(typeof(EnumStringPropertyAttribute))]
public class EnumStringPropertyDrawer : PropertyDrawer
{
    public new EnumStringPropertyAttribute attribute { get { return (EnumStringPropertyAttribute)base.attribute; } }
 
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        if(property.propertyType == SerializedPropertyType.String) {
            property.stringValue = getValue(position, property, label);
            return;
        }
 
        EditorGUI.LabelField(position, label, "EnumStringProperty must be string.");
    }
 
    private string getValue(Rect position, SerializedProperty property, GUIContent label)
    {
        var type = attribute.type;
 
        Enum selected = null;
 
        if(Enum.IsDefined(type, property.stringValue)) {
            selected = (Enum)Enum.Parse(type, property.stringValue);
        } else {
            // デフォルト値（0）を取得
            selected = (Enum)Activator.CreateInstance(type);
        }
 
        var value = EditorGUI.EnumPopup(position, label, selected);
        return value.ToString();
    }
}

[SerializeField]
[EnumStringProperty(typeof(Type))]
private string _string = default(Type).ToString();

using UnityEngine;
using System;
 
[Serializable]
public abstract class EnumStringBase
{
    public virtual string text { get { return _text; } protected set { _text = value; } }
 
    [SerializeField]
    private string _text = "";
}
 
[Serializable]
public class EnumString<T> : EnumStringBase
    where T : struct, IConvertible
{
    public static Type type { get { return typeof(T); } }
 
    public static bool isDefined(string text)
    {
        return EnumUtil<T>.isDefined(text);
    }
 
    public static T parseOrDefault(string name)
    {
        return EnumUtil<T>.parseOrDefault(name);
    }
 
    public static T? parseOrNull(string name)
    {
        return EnumUtil<T>.parseOrNull(name);
    }
 
    public override string text
    {
        get { return base.text; }
        protected set
        {
            base.text = value;
            _cache = null;
        }
    }
 
    public T value
    {
        get
        {
            if(_cache == null) {
                _cache = parseOrDefault(text);
            }
            return (T)_cache;
        }
        set
        {
            text = value.ToString();
            _cache = value;
        }
    }
 
    public T? cache { get { return _cache; } }
 
    public EnumString() { }
 
    public EnumString(T value)
    {
        this.value = value;
    }
 
    public static implicit operator T(EnumString<T> obj) { return obj.value; }
 
    private T? _cache = null;
}

using System;
using System.Reflection;
using UnityEngine;
using UnityEditor;
 
[CustomPropertyDrawer(typeof(EnumStringBase), true)]
public class EnumStringDrawer : PropertyDrawer
{
    private Type fieldType { get { return fieldInfo.FieldType; } }
    private PropertyInfo typePropertyInfo { get { return fieldType.GetProperty("type", BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Static); } }
 
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        var textProperty = property.FindPropertyRelative("_text");
        textProperty.stringValue = getValue(position, textProperty, label);
    }
 
    private string getValue(Rect position, SerializedProperty property, GUIContent label)
    {
        var type = getEnumType();
        Debug.Assert(type != null, "type is null.");
        if(type == null) return "";
 
        Enum selected = null;
 
        if(Enum.IsDefined(type, property.stringValue)) {
            selected = (Enum)Enum.Parse(type, property.stringValue);
        } else {
            // デフォルト値（0）を取得
            selected = (Enum)Activator.CreateInstance(type);
        }
 
        var value = EditorGUI.EnumPopup(position, label, selected);
        return value.ToString();
    }
 
    private Type getEnumType()
    {
        var propertyInfo = typePropertyInfo;
        if(propertyInfo != null) {
            var methodInfo = propertyInfo.GetGetMethod();
            if(methodInfo != null) {
                return (Type)methodInfo.Invoke(null, null);
            }
        }
        return null;
    }
}

[Serializable]
public class TypeString : EnumString<Type> { }
 
[SerializeField]
private TypeString _typeString = new TypeString();

using System;
using UnityEngine;
 
public class EnumTest : MonoBehaviour
{
    public enum Type
    {
        Invalid,
        A,
        B,
        C,
    }
 
    [Serializable]
    public class TypeString : EnumString<Type> { }
 
    private void Start()
    {
        Debug.Log(_type.ToString());
        Debug.Log(Enum.Parse(typeof(Type), _string).ToString());
        Debug.Log(_typeString.value.ToString());
    }
 
    [SerializeField]
    private Type _type = Type.Invalid;
 
    [SerializeField]
    [EnumStringProperty(typeof(Type))]
    private string _string = default(Type).ToString();
 
    [SerializeField]
    private TypeString _typeString = new TypeString();
}