Solution (Edit):

In the button-command, I have to provide that the Relative Source AncestorType=ItemsControl. This binds the button(s) to the same ItemsSource that the ItemsControl has (i suppose), which is Items.

<Button Content="Display Message" Height="25" 
        Command="{Binding RelativeSource={RelativeSource AncestorType=ItemsControl}, Path=DataContext.DisplayMessageCommand}"/>

In the ViewModel, the RelayCommand and corresponding function can be defined like this. I have to specify that the parameter is an ItemModel. Then I can call the properties of the ItemModel as shown in DisplayMessage()

public RelayCommand DisplayMessageCommand => new RelayCommand(parameter => DisplayMessage((ItemModel)parameter), parameter => true);

private void DisplayMessage(ItemModel item)
    {
        MessageBox.Show(item.ItemMessage); 
    }

My question is: When I have a button within an ItemsControl, how do I let the command know which instance of the button has been clicked?

I have included a simple example below, where i have a Textblock+Button in an ItemsControl.

The ItemsSource of the ItemsControl is an ObservableCollection of ItemModel. When i click a button, i want to tell the corresponding command which ItemModel the button belonged to, and display its ItemMessage in a MessageBox.

How do i do that?

This is what I have so far:

MainWindow.xaml

<Window x:Class="TestApp2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:TestApp2"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="200">
    <StackPanel Margin="20">
        <ItemsControl ItemsSource="{Binding Items}">
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal" Margin="0 0 0 5">
                        <TextBlock Margin="0 0 20 0" Text="{Binding ItemName}"/>
                        <Button Content="Display Message" Height="25" 
                                Command="{Binding DisplayMessageCommand}"/>
                    </StackPanel>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </StackPanel>
</Window>

MainWindow.xaml.cs

public partial class MainWindow : Window
{
    public MainWindow()
    {
        ItemViewModel viewModel = new ItemViewModel();
        this.DataContext = viewModel;
        InitializeComponent();
    }
}

ItemModel.cs

public class ItemModel
{
    public string ItemName { get; set; }
    public string ItemMessage { get; set; }

    public ItemModel() { }
}

ItemViewModel.cs

public class ItemViewModel
{
    public ObservableCollection<ItemModel> Items { get; set; }

    public ItemViewModel()
    {
        Items = new ObservableCollection<ItemModel>()
        {
            new ItemModel {ItemName = "Item 1", ItemMessage = "This is item 1"},
            new ItemModel {ItemName = "Item 2", ItemMessage = "This is item 2"},
            new ItemModel {ItemName = "Item 3", ItemMessage = "This is item 3"}
        };
    }

    public RelayCommand DisplayMessageCommand => new RelayCommand(execute => DisplayMessage(), canExecute => true);

    private void DisplayMessage()
    {
        //I want the MessageBox to display the ItemMessage that the clicked button corresponds to
        MessageBox.Show("..."); 
    }
}

RelayCommand.cs

public class RelayCommand : ICommand
{
    private Action<object> _execute;
    private Func<object, bool> _canExecute;

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

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

    public bool CanExecute(object? parameter)
    {
        return _canExecute == null || _canExecute(parameter);
    }

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