C# class inheritance with ScriptableObject UnityEvents and differently-typed UnityActions

Question

I'm creating custom UnityEvents for a game. The base class looks like this:

public class EventSO : ScriptableObject
{
    List<UnityAction> listeners = new List<UnityAction>();

    public virtual void Raise() { ... }
    public virtual void AddListener(UnityAction listener) { ... }
    public virtual void RemoveListener(UnityAction listener) { ... }
}

Sometimes I want to pass variables to an event. So I inherit:

public class FloatEventSO : EventSO
{
    List<UnityAction<float>> listeners = new List<UnityAction<float>>();

    public override void Raise(float f) { ... }
    public override void AddListener(UnityAction<float> listener) { ... }
    public override void RemoveListener(UnityAction<float> listener) { ... }
}

My goal is to be able to create ScriptableObjects for individual events I can then assign and invoke: a good example for a Float event might be to communicate game times. So, a ScriptableObject named "OnEveryHalfSec", for example.

The first problem with this approach is that I'll need to make a new class for each combination of variables passed to an event: UnityAction<float, int>, UnityAction<float, string>... and so on.

The second problem is that I can't override the base class like I've shown above; Raise(float) can't override Raise(). So I have to re-define on every class.

Is there a better way to approach this problem?

derHugo · Accepted Answer · 2022-02-19 13:06:47Z

You want to use generics!

Have a base class like e.g.

public abstract ParameterEventSO<T> : ScriptableObject
{
    List<UnityAction<T>> listeners = new List<UnityAction<T>>();

    public virtual void Raise(T value) 
    {
        foreach(var listener in listeners)
        {
            listener?.Invoke (value);
        }
    }
    public virtual void AddListener(UnityAction<T> listener)
    {
        listeners.Add(listener);
    }
    public virtual void RemoveListener(UnityAction<T> listener)
    {
        listeners.Remove(listener);
    }
}

Now you can have as many derived classes as you need with specific types like e.g.

[CreateAssetMenu]
public class FloatEvent : ParameterEventSO<float> { }

or

[CreateAssetMenu]
public class IntListEvent : ParameterEventSO<List<int>> { }

or also

public class CustomArgs
{
    public Vector3 Position;
    public string Name;
    public DateTime TimeStamp;
}

[CreateAssetMenu]
public class CustomArgsEvent : ParameterEventSO<CustomArgs> { }

John Murphy · Accepted Answer · 2022-02-19 10:24:26Z

1

It looks like you should define

public override void Raise(float f) { ... }

as

 public virtual void Raise(float f) { ... } in the base class

You didn't put "(float f)" in the base class

answered Feb 19, 2022 at 10:24

John Murphy

1963 silver badges12 bronze badges

4 Comments

Jasper R. Over a year ago

That would work if I only ever intended to extend to a float-carrying class, but what if I want a UnityEvent<int>? Then I need a Raise(float) and a Raise(int) in the base class. And so on for every permutation.

John Murphy Over a year ago

Maybe use generics, public virtual void Raise<T>(T value), and when you override, public override void Raise<float>(float f) or something similar to replace the genric value of T

Jasper R. Over a year ago

And if I wanted a UnityEvent<int, float>, create a new Raise<T1, T2>(T1 val1, T2 val2) method in the base, adding a new method each time I increase the number of arguments?

John Murphy Over a year ago

Yes you would have to create a new Raise<T> each time with however many arguments you want, like you said Raise<T1, T2>, or Raise<T1, T2, T3>, etc...

Collectives™ on Stack Overflow

C# class inheritance with ScriptableObject UnityEvents and differently-typed UnityActions

2 Answers 2

Comments

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related