Como comunicar entre usercontrol e mainVM

Existem duas maneiras de desenvolver aplicativos em WPF: o padrão code-behind e o MVVM (Model, View, ViewModel), que é o recomendado.

Vou mostrar a você um passo a passo simples sobre como criar o que você deseja usando o padrão MVVM (maneira recomendada):

<UserControl  ....>
  <Grid Margin="10">
    <Button
        Padding="10,5"
        Command="{Binding AddUserCommand}"
        Content="Add User" />
</Grid>
</UserControl>

<UserControl ...>
  <Grid Margin="10">
    <StackPanel>
        <Label Content="Name:" />
        <TextBox Margin="0,0,0,10" Text="{Binding CurrentUser.Name, UpdateSourceTrigger=PropertyChanged}" />

        <Label Content="Description:" />
        <TextBox Margin="0,0,0,10" Text="{Binding CurrentUser.Description}" />

        <CheckBox
            Margin="0,0,0,10"
            Content="Is Active"
            IsChecked="{Binding CurrentUser.IsActive}" />
    </StackPanel>
</Grid>
</UserControl>

2- Crie o Modelo de Usuário:

public class User : INotifyPropertyChanged
    {
        private string _name;
        private string _description;
        private bool _isActive;

        public string Name
        {
            get => _name;
            set
            {
                if (_name != value)
                {
                    _name = value;
                    OnPropertyChanged();
                }
            }
        }

        public string Description
        {
            get => _description;
            set
            {
                if (_description != value)
                {
                    _description = value;
                    OnPropertyChanged();
                }
            }
        }

        public bool IsActive
        {
            get => _isActive;
            set
            {
                if (_isActive != value)
                {
                    _isActive = value;
                    OnPropertyChanged();
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

3- Crie a classe RelayCommand para manipular o clique do botão Adicionar Usuário:

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

        public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

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

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

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

4- Adicione o MainVM:

public class MainVM : INotifyPropertyChanged
    {
        private User _currentUser;

        public MainVM()
        {
            Users = new ObservableCollection<User>();
            CurrentUser = new User();
            AddUserCommand = new RelayCommand(AddUser, CanAddUser);
        }

        public ObservableCollection<User> Users { get; }

        public User CurrentUser
        {
            get => _currentUser;
            set
            {
                if (_currentUser != value)
                {
                    _currentUser = value;
                    OnPropertyChanged();
                }
            }
        }

        public RelayCommand AddUserCommand { get; }

        private bool CanAddUser(object obj)
        {
            return !string.IsNullOrWhiteSpace(CurrentUser.Name);
        }

        private void AddUser(object obj)
        {
            Users.Add(new User
            {
                Name = CurrentUser.Name,
                Description = CurrentUser.Description,
                IsActive = CurrentUser.IsActive
            });

            CurrentUser = new User();
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

5- Agora no arquivo xaml da MainWindow adicione estes dois namespaces:

nota: veja que adicionei o ViewModel na pasta ViewModels e o mesmo para o controle do usuário, embora seja um aplicativo simples que usei apenas para organizar meus arquivos.

xmlns:viewmodels="clr-namespace:SimpleWpfApp.ViewModels"
xmlns:views="clr-namespace:SimpleWpfApp.UserControls"

5.1- então utilize os user controls criados (no mesmo arquivo xaml):

<Window.DataContext>
    <viewmodels:MainVM />
</Window.DataContext>

<Grid Margin="10">
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>

    <views:FillUserDataUserControl Grid.Row="0" />

    <views:ButtonUserControl Grid.Row="1" />

    <DataGrid
        Grid.Row="2"
        Margin="0,10,0,0"
        AutoGenerateColumns="False"
        IsReadOnly="True"
        ItemsSource="{Binding Users}">
        <DataGrid.Columns>
            <DataGridTextColumn
                Width="*"
                Binding="{Binding Name}"
                Header="Name" />
            <DataGridTextColumn
                Width="2*"
                Binding="{Binding Description}"
                Header="Description" />
            <DataGridCheckBoxColumn
                Width="*"
                Binding="{Binding IsActive}"
                Header="Is Active" />
        </DataGrid.Columns>
    </DataGrid>
</Grid>

Nota: o exemplo foi testado antes de ser escrito, você pode encontrá-lo aqui: https://github.com/amuza2/100DaysOfCode/tree/main/Day93/WpfApp1/SimpleWpfApp

Explicando algumas ideias principais:
1- Vinculação de dados entre View (controle de usuário) e ViewModel (MainVM), como no FillUserDataUserControl, Text = "{Binding CurrentUser.Name}"que cria uma vinculação entre a propriedade Text da caixa de texto e a CurrentUser.Namepropriedade no ViewModel (MainVM).

2- INotifyPropertyChanged : Tanto o modelo User quanto o MainViewModel implementam essa interface, que é crucial para a vinculação bidirecional. Quando uma propriedade muda, o PropertyChangedevento é levantado por meio do OnPropertyChanged()método, alertando a UI para atualizar.

3- DataContext : Em MainWindow.xaml, a linha <Window.DataContext><viewmodels:MainVM /></Window.DataContext>estabelece o ViewModel como a fonte de dados para todas as ligações na janela e seus controles filhos.
Este sistema de ligação permite alterações na UI para atualizar o ViewModel (e vice-versa) sem escrever manipuladores de eventos explícitos e código de atualização da UI.

4- No ButtonUserControl.xaml, Command="{Binding AddUserCommand}"vincule a propriedade Command do botão à propriedade AddUserCommand no ViewModel (MainVM).

• A RelayCommandclasse implementa a ICommandinterface, que define o contrato para comandos no WPF.

O Commandmanager no RelayCommand se conecta ao CommandManager do WPF, que chama automaticamente CanExecute quando os estados de entrada mudam (como quando o texto é inserido na caixa de texto Nome).

5- Diferentemente do List<T>, o ObservableCollection implementa INotifyCollectionChanged, que gera eventos quando itens são adicionados, removidos ou quando a coleção muda, o que significa que quando você chama Users.Add(newUser)o ViewModel, o ObservableCollection gera automaticamente o evento CollectionChanged, que o DataGrid escuta, o que significa que novamente o DataGrid é atualizado automaticamente para mostrar o novo item sem exigir nenhum código de atualização manual 🥳.

Se usássemos uma lista normal, adicionar itens não atualizaria automaticamente a interface do usuário.

você pode dizer que é muito para um aplicativo simples que tem poucos controles, você está certo, mas o MVVM brilha quando você cria projetos de médio a grande porte.