Do not serialize field but show in the inspector

Question

Let's say I have a class like this:

[System.Serializable]
public class Item {
private Transform _transform;
private float _value;
}

I want to serialize this class using BinaryFormatter. I can't serialize Transform component so I need to ignore it while serializing but I still need this _transform field to be visible in the inspector. In this example only field _value should be serialized.

If I use [System.NonSerialized] on _transform field it won't be visible in the Unity inspector and if I use [SerializeField] I can't serialize Transform with BinaryFormatter.

Seems a bit like a paradox... Is it possible to do so?

BinaryFormatter Is notoriously hard to use, could you use `JsonUtilty` and save it as json instead? — Scott Chamberlain, Jun 13 '17 at 20:43
@ScottChamberlain I could use JsonUtility but how it will affect my problem? I still don't want to serialize Transform field. — Powderek, Jun 13 '17 at 20:55
Well you kind of have to, The editor shows it's stuff by serializing the object and sending it to the editor. You will need to write a [custom editor](https://docs.unity3d.com/Manual/editor-CustomEditors.html) component to bypass this process. Also you never said you did not ***want*** to serialize the field, you said you ***can't*** serialize it, like you wanted to but you where getting a error when you tried. My JsonUtility suggestion was maybe the class could serialize it (I am not in a place to try) — Scott Chamberlain, Jun 13 '17 at 20:58

Reasurria · Answer 1 · 2017-06-14T06:48:02.803

I would not recommend using your scene objects or domain objects for serialization as well. You will always be battling between the two different serialization requirements.

I would recommend separating your models between scene model and persistence/serialization model.

public class SerializableItemModel
{
    public Vector3 position;
    public Quaternion rotation;
    public float _value;
}

Then have a mapper than can map between your objects.

public class ItemToModelMapper
{
    public SerializableItemModel MapToModel(Item item)
    {
        var model = new SerializableItemModel
        {
            position = item.transform.position;
            rotation = item.transform.rotation;
            _value = item._value;
        };
        return model
    }

    public Item MapFromModel(SerializableItemModel model)
    {
        return new Item(model.position, model.rotation, model._value);
    }
}

If you separate your objects like this you will never have to worry about cross cutting concerns like serializing your object for persistence and also somehow display it in the inspector etc. If you want to serialize only 10% of your scene object then you map it into a small model and serialize that instead.

Of course this is a lot more code than you probably were hoping to write. If you wanted to you could just provide the Item to the SerializableItemModel constructor and skip the mapping layer.

public class SerializableItemModel
{
    public Vector3 position;
    public Quaternion rotation;
    public float _value;

    public SerializableItemModel(Item item)
    {
         this.position = item.transform.position;
         this.rotation = item.transform.rotation;
         this._value = item.transform._value;
    }
}

Now your code will look like this when serializing:

private ItemToModelMapper mapper;
void Start()
{
    Item item = new Item();
    ...
    ...
    // Serialize
    var serializationModel = this.mapper.MapToModel(item);
    string json = JsonUtility.ToJson(serializationModel );

    // Deserialize
    SerializableItemModel deserializedModel = JsonUtility.FromJson<SerializableItemModel>(json);
    Item loadedItem = this.mapper.MapFromModel(deserializedModel);
}

EDIT: As pointed out by Programmer I never addressed the inspector view for Item. Because the Item class now only has one responsibility you are welcome to put [SerializeField] on any field because this object will not be used for any other serialization. You can now also use any serializer you want (JsonUtility, BinaryFormatter, JsonConvert, XmlSerializer, etc).

Don't see any difference between between what I have in my answer an what's in your answer. Basically the-same thing of separating position, rotation and scale then saving it as json. Things you should know about this answer: 1.OP wants to see `_transform` variable in the Editor and you left that out. 2.`JsonUtility` cannot serialize/de-serialize the class in your answer due to the use of properties. — Programmer, Jun 14 '17 at 06:19
@Programmer The striking difference is that you use a single object for both purposes which will always be problematic. This already manifests here "Call the updateValues() function before serializing the object to json". Good luck remembering that every time. The properties is an implementation detail. The problem with your answer is the violation of single responsibility, using one object for 2 purposes. What happens when he adds a LineRenderer and he needs to serialize the positions? After separating the concerns properly he can add [SerializeField] on the Item._transform. — Reasurria, Jun 14 '17 at 06:27
This concept is good and it`s propably the "proper" way in most cases but it is not what I was hoping to get. I do want to have single object for inspector and serialization. — Powderek, Jun 15 '17 at 07:17
@Powderek Ah in that case Programmer's answer is the way to go. — Reasurria, Jun 15 '17 at 07:39

score 2 · Accepted Answer · answered Jun 13 '17 at 21:20

I can't serialize Transform component so I need to ignore it while serializing but I still need this _transform field to be visible in the inspector.

You can't do this but there is a workaround. Like scott mentioned, use JsonUtilty. That will not completely solve your problem but will prevent giving you error when you try to de-serialize the json data due to the _transform variable.

You only need position, rotation and scale from the Transform class and all these can be serialized since they are either Vector3 or Quaternion but Transform cannot be serialized. So you have to declare position, rotation and scale and get their values from the _transform variable. You can then serialize those 3 values.

[System.Serializable]
public class Item
{
    //Will be ignored by JsonUtility but will be visible in the Editor
    [SerializeField]
    private Transform _transform;
    [SerializeField]
    private float _value;

    [SerializeField]
    private Vector3 position;
    [SerializeField]
    private Quaternion rotation;
    [SerializeField]
    private Vector3 scale;

    //Call before serializing
    public void updateValues()
    {
        position = _transform.position;
        rotation = _transform.rotation;
        scale = _transform.localScale;
    }
}

Call the updateValues() function before serializing the object to json.

void Start()
{
    Item item = new Item();
    ...
    ...
    item.updateValues();
    string json = JsonUtility.ToJson(item);
    Debug.Log(json);
}

By using json you will not have any problems while serializing the data. If you plan on saving this then look into a simple wrapper I made to handle all these.

Do not serialize field but show in the inspector

2 Answers2