Type Reference

A Type Reference is an object whose value represents a C# type and that can be serialized. It's supposed to be used only in case it has to be shown in the Inspector or any other Editor window (in other instances it's more optimal to serialize a simple string.)

A Type Reference is declared as follows:

[SerializeField]
private TypeReference<Type> _typeRef;

The generic parameter is used to limit the choices to only the subtypes of a given base type. For instance, let's consider the following types:

namespace Construct 
{
    public abstract class Type { ... }

    internal sealed class InternalType : Type { ... }

    public sealed class TypeA : Type { ... }

    public sealed class TypeB : Type { ... }

    public sealed class TypeC : Type { ... }
}

Specifying as generic parameter the abstract type Construct.Type, the possible options will be limited to itself and Construct.TypeA, Construct.TypeB, Construct.TypeC and Construct.InternalType.

In an editor window, a Type Reference shows up as a dropdown with a searchbar to filter through the possible options and a list of those options identified by the Type's Full Name. If there are more than 16 options, it will only list some options after a filter has been applied.

Customization Attributes

The Type Reference inspector can be further customized by decorating the field with attributes.

Optional

A Type Reference decorated with the Optional attribute will have System.Void among the possible options.

[SerializeField, Optional]
private TypeReference<Type> _typeRef;

Type Visibility

A Type Reference decorated with the TypeVisibility attribute changes what available options are present in the dropdown.

[SerializeField, TypeVisibility(TypeVisibility)]
private TypeReference<Type> _typeRef;

The TypeVisibility attribute pre-filters the options based on what parameter is passed to its constructor. The possible parameters are:

• TypeVisibility.Public. The default, equivalent to not specifying this attribute. It only shows the subtypes that are declared as public.

• TypeVisibility.NonPublic. Only show the subtypes that are internal or private.

• TypeVisibility.All. Shows both public and non-public subtypes.

tip

It's recommended to use TypeVisibility.NonPublic as sparingly as possible, since private or internal types are usually not supposed to be used outside their scope.

ConcreteTypes

A Type Reference decorated with the ConcreteTypes attribute will filter out any abstract parent type, allowing only concrete types as possible options.

[SerializeField, ConcreteTypes]
private TypeReference<Type> _typeRef;

tip

All these attributes can be combined to decorate a single Type Reference.