MVVM ICommand-Implementierung

So, in diesem speziellen MVVM-Implementierung, die ich mache, ich brauche mehrere Befehle. Ich habe wirklich müde von der Implementierung der ICommand-Klassen eins nach dem anderen, und so kam ich auf eine Lösung, aber ich weiß nicht, wie gut es ist, so erfolgt die Preisgabe jeder WPF-Experten hier werden sehr geschätzt. Und wenn Sie könnten, bieten eine bessere Lösung, noch besser.

Was ich getan habe, ist eine einzelne ICommand Klasse und zwei Delegierten, die ein Objekt als parameter, eine Stellvertretung ist nichtig (für OnExecute), die andere bool (für OnCanExecute). So im Konstruktor meiner ICommand (das heißt von der ViewModel-Klasse) sende ich die beiden Methoden, und auf jeden ICommand-Methode rufe ich den Abgeordneten Methoden.

Es funktioniert wirklich gut, aber ich bin mir nicht sicher, ob dies ist ein schlechter Weg, es zu tun, oder ob es einen besseren Weg. Unten ist der komplette code, jede Eingabe wird sehr geschätzt, auch negativ, aber bitte konstruktiv sein.

ViewModel:

public class TestViewModel : DependencyObject
{
    public ICommand Command1 { get; set; }
    public ICommand Command2 { get; set; }
    public ICommand Command3 { get; set; }

    public TestViewModel()
    {
        this.Command1 = new TestCommand(ExecuteCommand1, CanExecuteCommand1);
        this.Command2 = new TestCommand(ExecuteCommand2, CanExecuteCommand2);
        this.Command3 = new TestCommand(ExecuteCommand3, CanExecuteCommand3);
    }

    public bool CanExecuteCommand1(object parameter)
    {
        return true;
    }

    public void ExecuteCommand1(object parameter)
    {
        MessageBox.Show("Executing command 1");
    }

    public bool CanExecuteCommand2(object parameter)
    {
        return true;
    }

    public void ExecuteCommand2(object parameter)
    {
        MessageBox.Show("Executing command 2");
    }

    public bool CanExecuteCommand3(object parameter)
    {
        return true;
    }

    public void ExecuteCommand3(object parameter)
    {
        MessageBox.Show("Executing command 3");
    }
}

ICommand:

public class TestCommand : ICommand
{
    public delegate void ICommandOnExecute(object parameter);
    public delegate bool ICommandOnCanExecute(object parameter);

    private ICommandOnExecute _execute;
    private ICommandOnCanExecute _canExecute;

    public TestCommand(ICommandOnExecute onExecuteMethod, ICommandOnCanExecute onCanExecuteMethod)
    {
        _execute = onExecuteMethod;
        _canExecute = onCanExecuteMethod;
    }

    #region ICommand Members

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

    public bool CanExecute(object parameter)
    {
        return _canExecute.Invoke(parameter);
    }

    public void Execute(object parameter)
    {
        _execute.Invoke(parameter);
    }

    #endregion
}

Check-out von Karl Shifflet Umsetzung von RelayCommand: codeproject.com/KB/WPF/ExploringWPFMVVM.aspx

InformationsquelleAutor Carlo | 2009-09-23

.net c#icommand mvvm wpf

67

Dies ist fast identisch wie Karl Shifflet gezeigt eine RelayCommand, wo Execute feuert einen vorbestimmten Action<T>. Eine erstklassige Lösung, wenn Sie mich Fragen.
```
public class RelayCommand : ICommand
{
    private Predicate<object> _canExecute;
    private Action<object> _execute;

    public RelayCommand(Predicate<object> canExecute, Action<object> execute)
    {
        this._canExecute = canExecute;
        this._execute = execute;
    }

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

    public bool CanExecute(object parameter)
    {
        return _canExecute(parameter);
    }

    public void Execute(object parameter)
    {
        _execute(parameter);
    }
}
```
Diese könnten dann verwendet werden, als...
```
public class MyViewModel
{
    private ICommand _doSomething;
    public ICommand DoSomethingCommand
    {
        get
        {
            if (_doSomething == null)
            {
                _doSomething = new RelayCommand(
                    p => this.CanDoSomething,
                    p => this.DoSomeImportantMethod());
            }
            return _doSomething;
        }
    }
}
```
Lesen Sie mehr:

Josh Smith (introducer von RelayCommand): - Muster-und WPF-Anwendungen Mit Dem MVVM Design Pattern
- Es sieht ähnlich wie mir. Es wäre interessant zu wissen, die vor-und Nachteile der Verwendung von diese. Hast du einen link zu dem Artikel oder blog, in dem Sie dies Lesen?
- Ich bin usins dieser Ansatz, da arbeite ich mit MVVM und es funktioniert wie ein Charme 😉
- im mit es als gut, die einzige con die ich finden kann ist, dass Sie nicht über eine Tastenkombination dem Befehl zugewiesen. irgendwelche Ideen?
- Die beste Lösung, die ich gefunden habe, für die Zuweisung von Tastatur-shortcuts, um ein RelayCommand ist CommandReference. Die einzige con ist es, dass Sie nicht bekommen, das auto Bevölkerung der Verknüpfung im Kontext-Menüs und so. joyfulwpf.blogspot.com/2009/05/...
- Ich verstehe nicht, wie dieser.DoSomeImportantMethod würde ein Kommando-parameter
- Sollte nicht die Implementierung geändert werden, wenn (_doSomething != null) der habe ich etwas missverstehen?
- Nein, es ist richtig, die Umsetzung verzögerte Initialisierung-- instanziiert _doSomething wenn es nicht bereits instanziiert wurde.
- Diese Artikel sind erstaunlich, ich danke dir für diese links.
InformationsquelleAutor Jarrett Meyer

Ich habe dies geschrieben Artikel über die ICommand-Schnittstelle.

Die Idee, die Schaffung einer universellen Befehl, der zwei Delegierten: der eine wird aufgerufen, wenn ICommand.Execute (object param) aufgerufen wird, die zweite prüft den status, ob Sie den Befehl ausführen (ICommand.CanExecute (object param)).

Erfordert die Methode Schaltvorgang CanExecuteChanged. Es wird aufgerufen, aus dem Elemente der Benutzeroberfläche für die Umschaltung der Staat CanExecute() Befehl.

public class ModelCommand : ICommand
{
    #region Constructors

    public ModelCommand(Action<object> execute)
        : this(execute, null) { }

    public ModelCommand(Action<object> execute, Predicate<object> canExecute)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    #endregion

    #region ICommand Members

    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object parameter)
    {
        return _canExecute != null ? _canExecute(parameter) : true;
    }

    public void Execute(object parameter)
    {
        if (_execute != null)
            _execute(parameter);
    }

    public void OnCanExecuteChanged()
    {
        CanExecuteChanged(this, EventArgs.Empty);
    }

    #endregion

    private readonly Action<object> _execute = null;
    private readonly Predicate<object> _canExecute = null;
}

InformationsquelleAutor kurik

10

Ich habe gerade ein wenig Beispiel zeigen, wie Befehle zu implementieren, die in der Konvention über die Konfiguration. Allerdings Bedarf es der Reflexion.Emit() verfügbar sein. Die unterstützenden code mag ein wenig seltsam, aber einmal geschrieben, es kann viele Male verwendet werden.

Teaser:
```
public class SampleViewModel: BaseViewModelStub
{
    public string Name { get; set; }

    [UiCommand]
    public void HelloWorld()
    {
        MessageBox.Show("Hello World!");
    }

    [UiCommand]
    public void Print()
    {
        MessageBox.Show(String.Concat("Hello, ", Name, "!"), "SampleViewModel");
    }

    public bool CanPrint()
    {
        return !String.IsNullOrEmpty(Name);
    }
}
```
}

UPDATE: jetzt scheint es zu existieren einige Bibliotheken, wie die http://www.codeproject.com/Articles/101881/Executing-Command-Logic-in-a-View-Model das löst das problem der ICommand-boilerplate-code.

InformationsquelleAutor Boris Treukhov

@Carlo ich mag deine Umsetzung dieses, aber ich wollte meine version und wie es zu benutzen in meinem ViewModel

Ersten ICommand implementieren

public class Command : ICommand
{
    public delegate void ICommandOnExecute();
    public delegate bool ICommandOnCanExecute();

    private ICommandOnExecute _execute;
    private ICommandOnCanExecute _canExecute;

    public Command(ICommandOnExecute onExecuteMethod, ICommandOnCanExecute onCanExecuteMethod = null)
    {
        _execute = onExecuteMethod;
        _canExecute = onCanExecuteMethod;
    }

    #region ICommand Members

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

    public bool CanExecute(object parameter)
    {
        return _canExecute?.Invoke() ?? true;
    }

    public void Execute(object parameter)
    {
        _execute?.Invoke();
    }

    #endregion
}

Bemerken, ich habe entfernt die parameter aus ICommandOnExecute und ICommandOnCanExecute und fügte hinzu, eine null im Konstruktor

Nutzen Sie dann im ViewModel

public Command CommandToRun_WithCheck
{
    get
    {
        return new Command(() =>
        {
            //Code to run
        }, () =>
        {
            //Code to check to see if we can run 
            //Return true or false
        });
    }
}

public Command CommandToRun_NoCheck
{
    get
    {
        return new Command(() =>
        {
            //Code to run
        });
    }
}

Ich finde einfach diese Art und Weise sauberer als ich brauche nicht zu Variablen zuweisen und dann instanziieren, es alles in einem Rutsch.

Vielen Dank für das teilen dieses! Es ist definitiv interessant zu sehen, andere Wege, diese zu lösen. Seit ich gelesen habe über die RelayCommand, entschied ich mich zu verabschieden, dass Muster. Ich habe nicht getan, WPF in JAHREN, aber ich auf jeden Fall verwendet die RelayCommand für ein paar Jahre, bevor der trend in meiner Firma verlagert ins web.

InformationsquelleAutor jack_tux

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.