如何从另一个类的一个类的属性更改触发事件？

Question

i have the following class structure and im trying to trigger an event in class when theres a change in a property in another class. the prop property in class C is bound to a checkbox element so every time a user ticks or unticks that box - so when it changes from true to false or vice versa - i want to deliver that message to class A so it can run MethodTriggeredByChangeinProp. I need class A to know which instance of class B and also which instance of class C in B is triggering that method. the only thing i can think of is making listC an observablecollection and adding the propertychanged event in class B but then i get confused about where to go from there and liking it to class A. any help is appreciated! thanks.

public class A{
    List<B> listB;

    void MethodTriggeredByChangeinProp(){
    }
}

public class B{
    List<C> listC;
}

public class C{
    public bool Prop{ get; set; }
}

Answer 1

This can be accomplished with just INotifyPropertyChanged and keeping track of "owners".

Class C will keep track of property changes, but will accept a B owner and an A notifyMe objects on construction:

    public class C : INotifyPropertyChanged
    {
        public C(B owner, A notifyMe)
        {
            Owner = owner;
            PropertyChanged += notifyMe.MethodTriggeredByChangeinProp;
        }

        public B Owner { get; private set; }

        private bool prop;
        public bool Prop
        {
            get => prop;
            set
            {
                prop = value;
                NotifyPropertyChanged();
            }
        }

        private void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

        public event PropertyChangedEventHandler PropertyChanged;
    }

Class B doesn't actually need to be anything special, unless you want to know when an object of Class C is added to your list - then you need the ObservableCollection setup; otherwise, List<C> is fine.

Class A's MethodTriggeredByChangeinProp changes slightly:

    public class A
    {
        public List<B> listB;

        public void MethodTriggeredByChangeinProp(object sender, PropertyChangedEventArgs e)
        {
            if(sender is C responsibleC)
            {
                var responsibleB = responsibleC.Owner;
                var changedProp = e.PropertyName;
            }
        }

You now know the responsible instances of class B and class C in A whenever a property changes in C.

You may also want to take a look at the Observer Pattern in .NET for a more in-depth configuration.