C# 如何在不同的windows phone页面之间共享xaml代码？

在我的应用程序中，我希望有以下一组控件：

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

我想在项目中的不同页面上共享。但问题是：

---

文本块和图像控件的内容将在运行时加载到PageLoad事件中。因此，每次导航时都必须加载它们。我不想发生这种事。我尝试将控件放在UserControl中，将它们加载到UserControl的Loaded事件中，并将UserControl包含在各个页面中。但UserControl的已加载事件仍会在每个页面上激发。我可以有一种方式，我可以只加载一次，每个页面都使用它吗？希望我能清楚地回答这个问题。

考虑利用带有参数的消息传递在对象之间传递数据

您可以使用or

其想法是让您的用户控件订阅他们想要响应的事件

注:

我使用viewmodels执行此操作。 然而，我认为，当将此代码添加到用户控件时，无论应用程序使用何种控件，都会产生代码气味

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

视图模型：

窗口：

您可以利用它来获取MessageBus

消息总线

}

订阅

---

请更清楚地说明为什么要避免加载事件。您不希望发生的具体问题是什么？我怀疑您是否能够抑制XAML框架导航的固有行为，但是如果您能够解释这里更大的问题是什么，您可能会得到一些建议来帮助解决这个问题。请参阅，以获取有关如何以清晰易懂的方式表达问题的建议。当我浏览想要避免的页面时，图像需要一些时间才能加载。我希望它尽可能的即时。没别的了。你不能试试单例模式吗？为什么不加载一次图像呢？如果需要，图像控件将代表您加载图像对象，但您也可以将已加载的对象交给它。实际上，您可以从使用UserControl的第一个页面检索加载的对象，并在导航时将其传递到下一个页面。如果没有，我无法具体说明在代码中如何工作，但这是基本的想法。是的，我绝对可以做到。事实上，我将图像作为位图图像加载到全局对象中，并一直将其分配给各个页面上的图像控件。我只是想知道是否有其他方法可以做同样的事情。

    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();
            });
    }
}

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);
    }
}