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

У меня возникла проблема с 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 перед командой (как предлагалось), но это все еще не работает. Любые советы о том, как это контролировать.

Update2: есть ли способ определить, когда привязка «выполнена», чтобы я мог принудительно переоценить команду? Кроме того, проблема в том, что у меня есть несколько кнопок (по одной для каждого элемента в ItemsControl), которые привязаны к одному и тому же экземпляру объекта Command?

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

Я наткнулся на похожую проблему и решил ее с помощью моего надежного 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 вместо. для достижения того же эффекта.

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

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

Старый код:

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

Новый код:

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

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

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

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

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

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

Я придумал еще один вариант решения этой проблемы, которым хотел бы поделиться. Поскольку метод 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}" />

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

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

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

CommandParameter="{Binding .}"

к

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

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

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

<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немного задержит привязку фактической команды (и, следовательно, ее вызов), поэтому параметр уже будет доступен. Это означает, однако, что на короткое время состояние enabled может быть неправильным, но для моего случая это было вполне приемлемо.

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

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

Возможно, вам придется удалить этот IDelegateCommandматериал, если вы не используете Prism (и хотите внести те же изменения, что и я, в библиотеку Prism). Также обратите внимание, что мы обычно RoutedCommandздесь не используем s (мы используем Prism DelegateCommand<T>практически для всего), поэтому, пожалуйста, не возлагайте на меня ответственность, если мой призыв 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();
            }

        }
    }
}

Существует относительно простой способ «исправить» эту проблему с помощью 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) В защищенном виртуальном void 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.

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

рефери в Gmail

Прочитав несколько хороших ответов на похожие вопросы, я немного изменил в вашем примере 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);

Привет, Джонас, не уверен, будет ли это работать в шаблоне данных, но вот синтаксис привязки, который я использую в контекстном меню ListView, чтобы получить текущий элемент в качестве параметра команды:

CommandParameter = "{Binding RelativeSource = {RelativeSource AncestorType = ContextMenu}, Path = PlacementTarget.SelectedItem, Mode = TwoWay}"

Я зарегистрировал это как ошибку WPF в .Net 4.0, поскольку проблема все еще существует в бета-версии 2.

https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=504976

Некоторые из этих ответов касаются привязки к 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;
        }
    }

Это долгий путь. для отладки вы можете попробовать:
- проверить событие PreviewCanExecute.
- используйте snoop / wpf крот, чтобы заглянуть внутрь и посмотреть, что такое параметр команды.

HTH,

У меня тоже работает commandManager.InvalidateRequerySuggested. Я считаю, что следующая ссылка говорит об аналогичной проблеме, и M $ dev подтвердил ограничение в текущей версии, а commandManager.InvalidateRequerySuggested - это обходной путь.http://social.expression.microsoft.com/Forums/en-US/wpf/thread/c45d2272-e8ba-4219-bb41-1e5eaed08a1f/

Что важно, так это время вызова commandManager.InvalidateRequerySuggested. Это должно быть вызвано после уведомления о соответствующем изменении значения.

Помимо предложения Эда Болла по установке CommandParameter перед Command , убедитесь, что ваш метод CanExecute имеет параметр типа объекта .

private bool OnDeleteSelectedItemsCanExecute(object SelectedItems)  
{
    // Your goes heres
}

Надеюсь, это помешает кому-то потратить огромное количество времени, которое я потратил, чтобы выяснить, как получить SelectedItems в качестве параметра CanExecute.