RelayCommand wird nicht ausgeführt

Hallo!

Ich habe ein ViewModel:

        /// <summary>
        /// UI Dispatcher
        /// </summary>
        private IDispatcher dispatcher = null;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="dispatcher">UI Dispatcher</param>
        private PlayerViewModel(IDispatcher dispatcher)
        {
            // Set dispatcher
            this.dispatcher = dispatcher;

            // Set commands
            CommandPrev = new RelayCommand(Prev, true);
        }

        /// <summary>
        /// Get instance
        /// </summary>
        /// <returns>Instance of player view model</returns>
        public static PlayerViewModel GetInstance(IDispatcher dispatcher)
        {
            return new PlayerViewModel(dispatcher);
        }

        /// <summary>
        /// Now playing info
        /// </summary>
        private String nowPlaying = "nothing";
        public String NowPlaying
        {
            get
            {
                return nowPlaying;
            }
            set
            {
                if (nowPlaying != value)
                {
                    nowPlaying = value;
                    OnPropertyChanged("NowPlaying");
                }
            }
        }

        /// <summary>
        /// Command prev
        /// </summary>
        private RelayCommand commandPrev = null;
        public RelayCommand CommandPrev
        {
            get
            {
                Console.WriteLine("A");
                return commandPrev;
            }
            private set
            {
                this.commandPrev = value;
                OnPropertyChanged("CommandPrev");
            }
        }

        /// <summary>
        /// Prev
        /// </summary>
        public void Prev()
        {
            NowPlaying = "Prev";
            Console.WriteLine("Prev");
        }

Dazu kommt die View:

    <Grid>
        <StackPanel>
            <TextBlock Text="{Binding NowPlaying}"></TextBlock>
            <Button Command="{Binding CommandPrev}" Content="{Binding NowPlaying}"></Button>
        </StackPanel>
    </Grid>

Die RelayCommand Klasse:

    /// <summary>
    /// Relay command class
    /// </summary>
    class RelayCommand
    {

        /// <summary>
        /// Action
        /// </summary>
        private readonly Action _handler;

        /// <summary>
        /// Is enabled
        /// </summary>
        private bool _isEnabled;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="handler">Action handler</param>
        public RelayCommand(Action handler)
        {
            _handler = handler;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="handler">Handler</param>
        /// <param name="isEnabled">Is enabled?</param>
        public RelayCommand(Action handler, bool isEnabled)
        {
            _handler = handler;
            _isEnabled = isEnabled;
        }

        /// <summary>
        /// Is enabled
        /// </summary>
        public bool IsEnabled
        {
            get {
                return _isEnabled;
            }
            set
            {
                if (value != _isEnabled)
                {
                    _isEnabled = value;
                    if (CanExecuteChanged != null)
                    {
                        CanExecuteChanged(this, EventArgs.Empty);
                    }
                }
            }
        }

        /// <summary>
        /// Can execute?
        /// </summary>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public bool CanExecute(object parameter)
        {
            Console.WriteLine("B");
            return IsEnabled;
        }

        /// <summary>
        /// Can execute changed event
        /// </summary>
        public event EventHandler CanExecuteChanged;

        /// <summary>
        /// Execute
        /// </summary>
        /// <param name="parameter"></param>
        public void Execute(object parameter)
        {
            Console.WriteLine("C");
            _handler();
        }

    }

Und die Code-Behind Datei:

        // Player view model
        private PlayerViewModel player = null;

        /// <summary>
        /// Constructor
        /// </summary>
        public MainWindow()
        {
            
            // Instance player view model
            player = PlayerViewModel.GetInstance(null);

            // Initialize Component
            InitializeComponent();
            
            // Set player as data context
            DataContext = player;
        }

Während NowPlaying ganz normal gebunden wird, wird das RelayCommand einfach nicht ausgeführt. Die Console.WriteLine Ausgabe zeigt, dass das RelayCommand zwar aus dem ViewModel geholt wird, jedoch weder die Execute noch die CanExecute Methode ausgeführt werden weder beim Klick auf den Button noch sonst irgendwie.

Leider kann ich aus der Ausgabe auch nichts sinnvolles entnehmen dass irgendwo irgendein Fehler oder so aufgetreten wäre. Hat jemand von Euch da ne idee dazu!?

Hallo,

Dein RelayCommand muss die ICommand-Schnittstelle implementieren, um es als Command binden zu können.
Im Moment wird der Getter des Commands ausgeführt, und dann müsste es zu einem Fehler beim Binding kommen, weil der Typ nicht passt. Das müsstest Du aber beim Debuggen auch im Output-Fenster sehen.

Gruß, MarsStein

Nur davon das du die Klasse RelayCommand genannt hast, implementiert sie doch nicht das ICommand Interface.

Du solltest das Interface auch angeben.

Mist zu langsam

Ah, alles klar. Da ist mir bei Copy 'N' Paste wohl n Fehler unterlaufen, hatte das irgendwie total übersehen gehabt. Nun läuft das Ganze auch. 😉