Wpf Interaction Behavior in nested DataGrids MVVM pattern

huangapple
go评论92阅读模式
英文:

Wpf Interaction Behavior in nested DataGrids MVVM pattern

问题

我已翻译你提供的代码部分，如下所示：

  1. 我有一个简单的`DataGrid`，其中`RowDetailsTemplate`的`DataTemplate`也是一个`DataGrid`。
  3. 使用一个`behavior`以双向绑定模式将`DataGrid`的`SelectedItems`绑定到`ViewModel`中。
  4. 该`behavior`同时用于主`DataGrid`和主`DataGrid`行的详细信息。
  6. 我面临的问题是，子`DataGrids`中的`behaviors`似乎永远不会被引用，子`DataGrid`中的每个`DataGrid.SelectionChanged`事件总是引用主`DataGrid`中的`behavior`。
  8. **视图**
  10. xmlns:i = "http://schemas.microsoft.com/xaml/behaviors"
  12. <DataGrid Name = "MainDataGrid"
  13. AutoGenerateColumns = "False"
  14. HorizontalScrollBarVisibility = "Disabled"
  15. Height = "Auto"
  16. ItemsSource = "{Binding ObCol_Model}"
  17. VerticalAlignment = "Stretch" CanUserAddRows = "false" BorderThickness = "1"
  18. AlternatingRowBackground = "#FFFFFFCC"
  19. HorizontalGridLinesBrush = "#FFA0A0A0"
  20. VerticalGridLinesBrush = "#FFA0A0A0"
  21. SelectionUnit = "FullRow"
  22. HeadersVisibility = "Column"
  23. GridLinesVisibility = "Horizontal"
  24. ColumnHeaderHeight = "25" IsReadOnly = "True" CanUserResizeRows = "False" RowHeight = "22" VerticalContentAlignment = "Center"
  25. BorderBrush = "DarkGray" HorizontalAlignment = "Left"
  26. RowDetailsVisibilityMode = "VisibleWhenSelected">
  28. <i:Interaction.Behaviors>
  29. <local:DataGridSelectedItemsBehavior SelectedItems = "{Binding SelectedItems}" />
  30. </i:Interaction.Behaviors>
  32. <DataGrid.Columns>
  33. <DataGridTextColumn Header = "Code" Binding = "{Binding Code}" Width = "80" />
  34. <DataGridTextColumn Header = "Name" Binding = "{Binding Name}" Width = "*" />
  35. </DataGrid.Columns>
  37. <DataGrid.RowDetailsTemplate>
  38. <DataTemplate>
  39. <DataGrid Name = "SubDataGrid"
  40. Margin = "10,0,0,0" AutoGenerateColumns = "False" ItemsSource = "{Binding ObCol_SubModel}"
  41. Height = "Auto" Width = "auto"
  42. VerticalAlignment = "Stretch" CanUserAddRows = "false" BorderThickness = "1"
  43. AlternatingRowBackground = "#FFFFFFCC"
  44. HorizontalGridLinesBrush = "#FFA0A0A0"
  45. VerticalGridLinesBrush = "#FFA0A0A0"
  46. SelectionUnit = "FullRow"
  47. HeadersVisibility = "Column"
  48. GridLinesVisibility = "Horizontal"
  49. ColumnHeaderHeight = "25" IsReadOnly = "True" CanUserResizeRows = "False" RowHeight = "22" VerticalContentAlignment = "Center"
  50. BorderBrush = "DarkGray" HorizontalAlignment = "Left">
  52. <i:Interaction.Behaviors>
  53. <local:DataGridSelectedItemsBehavior SelectedItems = "{Binding SubSelectedItems}" />
  54. </i:Interaction.Behaviors>
  56. <DataGrid.Style>
  57. <Style TargetType = "{x:Type DataGrid}">
  58. <Setter Property = "Visibility" Value = "Visible" />
  59. <Style.Triggers>
  60. <DataTrigger Binding = "{Binding ObCol_SubModel}" Value = "{x:Null}">
  61. <Setter Property = "Visibility" Value = "Collapsed" />
  62. </DataTrigger>
  63. </Style.Triggers>
  64. </Style>
  65. </DataGrid.Style>
  67. <DataGrid.Columns>
  68. <DataGridTextColumn Header = "Detail" Binding = "{Binding Detail}" Width = "80" />
  69. <DataGridTextColumn Header = "Detail Name" Binding = "{Binding Name}" Width = "150" />
  70. <DataGridTextColumn Header = "Comment" Binding = "{Binding Comment}" Width = "*" />
  71. </DataGrid.Columns>
  72. </DataGrid>
  73. </DataTemplate>
  74. </DataGrid.RowDetailsTemplate>
  75. </DataGrid>
  77. **行为（Behavior）**
  79. public class DataGridSelectedItemsBehavior: Behavior <DataGrid>
  80. {
  81. protected override void OnAttached()
  82. {
  83. base.OnAttached();
  84. if (SelectedItems != null)
  85. {
  86. AssociatedObject.SelectedItems.Clear();
  87. foreach (var item in SelectedItems)
  88. {
  89. AssociatedObject.SelectedItems.Add(item);
  90. }
  91. }
  92. }
  94. public IList SelectedItems
  95. {
  96. get { return (IList)GetValue(SelectedItemsProperty); }
  97. set { SetValue(SelectedItemsProperty, value); }
  98. }
  100. public static readonly DependencyProperty SelectedItemsProperty =
  101. DependencyProperty.Register("SelectedItems", typeof(IList), typeof(DataGridSelectedItemsBehavior), new UIPropertyMetadata(null, SelectedItemsChanged));
  103. private static void SelectedItemsChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
  104. {
  105. var behavior = o as DataGridSelectedItemsBehavior;
  106. if (behavior == null) return;
  108. var oldValue = e.OldValue as INotifyCollectionChanged;
  109. var newValue = e.NewValue as INotifyCollectionChanged;
  111. if (oldValue != null)
  112. {
  113. oldValue.CollectionChanged -= behavior.SourceCollectionChanged;
  114. behavior.AssociatedObject.SelectionChanged -= behavior.DataGridSelectionChanged;
  115. }
  116. if (newValue != null)
  117. {
  118. behavior.AssociatedObject.SelectedItems.Clear();
  119. foreach (var item in (IEnumerable) newValue)
  120. {
  121. behavior.AssociatedObject.SelectedItems.Add(item);
  122. }
  124. behavior.AssociatedObject.SelectionChanged += behavior.DataGridSelectionChanged;
  125. newValue.CollectionChanged += behavior.SourceCollectionChanged;
  126. }
  127. }
  129. private bool _isUpdatingTarget;
  130. private bool _isUpdatingSource;
  132. void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
  133. {
  134. if (_isUpdatingSource)
  135. return;
  137. try
  138. {
  139. _isUpdatingTarget = true;
  141. if (e.OldItems != null)
  142. {
  143. foreach (var item in e.OldItems)
  144. {
  145. AssociatedObject.SelectedItems.Remove(item);
  146. }
  147. }
  149. if (e.NewItems != null)
  150. {
  151. foreach (var item in e.NewItems)
  152. {
  153. AssociatedObject.SelectedItems.Add(item);
  154. }
  155. }
  157. if (e.Action == NotifyCollectionChangedAction.Reset)
  158. {
  159. AssociatedObject.SelectedItems.Clear();
  160. }
  161. }
  162. finally
  163. {
  164. _isUpdatingTarget = false;
  165. }
  166. }
  168. private void DataGridSelectionChanged(object sender, SelectionChangedEventArgs e)
  169. {
  170. if (_isUpdatingTarget)
  171. return;
  173. var selectedItems = this.SelectedItems;
  174. if (selectedItems == null)
  175. return;
  177. try
  178. {
  179. _isUpdatingSource = true;
  181. foreach (var item in e.RemovedItems)
  182. {
  183. selectedItems.Remove(item);
  184. }
  186. foreach (var item in e.AddedItems)
  187. {
  188. selectedItems.Add(item);
  189. }
  190. }
  191. finally
  192. {
  193. _isUpdatingSource = false;
  194. }
  195. }
  196. }
  198. **视图模型（ViewModel）**
  200. public class ViewModel: ObservableObject
  201. {
  202. private readonly ObservableCollection <Model> myObCol_Model;
  203. private ObservableCollection <Model> mySelectedItems;
  205. public ViewModel()
  206. {
  207. mySelectedItems = new ObservableCollection <Model> ();
  209. myObCol_Model = new ObservableCollection <Model> ()
  210. {
  211. new Model("100", "Hundred"),
  212. new Model("200", "Two Hundred"),
  213. new Model("300", "Three Hundred")
  214. };
  216. var item = new Model("400", "Four Hundred");
  217. item.AddSubModel(new SubModel("10", "Ten", "sub 10"));
  218. item.AddSubModel(new SubModel("20", "Twenty", "sub 20"));
  219. item.AddSubModel(new SubModel("30", "Thirty", "sub 30"));
  221. myObCol_Model.Add(item);
  222. }
  224. public ObservableCollection <Model> ObCol_Model { get { return myObCol_Model; } }
  226. public ObservableCollection <Model> SelectedItems
  227. {
  228. get
  230. <details>
  231. <summary>英文:</summary>
  233. I have a simple `DataGrid` with `RowDetailsTemplate` where the `DataTemplate` is also a `DataGrid`.
  235. A `behavior` is used to bind in two way mode `DataGrid&#39;s SelectedItems` to the `ViewModel`.
  236. The `behavior` is used both in main `DataGrid` and in subs `DataGrids` which are details of the main `DataGrid` rows.
  238. I&#39;m facing the problem that the behaviors in sub DataGrids seems to be never be referenced and each `DataGrid.SelectionChanged` event in the sub DataGrid refers always to the behavior in the main DataGrid.
  240. **THE VIEW**
  242.     xmlns:i=&quot;http://schemas.microsoft.com/xaml/behaviors&quot;
  244.         &lt;DataGrid Name=&quot;MainDataGrid&quot;
  245.                   AutoGenerateColumns=&quot;False&quot;
  246.                   HorizontalScrollBarVisibility=&quot;Disabled&quot;
  247.                   Height=&quot;Auto&quot; 
  248.                   ItemsSource=&quot;{Binding ObCol_Model}&quot;
  249.                   VerticalAlignment=&quot;Stretch&quot; CanUserAddRows=&quot;false&quot; BorderThickness=&quot;1&quot;
  250.                   AlternatingRowBackground=&quot;#FFFFFFCC&quot;
  251.                   HorizontalGridLinesBrush=&quot;#FFA0A0A0&quot;
  252.                   VerticalGridLinesBrush=&quot;#FFA0A0A0&quot;
  253.                   SelectionUnit=&quot;FullRow&quot;
  254.                   HeadersVisibility=&quot;Column&quot;
  255.                   GridLinesVisibility=&quot;Horizontal&quot;
  256.                   ColumnHeaderHeight=&quot;25&quot; IsReadOnly=&quot;True&quot; CanUserResizeRows=&quot;False&quot; RowHeight=&quot;22&quot; VerticalContentAlignment=&quot;Center&quot;
  257.                   BorderBrush=&quot;DarkGray&quot; HorizontalAlignment=&quot;Left&quot;
  258.                   RowDetailsVisibilityMode=&quot;VisibleWhenSelected&quot;&gt;
  259.             
  260.             &lt;i:Interaction.Behaviors&gt;
  261.                 &lt;local:DataGridSelectedItemsBehavior SelectedItems=&quot;{Binding SelectedItems}&quot; /&gt;
  262.             &lt;/i:Interaction.Behaviors&gt;
  263.             
  264.             &lt;DataGrid.Columns&gt;
  265.                 &lt;DataGridTextColumn Header=&quot;Code&quot; Binding=&quot;{Binding Code}&quot; Width=&quot;80&quot;/&gt;
  266.                 &lt;DataGridTextColumn Header=&quot;Name&quot; Binding=&quot;{Binding Name}&quot; Width=&quot;*&quot;/&gt;
  267.             &lt;/DataGrid.Columns&gt;
  268.             
  269.             &lt;DataGrid.RowDetailsTemplate&gt;
  270.                 &lt;DataTemplate&gt;
  271.                         &lt;DataGrid Name=&quot;SubDataGrid&quot;
  272.                                   Margin=&quot;10,0,0,0&quot; AutoGenerateColumns=&quot;False&quot; ItemsSource=&quot;{Binding ObCol_SubModel}&quot;
  273.                                   Height=&quot;Auto&quot; Width=&quot;auto&quot;
  274.                                   VerticalAlignment=&quot;Stretch&quot; CanUserAddRows=&quot;false&quot; BorderThickness=&quot;1&quot;
  275.                                   AlternatingRowBackground=&quot;#FFFFFFCC&quot;
  276.                                   HorizontalGridLinesBrush=&quot;#FFA0A0A0&quot;
  277.                                   VerticalGridLinesBrush=&quot;#FFA0A0A0&quot;
  278.                                   SelectionUnit=&quot;FullRow&quot;
  279.                                   HeadersVisibility=&quot;Column&quot;
  280.                                   GridLinesVisibility=&quot;Horizontal&quot;
  281.                                   ColumnHeaderHeight=&quot;25&quot; IsReadOnly=&quot;True&quot; CanUserResizeRows=&quot;False&quot; RowHeight=&quot;22&quot; VerticalContentAlignment=&quot;Center&quot;
  282.                                   BorderBrush=&quot;DarkGray&quot; HorizontalAlignment=&quot;Left&quot;&gt;
  284.                         &lt;i:Interaction.Behaviors&gt;
  285.                             &lt;local:DataGridSelectedItemsBehavior SelectedItems=&quot;{Binding SubSelectedItems}&quot; /&gt;
  286.                         &lt;/i:Interaction.Behaviors&gt;
  287.                             
  288.                         &lt;DataGrid.Style&gt;
  289.                             &lt;Style TargetType=&quot;{x:Type DataGrid}&quot;&gt;
  290.                                 &lt;Setter Property=&quot;Visibility&quot; Value=&quot;Visible&quot;/&gt;
  291.                                 &lt;Style.Triggers&gt;
  292.                                     &lt;DataTrigger Binding=&quot;{Binding ObCol_SubModel}&quot; Value=&quot;{x:Null}&quot;&gt;
  293.                                         &lt;Setter Property=&quot;Visibility&quot; Value=&quot;Collapsed&quot;/&gt;
  294.                                     &lt;/DataTrigger&gt;
  295.                                 &lt;/Style.Triggers&gt;
  296.                             &lt;/Style&gt;
  297.                         &lt;/DataGrid.Style&gt;
  299.                         &lt;DataGrid.Columns&gt;
  300.                             &lt;DataGridTextColumn Header=&quot;Detail&quot; Binding=&quot;{Binding Detail}&quot; Width=&quot;80&quot;/&gt;
  301.                             &lt;DataGridTextColumn Header=&quot;Detail Name&quot; Binding=&quot;{Binding Name}&quot; Width=&quot;150&quot;/&gt;
  302.                             &lt;DataGridTextColumn Header=&quot;Comment&quot; Binding=&quot;{Binding Comment}&quot; Width=&quot;*&quot;/&gt;
  303.                         &lt;/DataGrid.Columns&gt;
  304.                     &lt;/DataGrid&gt;
  305.                 &lt;/DataTemplate&gt;
  306.             &lt;/DataGrid.RowDetailsTemplate&gt;
  307.         &lt;/DataGrid&gt;
  309. **THE BEHAVIOR**
  311.     public class DataGridSelectedItemsBehavior : Behavior&lt;DataGrid&gt;
  312.     {
  313.         protected override void OnAttached()
  314.         {
  315.             base.OnAttached();
  316.             if (SelectedItems != null)
  317.             {
  318.                 AssociatedObject.SelectedItems.Clear();
  319.                 foreach (var item in SelectedItems)
  320.                 {
  321.                     AssociatedObject.SelectedItems.Add(item);
  322.                 }
  323.             }
  324.         }
  326.         public IList SelectedItems
  327.         {
  328.             get { return (IList)GetValue(SelectedItemsProperty); }
  329.             set { SetValue(SelectedItemsProperty, value); }
  330.         }
  332.         public static readonly DependencyProperty SelectedItemsProperty =
  333.             DependencyProperty.Register(&quot;SelectedItems&quot;, typeof(IList), typeof(DataGridSelectedItemsBehavior), new UIPropertyMetadata(null, SelectedItemsChanged));
  335.         private static void SelectedItemsChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
  336.         {
  337.             var behavior = o as DataGridSelectedItemsBehavior;
  338.             if (behavior == null) return;
  340.             var oldValue = e.OldValue as INotifyCollectionChanged;
  341.             var newValue = e.NewValue as INotifyCollectionChanged;
  343.             if (oldValue != null)
  344.             {
  345.                 oldValue.CollectionChanged -= behavior.SourceCollectionChanged;
  346.                 behavior.AssociatedObject.SelectionChanged -= behavior.DataGridSelectionChanged;
  347.             }
  348.             if (newValue != null)
  349.             {
  350.                 behavior.AssociatedObject.SelectedItems.Clear();
  351.                 foreach (var item in (IEnumerable)newValue)
  352.                 {
  353.                     behavior.AssociatedObject.SelectedItems.Add(item);
  354.                 }
  356.                 behavior.AssociatedObject.SelectionChanged += behavior.DataGridSelectionChanged;
  357.                 newValue.CollectionChanged += behavior.SourceCollectionChanged;
  358.             }
  359.         }
  361.         private bool _isUpdatingTarget;
  362.         private bool _isUpdatingSource;
  364.         void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
  365.         {
  366.             if (_isUpdatingSource)
  367.                 return;
  369.             try
  370.             {
  371.                 _isUpdatingTarget = true;
  373.                 if (e.OldItems != null)
  374.                 {
  375.                     foreach (var item in e.OldItems)
  376.                     {
  377.                         AssociatedObject.SelectedItems.Remove(item);
  378.                     }
  379.                 }
  381.                 if (e.NewItems != null)
  382.                 {
  383.                     foreach (var item in e.NewItems)
  384.                     {
  385.                         AssociatedObject.SelectedItems.Add(item);
  386.                     }
  387.                 }
  389.                 if (e.Action == NotifyCollectionChangedAction.Reset)
  390.                 {
  391.                     AssociatedObject.SelectedItems.Clear();
  392.                 }
  393.             }
  394.             finally
  395.             {
  396.                 _isUpdatingTarget = false;
  397.             }
  398.         }
  400.         private void DataGridSelectionChanged(object sender, SelectionChangedEventArgs e)
  401.         {
  402.             if (_isUpdatingTarget)
  403.                 return;
  405.             var selectedItems = this.SelectedItems;
  406.             if (selectedItems == null)
  407.                 return;
  409.             try
  410.             {
  411.                 _isUpdatingSource = true;
  413.                 foreach (var item in e.RemovedItems)
  414.                 {
  415.                     selectedItems.Remove(item);
  416.                 }
  418.                 foreach (var item in e.AddedItems)
  419.                 {
  420.                     selectedItems.Add(item);
  421.                 }
  422.             }
  423.             finally
  424.             {
  425.                 _isUpdatingSource = false;
  426.             }
  427.         }
  429.     }
  432. **THE VM**
  434.     public class ViewModel : ObservableObject
  435.     {
  436.         private readonly ObservableCollection&lt;Model&gt; myObCol_Model;
  437.         private ObservableCollection&lt;Model&gt; mySelectedItems;
  439.         public ViewModel()
  440.         {
  441.             mySelectedItems = new ObservableCollection&lt;Model&gt;();
  443.             myObCol_Model = new ObservableCollection&lt;Model&gt;()
  444.             {
  445.                 new Model(&quot;100&quot;, &quot;Hundred&quot;),
  446.                 new Model(&quot;200&quot;, &quot;Two Hundred&quot;),
  447.                 new Model(&quot;300&quot;, &quot;Three Hundred&quot;)
  448.             };
  450.             var item = new Model(&quot;400&quot;, &quot;Four Hundred&quot;);
  451.             item.AddSubModel(new SubModel(&quot;10&quot;, &quot;Ten&quot;, &quot;sub 10&quot;));
  452.             item.AddSubModel(new SubModel(&quot;20&quot;, &quot;Twenty&quot;, &quot;sub 20&quot;));
  453.             item.AddSubModel(new SubModel(&quot;30&quot;, &quot;Thirty&quot;, &quot;sub 30&quot;));
  455.             myObCol_Model.Add(item);
  456.         }
  458.         public ObservableCollection&lt;Model&gt; ObCol_Model { get { return myObCol_Model; } }
  460.         public ObservableCollection&lt;Model&gt; SelectedItems
  461.         {
  462.             get { return mySelectedItems; }
  463.             set
  464.             {
  465.                 if (mySelectedItems == value) return;
  467.                 mySelectedItems = value;
  468.                 OnPropertyChanged(nameof(SelectedItems));
  469.             }
  470.         }
  471.     }
  473. **THE MODELS**
  475.     public class Model : ObservableObject
  476.     {
  477.         private ObservableCollection&lt;SubModel&gt; myObCol_SubModel;
  478.         private ObservableCollection&lt;SubModel&gt; mySubModelSelectedItems;
  480.         public Model(string code, string name)
  481.         {
  482.             mySubModelSelectedItems = new ObservableCollection&lt;SubModel&gt;();
  484.             Code = code;
  485.             Name = name;
  486.         }
  488.         public string Code { get; set; }
  489.         public string Name { get; set; }
  490.         public ObservableCollection&lt;SubModel&gt; ObCol_SubModel { get { return myObCol_SubModel; } }
  492.         public void AddSubModel(SubModel subModel)
  493.         { 
  494.             if (myObCol_SubModel == null) myObCol_SubModel = new ObservableCollection&lt;SubModel&gt;();
  495.             myObCol_SubModel.Add(subModel);
  496.         }
  498.         public ObservableCollection&lt;SubModel&gt; SubSelectedItems
  499.         {
  500.             get { return mySubModelSelectedItems; }
  501.             set
  502.             {
  503.                 if (mySubModelSelectedItems == value) return;
  505.                 mySubModelSelectedItems = value;
  506.                 OnPropertyChanged(nameof(SubSelectedItems));
  507.             }
  508.         }
  509.     }
  511.     public class SubModel
  512.     {
  513.         public SubModel(string detail, string name, string comment)
  514.         {
  515.             Detail = detail;
  516.             Name = name;
  517.             Comment = comment;
  518.         }
  520.         public string Detail { get; set; }
  521.         public string Name { get; set; }
  522.         public string Comment { get; set; }
  523.     }
  525. </details>
  528. # 答案1
  529. **得分**: 1
  531. 下面是我翻译的代码部分：
  533. ```csharp
  534. 以下是我如何解决的问题：
  536.  - 在`OnAttached()`中添加了`AssociatedObject.SelectionChanged += DataGridSelectionChanged;`，应该在调用`OnAttached()`后首先访问`AssociatedObject`，否则`AssociatedObject`为`null`。
  538.  - 添加了`override OnDetaching()`。
  540.  - 在依赖属性更改回调中添加了`behavior.AssociatedObject==null`检查。
  542.  - 在`DataGridSelectionChanged`事件处理程序中添加了`e.Handled = true;`，以阻止事件冒泡，否则它将被父数据网格捕获。
  544. 我没有检查代码的其余部分，只修复了阻止选择工作的错误。

请注意，这是您提供的代码的翻译部分，不包括问题或其他内容。如果您有任何其他需求或问题，可以告诉我。

英文:

Below a behavior how it does work by me:

  1. public class DataGridSelectedItemsBehavior : Behavior&lt;DataGrid&gt;
  2. {
  3. protected override void OnAttached()
  4. {
  5. base.OnAttached();
  6. if (SelectedItems != null)
  7. {
  8. AssociatedObject.SelectedItems.Clear();
  9. foreach (var item in SelectedItems)
  10. {
  11. AssociatedObject.SelectedItems.Add(item);
  12. }
  13. }
  14. AssociatedObject.SelectionChanged += DataGridSelectionChanged;
  15. }
  16. protected override void OnDetaching()
  17. {
  18. base.OnDetaching();
  19. AssociatedObject.SelectionChanged -= DataGridSelectionChanged;
  20. }
  21. public IList SelectedItems
  22. {
  23. get { return (IList)GetValue(SelectedItemsProperty); }
  24. set { SetValue(SelectedItemsProperty, value); }
  25. }
  26. public static readonly DependencyProperty SelectedItemsProperty =
  27. DependencyProperty.Register(&quot;SelectedItems&quot;, typeof(IList), typeof(DataGridSelectedItemsBehavior), new UIPropertyMetadata(null, SelectedItemsChanged));
  28. private static void SelectedItemsChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
  29. {
  30. var behavior = o as DataGridSelectedItemsBehavior;
  31. if (behavior == null || behavior.AssociatedObject==null)
  32. return;
  33. var oldValue = e.OldValue as INotifyCollectionChanged;
  34. var newValue = e.NewValue as INotifyCollectionChanged;
  35. if (oldValue != null)
  36. {
  37. oldValue.CollectionChanged -= behavior.SourceCollectionChanged;
  38. behavior.AssociatedObject.SelectionChanged -= behavior.DataGridSelectionChanged;
  39. }
  40. if (newValue != null)
  41. {
  42. behavior.AssociatedObject.SelectedItems.Clear();
  43. foreach (var item in (IEnumerable)newValue)
  44. {
  45. behavior.AssociatedObject.SelectedItems.Add(item);
  46. }
  47. behavior.AssociatedObject.SelectionChanged += behavior.DataGridSelectionChanged;
  48. newValue.CollectionChanged += behavior.SourceCollectionChanged;
  49. }
  50. }
  51. private bool _isUpdatingTarget;
  52. private bool _isUpdatingSource;
  53. void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
  54. {
  55. if (_isUpdatingSource)
  56. return;
  57. try
  58. {
  59. _isUpdatingTarget = true;
  60. if (e.OldItems != null)
  61. {
  62. foreach (var item in e.OldItems)
  63. {
  64. AssociatedObject.SelectedItems.Remove(item);
  65. }
  66. }
  67. if (e.NewItems != null)
  68. {
  69. foreach (var item in e.NewItems)
  70. {
  71. AssociatedObject.SelectedItems.Add(item);
  72. }
  73. }
  74. if (e.Action == NotifyCollectionChangedAction.Reset)
  75. {
  76. AssociatedObject.SelectedItems.Clear();
  77. }
  78. }
  79. finally
  80. {
  81. _isUpdatingTarget = false;
  82. }
  83. }
  84. private void DataGridSelectionChanged(object sender, SelectionChangedEventArgs e)
  85. {
  86. if (_isUpdatingTarget)
  87. return;
  88. var selectedItems = this.SelectedItems;
  89. if (selectedItems == null)
  90. return;
  91. try
  92. {
  93. _isUpdatingSource = true;
  94. foreach (var item in e.RemovedItems)
  95. {
  96. selectedItems.Remove(item);
  97. }
  98. foreach (var item in e.AddedItems)
  99. {
  100. selectedItems.Add(item);
  101. }
  102. }
  103. finally
  104. {
  105. _isUpdatingSource = false;
  106. e.Handled = true;
  107. }
  108. }
  109. }

What was fixed?

  • Added AssociatedObject.SelectionChanged += DataGridSelectionChanged; to the OnAttached(), you should access AssociatedObject first after OnAttached() was called, otherwise AssociatedObject is null

  • Added override OnDetaching().

  • Added behavior.AssociatedObject==null check to the DP changed call back.

  • Added e.Handled = true; to the DataGridSelectionChanged event handler, in order to stop bubbling the event up, otherwise it comes by parent data grid.

I didn't check the rest of the code, just fixed errors which prevented selection to work.

huangapple
  • 本文由 发表于 2023年2月27日 03:08:20
  • 转载请务必保留本文链接：https://go.coder-hub.com/75574382.html
  • behavior
  • c#
  • datagrid
  • mvvm
  • wpf
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定