This library provides an Inspector dropdown (SubclassSelector) for fields serialized by Unity's [SerializeReference].

• Select a concrete type for [SerializeReference] fields via dropdown.
• Search candidates with a fuzzy finder.
• Collection support (T[], List<T>, etc.).
• Nested type support.
• Customize type display name/path with [AddTypeMenu].
• Supports CustomPropertyDrawer for selected subtypes.
• When switching types, restore previous values by matching property names (JSON-based).
• Context menu utilities:
  • Copy & paste managed-reference values
  • Clear / reset managed-reference values

Generic support improvements on Unity 2023.2+

• Supports variance matching (in/out) for generic interfaces (covariance / contravariance)

• Unity 2021.3 LTS or later (officially supported).
• Unity 2023.2 or later is recommended when you use generic field types (see “Generic support” below).

See below for the reason for the limitation of versions less than Unity 2021.3. https://blog.unity.com/engine-platform/serializereference-improvements-in-unity-2021-lts

Download any version from releases. https://github.com/mackysoft/Unity-SerializeReferenceExtensions/releases

Open Package Manager → “Add package from git URL…”, then input:

https://github.com/mackysoft/Unity-SerializeReferenceExtensions.git?path=Assets/MackySoft/MackySoft.SerializeReferenceExtensions

To pin a version, append #{VERSION}:

https://github.com/mackysoft/Unity-SerializeReferenceExtensions.git?path=Assets/MackySoft/MackySoft.SerializeReferenceExtensions#1.7.0

Or, you can install this package from the Open UPM registry.

More details here.

openupm add com.mackysoft.serializereference-extensions

using System;
using UnityEngine;

public class Example : MonoBehaviour {

	// The type that implements ICommand will be displayed in the popup.
	[SerializeReference, SubclassSelector]
	ICommand m_Command;

	// Collection support
	[SerializeReference, SubclassSelector]
	ICommand[] m_Commands = Array.Empty<ICommand>();

	void Start () {
		m_Command?.Execute();

		foreach (ICommand command in m_Commands) {
			command?.Execute();
		}
	}

	// Nested type support
	[Serializable]
	public class NestedCommand : ICommand {
		public void Execute () {
			Debug.Log("Execute NestedCommand");
		}
	}

}

public interface ICommand {
	void Execute ();
}

[Serializable]
public class DebugCommand : ICommand {

	[SerializeField]
	string m_Message;

	public void Execute () {
		Debug.Log(m_Message);
	}
}

[Serializable]
public class InstantiateCommand : ICommand {

	[SerializeField]
	GameObject m_Prefab;

	public void Execute () {
		UnityEngine.Object.Instantiate(m_Prefab,Vector3.zero,Quaternion.identity);
	}
}

// Menu override support
[AddTypeMenu("Example/Add Type Menu Command")]
[Serializable]
public class AddTypeMenuCommand : ICommand {
	public void Execute () {
		Debug.Log("Execute AddTypeMenuCommand");
	}
}

[Serializable]
public struct StructCommand : ICommand {
	public void Execute () {
		Debug.Log("Execute StructCommand");
	}
}

Unity 2023.2+ supports generic type instances for SerializeReference fields more reliably. SerializeReferenceExtensions also enhances type discovery for generic base types.

Examples:

• Generic interface as base type:
  • [SerializeReference, SubclassSelector] ICommand<int> cmd;
  • Show candidates that implement ICommand<int> (including variance rules if applicable)
• Abstract generic base type:
  • [SerializeReference, SubclassSelector] BaseCommand<int> cmd;
  • Show candidates derived from BaseCommand<int>

Note: Candidate types shown in the menu still follow “Type > eligibility rules” below.

The dropdown list is built by:

1. enumerating candidate types, then
2. filtering by eligibility (intrinsic) and compatibility with the field base type

Check the eligibility rules:

• Is it [Serializable]?
• Is it abstract?
• Is it a generic candidate type?
• Does it derive from UnityEngine.Object?
• Is [HideInTypeMenu] applied?

No. Unity does not allow UnityEngine.Object types in SerializeReference.

Unity documentation states that value types are not supported for SerializeReference, but in practice boxed structs may work in some scenarios. If you rely on structs, test on your target Unity versions and prefer classes when possible.

It is a limitation of SerializeReference of Unity.

When serializing a SerializeReference reference, the type name, namespace, and assembly name are used, so if any of these are changed, the reference cannot be resolved during deserialization.

To solve this problem, UnityEngine.Scripting.APIUpdating.MovedFromAttribute can be used.

Also, this thread will be helpful.

• https://forum.unity.com/threads/serializereference-data-loss-when-class-name-is-changed.736874/
• https://issuetracker.unity3d.com/issues/serializereference-serialized-reference-data-lost-when-the-class-name-is-refactored

I welcome feature requests and bug reports in issues and pull requests.

If you feel that my works are worthwhile, I would greatly appreciate it if you could sponsor me.

GitHub Sponsors: https://github.com/sponsors/mackysoft