Interface-based object references in Unity

Example.cs

public class Example : MonoBehaviour
{
    [SerializeField]
    private MyInterfaceReference reference;
    
    private void Awake()
    {
        reference.Value.Quack();
    }
}

IMyInterface.cs

public interface IMyInterface
{
    void Quack();
}

[Serializable]
public class MyInterfaceReference : InterfaceReference<IMyInterface>
{
    public override bool AllowSceneObjects => true;
}

InterfaceReference.cs

using System;
using UnityEngine;

/// <summary>
/// Base class required for the property drawer.
/// </summary>
[Serializable]
public class InterfaceReferenceBase
{
    public virtual bool AllowSceneObjects => true;

    [SerializeField]
    public UnityEngine.Object RawValue;
}

[Serializable]
public class InterfaceReference<T> : InterfaceReferenceBase where T: class
{
    public T Value
    {
        get { return RawValue as T; }
        set { RawValue = value as UnityEngine.Object; }
    }

    public static implicit operator T(InterfaceReference<T> reference)
    {
        return reference.Value;
    }
    
    public static implicit operator InterfaceReference<T>(T value)
    {
        return new InterfaceReference<T>
        {
            Value = value
        };
    }
}

InterfaceReferenceAttributePropertyDrawer.cs

using UnityEngine;
using UnityEditor;

[CustomPropertyDrawer(typeof(InterfaceReferenceBase), true)]
class InterfaceReferenceAttributePropertyDrawer : PropertyDrawer
{
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        var refType = fieldInfo.FieldType;
        if (refType.BaseType != null && refType.BaseType.IsGenericType)
        {
            var interfaceType = refType.BaseType.GenericTypeArguments[0];
            Debug.Assert(interfaceType != null);

            label = EditorGUI.BeginProperty(position, label, property);

            SerializedProperty valueProperty = null;
            foreach (SerializedProperty prop in property)
            {
                if (prop.name == "RawValue")
                {
                    valueProperty = prop;
                    break;
                }
            }
            Debug.Assert(valueProperty != null);

            // Hack to allow dragging GameObjects containing Behaviors that implement target interface
            var indentedRect = EditorGUI.IndentedRect(position);
            var e = Event.current;
            if (e.type == EventType.DragUpdated && indentedRect.Contains(e.mousePosition) && GUI.enabled)
            {
                var dragged = DragAndDrop.objectReferences;
                if (dragged.Length > 0 && dragged[0] is GameObject)
                {
                    var suitableComponent = (dragged[0] as GameObject).GetComponent(interfaceType);
                    if (suitableComponent)
                    {
                        // Force drag restart
                        e.type = EventType.MouseDrag;
                        DragAndDrop.PrepareStartDrag();

                        dragged[0] = suitableComponent;
                        DragAndDrop.objectReferences = dragged;

                        DragAndDrop.StartDrag("Drag");
                    }
                }
            }

            valueProperty.objectReferenceValue = EditorGUI.ObjectField(
                position,
                label,
                valueProperty.objectReferenceValue, 
                interfaceType,
                true);

            EditorGUI.EndProperty();
        }
        else
        {
            EditorGUI.PropertyField(position, property, label, true);
        }
    }
}