EventManager

FEventRegister

using UnityEngine;
using System.Collections;
using System;

public interface IRelease {
    void Release();
}

public abstract class FEventRegisterBase
{
    protected Delegate _delegate;

    public abstract FEventRegister CastDown();

    protected virtual void OnLastListenerRemoved() { }

    protected virtual void OnFirstListenerWillAdd() { }

    protected void _AddEventHandler(Delegate d)
    {
        if (_delegate == null)
        {
            OnFirstListenerWillAdd();
        }
        _delegate = Delegate.Combine(_delegate, d);
    }

    protected void _RemoveEventHandler(Delegate d)
    {
        _delegate = Delegate.RemoveAll(_delegate, d);
        if (_delegate == null)
        {
            OnLastListenerRemoved();
        }
    }
    protected IRelease _Subscribe(Delegate cb)
    {
        _AddEventHandler(cb);
        return new HandlerRemover(this, cb);
    }

    class HandlerRemover : IRelease
    {
        FEventRegisterBase _source;
        Delegate _value;

        public HandlerRemover(FEventRegisterBase source, Delegate value)
        {
            _source = source;
            _value = value;
        }

        void IRelease.Release()
        {
            _source._RemoveEventHandler(_value);
        }

    }

    static public FEventRegister operator +(FEventRegisterBase left, FEventRegisterBase right)
    {
        return left.CastDown() + right.CastDown();
    }

}



public class FEventRegister : FEventRegisterBase
{
    public void AddEventHandler(Action cb)
    {
        _AddEventHandler(cb);
    }
    public void RemoveEventHandler(Action cb)
    {
        _RemoveEventHandler(cb);
    }

    public IRelease Subscribe(Action cb)
    {
        return _Subscribe(cb);
    }
    public override FEventRegister CastDown()
    {
        return this;
    }

    protected void _BroadCastEvent()
    {
        if (_delegate != null)
        {
            (_delegate as Action)();
        }
    }
    static public FEventRegister operator +(FEventRegister left, FEventRegister right)
    {
        return left.CastDown() + right.CastDown();
    }

    public FEventRegister<T0> CastTo<T0>(Func<T0> castCall)
    {
        return new FEventRegisterCastTo<T0>(this, castCall);
    }
}
public class FEventRegister<T0> : FEventRegisterBase
{
    public void AddEventHandler(Action<T0> cb)
    {
        _AddEventHandler(cb);
    }
    public void RemoveEventHandler(Action<T0> cb)
    {
        _RemoveEventHandler(cb);
    }

    public IRelease Subscribe(Action<T0> cb)
    {
        return _Subscribe(cb);
    }

    protected void _BroadCastEvent(T0 arg0)
    {
        if (_delegate != null)
        {
            (_delegate as Action<T0>)(arg0);
        }
    }
    public override FEventRegister CastDown()
    {
        return new FEventRegisterCastDown<T0>(this);
    }

    public FEventRegister<U0> CastTo<U0>(Func<T0, U0> castCall)
    {
        return new FEventRegisterCastFromTo<T0, U0>(this, castCall);
    }
}

public class FEventRegister<T0, T1> : FEventRegisterBase
{
    public void AddEventHandler(Action<T0, T1> cb)
    {
        _AddEventHandler(cb);
    }
    public void RemoveEventHandler(Action<T0, T1> cb)
    {
        _RemoveEventHandler(cb);
    }

    public IRelease Subscribe(Action<T0, T1> cb)
    {
        return _Subscribe(cb);
    }

    protected void _BroadCastEvent(T0 arg0, T1 arg1)
    {
        if (_delegate != null)
        {
            (_delegate as Action<T0, T1>)(arg0, arg1);
        }
    }
    public override FEventRegister CastDown()
    {
        return new FEventRegisterCastDown<T0, T1>(this);
    }

}
public class FEventRegister<T0, T1, T2> : FEventRegisterBase
{
    public void AddEventHandler(Action<T0, T1, T2> cb)
    {
        _AddEventHandler(cb);
    }
    public void RemoveEventHandler(Action<T0, T1, T2> cb)
    {
        _RemoveEventHandler(cb);
    }

    public IRelease Subscribe(Action<T0, T1, T2> cb)
    {
        return _Subscribe(cb);
    }

    protected void _BroadCastEvent(T0 arg0, T1 arg1, T2 arg2)
    {
        if (_delegate != null)
        {
            (_delegate as Action<T0, T1, T2>)(arg0, arg1, arg2);
        }
    }
    public override FEventRegister CastDown()
    {
        return new FEventRegisterCastDown<T0, T1, T2>(this);
    }

}

public class FEventRegister<T0, T1, T2, T3> : FEventRegisterBase
{
    public void AddEventHandler(Action<T0, T1, T2, T3> cb)
    {
        _AddEventHandler(cb);
    }
    public void RemoveEventHandler(Action<T0, T1, T2, T3> cb)
    {
        _RemoveEventHandler(cb);
    }

    public IRelease Subscribe(Action<T0, T1, T2, T3> cb)
    {
        return _Subscribe(cb);
    }

    protected void _BroadCastEvent(T0 arg0, T1 arg1, T2 arg2, T3 arg3)
    {
        if (_delegate != null)
        {
            (_delegate as Action<T0, T1, T2, T3>)(arg0, arg1, arg2, arg3);
        }
    }
    public override FEventRegister CastDown()
    {
        return new FEventRegisterCastDown<T0, T1, T2, T3>(this);
    }

}

FEvent

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

public class FEvent : FEventRegister
{
    public void BoradCastEvent()
    {
        _BroadCastEvent();
    }
}

public class FEvent<T0> : FEventRegister<T0>
{
    public void BoradCastEvent(T0 arg0)
    {
        _BroadCastEvent(arg0);
    }
}
public class FEvent<T0, T1> : FEventRegister<T0, T1>
{
    public void BoradCastEvent(T0 arg0, T1 arg1)
    {
        _BroadCastEvent(arg0, arg1);
    }
}

public class FEvent<T0, T1, T2> : FEventRegister<T0, T1, T2>
{
    public void BoradCastEvent(T0 arg0, T1 arg1, T2 arg2)
    {
        _BroadCastEvent(arg0, arg1, arg2);
    }
}

public class FEvent<T0, T1, T2, T3> : FEventRegister<T0, T1, T2, T3>
{
    public void BoradCastEvent(T0 arg0, T1 arg1, T2 arg2, T3 arg3)
    {
        _BroadCastEvent(arg0, arg1, arg2, arg3);
    }
}

FEventRegisterCastDown

using UnityEngine;
using System.Collections;
using System;

public class FEventRegisterCastDown<T0> : FEventRegister
{
    FEventRegister<T0> _upper;
    private void BindAction(T0 arg0)
    {
        _BroadCastEvent();
    }
    protected override void OnFirstListenerWillAdd()
    {
        _upper.RemoveEventHandler(BindAction);
        base.OnFirstListenerWillAdd();
    }
    protected override void OnLastListenerRemoved()
    {
        base.OnLastListenerRemoved();
        _upper.AddEventHandler(BindAction);
    }

    public FEventRegisterCastDown(FEventRegister<T0> upper)
    {
        _upper = upper;
    }
}

public class FEventRegisterCastTo<T0> : FEventRegister<T0>
{
    FEventRegister _inner;
    Func<T0> _castvridge;
    private void BindAction()
    {
        if (_castvridge != null)
        {
            _BroadCastEvent(_castvridge());
        }
    }
    protected override void OnLastListenerRemoved()
    {
        _inner.RemoveEventHandler(BindAction);
        base.OnLastListenerRemoved();
    }
    protected override void OnFirstListenerWillAdd()
    {
        base.OnFirstListenerWillAdd();
        _inner.AddEventHandler(BindAction);
    }
    public FEventRegisterCastTo(FEventRegister inner, Func<T0> castFun)
    {
        _inner = inner;
        _castvridge = castFun;
    }
}
public class FEventRegisterCastFromTo<T0, U0> : FEventRegister<U0>
{
    FEventRegister<T0> _inner;
    Func<T0, U0> _castvridge;
    private void BindAction(T0 arg0)
    {
        if (_castvridge != null)
        {
            _BroadCastEvent(_castvridge(arg0));
        }
    }
    protected override void OnLastListenerRemoved()
    {
        _inner.RemoveEventHandler(BindAction);
        base.OnLastListenerRemoved();
    }
    protected override void OnFirstListenerWillAdd()
    {
        base.OnFirstListenerWillAdd();
        _inner.AddEventHandler(BindAction);
    }
    public FEventRegisterCastFromTo(FEventRegister<T0> inner, Func<T0, U0> castFun)
    {
        _inner = inner;
        _castvridge = castFun;
    }
}

public class FEventRegisterCastDown<T0, T1> : FEventRegister
{
    FEventRegister<T0, T1> _upper;
    private void BindAction(T0 arg0, T1 arg1)
    {
        _BroadCastEvent();
    }
    protected override void OnFirstListenerWillAdd()
    {
        _upper.RemoveEventHandler(BindAction);
        base.OnFirstListenerWillAdd();
    }
    protected override void OnLastListenerRemoved()
    {
        base.OnLastListenerRemoved();
        _upper.AddEventHandler(BindAction);
    }

    public FEventRegisterCastDown(FEventRegister<T0, T1> upper)
    {
        _upper = upper;
    }
}
public class FEventRegisterCastDown<T0, T1, T2> : FEventRegister
{
    FEventRegister<T0, T1, T2> _upper;
    private void BindAction(T0 arg0, T1 arg1, T2 arg2)
    {
        _BroadCastEvent();
    }
    protected override void OnFirstListenerWillAdd()
    {
        _upper.RemoveEventHandler(BindAction);
        base.OnFirstListenerWillAdd();
    }
    protected override void OnLastListenerRemoved()
    {
        base.OnLastListenerRemoved();
        _upper.AddEventHandler(BindAction);
    }

    public FEventRegisterCastDown(FEventRegister<T0, T1, T2> upper)
    {
        _upper = upper;
    }
}
public class FEventRegisterCastDown<T0, T1, T2, T3> : FEventRegister
{
    FEventRegister<T0, T1, T2, T3> _upper;
    private void BindAction(T0 arg0, T1 arg1, T2 arg2, T3 arg3)
    {
        _BroadCastEvent();
    }
    protected override void OnFirstListenerWillAdd()
    {
        _upper.RemoveEventHandler(BindAction);
        base.OnFirstListenerWillAdd();
    }
    protected override void OnLastListenerRemoved()
    {
        base.OnLastListenerRemoved();
        _upper.AddEventHandler(BindAction);
    }

    public FEventRegisterCastDown(FEventRegister<T0, T1, T2, T3> upper)
    {
        _upper = upper;
    }
}

FEventregisterComb

using UnityEngine;
using System.Collections;

public class FEventregisterComb : FEventRegister
{
    FEventRegister _left;
    FEventRegister _right;

    protected override void OnFirstListenerWillAdd()
    {
        base.OnFirstListenerWillAdd();
        _left.AddEventHandler(_BroadCastEvent);
        _right.AddEventHandler(_BroadCastEvent);
    }

    protected override void OnLastListenerRemoved()
    {
        _left.RemoveEventHandler(_BroadCastEvent);
        _right.RemoveEventHandler(_BroadCastEvent);
        base.OnLastListenerRemoved();
    }

    public FEventregisterComb(FEventRegister left, FEventRegister right)
    {
        _left = left;
        _right = right;
    }

}