Commands in WPF - lucyberryhub/WPF.Tutorial GitHub Wiki

Hiya, superstar! 🍓 Ready to make your WPF app shine like a berry in the sun? 🌞 Commands are like the magic wands of your app, making buttons and other controls do their thing without all the messy code. It’s time to sparkle and get those commands working with a dash of berry love. 🍒

First, let’s create a RelayCommand! It's like a cute berry box that holds all the fun actions when a user interacts with the app. 🌸

using System;
using System.Windows.Input;

public class BerryCommand : ICommand
{
    private Action<object> execute;
    
    // Constructor to initialize the execute action (so fun!)
    public BerryCommand(Action<object> execute)
    {
        this.execute = execute;
    }

    // This is where the berry magic happens ✨
    public void Execute(object parameter)
    {
        execute(parameter);
    }

    // Always returns true! Everything’s possible in BerryLand! 🍒
    public bool CanExecute(object parameter)
    {
        return true;
    }

    // You can use this for advanced berry moves (optional) 🍓
    public event EventHandler CanExecuteChanged;
}

Berry Vibe:

• 🍓 Action<object> execute: This is like the magic wand that makes something happen when the button is clicked! 🎉
• 🍒 Execute(object parameter): This is where the magic spell gets cast. It's the action you want to happen when the button’s clicked—like a berry bursting into life! 💥
• 🌸 CanExecute(object parameter): Always let the magic happen—this returns true, but you can change it to add restrictions (like only allowing berry picking when the basket is ready). 🍇
• 💖 CanExecuteChanged: This is like the little fairy that lets you know when it’s okay to do something else. It's optional but cute if you want to manage button availability!

Okay, now that we have our BerryCommand ready, let’s use it in the ViewModel. It's like putting your favorite berries into a beautiful basket! 🍓

using System.Windows.Input;

public class BerryViewModel
{
    // This is where the berry command lives 🍓
    public ICommand ShowBerryCommand { get; }

    // A sprinkle of magic in the constructor ✨
    public BerryViewModel()
    {
        // The berry command will make the message show up!
        ShowBerryCommand = new BerryCommand(o => ShowBerryMessage());
    }

    // This is where the berry message shows! 🍒
    private void ShowBerryMessage()
    {
        MessageBox.Show("Berries are the sweetest! 🍓🍒");
    }
}

Berry Vibe:

• 🍓 ShowBerryCommand: Here’s where the berry action starts. It’s tied to the command we created in the ViewModel. It does the magic! 💫
• 💖 ShowBerryMessage: This is the berry spell that gets cast when the button is clicked. It shows a message box with a sweet berry surprise. 🍓

Let’s make the button sparkle with our berry love! Bind the command to the button in the View so that when the button is clicked, the berry magic happens! ✨

<Window x:Class="BerryFarmApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Berry Farm" Height="350" Width="525">
    <Window.DataContext>
        <!-- Bind the ViewModel to the window's DataContext -->
        <local:BerryViewModel />
    </Window.DataContext>

    <Grid>
        <!-- The berry button bound to the BerryCommand -->
        <Button Command="{Binding ShowBerryCommand}" Content="Show Berry Love 🍓" HorizontalAlignment="Center" VerticalAlignment="Center" Width="200" Height="50"/>
    </Grid>
</Window>

Berry Vibe:

• 🍓 Window.DataContext: The ViewModel is like the berry basket that holds all your commands. You’ll see it from the View—the interface of your app! 🎀
• 🌸 Button Command="{Binding ShowBerryCommand}": The button is now linked to our command. When you click it, the magic happens, and the berry message pops up! 🎉

Let’s make the button extra cute by only allowing the user to click it if there’s text in the TextBox! If the TextBox is empty, the berry magic will stay in the basket. 🧺

Here’s how to add a bit of berry sparkle to disable the button until there’s something in the TextBox:

public bool CanExecute(object parameter)
{
    return !string.IsNullOrEmpty(parameter?.ToString()); // Only allow if there's text! 🍓
}

<TextBox x:Name="BerryTextBox" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,50,0,0"/>
<Button Command="{Binding ShowBerryCommand}" CommandParameter="{Binding Text, ElementName=BerryTextBox}" Content="Show Berry Love 🍓" HorizontalAlignment="Center" VerticalAlignment="Center" Width="200" Height="50"/>

Berry Vibe:

• 🍓 CommandParameter: We bind the TextBox’s Text property to the command’s parameter. If the TextBox is empty, the button is disabled—no berry magic until we’re ready! 🌸
• 🌸 CanExecute: Now, the command checks if the TextBox has text in it. If it’s empty, the button can’t be clicked, keeping everything organized and berry-licious!

🎉 You did it! Now you’ve learned how to work with Commands in your WPF app. You've just made your app sparkle with MVVM magic, keeping everything clean, cute, and berry-tastic!

• 🎯 RelayCommand: A cute little helper that lets you link user actions (like button clicks) to your app's logic. It’s like a berry fairy making everything happen.
• 🍓 Command Binding: Binding commands to UI elements (like buttons) keeps your app interactive without cluttering the UI code.
• 🌸 Disabling the Button: Use CanExecute to control when your buttons should be active or not—just like choosing when to pick the perfect berry!

Now go on, and let your berry magic flow! 🍓✨