xaml - 如何在具有 MVVM 体系结构的 WinRT 应用程序中重用 XAML 中的交互行为

Question

要绑定(bind)“加载”和“卸载”事件，我在 XAML 页面中使用以下代码:

<Page ...>
<interactivity:Interaction.Behaviors>
    <core:EventTriggerBehavior EventName="Loaded">
        <core:InvokeCommandAction Command="{Binding LoadedCommand}" />
    </core:EventTriggerBehavior>
    <core:EventTriggerBehavior EventName="Unloaded">
        <core:InvokeCommandAction Command="{Binding UnloadedCommand}" />
    </core:EventTriggerBehavior>
</interactivity:Interaction.Behaviors>
<Grid />
</Page>

一切都按预期工作但是我将同样的代码复制到每个 View 中？我怎样才能使这个可重复使用？

编辑

我使用此 post 中的代码创建了一个附加属性.

我的附加属性如下所示:

public static class UiBehaviors
{
    public static readonly DependencyProperty AttachedTriggersProperty = DependencyProperty.RegisterAttached("AttachedTriggers", typeof(EventTriggerCollection), typeof(UiBehaviors), new PropertyMetadata(null, OnAttachedTriggersChanged));

    private static void OnAttachedTriggersChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        BehaviorCollection triggers = Interaction.GetBehaviors(d);

        if (e.OldValue != null)
        {
            foreach (EventTriggerBehavior trigger in (EventTriggerCollection)e.OldValue)
                triggers.Remove(trigger);
        }

        if (e.NewValue == null)
            return;

        foreach (EventTriggerBehavior trigger in (EventTriggerCollection)e.NewValue)
            triggers.Add(trigger);

    }

    public static void SetAttachedTriggers(DependencyObject element, EventTriggerCollection value)
    {
        element.SetValue(AttachedTriggersProperty, value);
    }

    public static EventTriggerCollection GetAttachedTriggers(DependencyObject element)
    {
        return (EventTriggerCollection)element.GetValue(AttachedTriggersProperty);
    }
}

public class EventTriggerCollection : Collection<EventTriggerBehavior>
{
}

我的 Xaml 看起来像这样:

<Style x:Name="Test" TargetType="UserControl">
    <Setter Property="storeApplication:UiBehaviors.AttachedTriggers">
        <Setter.Value>
            <storeApplication:EventTriggerCollection>
                <core:EventTriggerBehavior EventName="Loaded">
                    <core:InvokeCommandAction Command="{Binding LoadedCommand}"  />
                </core:EventTriggerBehavior>
                <core:EventTriggerBehavior EventName="Unloaded">
                    <core:InvokeCommandAction Command="{Binding UnloadedCommand}" />
                </core:EventTriggerBehavior>
            </storeApplication:EventTriggerCollection>
        </Setter.Value>
    </Setter>
</Style>

每次访问该属性时，EventTriggerCollection 都需要 x:shared=False 属性来创建一组新的触发器。如果没有它，触发器将仅适用于访问该属性的第一个控件。

不幸的是，我无法使用此属性，因为 WinRT 不支持它。看到这个 post .我现在被卡住了:(我错过了什么？

Answer 1

您可以对您的页面进行子类化或定义在单个属性中执行相同操作的附加属性。

例如。对于基类解决方案:

MainPage.xaml

<local:MyAppPageBase
    x:Class="App16.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App16"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    LoadedCommand="{Binding LoadedCommand}"
    UnloadedCommand="{Binding UnloadedCommand}">
    <Grid />
</local:MyAppPageBase>

MainPage.xaml.cs

using System.Windows.Input;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace App16
{
    public abstract class MyAppPageBase : Page
    {
        #region LoadedCommand
        /// <summary>
        /// LoadedCommand Dependency Property
        /// </summary>
        private static readonly DependencyProperty _LoadedCommandProperty =
            DependencyProperty.Register(
                "LoadedCommand",
                typeof(ICommand),
                typeof(MyAppPageBase),
                new PropertyMetadata(null));

        /// <summary>
        /// Identifies the LoadedCommand dependency property.
        /// </summary>
        public static DependencyProperty LoadedCommandProperty { get { return _LoadedCommandProperty; } }

        /// <summary>
        /// Gets or sets the LoadedCommand property. This dependency property 
        /// indicates the command to execute when the page loads.
        /// </summary>
        public ICommand LoadedCommand
        {
            get { return (ICommand)GetValue(LoadedCommandProperty); }
            set { this.SetValue(LoadedCommandProperty, value); }
        }
        #endregion

        #region UnloadedCommand
        /// <summary>
        /// UnloadedCommand Dependency Property
        /// </summary>
        private static readonly DependencyProperty _UnloadedCommandProperty =
            DependencyProperty.Register(
                "UnloadedCommand",
                typeof(ICommand),
                typeof(MyAppPageBase),
                new PropertyMetadata(null));

        /// <summary>
        /// Identifies the UnloadedCommand dependency property.
        /// </summary>
        public static DependencyProperty UnloadedCommandProperty { get { return _UnloadedCommandProperty; } }

        /// <summary>
        /// Gets or sets the UnloadedCommand property. This dependency property 
        /// indicates the command to execute when the page unloads.
        /// </summary>
        public ICommand UnloadedCommand
        {
            get { return (ICommand)GetValue(UnloadedCommandProperty); }
            set { this.SetValue(UnloadedCommandProperty, value); }
        }
        #endregion

        public MyAppPageBase()
        {
            this.Loaded += (s, e) =>
            {
                if (LoadedCommand?.CanExecute(null) == true)
                {
                    LoadedCommand.Execute(null);
                }
            };

            this.Unloaded += (s, e) =>
            {
                if (UnloadedCommand?.CanExecute(null) == true)
                {
                    UnloadedCommand.Execute(null);
                }
            };
        }
    }

    public sealed partial class MainPage : MyAppPageBase
    {
        public MainPage()
        {
            this.InitializeComponent();
        }
    }
}

附加属性(附加行为)解决方案涉及更多，因为附加属性需要确保它不会导致静态类上的事件订阅引起的泄漏，但具有不需要更改基类的好处，即如果您想在多个项目中重用它特别有用，也许通过将它放在 NuGet 包中:

MainPage.xaml

<Page
    x:Class="App16.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App16"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    local:ElementExtensions.LoadedCommand="{Binding LoadedCommand}">
    <Grid />
</Page>

MainPage.xaml.cs

using System;
using System.Diagnostics;
using System.Windows.Input;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace App16
{
    public static class ElementExtensions
    {
        #region LoadedCommand
        /// <summary>
        /// LoadedCommand Attached Dependency Property
        /// </summary>
        private static readonly DependencyProperty _LoadedCommandProperty =
            DependencyProperty.RegisterAttached(
                "LoadedCommand",
                typeof(ICommand),
                typeof(ElementExtensions),
                new PropertyMetadata(null, OnLoadedCommandChanged));

        /// <summary>
        /// Identifies the LoadedCommand dependency property.
        /// </summary>
        public static DependencyProperty LoadedCommandProperty { get { return _LoadedCommandProperty; } }

        /// <summary>
        /// Gets the LoadedCommand property. This dependency property 
        /// indicates the command to execute when the element loads.
        /// </summary>
        public static ICommand GetLoadedCommand(DependencyObject d)
        {
            return (ICommand)d.GetValue(LoadedCommandProperty);
        }

        /// <summary>
        /// Sets the LoadedCommand property. This dependency property 
        /// indicates the command to execute when the element loads.
        /// </summary>
        public static void SetLoadedCommand(DependencyObject d, ICommand value)
        {
            d.SetValue(LoadedCommandProperty, value);
        }

        /// <summary>
        /// Handles changes to the LoadedCommand property.
        /// </summary>
        /// <param name="d">
        /// The <see cref="DependencyObject"/> on which
        /// the property has changed value.
        /// </param>
        /// <param name="e">
        /// Event data that is issued by any event that
        /// tracks changes to the effective value of this property.
        /// </param>
        private static void OnLoadedCommandChanged(
            DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ICommand oldLoadedCommand = (ICommand)e.OldValue;
            ICommand newLoadedCommand = (ICommand)d.GetValue(LoadedCommandProperty);

            if (oldLoadedCommand != null)
            {
                var handler = GetLoadedCommandHandler(d);
                handler?.Detach((FrameworkElement) d);
            }

            if (newLoadedCommand != null)
            {
                SetLoadedCommandHandler(d, new LoadedCommandHandler((FrameworkElement)d));
            }
        }
        #endregion

        #region LoadedCommandHandler
        /// <summary>
        /// LoadedCommandHandler Attached Dependency Property
        /// </summary>
        private static readonly DependencyProperty _LoadedCommandHandlerProperty =
            DependencyProperty.RegisterAttached(
                "LoadedCommandHandler",
                typeof(LoadedCommandHandler),
                typeof(ElementExtensions),
                new PropertyMetadata(null));

        /// <summary>
        /// Identifies the LoadedCommandHandler dependency property.
        /// </summary>
        public static DependencyProperty LoadedCommandHandlerProperty { get { return _LoadedCommandHandlerProperty; } }

        /// <summary>
        /// Gets the LoadedCommandHandler property. This dependency property 
        /// indicates the object that handles Loaded events on its owning element.
        /// </summary>
        internal static LoadedCommandHandler GetLoadedCommandHandler(DependencyObject d)
        {
            return (LoadedCommandHandler)d.GetValue(LoadedCommandHandlerProperty);
        }

        /// <summary>
        /// Sets the LoadedCommandHandler property. This dependency property 
        /// indicates the object that handles Loaded events on its owning element.
        /// </summary>
        internal static void SetLoadedCommandHandler(DependencyObject d, LoadedCommandHandler value)
        {
            d.SetValue(LoadedCommandHandlerProperty, value);
        }
        #endregion

        internal class LoadedCommandHandler
        {
            public LoadedCommandHandler(FrameworkElement element)
            {
                element.Loaded += OnLoaded;
            }

            public void Detach(FrameworkElement element)
            {
                element.Loaded -= OnLoaded;
            }

            private void OnLoaded(object sender, RoutedEventArgs e)
            {
                var command = GetLoadedCommand((DependencyObject) sender);
                if (command?.CanExecute(null) == true)
                {
                    command.Execute(null);
                }
            }
        }
    }

    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
            this.DataContext = new MyViewModel();
        }
    }

    public class MyViewModel
    {
        public ICommand LoadedCommand { get; private set; } = new MyCommand();
    }

    public class MyCommand : ICommand
    {
        public bool CanExecute(object parameter)
        {
            return true;
        }

        public void Execute(object parameter)
        {
            Debug.WriteLine("Blahr");
        }

        public event EventHandler CanExecuteChanged;
    }
}