我有一个静态类 (DataFormSubject)，它包含一个通用 List 对象，如下所示：

private static List<DataForm> dataForms = new List<DataForm>();

当列表更新时，需要告知依赖此列表的其他类，因此我创建了一个自定义事件，以及在添加或删除项目时可以触发的关联方法，如下所示：

    public delegate void DataFormsUpdatedHandler(object sender);
    public static event DataFormsUpdatedHandler DataFormsUpdatedEvent;

    public static void AddDataForm(DataForm df)
    {
        dataForms.Add(df);
        if (DataFormsUpdatedEvent != null)
            DataFormsUpdatedEvent(df);
    }

    public static void RemoveDataForm(DataForm df)
    {
        dataForms.Remove(df);
        if (DataFormsUpdatedEvent != null)
            DataFormsUpdatedEvent(df);
    }

该列表可通过属性从静态类获取，如下所示：

   public static List<DataForm> DataForms
    {
        get { return dataForms; }
        //set { dataForms = value; }
    }

但这里的问题是，客户端现在可以通过访问属性并在类上直接添加或删除来绕过更新事件！例如

     DataFormSubject.DataForms.Add(new DataForm);

我怎样才能防止这种情况，或者有更好的方法来实现我想要的？理想情况下，我想要的是观察者可以订阅的 List 类上的更新事件！

精简版:

对于缓存类,如果对象被垃圾收集(从我的缓存中删除相应的条目),我需要得到通知.这样做的最佳方法是什么？从析构函数发送事件？

长版:

我正在编写一个cacher/memoizer,用于获取一个巨大的参数树对象和许多小值类型参数的函数,例如,

double myFunc(HugeParTree parTree, int dynPar1, double dynPar2)

我想以下列方式缓存这些函数:

• 缓存元组的结果(parTree.GUID,dynPar1,dynPar2,...)
• 每当parTree很少发生变化时,所有相应的缓存条目都将被删除(通过Observer模式).(parTree.Equals()太贵了;它比较了100多种价值类型).

代码现在看起来像这样(对于一个值参数):

public class CachedFunction1ObsPar1Par<TRet, TObsPar1, TPar1>
        where TObsPar1 : IObservable, IProvideGUID
    {
        public delegate TRet ValueCalculator(TObsPar1 obsPar1, TPar1 par1);

        public CachedFunction1ObsPar1Par(ValueCalculator calc)
        {
            _calc = calc;
        }


        #region members

        private ValueCalculator _calc;

        private Dictionary<Guid, Dictionary<TPar1, TRet>> _cache = 
            new Dictionary<Guid, Dictionary<TPar1,TRet>>();

        #endregion


        public TRet value(TObsPar1 obsPar1, TPar1 par1)
        {
            TRet result;
            bool cacheHit = checkCache(obsPar1, par1, out result);

            if (cacheHit)
            {
                Debug.Assert(result.Equals(_calc(obsPar1, …

在PostObserver中的after_save方法中有一些对外部服务的API调用.但我不想在使用Rspec进行测试时调用after_save.有没有办法做到这一点？谢谢.

这是Rails 3.1

var f = function() {
    // Do something useful here
};

有没有办法'观察'这个功能,并在执行时得到通知？类似于jQuery中绑定的东西,但我想绑定函数而不是dom事件？

我不想要这样的东西:

var f = function() {
    // Do something useful here
    notifyObserver();
};

但是我想要这样的东西:

f.bind(function() {
    alert('F was executed.');
});

我在不同的环境中启用了不同的观察者,我希望能够通过控制台检查哪些是启用的

就像是

ActiveRecord::Observers.list

我正在寻找一种在Swing中清晰地组织我的UI代码的方法.

假设我的UI代码按以下方式构建:

class MainWindow extends JFrame {
    // SomePanel panel is added here
}
class SomePanel extends JPanel {
    // buttons, checkboxes and so on are added here
}

假设我在main方法中实例化一个MainWindow对象:

MainWindow frame = new MainWindow("I am an App");

在main-method中监听按钮的ActionEvents(在SomePanel中声明,在MainWindow中声明)的最佳做法是什么？

非常感谢您的帮助!

我观察了dataLayer数组，但没有看到push. 实际上根本没有自定义方法。GTM 如何观察数组的变化？据我所知，对 an 的更改Array不会引发任何事件，是吗？

编辑：

我做了一些更多的研究，发现谷歌的库与以下交互dataLayer：https : //github.com/google/data-layer-helper#listening-for-messages
我会看看代码，甚至可能回答我自己的问我是否了解内部运作。

嗨，我的问题是我的活动侦听viewmodel字段更改但未调用回调！

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ActivityMainBinding binding = DataBindingUtil.setContentView(this,R.layout.activity_main);
    binding.addOnPropertyChangedCallback(new Observable.OnPropertyChangedCallback() {
        @Override
        public void onPropertyChanged(Observable observable, int i) {
            Log.d(getClass().getSimpleName(), "changed");
        }
    });
    User user = new User("user");
    binding.setUser(user);
    user.setName("newUser");
    }

}

和我的视图模型：

public class User extends BaseObservable {

    public String name;

    public User(String name) {
        this.name = name;
    }

    @Bindable
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        notifyPropertyChanged(BR.name);
    } …

为什么我们在事件中指定一个委托,为什么不在C#中使用事件呢？

例如,我有以下代码:

class Shop
{
    internal delegate void _EventHandler(object sender, GoodsInfoEventArgs e);
    internal event _EventHandler GoodsArrived;

    public void BringGoods(string goods)
    {
        if (GoodsArrived != null)
        {
            GoodsArrived(this, new GoodsInfoEventArgs(goods));
        }
    }
}

为什么开发C#的人不会通过以下方式实现事件:

class Shop
{
    internal event _EventHandler GoodsArrived;

    public void BringGoods(string goods)
    {
        if (GoodsArrived != null)
        {
            GoodsArrived(this, new GoodsInfoEventArgs(goods));
        }
    }
}

我的意思是没有代表.

我知道事件在C#中是如何工作的.它将只调用所有已订阅的代理,如果有的话,它将等于null.而且我也知道事件和代表之间的区别.该事件仅允许添加或减少委托,但不允许更改指针(我们可以对事件执行+=和-=操作,但我们不能=对事件执行操作),而委托允许执行所有加法,减法和赋值操作.因此,事件是委托的包装器,包装器允许控制委托可以改变的方式.

所有这一切,我不明白其背后的原因需要在我们定义事件的程序中的每个地方都定义一个委托.

如果你不理解我的问题的一部分,请问我这个问题,我会提供更多信息.

谢谢.

我很抱歉混淆.我的意思是,为什么不使用这样的东西:

internal event _EventHandler(object sender, GoodsInfoEventArgs e) GoodsArrived;

？

我希望能够监视变量并在更改类的实例时调用类中的函数。

class Example:
    def __init__(self, content):
        self.content = content

example1 = Example('testing')

example1.content = 'testing123'

我希望能够检查是否example1.content已更改/更新，如果已更改，请运行一些代码。