Does anyone know how to display a templated class in a monobehaviour? This only shows the list in the inspector, and not my custom TestTemp class.
public class TestTemplateMain : MonoBehaviour
{
public TestTemp<int> mInts;// = new TestTemp<int>();
public List<int> mlist;
}
using UnityEngine;
using System.Collections;
using System;
[System.Serializable]
public class TestTemp<T>
{
public T v;
public string s = "This isn't showing up";
}
I’m not sure, but I think you gotta put that class in the first one to show all the things up.
[Serializable]
public class Currency{
public float scoreSize ;
public string scoreName ;
}
public Currency[] currencies ;
That’s no longer using generics.
What ‘asd’ was more refering to was using a nested class, but that is not necessary to show up in the inspector.
I personally think you can not see generic classes in the Inspector, due to the fact you need to give it it type when declaring it. Either that, or you need to add a constrain so it has a better idea what types it can support, or you need to be clear in your generic class whether ‘T’ it is a covariant, contravariant or both type.
Isn’t using a base non-generic class as a template an option for your case? That will work for sure.
Hm, I’m not quite sure I understand. I’m confused as to what the terms covariant and contravariant mean. And with the non-generic class being an option - yes it’s an option, I’m just unsure of how to do it.
Here is a read about Covariance and Contravariance: Covariance and Contravariance in Generics - .NET | Microsoft Learn
As for a definitive answer, it seems like my first thinking was correct, you can not use generic types in Unity directly: Serializable class using generics - Questions & Answers - Unity Discussions
Thanks. I guess I’m going to have to go about this another way. Back to the drawing board!
Unity does not directly support serializing generic types.
Also, I would like to point out that unity serializes based on the type that the field is, not the type of the object in the field. This means that if you use inheritance, and set the field type to the parent type, it will deserialize as that parent type.
example:
[System.Serializable()]
public class FooClass
{
public string ValueA;
}
[System.Serializable()]
public class BarClass : FooClass
{
public int ValueB;
}
public class MyScript : MonoBehaviour
{
public FooClass Obj = new BarClass();
}
In this example 2 things will happen.
There is a work around for all of this though. Both your generic issue, and this class inheritance issue.
Unity introduced the ISerializationCallbackReceiver:
With this you can serialize and deserialize anything you want using whatever serialization process you want. You can use .net’s binary serialization for instance.
Of course, you’ll need to ALSO create a custom inspector for the script as well, so that it appears in the inspector.
Another downside though is that these customly serialized classes don’t deal with unity Object references (references to gameobjects and components) very well. Unity’s built in serializer doesn’t serialize the reference and instead stores an ‘id’ value for the thing it references and attaches that reference after deserialization.
Following is how I do this personally.
I do this by creating a custom serializable data container that breaks apart serializable data from unity object references:
https://github.com/lordofduct/spacepuppy-unity-framework/blob/master/SpacepuppyBase/Serialization/UnityData.cs
Here you can see how you’d use it:
using UnityEnginer;
using System.Collections;
using com.spacepuppy.Serialization;
public class ExampleScript : MonoBehaviour, ISerializationCallbackReceiver
{
[System.NonSerialized()]
private GenericClass<Transform> _generic;
[SerializeField()]
private UnityData _data;
#region ISerializationNotificationCallback Interface
public void OnAfterDeserialize()
{
_mover = SerializationHelper.BinaryDeserialize(_data) as GenericClass<Transform>;
_data.Clear();
}
public void OnBeforeSerialize()
{
if (_data == null) _data = new UnityData();
SerializationHelper.BinarySerialize(_data, _generic);
}
#endregion
[System.Serializable()]
public class GenericClass<T> where T : UnityEngine.Object;
{
public T SomeReferencedObject;
public string SomeStringData;
}
}
Here’s a snippet of a realworld complex class that I use it in. In it I have to serialize an object that is referenced as an interface:
public class MovementController : SPComponent, IIgnorableCollision, IForceReceiver, ISerializationCallbackReceiver
{
#region Events
public event System.EventHandler<MovementControllerHitEventArgs> MovementControllerHit;
#endregion
#region Fields
[SerializeField()]
private bool _resetVelocityOnNoMove = false;
[System.NonSerialized()]
private bool _bMoveCalled = false;
[System.NonSerialized()]
private IGameObjectMover _mover; //this needs to be serialized, but can't be
[System.NonSerialized()]
private System.Action _updateCache;
[System.NonSerialized()]
private bool _bInUpdateSequence;
[System.NonSerialized()]
private Vector3 _lastPos;
[System.NonSerialized()]
private Vector3 _lastVel;
[SerializeField()]
private UnityData _moverData; //this stores the actual serialized data for '_mover'
[System.NonSerialized()]
private IGameObjectMover _pausedMover;
[System.NonSerialized()]
private Transform _transform;
#endregion
#region CONSTRUCTOR
protected override void Awake()
{
base.Awake();
//this.ChangeMoverType(_moverType);
_transform = this.GetComponent<Transform>();
_lastPos = _transform.position;
_mover.Reinit(this);
}
protected virtual void OnSpawn()
{
_lastPos = this.transform.position;
_mover.Reinit(this);
if (this.enabled) _mover.OnEnable();
}
protected override void OnStartOrEnable()
{
base.OnStartOrEnable();
_lastVel = Vector3.zero;
if (_mover != null) _mover.OnEnable();
}
protected override void OnDisable()
{
base.OnDisable();
if (_mover != null) _mover.OnDisable();
}
#endregion
#region ISerializationNotificationCallback Interface
public void OnAfterDeserialize()
{
_mover = SerializationHelper.BinaryDeserialize(_moverData) as IGameObjectMover;
_moverData.Clear();
}
public void OnBeforeSerialize()
{
if (_moverData == null) _moverData = new UnityData();
SerializationHelper.BinarySerialize(_moverData, _mover);
}
#endregion
//... a LOT more stuff
#region Special Mover Types
public interface IGameObjectMover : IIgnorableCollision, System.IDisposable
{
//... ommitted
}
[System.Serializable()]
public class DirectRigidBodyMover : IGameObjectMover
{
//... ommitted
}
[System.Serializable()]
public class CharacterControllerMover : IGameObjectMover
{
//... ommitted
}
[System.Serializable()]
public class RagdollBodyMover : IGameObjectMover
{
//... ommitted
}
//... more mover types that are IGameObjectMovers
#endregion
}
This is an Old Thread, but i stumbled upon it during my search, this a solution/workaround that might be sufficient in most cases
= Create a subclass that has explicit type for each Type you need
//instances of this class will not show up in inspector
[System.Serializable]
public abstract class MyGenericClass<T>
{
public T genericVariable;
}
//but explicitely typed subclasses will show up
[System.Serializable]
public class MyGenericClassInt: MyGenericClass<int>
{
}
//variable example:
public MyGenericClassInt myVar; //this will show up in Inspector with 'genericVariable' as int
EDIT: improved example for clarity
Had the same problem, but nothing worked for me.
There is a way that worked in my case, which is to override ToString(). I had the following classes:
public class MyScript : MonoBehavior
{
public BaseClass C; // no need to specify a type.
public void ShowValue()
{
Debug.Log(C.ToString());
}
}
public class ChildClass<T> : BaseClass
{
public T Data;
public override string ToString()
{
// return base.ToString() // We are not interested in 'base'
return Data.ToString();
}
}
This way, BaseClass could show up in the inspector, and no need to specify a type, just drag and drop any variable inheriting BaseClass and it will show up in the inspector.
My case was simple of course, complex data structures might require some work though…
If anyone knows a better way that would be nice 
I use the same method. I suggest making the generic classes that derive from Monobehaviour abstract. This prevents a lot of trouble that can happen with Unity.