コード例 #1
0
 public virtual void Invoke(T1 args0)
 {
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate(args0);
     }
 }
コード例 #2
0
        public void Invoke()
        {
            List <BaseInvokableCall> list = base.PrepareInvoke();

            for (int i = 0; i < list.Count; i++)
            {
                InvokableCall invokableCall = list[i] as InvokableCall;
                if (invokableCall != null)
                {
                    invokableCall.Invoke();
                }
                else
                {
                    InvokableCall invokableCall2 = list[i] as InvokableCall;
                    if (invokableCall2 != null)
                    {
                        invokableCall2.Invoke();
                    }
                    else
                    {
                        BaseInvokableCall baseInvokableCall = list[i];
                        if (this.m_InvokeArray == null)
                        {
                            this.m_InvokeArray = new object[0];
                        }
                        baseInvokableCall.Invoke(this.m_InvokeArray);
                    }
                }
            }
        }
コード例 #3
0
 public override void Invoke(object[] args)
 {
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate();
     }
 }
コード例 #4
0
 public void Invoke(T1 args0, T2 args1, T3 args2, T4 args3)
 {
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate(args0, args1, args2, args3);
     }
 }
コード例 #5
0
 public void Invoke(T1 args0, T2 args1)
 {
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate(args0, args1);
     }
 }
コード例 #6
0
 public void Invoke()
 {
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate();
     }
 }
コード例 #7
0
        public void Invoke(T0 arg0, T1 arg1, T2 arg2)
        {
            List <BaseInvokableCall> list = base.PrepareInvoke();

            for (int i = 0; i < list.Count; i++)
            {
                InvokableCall <T0, T1, T2> invokableCall = list[i] as InvokableCall <T0, T1, T2>;
                if (invokableCall != null)
                {
                    invokableCall.Invoke(arg0, arg1, arg2);
                }
                else
                {
                    InvokableCall invokableCall2 = list[i] as InvokableCall;
                    if (invokableCall2 != null)
                    {
                        invokableCall2.Invoke();
                    }
                    else
                    {
                        BaseInvokableCall baseInvokableCall = list[i];
                        if (this.m_InvokeArray == null)
                        {
                            this.m_InvokeArray = new object[3];
                        }
                        this.m_InvokeArray[0] = arg0;
                        this.m_InvokeArray[1] = arg1;
                        this.m_InvokeArray[2] = arg2;
                        baseInvokableCall.Invoke(this.m_InvokeArray);
                    }
                }
            }
        }
コード例 #8
0
 public override void Invoke(object[] args)
 {
     if (!BaseInvokableCall.AllowInvoke((System.Delegate) this.Delegate))
     {
         return;
     }
     this.Delegate();
 }
コード例 #9
0
        public override void Invoke(object[] args)
        {
            bool flag = BaseInvokableCall.AllowInvoke(this.Delegate);

            if (flag)
            {
                this.Delegate();
            }
        }
コード例 #10
0
        public void Invoke()
        {
            bool flag = BaseInvokableCall.AllowInvoke(this.Delegate);

            if (flag)
            {
                this.Delegate();
            }
        }
コード例 #11
0
 public override void Invoke(object[] args)
 {
     if (args.Length != 1)
     {
         throw new ArgumentException("Passed argument 'args' is invalid size. Expected size is 1");
     }
     BaseInvokableCall.ThrowOnInvalidArg <T1>(args[0]);
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate((T1)((object)args[0]));
     }
 }
コード例 #12
0
 public void Initialize(InvokableCallList invokableList, UnityEventBase unityEventBase)
 {
     foreach (PersistentCall call in this.m_Calls)
     {
         if (call.IsValid())
         {
             BaseInvokableCall runtimeCall = call.GetRuntimeCall(unityEventBase);
             if (runtimeCall != null)
             {
                 invokableList.AddPersistentInvokableCall(runtimeCall);
             }
         }
     }
 }
コード例 #13
0
 public override void Invoke(object[] args)
 {
     if (args.Length != 2)
     {
         throw new ArgumentException("Passed argument 'args' is invalid size. Expected size is 1");
     }
     BaseInvokableCall.ThrowOnInvalidArg <T1>(args[0]);
     BaseInvokableCall.ThrowOnInvalidArg <T2>(args[1]);
     if (!BaseInvokableCall.AllowInvoke((System.Delegate) this.Delegate))
     {
         return;
     }
     this.Delegate((T1)args[0], (T2)args[1]);
 }
コード例 #14
0
 public override void Invoke(object[] args)
 {
     if (args.Length != 4)
     {
         throw new ArgumentException("Passed argument 'args' is invalid size. Expected size is 1");
     }
     BaseInvokableCall.ThrowOnInvalidArg <T1>(args[0]);
     BaseInvokableCall.ThrowOnInvalidArg <T2>(args[1]);
     BaseInvokableCall.ThrowOnInvalidArg <T3>(args[2]);
     BaseInvokableCall.ThrowOnInvalidArg <T4>(args[3]);
     if (BaseInvokableCall.AllowInvoke(this.Delegate))
     {
         this.Delegate((T1)args[0], (T2)args[1], (T3)args[2], (T4)args[3]);
     }
 }
コード例 #15
0
 public void Initialize(InvokableCallList invokableList, UnityEventBase unityEventBase)
 {
     foreach (PersistentCall current in this.m_Calls)
     {
         bool flag = !current.IsValid();
         if (!flag)
         {
             BaseInvokableCall runtimeCall = current.GetRuntimeCall(unityEventBase);
             bool flag2 = runtimeCall != null;
             if (flag2)
             {
                 invokableList.AddPersistentInvokableCall(runtimeCall);
             }
         }
     }
 }
コード例 #16
0
 public void Initialize(InvokableCallList invokableList, UnityEventBase unityEventBase)
 {
     using (List <PersistentCall> .Enumerator enumerator = this.m_Calls.GetEnumerator())
     {
         while (enumerator.MoveNext())
         {
             PersistentCall current = enumerator.Current;
             if (current.IsValid())
             {
                 BaseInvokableCall runtimeCall = current.GetRuntimeCall(unityEventBase);
                 if (runtimeCall != null)
                 {
                     invokableList.AddPersistentInvokableCall(runtimeCall);
                 }
             }
         }
     }
 }
コード例 #17
0
ファイル: UnityEvent.cs プロジェクト: leek9d/UnityCsReference
 internal void AddCall(BaseInvokableCall call)
 {
     m_Calls.AddListener(call);
 }
コード例 #18
0
ファイル: UnityEvent.cs プロジェクト: leek9d/UnityCsReference
 public void AddListener(BaseInvokableCall call)
 {
     m_RuntimeCalls.Add(call);
     m_NeedsUpdate = true;
 }
コード例 #19
0
ファイル: UnityEvent.cs プロジェクト: leek9d/UnityCsReference
 public void AddPersistentInvokableCall(BaseInvokableCall call)
 {
     m_PersistentCalls.Add(call);
     m_NeedsUpdate = true;
 }
コード例 #20
0
 public void AddListener(BaseInvokableCall call)
 {
     this.m_RuntimeCalls.Add(call);
 }
コード例 #21
0
 public void AddPersistentInvokableCall(BaseInvokableCall call)
 {
     this.m_PersistentCalls.Add(call);
 }