如何在不同的Windows手机页面之间共享xaml代码？

Question

在我的应用我想有以下组控件：

<StackPanel Height="110" Orientation="Horizontal" HorizontalAlignment="Right"> 
    <StackPanel> 
     <TextBlock Name="NameTextBox"/> 
     <TextBlock Name="NumberTextBox"/> 
    </StackPanel> 
    <Image Name="ProfileImage"/> 
</StackPanel> 

，我希望跨项目不同的页面共享。但这里是问题：

TextBlock s和Image控件的内容正在运行时在PageLoad事件中加载。所以每次导航时都必须加载它们。我不希望发生这种情况。我尝试将控件放在UserControl中，将它们加载到UserControl的Loaded事件中，并在各种页面中包括UserControl。但UserControl的Loaded事件仍在每个页面上触发。我可以有一种方法，我可以只加载一次，每页使用它？希望我在问题中清楚。

Answer 1

考虑利用带参数的消息传递来传递对象之间的数据。可以使用EventAggregator或MessageBus。

这个想法是让您的用户控件订阅他们想要回复的事件。

注：

我这样做与的ViewModels。 但是，我认为将这些代码添加到用户控件时会产生代码异味，而这些用户控件是为了具有通用性而不管使用它们的应用程序。

我使用发布订阅模式复杂类的依赖关系：

视图模型：

public class ViewModel : ViewModelBase 
    { 
     public ViewModel() 
     { 
      CloseComand = new DelegateCommand((obj) => 
       { 
        MessageBus.Instance.Publish(Messages.REQUEST_DEPLOYMENT_SETTINGS_CLOSED, null); 
       }); 
     } 
} 

窗口：

public partial class SomeWindow : Window 
{ 
    Subscription _subscription = new Subscription(); 

    public SomeWindow() 
    { 
     InitializeComponent(); 

     _subscription.Subscribe(Messages.REQUEST_DEPLOYMENT_SETTINGS_CLOSED, obj => 
      { 
       this.Close(); 
      }); 
    } 
} 

您可以利用Bizmonger.Patterns来获取MessageBus。

MessageBus

public class MessageBus 
{ 
    #region Singleton 
    static MessageBus _messageBus = null; 
    private MessageBus() { } 

    public static MessageBus Instance 
    { 
     get 
     { 
      if (_messageBus == null) 
      { 
       _messageBus = new MessageBus(); 
      } 

      return _messageBus; 
     } 
    } 
    #endregion 

    #region Members 
    List<Observer> _observers = new List<Observer>(); 
    List<Observer> _oneTimeObservers = new List<Observer>(); 
    List<Observer> _waitingSubscribers = new List<Observer>(); 
    List<Observer> _waitingUnsubscribers = new List<Observer>(); 

    int _publishingCount = 0; 
    #endregion 

    public void Subscribe(string message, Action<object> response) 
    { 
     Subscribe(message, response, _observers); 
    } 

    public void SubscribeFirstPublication(string message, Action<object> response) 
    { 
     Subscribe(message, response, _oneTimeObservers); 
    } 

    public int Unsubscribe(string message, Action<object> response) 
    { 
     var observers = new List<Observer>(_observers.Where(o => o.Respond == response).ToList()); 
     observers.AddRange(_waitingSubscribers.Where(o => o.Respond == response)); 
     observers.AddRange(_oneTimeObservers.Where(o => o.Respond == response)); 

     if (_publishingCount == 0) 
     { 
      observers.ForEach(o => _observers.Remove(o)); 
     } 

     else 
     { 
      _waitingUnsubscribers.AddRange(observers); 
     } 

     return observers.Count; 
    } 

    public int Unsubscribe(string subscription) 
    { 
     var observers = new List<Observer>(_observers.Where(o => o.Subscription == subscription).ToList()); 
     observers.AddRange(_waitingSubscribers.Where(o => o.Subscription == subscription)); 
     observers.AddRange(_oneTimeObservers.Where(o => o.Subscription == subscription)); 

     if (_publishingCount == 0) 
     { 
      observers.ForEach(o => _observers.Remove(o)); 
     } 

     else 
     { 
      _waitingUnsubscribers.AddRange(observers); 
     } 

     return observers.Count; 
    } 

    public void Publish(string message, object payload) 
    { 
     _publishingCount++; 

     Publish(_observers, message, payload); 
     Publish(_oneTimeObservers, message, payload); 
     Publish(_waitingSubscribers, message, payload); 

     _oneTimeObservers.RemoveAll(o => o.Subscription == message); 
     _waitingUnsubscribers.Clear(); 

     _publishingCount--; 
    } 

    private void Publish(List<Observer> observers, string message, object payload) 
    { 
     Debug.Assert(_publishingCount >= 0); 

     var subscribers = observers.Where(o => o.Subscription.ToLower() == message.ToLower()); 

     foreach (var subscriber in subscribers) 
     { 
      subscriber.Respond(payload); 
     } 
    } 

    public IEnumerable<Observer> GetObservers(string subscription) 
    { 
     var observers = new List<Observer>(_observers.Where(o => o.Subscription == subscription)); 
     return observers; 
    } 

    public void Clear() 
    { 
     _observers.Clear(); 
     _oneTimeObservers.Clear(); 
    } 

    #region Helpers 
    private void Subscribe(string message, Action<object> response, List<Observer> observers) 
    { 
     Debug.Assert(_publishingCount >= 0); 

     var observer = new Observer() { Subscription = message, Respond = response }; 

     if (_publishingCount == 0) 
     { 
      observers.Add(observer); 
     } 
     else 
     { 
      _waitingSubscribers.Add(observer); 
     } 
    } 
    #endregion 
} 

}

认购

public class Subscription 
{ 
    #region Members 
    List<Observer> _observerList = new List<Observer>(); 
    #endregion 

    public void Unsubscribe(string subscription) 
    { 
     var observers = _observerList.Where(o => o.Subscription == subscription); 

     foreach (var observer in observers) 
     { 
      MessageBus.Instance.Unsubscribe(observer.Subscription, observer.Respond); 
     } 

     _observerList.Where(o => o.Subscription == subscription).ToList().ForEach(o => _observerList.Remove(o)); 
    } 

    public void Subscribe(string subscription, Action<object> response) 
    { 
     MessageBus.Instance.Subscribe(subscription, response); 
     _observerList.Add(new Observer() { Subscription = subscription, Respond = response }); 
    } 

    public void SubscribeFirstPublication(string subscription, Action<object> response) 
    { 
     MessageBus.Instance.SubscribeFirstPublication(subscription, response); 
    } 
}