CODEWITHSUNDEEP
mefinotifypropertychangedsystem.reactive
Random
Random

Reputation: 1956

MEF and IObservables

I have a singleton IObservable that returns the results of a Linq query. I have another class that listens to the IObservable to structure a message. That class is Exported through MEF, and I can import it and get asynchronous results from the Linq query.

My problem is that after initial composition takes place, I don't get any renotification on changes when the data supplied to the Linq query changes. I implemented INotifyPropertyChanged on the singleton, thinking it word make the exported class requery for a new IObservable, but this doesn't happen.

Maybe I'm not understanding something about the lifetime of MEF containers, or about property notification. I'd appreciate any help.

Below are the singleton and the exported class. I've left out some pieces of code that can be inferred, like the PropertyChanged event handlers and such. Suffice to say, that does work when the underlying Session data changes. The singleton raises a change event for UsersInCurrentSystem, but there is never any request for a new IObservable from the UsersInCurrentSystem property.

public class SingletonObserver: INotifyPropertyChanged
{
   private static readonly SingletonObserver _instance = new SingletonObserver();

   static SingletonObserver() { }

   private SingletonObserver()
   {
      Session.ObserveProperty(xx => xx.CurrentSystem, true)
         .Subscribe(x =>
            {
              this.RaisePropertyChanged(() => this.UsersInCurrentSystem);
            });
   }

   public static SingletonObserverInstance { get { return _instance; } }

   public IObservable<User> UsersInCurrentSystem
   {
      get
      {
         var x = from user in Session.CurrentSystem.Users
                 select user;
         return x.ToObservable();
      }
   }
}

[Export]
public class UserStatus : INotifyPropertyChanged
{
   private string _data = string.Empty;

   public UserStatus
   {
      SingletonObserver.Instance.UsersInCurrentSystem.Subscribe(sender =>
      {
         //set _data according to information in sender
         //raise PropertyChanged for Data
      }
   }

   public string Data
   {
      get { return _data; } }
   }
}

Upvotes: 0

Views: 249

Answers (1)

Gilles
Gilles

Reputation: 5417

My problem is that after initial composition takes place, I don't get any renotification on changes when the data supplied to the Linq query changes.

By default MEF will only compose parts once. When a part has been composed, the same instance will be supplied to all imports. The part will not be recreated unless you explicitly do so.

In your case, if the data of a part change, even if it implements INotifyPropertyChanged, MEF will not create a new one, and you don't need to anyway.

I implemented INotifyPropertyChanged on the singleton, thinking it word make the exported class requery for a new IObservable

No.

Maybe I'm not understanding something about the lifetime of MEF containers, or about property notification.

Property notification allows you to react to a change in the property and has no direct effect on MEF. As for the container's lifetime, it will remain active until it is disposed. While it is still active, the container will keep references to it's compose parts. It's actually a little more complex than that, as parts can have different CreationPolicy that affects how MEF holds the part, I refer you to the following page: Parts Lifetime for more information.

MEF does allow for something called Recomposition. You can set it likewise:

[Import(AllowRecomposition=true)]

What this does tough is allow MEF to recompose parts when new parts are available or existing parts aren't available anymore. From what I understand it isn't what you are referring to in your question.

Upvotes: 1

Related Questions