PatientEventSystem.cs

using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using System.Collections.Generic;
using System;

public class ObjectEvent : UnityEvent<object> { } //empty class; just needs to exist


public class EventTupel
{
    public ObjectEvent objEvent;
    public object obj;

    public EventTupel(ObjectEvent objEvent, object obj)
    {
        this.objEvent = objEvent;
        this.obj = obj;
    }
}
public class PatientEventSystem
{
    private Dictionary< Event, ObjectEvent> mEventDictionary;
    private static List<EventTupel> savedEvents = new List<EventTupel>();
    private static PatientEventSystem mInstance = null;

    public enum Event {
        PATIENT_StartLoading,
        PATIENT_Loaded,
        PATIENT_FinishedLoading,
        PATIENT_NewPatientDirectoryFound,

        PATIENT_Closed,
        MESH_LoadedSingle,      // Called whenever a new mesh has been loaded
        MESH_LoadedAll,         // Called after all of the patient's meshes have been loaded
        MESH_Opacity_Changed,

        DICOM_NewList,
        DICOM_StartLoadingSlice,
        DICOM_StartLoadingVolume,
        DICOM_NewLoadedSlice,
        DICOM_NewLoadedVolume,
        DICOM_AllCleared,
        DICOM_CloseVolume,

        LOADING_AddLoadingJob,
        LOADING_RemoveLoadingJob
    }

    public static PatientEventSystem instance
    {
        get {
            if (mInstance == null) {
                mInstance = new PatientEventSystem ();
            }
            return mInstance;
        }
    }

    public static void startListening(Event eventType, UnityAction<object> listener)
    {
        ObjectEvent thisEvent = null;
        // Attempt to get the the UnityEvent from the dictionary. If this succeeds,
        // thisEvent will be filled and the if will evaluate to true:
        if (instance.mEventDictionary.TryGetValue(eventType, out thisEvent))
        {
            thisEvent.AddListener(listener);
        }
        else {
            thisEvent = new ObjectEvent();
            thisEvent.AddListener(listener);
            instance.mEventDictionary.Add(eventType, thisEvent);
        }
        //Debug.Log("Added event listener for event: " + eventType);
    }
    public static void stopListening(Event eventType, UnityAction<object> listener)
    {
        if (mInstance == null)
            return;

        ObjectEvent thisEvent = null;
        // Attempt to get the the UnityEvent from the dictionary. If this succeeds,
        // thisEvent will be filled and the if will evaluate to true:
        if (instance.mEventDictionary.TryGetValue(eventType, out thisEvent))
        {
            thisEvent.RemoveListener(listener);
        }
        //Debug.Log("Removed event listener for event: " + eventType);
    }
    public static void triggerEvent(Event eventType, object obj = null )
    {
        ObjectEvent thisEvent = null;
        // Attempt to get the the UnityEvent from the dictionary. If this succeeds,
        // thisEvent will be filled and the if will evaluate to true:
        if (instance.mEventDictionary.TryGetValue(eventType, out thisEvent))
        {
            //Debug.Log("Triggering Event: " + eventType);
            //thisEvent.Invoke( obj );

            //save event and execute them in main thread, because events can be called form other thread (e.g. PATIENT_Loaded)
            savedEvents.Add(new EventTupel(thisEvent, obj));

        }
    }

    /*
     *  Executes all saved events since the last call 
     */
    public static void executeSavedEvents()
    {
        if (savedEvents.Count == 0)
        {
            return;
        }

        List<EventTupel> savedEventsCopy = new List<EventTupel>(savedEvents);
        savedEvents.Clear();

        foreach(EventTupel e in savedEventsCopy)
        {
            e.objEvent.Invoke(e.obj);
        }
    }

    private PatientEventSystem()
    {
        if( mEventDictionary == null )
        {
            mEventDictionary = new Dictionary< Event, ObjectEvent >();
        }
    }

}