动态资源是如何构建的以及它们在上下文菜单中的使用

Question

动态资源真的是动态的吗？如果我定义一个 DynamicResource，我意识到创建了一个表达式（在哪里？），直到运行时才转换为资源，但是，我不明白的是这个动态资源一旦构建，现在是否是“静态”的

例如，如果我通过动态资源创建上下文菜单，那么在运行时访问时创建的菜单项是否是静态的，即使它们已绑定？

如果是这样，我如何在 XAML 中创建动态上下文菜单？

Answer 1

这是一个非常复杂的主题，因为 WPF 中存在多种动态。我将从一个简单的示例开始，帮助您理解所需的一些基本概念，然后继续解释动态更新和/或替换 ContextMenu 的各种方法，以及 DynamicResource 如何融入其中。

初始示例：动态更新通过 StaticResource 引用的 ContextMenu

假设您有以下内容：

<Window>
  <Window.Resources>
    <ContextMenu x:Key="Vegetables">
      <MenuItem Header="Broccoli" />
      <MenuItem Header="Cucumber" />
      <MenuItem Header="Cauliflower" />
    </ContextMenu>
  </Window.Resources>

  <Grid>
    <Ellipse ContextMenu="{StaticResource Vegetables}" />
    <TextBox ContextMenu="{StaticResource Vegetables}" ... />
    ...
  </Grid>
</Window>

** 现在请注意 StaticResource 的使用。

此 XAML 将：

• 构造一个具有三个 MenuItem 的 ContextMenu 对象，并将其添加到 Window.Resources
• 构造一个引用 ContextMenu 的 Ellipse 对象
• 构造一个引用 ContextMenu 的 TextBox 对象

因为 Ellipse 和 TextBox 都引用相同的对象ContextMenu，更新 ContextMenu 将更改每个菜单上可用的选项。例如，当单击按钮时，以下内容会将“Carrots”添加到菜单中。

public void Button_Click(object sender, EventArgs e)
{
  var menu = (ContextMenu)Resources["Vegetables"];
  menu.Items.Add(new MenuItem { Header = "Carrots" });
}

从这个意义上说，每个 ContextMenu 都是动态的：它的项目可以随时修改，并且更改将立即生效。即使 ContextMenu 实际上在屏幕上打开（下拉）也是如此。

通过数据绑定更新动态 ContextMenu

单个 ContextMenu 对象动态的另一种方式是它响应数据绑定。您可以绑定到一个集合，而不是设置单独的 MenuItem，例如：

<Window.Resources>
  <ContextMenu x:Key="Vegetables" ItemsSource="{Binding VegetableList}" />
</Window.Resources>

这假设 VegetableList 被声明为 ObservableCollection 或实现 INotifyCollectionChanged 接口的其他类型。您对集合所做的任何更改都会立即更新上下文菜单，即使它是打开的。例如：

public void Button_Click(object sender, EventArgs e)
{
  VegetableList.Add("Carrots");
}

请注意，这种集合更新不需要在代码中进行：您还可以将蔬菜列表绑定到 ListView、DataGrid 等，以便最终用户可以进行更改。这些更改也会显示在您的上下文菜单中。

使用代码切换ContextMenu

您还可以用完全不同的ContextMenu替换项目的ContextMenu。例如：

<Window>
  <Window.Resources>
    <ContextMenu x:Key="Vegetables">
      <MenuItem Header="Broccoli" />
      <MenuItem Header="Cucumber" />
    </ContextMenu>
    <ContextMenu x:Key="Fruits">
      <MenuItem Header="Apple" />
      <MenuItem Header="Banana" />
    </ContextMenu>
  </Window.Resources>

  <Grid>
    <Ellipse x:Name="Oval" ContextMenu="{StaticResource Vegetables}" />
    ...
  </Grid>
</Window>

菜单可以用如下代码替换：

public void Button_Click(object sender, EventArgs e)
{
  Oval.ContextMenu = (ContextMenu)Resources.Find("Fruits");
}

请注意，我们不是修改现有的 ContextMenu，而是切换到完全不同的 ContextMenu。在这种情况下，两个 ContextMenus 都会在窗口首次构建时立即构建，但 Fruits 菜单只有在切换时才会使用。

如果您想避免在必要时构建“水果”菜单，您可以在 Button_Click 处理程序中构建它，而不是在 XAML 中构建：

public void Button_Click(object sender, EventArgs e)
{
  Oval.ContextMenu =
    new ContextMenu { ItemsSource = new[] { "Apples", "Bananas" } };
}

在此示例中，每次单击按钮时，都会构建一个新的 ContextMenu 并将其分配给椭圆形。 Window.Resources 中定义的任何 ContextMenu 仍然存在，但未使用（除非另一个控件使用它）。

使用 DynamicResource 切换 ContextMenus

使用 DynamicResource 允许您在 ContextMenus 之间切换，而无需显式分配代码。例如：

<Window>
  <Window.Resources>
    <ContextMenu x:Key="Vegetables">
      <MenuItem Header="Broccoli" />
      <MenuItem Header="Cucumber" />
    </ContextMenu>
  </Window.Resources>

  <Grid>
    <Ellipse ContextMenu="{DynamicResource Vegetables}" />
    ...
  </Grid>
</Window>

由于此 XAML 使用 DynamicResource 而不是 StaticResource，因此修改字典将更新 Ellipse 的 ContextMenu 属性。例如：

public void Button_Click(object sender, EventArgs e)
{
  Resources["Vegetables"] =
    new ContextMenu { ItemsSource = new[] {"Zucchini", "Tomatoes"} };
}

这里的关键概念是 DynamicResource 与 StaticResource 仅控制何时完成字典查找。如果在上面的示例中使用 StaticResource，则分配给 Resources["Vegetables"] 将不会更新 Ellipse 的 ContextMenu 属性。

另一方面，如果您要更新 ContextMenu 本身（通过更改其 Items 集合或通过数据绑定），则使用 DynamicResource 还是 StaticResource 并不重要：在每种情况下，您对 ContextMenu 所做的任何更改都将立即可见。

使用数据绑定更新单个 ContextMenu ITEMS

根据右键单击的项目的属性更新 ContextMenu 的最佳方法是使用数据绑定：

<ContextMenu x:Key="SelfUpdatingMenu">
  <MenuItem Header="Delete" IsEnabled="{Binding IsDeletable}" />
    ...
</ContextMenu>

这将导致“删除”菜单项被删除。除非该项目设置了 IsDeletable 标志，否则会自动变灰。在这种情况下，不需要（甚至不需要）任何代码。

如果您想隐藏该项目而不是简单地将其变灰，请设置 Visibility 而不是 IsEnabled：

<MenuItem Header="Delete"
          Visibility="{Binding IsDeletable, Converter={x:Static BooleanToVisibilityConverter}}" />

如果您想根据您的数据从 ContextMenu 添加/删除项目，您可以使用 CompositeCollection 进行绑定。语法有点复杂，但仍然非常简单：

<ContextMenu x:Key="MenuWithEmbeddedList">
  <ContextMenu.ItemsSource>
    <CompositeCollection>
      <MenuItem Header="This item is always present" />
      <MenuItem Header="So is this one" />
      <Separator /> <!-- draw a bar -->
      <CollectionContainer Collection="{Binding MyChoicesList}" />
      <Separator />
      <MenuItem Header="Fixed item at bottom of menu" />
    </CompositeCollection>
  </ContextMenu.ItemsSource>
</ContextMenu>

假设“MyChoicesList”是一个 ObservableCollection（或任何其他实现 INotifyCollectionChanged 的​​类），在此集合中添加/删除/更新的项目将立即在 ContextMenu 上可见。

在没有数据绑定的情况下更新单个 ContextMenu 项目

只要有可能，您应该使用数据绑定来控制您的 ContextMenu 项目。它们工作得很好，几乎万无一失，并且大大简化了您的代码。仅当数据绑定无法正常工作时，使用代码更新菜单项才有意义。在这种情况下，您可以通过处理 ContextMenu.Opened 事件并在此事件中进行更新来构建 ContextMenu。例如：

<ContextMenu x:Key="Vegetables" Opened="Vegetables_Opened">
  <MenuItem Header="Broccoli" />
  <MenuItem Header="Green Peppers" />
</ContextMenu>

使用此代码：

public void Vegetables_Opened(object sender, RoutedEventArgs e)
{
  var menu = (ContextMenu)sender;
  var data = (MyDataClass)menu.DataContext

  var oldCarrots = (
    from item in menu.Items
    where (string)item.Header=="Carrots"
    select item
  ).FirstOrDefault();

  if(oldCarrots!=null)
    menu.Items.Remove(oldCarrots);

  if(ComplexCalculationOnDataItem(data) && UnrelatedCondition())
    menu.Items.Add(new MenuItem { Header = "Carrots" });
}

或者，如果您使用数据绑定，则此代码可以简单地更改 menu.ItemsSource。

使用触发器切换ContextMenus

更新ContextMenus常用的另一种技术是使用触发器或DataTrigger根据触发条件在默认上下文菜单和自定义上下文菜单之间切换。这可以处理您想要使用数据绑定但需要替换整个菜单而不是更新其部分内容的情况。

下面是其外观的说明：

<ControlTemplate ...>

  <ControlTemplate.Resources>
    <ContextMenu x:Key="NormalMenu">
      ...
    </ContextMenu>
    <ContextMenu x:Key="AlternateMenu">
      ...
    </ContextMenu>
  </ControlTemplate.Resources>

  ...

  <ListBox x:Name="MyList" ContextMenu="{StaticResource NormalMenu}">

  ...

  <ControlTemplate.Triggers>
    <Trigger Property="IsSpecialSomethingOrOther" Value="True">
      <Setter TargetName="MyList" Property="ContextMenu" Value="{StaticResource AlternateMenu}" />
    </Trigger>
  </ControlTemplate.Triggers>
</ControlTemplate>

在这种情况下，仍然可以使用数据绑定来控制 NormalMenu 和 AlternateMenu 中的各个项目。

菜单关闭时释放 ContextMenu 资源

如果 ContextMenu 中使用的资源在 RAM 中保存起来很昂贵，您可能需要释放它们。如果您使用数据绑定，这可能会自动发生，因为当菜单关闭时 DataContext 将被删除。如果您使用代码，则可能必须捕获 ContextMenu 上的 Closed 事件，以释放您为响应 Opened 事件而创建的任何内容。

从 XAML 延迟构造 ContextMenu

如果您有一个非常复杂的 ContextMenu，想要在 XAML 中进行编码，但不想在需要时才加载，则可以使用两种基本技术：

1. Put它在一个单独的资源字典中。必要时，加载该 ResourceDictionary 并将其添加到 MergedDictionaries。只要您使用DynamicResource，合并的值就会被拾取。

2. 将其放入 ControlTemplate 或 DataTemplate 中。在第一次使用模板之前，菜单实际上不会被实例化。

然而，这些技术本身都不会导致在上下文菜单打开时发生加载 - 仅当包含模板被实例化或字典被合并时。要实现此目的，您必须使用带有空 ItemsSource 的 ContextMenu，然后在 Opened 事件中分配 ItemsSource。然而，ItemsSource 的值可以从单独文件中的 ResourceDictionary 加载：

<ResourceDictionary ...>
  <x:Array x:Key="ComplexContextMenuContents">
    <MenuItem Header="Broccoli" />
    <MenuItem Header="Green Beans" />
    ... complex content here ...
  </x:Array>
</ResourceDictionary>

在 Opened 事件中使用此代码：

var dict = (ResourceDictionary)Application.LoadComponent(...);
menu.ItemsSource = dict["ComplexMenuContents"];

在 Closed 事件中使用此代码：

menu.ItemsSource = null;

实际上，如果您只有一个 x:Array，您也可以跳过资源字典。如果 XAML 的最外层元素是 x:Array，则 Opened 事件代码很简单：

menu.ItemsSource = Application.LoadComponent(....)

关键概念摘要

DynamicResource 仅用于根据加载的资源字典及其包含的内容切换值：更新字典的内容，DynamicResource 会自动更新属性。 StaticResource 仅在加载 XAML 时读取它们。

无论使用 DynamicResource 还是 StaticResource，ContextMenu 都是在加载资源字典时创建的，而不是在打开菜单时创建的。

上下文菜单非常动态，您可以使用数据绑定或代码来操作它们，并且更改会立即生效。

在大多数情况下，您应该使用数据绑定而不是代码来更新 ContextMenu。

可以使用代码、触发器或 DynamicResource 来完全替换菜单。

如果只有在菜单打开时才必须将内容加载到 RAM 中，则可以在 Opened 事件中从单独的文件加载它们，并在 Closed 事件中清除它们。