C# 我可以用被动扩展独立订阅/发布吗？

假设我有一些课，我的课。在我的代码的一部分中，我希望这样：

Observable.Subscribe<MyClass>(myClass => DoSomething(myClass));

Observable.Publish(instanceOfMyClass);

第二行将触发使用该类类型订阅的所有方法。这是被动扩展（v1或v2）支持的吗

---

将SynchronizationContext指定为Subscribe调用的一部分会很有用。在那里指定是否应该使用WeakReference保存该方法也很好。发布方法应该能够同步完成这一切，或者给我一些我可以等待的东西。

我相信您正在寻找类似ReactiveUI的东西。这个类使用Rx实现发布/订阅模型，基本上只需拥有一个类型为=>IObservables的字典。

我相信您正在寻找类似ReactiveUI的字典。这个类使用Rx实现发布/订阅模型，基本上只需拥有一个类型为=>IObservables的字典。

这并不难创建

您只需要一个内部

词典

，并使用它通过

类型

存储每个

主题

（作为对象）

然后，您只需编写两个

Subscribe

和

Publish

方法即可使用内部字典

其实应该很简单

---

与其说这很简单，我还不如试试看

这是我的Rx酒吧/小班：

public static class RxPS
{
    private static Dictionary<Type, object> _subjects
        = new Dictionary<Type, object>();

    public static IDisposable Subscribe<T>(Action<T> observer)
    {
        lock(_subjects)
        {
            if (!_subjects.ContainsKey(typeof(T)))
            {
                _subjects.Add(typeof(T), new Subject<T>());
            }
            return (_subjects[typeof(T)] as Subject<T>)
                .Subscribe(observer);
        }
    }

    public static void Publish<T>(T item)
    {
        lock(_subjects)
        {
            if (_subjects.ContainsKey(typeof(T)))
            {
                (_subjects[typeof(T)] as Subject<T>)
                    .OnNext(item);
            }
        }
    }
}

公共静态类RxPS
{
私有静态词典(private static Dictionary)
=新字典（）；
公共静态IDisposable订阅（操作观察者）
{
锁定（_主题）
{
if（！_subjects.ContainsKey（typeof（T）））
{
_添加（typeof（T），new Subject（））；
}
返回（_主题[类型（T）]作为主题）
.签署（观察员）；
}
}
公共静态无效发布（T项）
{
锁定（_主题）
{
if（_subjects.ContainsKey（typeof（T）））
{
（_受试者[类型（T）]作为受试者）
.OnNext（项目）；
}
}
}
}

这就是它的使用方式：

RxPS.Publish(1);
var d = RxPS.Subscribe<int>(x => Console.WriteLine(x)); 
RxPS.Publish(2);
d.Dispose();
RxPS.Publish(3);

RxPS.Publish（1）；
vard=RxPS.Subscribe（x=>Console.WriteLine（x））；
RxPS.出版（2）；
d、 处置（）；
RxPS.出版（3）；

结果是此代码将仅向控制台写入

2

---

享受吧

这并不难做到

您只需要一个内部

词典

，并使用它通过

类型

存储每个

主题

（作为对象）

然后，您只需编写两个

Subscribe

和

Publish

方法即可使用内部字典

其实应该很简单

---

与其说这很简单，我还不如试试看

这是我的Rx酒吧/小班：

public static class RxPS
{
    private static Dictionary<Type, object> _subjects
        = new Dictionary<Type, object>();

    public static IDisposable Subscribe<T>(Action<T> observer)
    {
        lock(_subjects)
        {
            if (!_subjects.ContainsKey(typeof(T)))
            {
                _subjects.Add(typeof(T), new Subject<T>());
            }
            return (_subjects[typeof(T)] as Subject<T>)
                .Subscribe(observer);
        }
    }

    public static void Publish<T>(T item)
    {
        lock(_subjects)
        {
            if (_subjects.ContainsKey(typeof(T)))
            {
                (_subjects[typeof(T)] as Subject<T>)
                    .OnNext(item);
            }
        }
    }
}

公共静态类RxPS
{
私有静态词典(private static Dictionary)
=新字典（）；
公共静态IDisposable订阅（操作观察者）
{
锁定（_主题）
{
if（！_subjects.ContainsKey（typeof（T）））
{
_添加（typeof（T），new Subject（））；
}
返回（_主题[类型（T）]作为主题）
.签署（观察员）；
}
}
公共静态无效发布（T项）
{
锁定（_主题）
{
if（_subjects.ContainsKey（typeof（T）））
{
（_受试者[类型（T）]作为受试者）
.OnNext（项目）；
}
}
}
}

这就是它的使用方式：

RxPS.Publish(1);
var d = RxPS.Subscribe<int>(x => Console.WriteLine(x)); 
RxPS.Publish(2);
d.Dispose();
RxPS.Publish(3);

RxPS.Publish（1）；
vard=RxPS.Subscribe（x=>Console.WriteLine（x））；
RxPS.出版（2）；
d、 处置（）；
RxPS.出版（3）；

结果是此代码将仅向控制台写入

2

---

享受吧

给我解释一下“OnNext”？这会触发多个订户吗？如果我让“d”超出范围会发生什么？当垃圾回收器“轮到”或“不轮到”时，它是否会处理？调用

OnNext

为主题提供其自身可观察序列的下一个值，该值将发送给主题的任何和所有订户。如果您让

d

超出范围，将不会发生任何事情。GC将收集变量，但它从不调用

Dispose

，因此不会取消任何订阅。调用

Dispose

始终是程序员的责任。在接收的情况下，如果您想提前取消订阅，即在自然调用

OnCompleted

或

OnError

之前，您只需调用

Dispose

。请向我解释“OnNext”？这会触发多个订户吗？如果我让“d”超出范围会发生什么？当垃圾回收器“轮到”或“不轮到”时，它是否会处理？调用

OnNext

为主题提供其自身可观察序列的下一个值，该值将发送给主题的任何和所有订户。如果您让

d

超出范围，将不会发生任何事情。GC将收集变量，但它从不调用

Dispose

，因此不会取消任何订阅。调用

Dispose

始终是程序员的责任。在接收的情况下，如果您想提前取消订阅，即在自然调用

OnCompleted

或

OnError

之前，您只需调用

Dispose

。断开的链接：断开的链接：