WPF CommandParameter имеет значение NULL при первом вызове CanExecute

Question

Я столкнулся с проблемой с WPF и командами, которые связаны с кнопкой внутри DataTemplate ItemsControl. Сценарий довольно прямой. ItemsControl привязан к списку объектов, и я хочу иметь возможность удалить каждый объект в списке, нажав кнопку. Кнопка выполняет команду, а команда заботится об удалении. CommandParameter привязан к объекту, который я хочу удалить. Таким образом, я знаю, что пользователь нажал. Пользователь должен иметь возможность удалять только свои «собственные» объекты, поэтому мне нужно выполнить некоторые проверки в вызове «CanExecute» команды, чтобы убедиться, что у пользователя есть необходимые разрешения.

Проблема в том, что параметр, переданный в CanExecute, имеет значение NULL при первом вызове - поэтому я не могу запустить логику для включения / отключения команды. Однако, если я включу его всегда, а затем нажму кнопку, чтобы выполнить команду, CommandParameter будет передан правильно. Это означает, что связывание с CommandParameter работает.

XAML для ItemsControl и DataTemplate выглядит следующим образом:

<ItemsControl 
    x:Name="commentsList"
    ItemsSource="{Binding Path=SharedDataItemPM.Comments}"
    Width="Auto" Height="Auto">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                <Button                             
                    Content="Delete"
                    FontSize="10"
                    Command="{Binding Path=DataContext.DeleteCommentCommand, ElementName=commentsList}" 
                    CommandParameter="{Binding}" />
            </StackPanel>                       
         </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

Итак, как вы можете видеть, у меня есть список объектов комментариев. Я хочу, чтобы CommandParameter команды DeleteCommentCommand был привязан к объекту Command.

Итак, я думаю, мой вопрос: кто-нибудь сталкивался с этой проблемой раньше? CanExecute вызывается для моей команды, но в первый раз параметр всегда равен NULL - почему это так?

Обновление: Мне удалось немного сузить проблему. Я добавил пустой Debug ValueConverter, чтобы вывести сообщение, когда CommandParameter привязан к данным. Оказывается, проблема в том, что метод CanExecute выполняется до того, как CommandParameter будет привязан к кнопке. Я попытался установить CommandParameter перед командой (как предложено) - но он все еще не работает. Любые советы о том, как его контролировать.

Обновление 2: Есть ли способ определить, когда привязка "выполнена", чтобы я мог принудительно выполнить повторную оценку команды? Кроме того - это проблема, что у меня есть несколько кнопок (по одной для каждого элемента в ItemsControl), которые связаны с одним и тем же экземпляром объекта Command?

Обновление 3: Я загрузил репродукцию ошибки в мой SkyDrive: http://cid -1a08c11c407c0d8e.skydrive.live.com / self.aspx / Код% 20samples / CommandParameterBinding.zip

Answer 1

У меня возникла такая же проблема при попытке привязать команду к моей модели представления.

Я изменил его, чтобы использовать относительную привязку к источнику вместо ссылки на элемент по имени, и это помогло. Привязка параметров не изменилась.

Старый код:

Command="{Binding DataContext.MyCommand, ElementName=myWindow}"

Новый код:

Command="{Binding DataContext.MyCommand, RelativeSource={RelativeSource AncestorType=Views:MyView}}"

Обновление : Я только что столкнулся с этой проблемой, не используя ElementName, я привязываю команду к моей модели представления, и мой контекст данных кнопки - это моя модель представления. В этом случае мне пришлось просто переместить атрибут CommandParameter перед атрибутом Command в объявлении Button (в XAML).

CommandParameter="{Binding Groups}"
Command="{Binding StartCommand}"

Answer 2

Я обнаружил, что порядок, в котором я устанавливаю Command и CommandParameter, имеет значение. Установка свойства Command приводит к немедленному вызову CanExecute, поэтому вы хотите, чтобы CommandParameter уже был установлен в этой точке.

Я обнаружил, что изменение порядка свойств в XAML действительно может иметь эффект, хотя я не уверен, что это решит вашу проблему. Хотя стоит попробовать.

Похоже, вы предполагаете, что кнопка никогда не активируется, что удивительно, поскольку я ожидаю, что CommandParameter будет установлен вскоре после свойства Command в вашем примере. Вызывает ли вызов CommandManager.InvalidateRequerySuggested () кнопку включенной?

Answer 3

Я наткнулся на похожую проблему и решил ее, используя мой надежный TriggerConverter.

public class TriggerConverter : IMultiValueConverter
{
    #region IMultiValueConverter Members

    public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        // First value is target value.
        // All others are update triggers only.
        if (values.Length < 1) return Binding.DoNothing;
        return values[0];
    }

    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }

    #endregion
}

Этот преобразователь значений принимает любое количество параметров и передает первый из них обратно в качестве преобразованного значения. При использовании в MultiBinding в вашем случае это выглядит следующим образом.

<ItemsControl 
    x:Name="commentsList"
    ItemsSource="{Binding Path=SharedDataItemPM.Comments}"
    Width="Auto" Height="Auto">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                <Button                             
                    Content="Delete"
                    FontSize="10"
                    CommandParameter="{Binding}">
                    <Button.Command>
                        <MultiBinding Converter="{StaticResource TriggerConverter}">
                            <Binding Path="DataContext.DeleteCommentCommand"
                                     ElementName="commentsList" />
                            <Binding />
                        </MultiBinding> 
                    </Button.Command>
                </Button>
            </StackPanel>                                       
         </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

Вам нужно будет добавить TriggerConverter в качестве ресурса, чтобы это работало. Теперь свойство Command устанавливается не раньше, чем значение CommandParameter станет доступным. Вы могли бы даже связываться с RelativeSource.Self и CommandParameter вместо. добиться того же эффекта.

Answer 4

Я знаю, что эта ветка довольно старая, но у меня есть еще одна возможность обойти эту проблему, которой я хотел бы поделиться. Поскольку метод CanExecute этой команды выполняется до того, как задано свойство CommandParameter, я создал вспомогательный класс со вложенным свойством, которое вызывает повторный вызов метода CanExecute при изменении привязки.

public static class ButtonHelper
{
    public static DependencyProperty CommandParameterProperty = DependencyProperty.RegisterAttached(
        "CommandParameter",
        typeof(object),
        typeof(ButtonHelper),
        new PropertyMetadata(CommandParameter_Changed));

    private static void CommandParameter_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var target = d as ButtonBase;
        if (target == null)
            return;

        target.CommandParameter = e.NewValue;
        var temp = target.Command;
        // Have to set it to null first or CanExecute won't be called.
        target.Command = null;
        target.Command = temp;
    }

    public static object GetCommandParameter(ButtonBase target)
    {
        return target.GetValue(CommandParameterProperty);
    }

    public static void SetCommandParameter(ButtonBase target, object value)
    {
        target.SetValue(CommandParameterProperty, value);
    }
}

И затем на кнопке вы хотите привязать параметр команды к ...

<Button 
    Content="Press Me"
    Command="{Binding}" 
    helpers:ButtonHelper.CommandParameter="{Binding MyParameter}" />

Я надеюсь, что это, возможно, поможет кому-то еще с этой проблемой.

Answer 5

Это старая ветка, но так как Google привел меня сюда, когда у меня возникла эта проблема, я добавлю то, что у меня работает, для DataGridTemplateColumn с кнопкой.

Изменить привязку с:

CommandParameter="{Binding .}"

до

CommandParameter="{Binding DataContext, RelativeSource={RelativeSource Self}}"

Не уверен, почему это работает, но у меня получилось.

Answer 6

Вы можете использовать мои CommandParameterBehavior, которые я опубликовал на форумах Prism вчера. Он добавляет недостающее поведение, когда изменение CommandParameter вызывает запрос Command.

Здесь есть некоторая сложность, вызванная моими попытками избежать утечки памяти, вызванной тем, что вы вызываете PropertyDescriptor.AddValueChanged без последующего вызова PropertyDescriptor.RemoveValueChanged. Я пытаюсь исправить это, отменив регистрацию обработчика при выгрузке ekement.

Возможно, вам придется удалить материал IDelegateCommand, если вы не используете Prism (и не хотите вносить те же изменения, что и я, в библиотеку Prism). Также обратите внимание, что мы обычно не используем RoutedCommand s здесь (мы используем DelegateCommand<T> Prism для почти всего), поэтому, пожалуйста, не считайте меня ответственным, если мой вызов CommandManager.InvalidateRequerySuggested вызывает какой-то квантовый каскад коллапса волновой функции который разрушает известную вселенную или что-либо еще.

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;

namespace Microsoft.Practices.Composite.Wpf.Commands
{
    /// <summary>
    /// This class provides an attached property that, when set to true, will cause changes to the element's CommandParameter to 
    /// trigger the CanExecute handler to be called on the Command.
    /// </summary>
    public static class CommandParameterBehavior
    {
        /// <summary>
        /// Identifies the IsCommandRequeriedOnChange attached property
        /// </summary>
        /// <remarks>
        /// When a control has the <see cref="IsCommandRequeriedOnChangeProperty" />
        /// attached property set to true, then any change to it's 
        /// <see cref="System.Windows.Controls.Primitives.ButtonBase.CommandParameter" /> property will cause the state of
        /// the command attached to it's <see cref="System.Windows.Controls.Primitives.ButtonBase.Command" /> property to 
        /// be reevaluated.
        /// </remarks>
        public static readonly DependencyProperty IsCommandRequeriedOnChangeProperty =
            DependencyProperty.RegisterAttached("IsCommandRequeriedOnChange",
                                                typeof(bool),
                                                typeof(CommandParameterBehavior),
                                                new UIPropertyMetadata(false, new PropertyChangedCallback(OnIsCommandRequeriedOnChangeChanged)));

        /// <summary>
        /// Gets the value for the <see cref="IsCommandRequeriedOnChangeProperty"/> attached property.
        /// </summary>
        /// <param name="target">The object to adapt.</param>
        /// <returns>Whether the update on change behavior is enabled.</returns>
        public static bool GetIsCommandRequeriedOnChange(DependencyObject target)
        {
            return (bool)target.GetValue(IsCommandRequeriedOnChangeProperty);
        }

        /// <summary>
        /// Sets the <see cref="IsCommandRequeriedOnChangeProperty"/> attached property.
        /// </summary>
        /// <param name="target">The object to adapt. This is typically a <see cref="System.Windows.Controls.Primitives.ButtonBase" />, 
        /// <see cref="System.Windows.Controls.MenuItem" /> or <see cref="System.Windows.Documents.Hyperlink" /></param>
        /// <param name="value">Whether the update behaviour should be enabled.</param>
        public static void SetIsCommandRequeriedOnChange(DependencyObject target, bool value)
        {
            target.SetValue(IsCommandRequeriedOnChangeProperty, value);
        }

        private static void OnIsCommandRequeriedOnChangeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!(d is ICommandSource))
                return;

            if (!(d is FrameworkElement || d is FrameworkContentElement))
                return;

            if ((bool)e.NewValue)
            {
                HookCommandParameterChanged(d);
            }
            else
            {
                UnhookCommandParameterChanged(d);
            }

            UpdateCommandState(d);
        }

        private static PropertyDescriptor GetCommandParameterPropertyDescriptor(object source)
        {
            return TypeDescriptor.GetProperties(source.GetType())["CommandParameter"];
        }

        private static void HookCommandParameterChanged(object source)
        {
            var propertyDescriptor = GetCommandParameterPropertyDescriptor(source);
            propertyDescriptor.AddValueChanged(source, OnCommandParameterChanged);

            // N.B. Using PropertyDescriptor.AddValueChanged will cause "source" to never be garbage collected,
            // so we need to hook the Unloaded event and call RemoveValueChanged there.
            HookUnloaded(source);
        }

        private static void UnhookCommandParameterChanged(object source)
        {
            var propertyDescriptor = GetCommandParameterPropertyDescriptor(source);
            propertyDescriptor.RemoveValueChanged(source, OnCommandParameterChanged);

            UnhookUnloaded(source);
        }

        private static void HookUnloaded(object source)
        {
            var fe = source as FrameworkElement;
            if (fe != null)
            {
                fe.Unloaded += OnUnloaded;
            }

            var fce = source as FrameworkContentElement;
            if (fce != null)
            {
                fce.Unloaded += OnUnloaded;
            }
        }

        private static void UnhookUnloaded(object source)
        {
            var fe = source as FrameworkElement;
            if (fe != null)
            {
                fe.Unloaded -= OnUnloaded;
            }

            var fce = source as FrameworkContentElement;
            if (fce != null)
            {
                fce.Unloaded -= OnUnloaded;
            }
        }

        static void OnUnloaded(object sender, RoutedEventArgs e)
        {
            UnhookCommandParameterChanged(sender);
        }

        static void OnCommandParameterChanged(object sender, EventArgs ea)
        {
            UpdateCommandState(sender);
        }

        private static void UpdateCommandState(object target)
        {
            var commandSource = target as ICommandSource;

            if (commandSource == null)
                return;

            var rc = commandSource.Command as RoutedCommand;
            if (rc != null)
            {
                CommandManager.InvalidateRequerySuggested();
            }

            var dc = commandSource.Command as IDelegateCommand;
            if (dc != null)
            {
                dc.RaiseCanExecuteChanged();
            }

        }
    }
}

Answer 7

Прочитав несколько хороших ответов на подобные вопросы, я в вашем примере немного изменил DelegateCommand, чтобы он заработал. Вместо использования:

public event EventHandler CanExecuteChanged;

Я изменил его на:

public event EventHandler CanExecuteChanged
{
    add { CommandManager.RequerySuggested += value; }
    remove { CommandManager.RequerySuggested -= value; }
}

Я удалил следующие два метода, потому что мне было лень их исправлять

public void RaiseCanExecuteChanged()

и

protected virtual void OnCanExecuteChanged()

И это все ... похоже, это гарантирует, что CanExecute будет вызываться при изменении Binding и после метода Execute

Он не будет автоматически запускаться при изменении ViewModel, но, как указано в этом потоке, это возможно, вызывая CommandManager.InvalidateRequerySuggested в потоке графического интерфейса

Application.Current?.Dispatcher.Invoke(DispatcherPriority.Normal, (Action)CommandManager.InvalidateRequerySuggested);

Answer 8

Существует относительно простой способ «исправить» эту проблему с DelegateCommand, хотя он требует обновления источника DelegateCommand и повторной компиляции Microsoft.Practices.Composite.Presentation.dll.

1) Загрузите исходный код Prism 1.2 и откройте CompositeApplicationLibrary_Desktop.sln. Здесь находится проект Composite.Presentation.Desktop, который содержит источник DelegateCommand.

2) В открытом событии EventHandler CanExecuteChanged измените его следующим образом:

public event EventHandler CanExecuteChanged
{
     add
     {
          WeakEventHandlerManager.AddWeakReferenceHandler( ref _canExecuteChangedHandlers, value, 2 );
          // add this line
          CommandManager.RequerySuggested += value;
     }
     remove
     {
          WeakEventHandlerManager.RemoveWeakReferenceHandler( _canExecuteChangedHandlers, value );
          // add this line
          CommandManager.RequerySuggested -= value;
     }
}

3) В защищенной виртуальной пустоте OnCanExecuteChanged () измените его следующим образом:

protected virtual void OnCanExecuteChanged()
{
     // add this line
     CommandManager.InvalidateRequerySuggested();
     WeakEventHandlerManager.CallWeakReferenceHandlers( this, _canExecuteChangedHandlers );
}

4) Перекомпилируйте решение, затем перейдите в папку Debug или Release, где находятся скомпилированные библиотеки DLL. Скопируйте файлы Microsoft.Practices.Composite.Presentation.dll и .pdb (если вы хотите) туда, где вы ссылаетесь на внешние сборки, а затем перекомпилируйте приложение, чтобы получить новые версии.

После этого CanExecute должен запускаться каждый раз, когда пользовательский интерфейс отображает элементы, связанные с рассматриваемым DelegateCommand.

Береги себя, Джо

refereejoe в gmail

Answer 9

Недавно я столкнулся с той же проблемой (для меня это было для пунктов меню в контекстном меню), хотя, возможно, это не подходящее решение для каждой ситуации, я нашел другой (и намного короче!) Способ решения этой проблемы:

<MenuItem Header="Open file" Command="{Binding Tag.CommandOpenFile, IsAsync=True, RelativeSource={RelativeSource AncestorType={x:Type ContextMenu}}}" CommandParameter="{Binding Name}" />

Игнорируя обходной путь на основе Tag для особого случая контекстного меню, ключом здесь является регулярное связывание CommandParameter, но связывание Command с дополнительным IsAsync=True. Это задержит привязку действительной команды (и, следовательно, ее CanExecute вызова), так что параметр уже будет доступен. Это означает, однако, что на короткое время включенное состояние может быть неправильным, но для моего случая это было вполне приемлемо.

Answer 10

Некоторые из этих ответов касаются привязки к DataContext для получения самой команды, но вопрос заключался в том, что CommandParameter имеет значение null, а это не должно быть. Мы тоже это испытали. В догадках, мы нашли очень простой способ заставить это работать в нашей ViewModel. Это специально для проблемы с пустым значением CommandParameter, о которой сообщает клиент, с одной строкой кода. Обратите внимание на Dispatcher.BeginInvoke ().

public DelegateCommand<objectToBePassed> CommandShowReport
    {
        get
        {
            // create the command, or pass what is already created.
            var command = _commandShowReport ?? (_commandShowReport = new DelegateCommand<object>(OnCommandShowReport, OnCanCommandShowReport));

            // For the item template, the OnCanCommand will first pass in null. This will tell the command to re-pass the command param to validate if it can execute.
            Dispatcher.BeginInvoke((Action) delegate { command.RaiseCanExecuteChanged(); }, DispatcherPriority.DataBind);

            return command;
        }
    }