本节对事件举行计算。

缘何使用ReactiveCocoa

原来的书文公布时间为：二零零六-1一-0壹 —— 来源于自身的百度小说 [由搬家工具导入]

信托和事件的有个别基础知识可参见 C#/.NET 基础学习之 [委托-事件]
部分；

二、事件：

一、开发进度中，状态及气象之间依赖过多，状态变化很难跟踪，令人讨厌，RAC能更为有效处管事人件流，而无需去管理状态。

一、委托的评释：

参考
[1]. 初识事件到
自定义事件；
[2]. 从项目不安全的信托到
类型安全的风云；
[3]. 函数指针 ~
C#中的委托(Delegate)和事件(伊夫nt)；
[4]. C# 中的委托和事件 –
张子阳；
　 C#【亚洲必赢官网】要留心的事项，观察者格局。中的委托和事件（续） –
张子阳；

一、概念：伊芙nt:A member that enables an object or class to provide notifications;官方的分解是那样，就是说在C#中，事件是使

二、裁减方法的调用，由于它跟踪状态和值的扭转，因而不要求状态更新时手动调用，收缩失误的只怕。

<access modifier> delegate <returnType> HandlerName
([parameters])

目的大概类具有公告能力的积极分子。比如说手提式有线电话机接到短信唤醒小编去开会，那么手提式有线电话机就担任了3个存有布告能力的分子。说白了，事件

3、提供联合的信息传递方法，将通知、代理、kvo以及别的全数UIControl事件的生安特卫普开始展览监察和控制，当发生变化时，就会传递事件和值。

例如：

委托

　委托本质是八个密封类，定义方法的档次，将艺术作为艺术的参数。委托包涵3个装有相同签名和再次来到值类型的静止的情势列表（调用列表）。
　委托注脚：public delegate void MyDel(string str)；
编写翻译结果为:

public sealed class MyDel : System.MulticastDelegate
{
   public MyDel(object @object, IntPtr method);
   public virtual void Invoke(string str);
   public virtual void EndInvoke(IAsyncResult res);
   public virtual IAsyncResult BeginInvoke(string str, AsyncCallback callback, object @object);
}

扩大：自定义委托类 MyDel 继承于类
MulticastDelegate，MulticastDelegate 类是 System.Delegate
的子类，帮忙多路广播委托并维护对应的寄托列表。七个常用 public 属性：
　·　Target：委托调用的办法所属的类实例的引用，若方法是静态方法，则为
null；
　·　Method：委托所代表的章程的音讯；
构造函数中的参数：object 为指标实例的引用，methodPtr
用于标识回调方法，分别对应 Target 和 Method。2个常用 public 方法：
　·　public Delegate[]
GetInvocationList()；委托的调用列表中艺术的数组；
参考：C# –
委托链；信托的本质论；　

的意义就是指标和类之间的消息传递的桥梁。

四、当班值日随着事件变化时，能够利用combineLatest、map、filter等函数便利地对值实行转变操作。

public delegate void PrintHandler(string str);

一.　创制委托（对象）

 [修饰符] delegate 返回值类型 MyDel(参数列表);
 MyDel objDel1 = new MyDel(obj.实例方法);   或 MyDel objDel1 = obj.实例方法;
 MyDel objDel2 = new MyDel(Class.静态方法); 或 MyDel objDel2 = Class.静态方法;

　　·　为委托对象分配内存；
　　·　把办法添加到委托对象的调用列表中；

贰、原理：源于产生-响应模型：

5、事件的拍卖及监听能够放在1块儿，符合高内聚、低耦合的盘算

委托表明定义了壹体系型，它用一组特定的参数以及重临类型来封装方法。对于静态方法，委托对象封装要调用的章程。对于实例方法，委托对象同时包装一个实例和该实例上的3个艺术。假若您有3个寄托对象和一组适当的参数，则足以用这个参数调用该信托。

2.　组合委托 (Combining Delegate)

　委托是固定的，委托对象被创立后就不会再被转移。委托组合拷贝的是操作数的副本，唯有相同类其他寄托才方可整合。委托的重组和移除分别用”+”和”-“；

  MyDel objDel = objDel1 + objDel2;

事件源(event source) + 事件作者(event) => 事件的订阅者(event subscriber) + 事件处理器(event handler)

RAC的编制程序思想

在C#中选取委托方法：

3.　调用委托

 objDel(参数列表); 或 objDel.Invoke(参数列表);

　用于调用委托的参数会去调用调用列表中的种种方法。
　　·　调用带再次来到值的寄托：委托调用的再次来到值是其调用列表中最后2个格局的重回值。
　　·　调用带引用参数的嘱托：调用委托的参数会趁机调用列表中方法的调用而变更。
　注：Invoke
是一道方法，BeginInvoke/EndInvoke 是异步方法，但其调用者 myDel
的调用列表有且不得不用三个措施，而 Invoke 没有这一个范围。Invoke and
BeginInvoke
介绍；

 IAsyncResult res = myDel.BeginInvoke(委托的参数列表, null, null);            
 myDel.EndInvoke(res);

(其它还有事件的订阅者和事件源之间的订阅关系subscribe relationship)

面向进度：以处管事人件的长河为主干，一步一步达成。

·
成立委托所运用的方法必须和委托证明相平等（参数列表、再次来到值都一致）

4.　匿名委托

　匿名委托能够访问其所在格局的①对变量，具体 .Net委托和事件 –
匿名委托部分；
　

只怕以手提式有线话机械收割到短信提示本人去开会为例，事件源：手提式有线电话机啊，事件：收到短信，事件的订阅者：小编，事件处理器：去开会，订阅关系：小编订阅手提式有线电电话机

面向对象：万物皆对象

· 利用
+=、-=来进行委托的链接、撤废链接或直接利用Delegate.Combine和Delegate.Remove方法来兑现

5.　Action<> 和 Func<> 以及 Predicate<>

　
将委托的评释和赋值合并，进一步简化。Action<>没有再次回到值，Func<>有重回值。

  // 委托的几种赋值方法均可用在此处
  Func<int,bool> myDel = (Lambda表达式);
  Func<int,bool> myDel = new Func<int,bool>(函数名);

　 Predicate<T> 是回到 bool 的泛型委托，能够领略为
Func<T，bool>的泛型委托的别称，多用来查询的条件表明式。
　
　参考
　[1]. 从委托到匿名委托到Lambda表明式再到
Action<>和Func<>；
　[2].
深深解析委托与事件；

三、事件的扬言：分为详细申明和省略表明：

链式编制程序：将多少个操作通过点号链接在共同成为一句代码，是代码的可读性更好，代表masonry框架

·
能够选用MulticastDelegate的实例方法GetInvocationList()来获得委托链中装有的委托

事件

　参考：浓厚领悟事件的本来面目；
　对象1是事件发生者或发送者，对象贰是事件接收者或订阅者，对象一产生音信，对象二响应并拍卖音信（事件/消息机制）。
　event 是 delegate 的高等级格局，事件封装了信托，委托封装了主意。事件涵盖三个私有委托，事件提供对个人控制委托的结构化访问，当事件触发时，调用委托来挨家挨户调用调用列表中的方法。在事变中，委托是事件的发起者
sender 将伊夫ntArgs 传递给处理者的管道。

（一）详细注解：

public delegate void MyDelegateEventHandler();
    public class Event
    {
        private MyDelegateEventHandler myDelegateEventHandler;
        public event MyDelegateEventHandler MyDelegate
        {
            add
            {
                this.myDelegateEventHandler += value;
            }
            remove
            {
                this.myDelegateEventHandler -= value;
            }
        }
    }

链式编制程序的特征：方法的再次来到值是block，block必须有重回值（本人对象），block参数（须要操作的值）

· 无法创作包蕴 out 参数的信托

1.　事件证明

　保存和调用事件处理程序。

public [static] event 委托类型 Notify;

　推荐应用：事件接纳标准的预订义委托类型

public delegate void EventHandler(object sender, EventArgs e);

（二）简略表达：

public delegate void MyDelegateEventHandler();
    public class Event
    {
         public event MyDelegateEventHandler myDelegate;
    }

响应式编制程序：不须要思索调用的依次，只须求思索结果，类似于蝴蝶效应，产生3个事变，会影响很多事物，那个事件就像流1样的散播出去，借用面向对象的一句话正是万物皆流。

二、事件的简介

2.　事件注册形式

　·　方法格局
　　[1]. 实例方法：publisher.Notify += subscriber.实例方法；
　　[2]. 静态方法：publisher.Notify += Subscriber.静态方法；
　·　委托情势
　　[1]. 实例方法：publisher.Notify += new 伊芙ntHandler(subscriber.实例方法)；
　　[2]. 静态方法：publisher.Notify += new 伊芙ntHandler(Subscriber.静态方法)；
　·　匿名格局
　　publisher.Notify += delegate(object source, EventArgs args) { … }；
　·　 Lambda表达式
　　publisher.Notify += (source, args) => { … }；
　注：publisher
是公布者类对象；subscriber 是订阅者类对象，Subscriber 是订阅者类。

能够看看，在全部注脚中第二添加了三个委托项指标字段，然后暴漏了充足和移除事件处理器的作用，可是大家通常用的是简简单单表明，因为代码越发从简，

代表：KVO

C# 中的“事件”是当对象发生壹些事情时，类向该类的客户提供布告的1种办法。

3.　事件访问器（伊夫nt Accessor）

　事件访问器表现为 void 方法，add 和 remove 访问器均包括隐式值参数
value。通过为事件注解自定义的轩然大波访问器，此时风云尚无内嵌委托对象，须要自定义添加和移除注册事件的法子来自行封装贰个信托的实例。事件的
add 和 remove 不能够缺且务必有得以实现主体但足以为空。

　private MyEventHandler notify = null;   /// [1] 声明委托的实例
　public event MyEventHandler Notify      /// [2] 事件封装委托的实例
　{
　　　add      /// 增加
　　　{
　　　　　if (null != value)
　　　　　　　notify += value;
　　　}
　　　remove   /// 删除
　　　{
　　　　　Delegate[] funList = notify.GetInvocationList();   /// 获取调用列表
　　　　　if (-1 != Array.IndexOf(funList, value))
　　　　　　　notify -= value;             
　　　}
　}

　参考
　[1]. 字段访问器 ~ 事件访问器 ~
索引器；
　[2]亚洲必赢官网，. C#
事件访问器；

能够观望事件对外围隐藏了绝大部分职能，它的黄山真面目就是对内部委托字段的一个卷入(encapsulation)，防止外界偷用滥用委托字段。

函数式编制程序：把操作尽量写成一文山会海嵌套的函数也许措施调用

一、事件的评释：

函数指针 vs 委托

　回调函数，Callback，在函数体内调用主调用函数中的函数。
　·　函数指针：保存函数的输入地址，作为函数的参数、用于调用函数；
　委托：保存函数的输入地址同时保存调用该函数的类/类实例的引用；
　·　委托增加性更好，协理多播委托（MulitCast）和异步调用；

那正是说难题来了：第几个难题：有了委托为何还会有事件呢，事件之中不就是信托吗，原因是为了防患public型的委托字段在外头被滥用，比如信托能够用invoke调用，

函数式编制程序的特征：每一个主意必须有重临值（自身对象），把函数或许block当做参数，block参数（须要操作的值）block重返值（操作结果）

注脚的格式为：<access modifier> event <delegate type>
伊芙ntName

委托 vs 事件

　·　
委托协理”+”和”-“、”+=”和”-=”、赋值运算符”=”；事件只是扶助”+=”和”-=”；
　·　 Delegate
是类（型），伊夫nt 是成员，伊芙nt 成员类型派生于 Delegate；
　·　
委托常用来抒发回调，事件表达外发的接口；
　·　
委托：能够在类外部触发、允许直接通过委托调用相应的处理函数：委托对象(参数列表)；
　事件：只可以在类内部触发、通过发布者类提供的 public 方法去调用。
　注：事件涵盖1个私家的委托对象。
事件的封装性和易用性更好。

　public MyEventHandler Notify1;
　public event MyEventHandler Notify2;

　其实，Notify1 也正是 Class 里面包车型客车字段Field，访问级别 public ，Notify2相当于属性Property，访问级别也是 public，不过，Notify二内部封装了一个访问级别为 private 的委托对象！（带 event
关键字，编写翻译之后，委托对象变成
private，并自动生成二个与寄托对象对应的风浪）
　属性封装字段，事件封装委托。
　亚洲必赢官网 1 　
　
　参考
　[1]. Event
详解；
　[2]. 谈 C# 中的 delegate – hyddd –
博客园；
　[3]. 不惧面试 –
关于信托；3个委托的事例；

可是事件只可以在+=或-=的左侧，那样就扩张了全副程序的安全性。

代表：ReactiveCocoa

因为运用委托来声称事件，所以在类里声称事件时，首先必须先注明该事件的嘱托项目<delegate
type>（固然未有注明的话）。在上面我们早就提到过了信托项指标扬言，可是在.net
framework下为事件选拔的嘱托项目进行宣示时有更严酷的规定：

观察者方式

　Observer Pattern，即 Subject-Observer，又称监听方式 (Source/Listener)
或发表-订阅方式(Publisher-Subscriber)，情势中的皇后。Observer
形式定义对象间的1（Subject）对多（Observer）的注重关系，当2个指标情形改变时，依赖于它的别的对象会被自动告知并立异。Observer
格局一对多将依靠具体转会为借助抽象，是1种松耦合的设计格局，但抽象类Subject如故借助于抽象类(接口)Observer。逻辑关系图：
亚洲必赢官网 2
　注：事件处理程序即被托付的点子。Observer
情势典例：报纸订阅、短信分发、电热水器，可参考委托和事件详解 –
补充；

Java API 内置的观看者形式：

java.util.Observable — Subject 被观看者
java.util.Observer — Observer 观察者

参考：

设计情势学习笔记 –
观望者方式；

其次个难题：那委托和事件的关系如何的吧？大家说事件是根据委托的。1方面，事件需求委托来做多少个约束，那个约束规定了事件源发送什么须要给事件的订阅者，

ReactiveCocoa常见类

（一）、事件的嘱托项目应采取多个参数；

问题

·　如何界定事件只同意3个客户订阅？
将事件评释为 private，然后提供四个 public
方法用于注册和收回。或采取事件访问器。
·　如何取得两个订阅者的重临值？
利用 Delegate 类的静态方法 Delegate[]
GetInvocationList()，委托/事件变量调用之，然后遍历包罗委托方法的数组即可。

事件订阅者的风云处理器必须和那几个约束相对应才方可订阅那个事件，另1方面，事件订阅者收到事件未来做出事件处理器，而以此事件处理器必须透过委托才足以形成。

在RAC中最中央的类RACSiganl，消除那个类就能用ReactiveCocoa开发了。

（二）、三个参数分别是：提示事件源的“对象源”参数和包裹事件的其余任何有关音讯的“e”参数；

四、简单实例：

RACSignal：时域信号类，一般代表以后有多少传递，只要有数据变化，实信号内部接收到多少，就会及时发出数据。

（三）、“e”参数的体系应为伊芙ntArgs 类或派生自伊夫ntArgs 类。

Example:做三个窗口，有文本框和按钮，点击按钮文本框显示时间，不用WindowsForms

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ConsoleApp14
{
    class Program
    {
        public static TextBox textBox;
        public static Button button;
        static void Main(string[] args)
        {
            Form form = new Form();
            TextBox textBox = new TextBox();
            Button button = new Button();
            form.Controls.Add(textBox);
            form.Controls.Add(button);
            textBox.Width = 400;
            button.Top = 100;
            button.Click += Button_Click;
            form.ShowDialog();
        }

        private static void Button_Click(object sender, EventArgs e)
        {
            textBox.Text = DateTime.Now.ToString();
        }
    }
}

亚洲必赢官网 3

注意：

1般来说的定义：

此处举的事例正是windowsforms内部的代码，大家说事件作者是不会发生的是由事件源内部的逻辑所接触，在本例中，并不是人按了按钮然后按钮触发了事件，

时域信号类（RACSignal），只是意味着当数码变动时，复信号内部会时有发生数据，它本人不有所发功率信号的能力，而是交由内部1个订阅者去产生。

public delegate void PrintHandler(object sender,System.EventArgs e);

那里面还有三个小进程，正是当按钮被key down再key up时，向程序内部发送了壹层层电子通信号，公告电脑，然后再发生事件，

暗中同意二个能量信号都以冷数字信号，也正是值改变了也不会接触，唯有订阅了那一个时域信号，那几个确定性信号才变成热时限信号，值改变了才会接触。

然后大家才能宣称该委托类型的轩然大波

伍、注脚事件的有关约定：

RACSignal的简便利用：

例如：

用来表明事件的嘱托一般用：事件+EvnetHandler,参数①般有二个，第一个事件源，第二个伊夫ntArgs的派生类，用于触发事件的法子名壹般为On+方法名，

//RACSignal底层完结：

public event PrintHandler Print;

做客级别Protected。大概有点蒙，举个实例就懂了。

//一创制时域信号，首先把didSubscribe保存到连续信号中，还不会触发

当事件产生时，将调用其客户提供给它的委托。

Example:举一个买主在KFC点餐的例子

namespace ConsoleApp15
{
    class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            Waitor waitor = new Waitor();
            customer.Order += waitor.Serve;
            customer.Eat();
            customer.Pay();
        }
    }
    public delegate void OrderEventHandler(Customer customer, OrderEventArgs e);
    public class Customer
    {
        public int Money { get; set; }
        public event OrderEventHandler Order;
        public void Pay()
        {
            Console.WriteLine($"OK,{Money} dollars");
        }
        public void Eat()
        {
            Console.WriteLine("Let's go to the KFC...");
            Console.WriteLine("Stand in front of the waitor...");
            Console.WriteLine("A hamburger，Please...");
            OnOrder();
        }
        protected void OnOrder()
        {
            OrderEventArgs orderEventArgs = new OrderEventArgs();
            orderEventArgs.Snack = "Hamburger";
            orderEventArgs.Size = "large";
            this.Order.Invoke(this, orderEventArgs);

        }
    }
    public class OrderEventArgs : EventArgs
    {
        public string Snack { get; set; }
        public string Size { get; set; }
    }
    class Waitor
    {
        public void Serve(Customer customer, OrderEventArgs e)
        {
            Console.WriteLine($"Here is your snack {e.Snack}");
            int price = 20;
            switch (e.Size)
            {
                case "large":
                    price *= 2;
                    break;
                case "small":
                    price *= 1;
                    break;
                default:
                    break;
            }
            customer.Money += price;
        }
    }
}

//2当时限信号被订阅，也便是调用signal的subscribeNext:nextBlock

二、调用事件：

//二.1subscribeNext内部创建订阅者subscriber，并且把nextBlock保存到subcriber中

类注明了事件之后，能够就像是处理所提示的信托项目的字段那样处理该事件。若是未有别的客户将委托与该事件绑定，则该字段将为空；不然该字段引用应在调用该事件时调用的嘱托。因而，调用事件时1般先检查是还是不是为空，然后再调用事件。（调用事件，即触发事件，只好从注脚该事件的类内实行）

遵守事件的多少个因素，首先必要事件源，做二个Customer类，还索要四个事变订阅者，做3个Waitor类，然后根据订阅关系去写实际的主意，订阅关系customer.Order += waitor.Serve; Customer点餐Waitor服务，waitor类中上餐并算好价格，这年需求一个事件处理器Order伊夫ntHandler,那个委托的参数须要3个Order伊芙ntArgs，创造这一个类写好属性，在写好委托和事件，然后在Customer类中写点餐事件，点餐事件为Protected的，和public型的嘱托字段一样防止被外边滥用，进步安全性。

//2.二subscribeNext内部调用signal的didSubscribe

if(Print != null)

想融会贯通其实也简单，只供给将事件的多个成分每多少个点数出来，那么最后事件也就出去了。

//3.Signal的didsubscribe中调用[subscriber sendNext:@1];

{

//3.二sendNext底层其实正是进行subscriber的nextBlock

Print (this,e);

迄今停止事件下结论收尾，有暧昧之处还请指教。　　　　　　　　　　　　　　　　201八-0八-一7 1陆:肆叁:19

//一创造时限信号

}

RACSignal *signal = [RACSignal createSignal:^RACDisposable *
_Nullable(id<RACSubscriber> _Nonnull subscriber) {

三、事件绑定：

//每当有订阅者订阅功率信号，就会调用该block

从类的外侧来看，事件就象类的1个共用成员，通过类名.事件名
的样式来访问，不过只可以对它做绑定和扫除绑定的操作，而不能够有别的操作。

//3发送时域信号

类名. Print += new PrintHandler(绑定的秘籍名) //
将有些方法绑定到Print事件上

[subscriber sendNext:@”1″];

类名. Print -= new PrintHandler(绑定的艺术名) //
将有些已绑定到Print事件上的格局从Print事件上排除

[subscriber sendNext:@”2″];

3、委托和事件的使用

[subscriber sendNext:@”3″];

寄托和事件在用户界面程序里用的比较的多，比如象在winform或webform的用户UI上的button和它的click事件：

//借使不再发送数据，内部会自行调用[RACDisposable
disposable]撤回订阅时限信号

// 将Button1_Click()方法绑定到按钮控件Button壹的Click事件上

[subscriber sendCompleted];

this.Button1.Click += new System.EventHandler(this. Button1_Click);

[subscriber sendNext:@”5″];

private void Button1_Click(object sender, System.EventArgs e) //
Button1_Click()方法

return [RACDisposable disposableWithBlock:^{

{

//block调用的时刻：当实信号发送完成大概发送错误，就会执行那几个blcok，撤除订阅复信号

……

//执行完block后，当前随机信号就不存在被订阅了

}

NSLog(@”功率信号订阅者被灭绝”);

不过除了用户界面程序外，在恒河沙数此外地点也选择了事件驱动形式，比如观看者形式（Observer）或发表/订阅（Publish/Subscribe）里：在1个类里公布（Publish）有些能够被触发的轩然大波，而其余的类就足以来订阅（Subscribe）该事件。1旦这些公布者类触发了该事件，那么运转时环境会立马告知全数订阅了该事件的订阅者类：那几个事件产生了！从而种种订阅者类能够作出它们本人的反响（调用相应措施）。

}];

//贰订阅实信号，才会激活时限信号

[signal subscribeNext:^(id _Nullable x) {

//每当有功率信号发出数据，调用该block

NSLog(@”接收数据：%@”,x);

}];

RACSubscriber：表示订阅者的意思，用于发送连续信号，这是三个切磋，不是一个类，只要根据这些体协会议，并且达成方式才能变成订阅者。通过create创设的时域信号，都有三个订阅者，支持她发送数据。

RACDisposable：用于撤销订阅恐怕清理能源，当非能量信号发送完毕或许发送错误的时候，就会自行触发它。

行使景况：不想监听有些功率信号时，可以因而它主动积极打消订阅时限信号

RACSubject：时域信号提供者，自身能够充当随机信号，又能发送能量信号。

动用情况：经常用来顶替代理，有了它，就无需定义代理了。

RACReplaySubject：重复提供复信号类，RACSubject的子类。

RACReplaySubject与RACSubject区别：

RACReplaySubject能够头阵送模拟信号，再订阅信号，RACSubject就不得以

使用意况一：假使三个复信号每被订阅三遍，就供给把此前的值重新发送1遍，使用重复提供非频域信号类

动用处境2：能够设置capacity数量来界定缓存的value的数额，即值缓存最新的多少个值。

RACSubject和RACReplaySubject的简练利用：

//RACSubject:底层完成与RACSignal不一致等

//壹调用subscribeNext订阅实信号，只是把订阅者保存起来，并且订阅者的nextBlock已经赋值了

//二调用sendNext发送实信号，遍历刚刚保存的有所订阅者，三个八个调用订阅者的nextBlock

//一创设时限信号

RACSubject *subject = [RACSubject subject];

//贰订阅随机信号

[subject subscribeNext:^(id _Nullable x) {

NSLog(@”第二个订阅者%@”,x);

}];

[subject subscribeNext:^(id _Nullable x) {

NSLog(@”首个订阅者%@”,x);

}];

//三发送数字信号

[subject sendNext:@”1″];

//RACReplaySubject的底层完成：

//一.调用sendNext发送功率信号，把值保存起来，然后遍历刚刚保存的保有的订阅者，二个2个调用订阅者的nextBlock

//二.调用subscribeNext订阅连续信号，遍历保存的富有值，三个一个调用订阅者的nextBlock

//假如想当贰个能量信号被订阅，就重新播放以前全部值，要求首发时限信号，再订阅连续信号（也正是先保存值，再订阅值）

//一.创立实信号

RACReplaySubject *replaySubject = [RACReplaySubject
replaySubjectWithCapacity:2];

[replaySubject subscribeNext:^(id _Nullable x) {

NSLog(@”第0个订阅者收到的数据%@”,x);

}];

//2发送时限信号

[replaySubject sendNext:@”1″];

[replaySubject sendNext:@”2″];

[replaySubject sendNext:@”3″];

//三订阅复信号

[replaySubject subscribeNext:^(id _Nullable x) {

NSLog(@”第一个订阅者收到的数据%@”,x);

}];

[replaySubject subscribeNext:^(id _Nullable x) {

NSLog(@”第3个订阅者收到的数据%@”,x);

}];

RACTuole：元组类，类似于NSArray，用于包装值

RACSequence：RAC中的集合类，用于代替NSArray，NSDictionary，能够运用它来十分的快遍历数组和字典。

RACCommand：RAC中用于处管事人件的类，能够把事件怎样处理，实践中数据怎样传递，包装到那么些类中，它能够很方便的督查事件的履行进度。

接纳情形：监听按钮点击，互联网请求

RACCommand的简练利用：

RACMulticasConnection：用于当二个非确定性信号，被频仍订阅时，为了保障开创时限信号时，幸免频仍调用频域信号中的block，造成副效用，能够选择这些类处理。

利用注意：RACMulticastConnection通过RACSignal的-publish大概-muticast方法成立。

RACScheduler：RAC中的队列，用GCD封装的。

RACUnit：表示stream不蕴含有意义的值，也便是见到这些，能够一向了解为nil

RACEVent：把数据包装成复信号事件（singnal
event）。它最首要通过RACSignal的-materialize来行使的。

ReactiveCocoa开发常见用法

取代代理：rac_signalForSelector

代替KVO：rac_valueAndChangesForKeyPath

监听事件：rac_signalForControlEvents

代表布告：arc_addObserverForName

监听文本框文字改变：rac_textSignal

ReactiveCocoa常见宏

RAC(TARGET,[KEYPATH,[NIL_VALUE]]):用于给有个别对象的某些属性绑定

//只要文本框文字改变，就会变动label的文字

//只要文本框文字改变，就会修改label的文字

RAC(self.labelView,text) = _textfield.rac_textSignal;

RACObserve(self,name):监听有些对象的脾性，重临的是时限信号

[RACObserve(self.view,center) subscribeNext:(^id x){

NSLog(@”%@”,x);

}

@weakfy(Obj)和@strongfy(Obj),供给手动导入RACEXTScope.h才能动用

RACTuplePack:把多少包装成RACTuple(元组类)

//把参数中的数据包装成元组

RACTuple *tuple = RACTuplePack(@10,@20);

RACTupleUnpack:把RACTuple(元组类)解包成对应的多寡

参考：

本节对事件举行计算。

二、事件：

一、概念：伊芙nt:A member that enables an object or class to provide notifications;官方的分解是那样，就是说在C#中，事件是使

目的大概类具有公告能力的积极分子。比如说手提式有线电话机接到短信唤醒小编去开会，那么手提式有线电话机就担任了3个存有布告能力的分子。说白了，事件

委托

的意义就是指标和类之间的消息传递的桥梁。

一. 创制委托（对象）

贰、原理：源于产生-响应模型：

2. 组合委托 (Combining Delegate)

事件源(event source) + 事件作者(event) => 事件的订阅者(event subscriber) + 事件处理器(event handler)

3. 调用委托

(其它还有事件的订阅者和事件源之间的订阅关系subscribe relationship)

4. 匿名委托

只怕以手提式有线话机械收割到短信提示本人去开会为例，事件源：手提式有线电话机啊，事件：收到短信，事件的订阅者：小编，事件处理器：去开会，订阅关系：小编订阅手提式有线电电话机

5. Action<> 和 Func<> 以及 Predicate<>

三、事件的扬言：分为详细申明和省略表明：

事件

（一）详细注解：

1. 事件证明

（二）简略表达：

2. 事件注册形式

能够看看，在全部注脚中第二添加了三个委托项指标字段，然后暴漏了充足和移除事件处理器的作用，可是大家通常用的是简简单单表明，因为代码越发从简，

3. 事件访问器（伊夫nt Accessor）

能够观望事件对外围隐藏了绝大部分职能，它的黄山真面目就是对内部委托字段的一个卷入(encapsulation)，防止外界偷用滥用委托字段。

函数指针 vs 委托

那正是说难题来了：第几个难题：有了委托为何还会有事件呢，事件之中不就是信托吗，原因是为了防患public型的委托字段在外头被滥用，比如信托能够用invoke调用，

委托 vs 事件

可是事件只可以在+=或-=的左侧，那样就扩张了全副程序的安全性。

观察者方式

其次个难题：那委托和事件的关系如何的吧？大家说事件是根据委托的。1方面，事件需求委托来做多少个约束，那个约束规定了事件源发送什么须要给事件的订阅者，

问题

事件订阅者的风云处理器必须和那几个约束相对应才方可订阅那个事件，另1方面，事件订阅者收到事件未来做出事件处理器，而以此事件处理器必须透过委托才足以形成。

四、简单实例：

Example:做三个窗口，有文本框和按钮，点击按钮文本框显示时间，不用WindowsForms

此处举的事例正是windowsforms内部的代码，大家说事件作者是不会发生的是由事件源内部的逻辑所接触，在本例中，并不是人按了按钮然后按钮触发了事件，

那里面还有三个小进程，正是当按钮被key down再key up时，向程序内部发送了壹层层电子通信号，公告电脑，然后再发生事件，

伍、注脚事件的有关约定：

用来表明事件的嘱托一般用：事件+EvnetHandler,参数①般有二个，第一个事件源，第二个伊夫ntArgs的派生类，用于触发事件的法子名壹般为On+方法名，

做客级别Protected。大概有点蒙，举个实例就懂了。

Example:举一个买主在KFC点餐的例子

想融会贯通其实也简单，只供给将事件的多个成分每多少个点数出来，那么最后事件也就出去了。

迄今停止事件下结论收尾，有暧昧之处还请指教。 201八-0八-一7 1陆:肆叁:19

相关文章

一.　创制委托（对象）

2.　组合委托 (Combining Delegate)

3.　调用委托

4.　匿名委托

5.　Action<> 和 Func<> 以及 Predicate<>

1.　事件证明

2.　事件注册形式

3.　事件访问器（伊夫nt Accessor）

迄今停止事件下结论收尾，有暧昧之处还请指教。　　　　　　　　　　　　　　　　201八-0八-一7 1陆:肆叁:19