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

        public event EventHandler CanExecuteChanged;

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;

namespace WpfApp18
{
    public abstract class BaseModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public void OnPropertyChagned(string name)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }
    }

    public class MainModel : BaseModel
    {
        private string _myText;
        public string MyText
        {
            get => _myText;
            set
            {
                if (Equals(_myText, value)) return;
                _myText = value;
                OnPropertyChagned(nameof(MyText));
                MyCommand1.UpdateState();
            }
        }

        private IRelayCommand _myCommand1;
        public IRelayCommand MyCommand1 => _myCommand1 ??
            (_myCommand1 = new RelayCommand(OnMyCommand, CanMyCommand));


        private IRelayCommand _myCommand2;
        public IRelayCommand MyCommand2 => _myCommand2 ??
            (_myCommand2 = new RelayCommand(OnMyCommand, CanMyCommand));


        private bool CanMyCommand(object arg)
        {
            return !string.IsNullOrWhiteSpace(MyText);
        }

        private void OnMyCommand(object obj)
        {
            MessageBox.Show(MyText, "Message");
        }

        public MainModel()
        {

        }
    }


    public interface IRelayCommand : ICommand
    {
        void UpdateState();
    }

    public class RelayCommand : IRelayCommand
    {
        public event EventHandler CanExecuteChanged;

        private readonly Action<object> _onExecute;
        private readonly Func<object, bool> _canExecute;


        public RelayCommand(Action<object> onExecute, Func<object, bool> canExecute)
        {
            _onExecute = onExecute;
            _canExecute = canExecute;
        }

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

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

        public void UpdateState()
        {
            OnCanExecuteCahgned();
        }

        protected void OnCanExecuteCahgned()
        {
            CanExecuteChanged?.Invoke(this, null);
        }

    }
}

<Window x:Class="WpfApp18.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:WpfApp18"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Window.DataContext>
        <local:MainModel/>
    </Window.DataContext>
    <Grid>
        <StackPanel>
            <TextBox Text="{Binding MyText, UpdateSourceTrigger=PropertyChanged}" Margin="5"/>
            <Button Content="Save" Command="{Binding MyCommand1}" Margin="5,0,5,5"/>
            <Button Content="Save" Command="{Binding MyCommand2}" Margin="5,0,5,5"/>
        </StackPanel>
    </Grid>
</Window>