using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows.Input;

namespace WpfApp1
{
    public class BaseModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public class Person : BaseModel
    {
        private string _name;
        private int _age;

        public Person(string name, int age)
        {
            _name = name;
            _age = age;
        }
        
        public string Name { get => _name; set { _name = value; OnPropertyChanged(nameof(Name)); } }

        public int Age { get => _age; set { _age = value; OnPropertyChanged(nameof(Age)); } }
    }

    public interface IGroup<T>
    {
        bool AllTheSome { get; }
        string Text { set; get; }
    }

    public class Group<T> : BaseModel, IGroup<T>
    {

        private readonly Func<T, string> _getValue;
        private readonly Action<T, string> _setValue;
        private readonly IEnumerable<T> _items;


        public Group(IEnumerable<T> items, Func<T, string> get, Action<T, string> set)
        {
            _items = items;
            _getValue = get;
            _setValue = set;

            GetValue();
        }

        private bool _allTheSome;
        public bool AllTheSome
        {
            private set
            {
                _allTheSome = value;
                OnPropertyChanged(nameof(AllTheSome));
            }
            get
            {
                return _allTheSome;
            }
        }

        private string _text;

        public string Text
        {
            get => _text;
            set
            {
                _text = value;
                SetValue(value);
                OnPropertyChanged(nameof(Text));
            }
        }

        private void GetValue()
        {
            var firstItem = _items.FirstOrDefault();
            if (firstItem != null)
            {
                var firstValue = _getValue(firstItem);
                AllTheSome = _items.All(p => string.Equals(_getValue(p), firstValue, StringComparison.Ordinal));

                if (AllTheSome)
                {
                    _text = firstValue;
                }
            }
            else
            {
                _text = null;
            }

            OnPropertyChanged(nameof(Text));
        }

        private void SetValue(string value)
        {
            foreach (var i in _items)
            {
                _setValue(i, value);
            }
        }
    }


    public class MainModel : BaseModel
    {
        private readonly Func<Person, string> _getName = p => p.Name;
        private readonly Action<Person, string> _setName = (p, v) => p.Name = v;
        private readonly Func<Person, string> _getAge = p => p.Age.ToString();
        private readonly Action<Person, string> _setAge = (p, v) => p.Age = Convert.ToInt32(v);
        private Group<Person> _names;
        private Group<Person> _ages;

        public List<Person> Persones { set; get; }

        public MainModel()
        {
            Persones = new List<Person>
            {
                new Person("User 1", 1),
                new Person("User 2", 2),
                new Person("User 2", 3),
                new Person("User 2", 4),
                new Person("User 3", 4),
                new Person("User 4", 4),
                new Person("User 5", 5)
            };
        }

        public Group<Person> Names { get => _names; private set { _names = value; OnPropertyChanged(nameof(Names)); } }
        public Group<Person> Ages { get => _ages; private set { _ages = value; OnPropertyChanged(nameof(Ages)); } }

        private ICommand _selctionChangedCommand;
        public ICommand SelctionChangedCommand { get => _selctionChangedCommand ?? (_selctionChangedCommand = new ActionCommand<IEnumerable>(SelectonChanged)); }

        private void SelectonChanged(IEnumerable items)
        {
            var persones = items.Cast<Person>();
            Names = new Group<Person>(persones, _getName, _setName);
            Ages = new Group<Person>(persones, _getAge, _setAge);
        }
    }

    public class ActionCommand<T> : ICommand
    {
        public event EventHandler CanExecuteChanged;

        private readonly Action<T> _action;

        public ActionCommand(Action<T> action)
        {
            _action = action;
        }

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

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

}

<Window x:Class="WpfApp1.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:WpfApp1"
        xmlns:view="clr-namespace:WpfApp1.View"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <local:MainModel/>
    </Window.DataContext>
    <Window.Resources>
        <Style TargetType="{x:Type ListBox}">
            <Setter Property="SelectionMode" Value="Multiple" />
        </Style>
        <Style TargetType="{x:Type TextBox}">
            <Setter Property="Margin" Value="3,3,3,0" />
        </Style>
  
    </Window.Resources>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition/>
            <ColumnDefinition/>
        </Grid.ColumnDefinitions>
        <ListBox Grid.Column="0" ItemsSource="{Binding Persones}" view:SelectedChangedNotify.Command="{Binding SelctionChangedCommand}">
            <ListBox.ItemTemplate>
                <DataTemplate DataType="{x:Type local:Person}">
                    <TextBlock>
                        <TextBlock.Inlines>
                            <Run Text="{Binding Name}" /> ,
                            <Run Text="{Binding Age}" />
                        </TextBlock.Inlines>
                    </TextBlock>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <StackPanel Grid.Column="1" >
            <TextBox Text="{Binding Names.Text}"/>
            <TextBox Text="{Binding Ages.Text}"/>
        </StackPanel>

    </Grid>
</Window>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace WpfApp1.View
{
    public static class SelectedChangedNotify
    {
        public static ICommand GetCommand(DependencyObject obj)
        {
            return (ICommand)obj.GetValue(CommandProperty);
        }

        public static void SetCommand(DependencyObject obj, ICommand value)
        {
            obj.SetValue(CommandProperty, value);
        }

        // Using a DependencyProperty as the backing store for Command.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.RegisterAttached("Command", typeof(ICommand), typeof(SelectedChangedNotify), new PropertyMetadata(null, OnPropertyChanged));

        private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is ListBox listBox)
            {
                listBox.SelectionChanged += ListBox_SelectionChanged;
            }
        }

        private static void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (sender is ListBox listBox)
            {
                var command = GetCommand(listBox);
                command.Execute(listBox.SelectedItems);
            }
        }
    }

}