Разделение функционала между слоями MVVM на примере создания простого WPF приложения с БД

Context.People.Local.ToObservableCollection()

  Context.People.Load();
  Context.Product.Load();

  public bool Any<T>(Func<T, bool> predicate) where T : class =>  Context.Set<T>().Any(predicate);

 if(user.Any<User>(x => x.Name == _user.Name));

user.Any(x => x.Name == _user.Name)

Command<People> people = new Command<People>();
var ss = people.Any(x => x.CompletedTasks == 1);
var re = people.Where(x => x.Name == x.Name).ToList();
 
Command<Product> product = new Command<Product>();
var res = product.Where(x => x.Name == x.Name).ToList();
var ssss = product.Any(x => x.Description == "");

        public void Authorize(string? name)
        {
            IsAuthorizedChangedEventArgs args = new IsAuthorizedChangedEventArgs(!string.IsNullOrEmpty(name));
            if (args.IsAuthorized)
            {
                User? old = Context.User.FirstOrDefault(x => x.Name == name);
                if (old is null)
                {
                    Context.User.Add(new User() { Name = name, IsAuthorized = true });
                    Context.SaveChanges();
                }
                else
                {
                    old.Name = name!; // По условию поиска Name == name. Зачем его перезаписывать?
                    Context.User.Update(old);
                    Context.SaveChanges();
                }
            }
            else
            {
                Context.SaveChanges(); // Зачем сохранение, если не было изменений?
            }
 
            IsAuthorized = args.IsAuthorized;
            AuthorizedChanged?.Invoke(this, args);
        }
    }

        public void Authorize1(string? name)
        {
            bool isAuthorized = false;
            if (!string.IsNullOrEmpty(name))
            {
                isAuthorized = true;
                User? old = Context.User.FirstOrDefault(x => x.Name == name);
                if (old is null)
                {
                    Context.User.Add(new User() { Name = name, IsAuthorized = true });
                    Context.SaveChanges();
                }
                else if(!old.IsAuthorized)
                {
                    old.IsAuthorized = true;
                    Context.User.Update(old);
                    Context.SaveChanges();
                }
            }
 
            IsAuthorizedChangedEventArgs args = new IsAuthorizedChangedEventArgs(isAuthorized);
            IsAuthorized = args.IsAuthorized;
            AuthorizedChanged?.Invoke(this, args);
        }

        public void CopyProperties(object source, object destination)

public static class Mapper
{
        public void CopyProperties(object source, object destination)

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows;
 
namespace CommonCore.Helpers
{
    public static partial class PropertyDescriptorHelper
    {
        private static readonly Dictionary<Type, PropertyDescriptorCollection> types = new();
 
        private static PropertyDescriptorCollection GetProperties(Type targetType)
        {
            if (!types.TryGetValue(targetType, out var properties))
            {
                properties = TypeDescriptor.GetProperties(targetType);
                types.Add(targetType, properties);
            }
            return properties;
        }
 
        public static void SetValue<T>(this T target, string propertyName, object value)
            where T : class
        {
            GetProperties(target.GetType())[propertyName].SetValue(target, value);
        }
        public static void SetValue<T>(this T target, PropertyDescriptor propertyDescriptor, object value)
            where T : class
        {
            propertyDescriptor.SetValue(target, value);
        }
 
        public static object GetValue<T>(this T target, string propertyName)
            where T : class
        {
            return GetProperties(target.GetType())[propertyName].GetValue(target);
        }
        public static object GetValue<T>(this T target, PropertyDescriptor propertyDescriptor)
            where T : class
        {
            return propertyDescriptor.GetValue(target);
        }
    }
    public static partial class PropertyDescriptorHelper
    {
        /// <summary>Присоединение прослушки изменения свойства.</summary>
        /// <typeparam name="T">Тип прослушиваемоего объекта. <see cref="DependencyObject"/> или производный от него.</typeparam>
        /// <param name="source">Прослушиваемый объект.</param>
        /// <param name="dependencyProperty">Прослушиваемое свойство.</param>
        /// <param name="listener">Метод прослушки.</param>
        public static void AddPropertyChanged<T>(this T source, DependencyProperty dependencyProperty, DependencyPropertyChangedHandler listener)
            where T : DependencyObject
        {
            var descriptor = DependencyPropertyDescriptor.FromProperty(dependencyProperty, source.GetType());
            var propertyHandler = AddPropertyHandler(source, listener, dependencyProperty);
            descriptor.AddValueChanged(source, propertyHandler.Raise);
        }
 
        /// <summary>Отсоединение прослушки изменения свойства.</summary>
        /// <typeparam name="T">Тип прослушиваемоего объекта. <see cref="DependencyObject"/> или производный от него.</typeparam>
        /// <param name="source">Прослушиваемый объект.</param>
        /// <param name="dependencyProperty">Прослушиваемое свойство.</param>
        /// <param name="listener">Метод прослушки.</param>
        public static void RemovePropertyChanged<T>(this T source, DependencyProperty dependencyProperty, DependencyPropertyChangedHandler listener)
            where T : DependencyObject
        {
            var descriptor = DependencyPropertyDescriptor.FromProperty(dependencyProperty, source.GetType());
            var propertyHandler = RemovePropertyHandler(source, listener, dependencyProperty);
            if (propertyHandler != null)
                descriptor.RemoveValueChanged(source, propertyHandler.Raise);
        }
 
        private static readonly ConditionalWeakTable<DependencyObject, Dictionary<(DependencyPropertyChangedHandler handler, DependencyProperty property), PropertyHandler>> handlers = new();
 
        //private static readonly Dictionary<(DependencyObject source, DependencyPropertyChangedHandler handler, DependencyProperty property), PropertyHandler> handlers = new();
 
        private static PropertyHandler AddPropertyHandler(DependencyObject source, DependencyPropertyChangedHandler handler, DependencyProperty property)
        {
 
            if (!handlers.TryGetValue(source, out var properties))
            {
                properties = new();
                handlers.Add(source, properties);
            }
 
            if (properties.TryGetValue((handler, property), out var pHandler))
            {
                pHandler.Count++;
            }
            else
            {
                pHandler = new(handler, property, source.GetValue(property));
                properties.Add((handler, property), pHandler);
            }
            return pHandler;
        }
 
        private static PropertyHandler RemovePropertyHandler(DependencyObject source, DependencyPropertyChangedHandler handler, DependencyProperty property)
        {
            PropertyHandler pHandler = null;
            if (handlers.TryGetValue(source, out var properties))
            {
                if (properties.TryGetValue((handler, property), out pHandler))
                {
                    pHandler.Count--;
                    if (pHandler.Count == 0)
                    {
                        properties.Remove((handler, property));
                    }
                    if (properties.Count == 0)
                    {
                        handlers.Remove(source);
                    }
                }
            }
 
            return pHandler;
        }
 
 
        private class PropertyHandler
        {
            public DependencyPropertyChangedHandler Handler { get; }
 
            public int Count { get; set; }
 
            public DependencyProperty Property { get; }
 
            public object OldValue { get; private set; }
 
            public void Raise(object sender, EventArgs e)
            {
                if (sender is not DependencyObject dObj)
                {
                    throw new InvalidCastException("sender может быть только DependencyObject.");
                }
 
                object oldValue = OldValue;
                object newValue = dObj.GetValue(Property);
 
                Handler(dObj, new DependencyPropertyChangedEventArgs(Property, oldValue, newValue));
 
                OldValue = newValue;
            }
 
            public PropertyHandler(DependencyPropertyChangedHandler handler, DependencyProperty property, object oldValue)
            {
                Handler = handler;
                Property = property;
                Count = 1;
                OldValue = oldValue;
            }
        }
    }
    /// <summary>Делегат метода прослушки изменения <see cref="DependencyProperty"/>.</summary>
    /// <param name="sender">Объект в котором изменилось свойство.</param>
    /// <param name="args">Аргументы изменения.</param>
    public delegate void DependencyPropertyChangedHandler(DependencyObject sender, DependencyPropertyChangedEventArgs args);
}

    public class Command<T> : IRepository<T> where T : class
    {
        public Context Context; //*Сделал публичным так как реализованы не все функции ef, сейчас они не нужны для реализации. Но можно сделать позже.
                                //Потом сделаю это свойство приватным*//
        public Command()
        {
            Context = new Context();
            Context.Database.EnsureCreated();
            Context.People.Load();
            Context.Product.Load();
        }

namespace Repositories
{
    public class PeopleRepository : IRepository<Person>
    {
        private readonly Context context;
 
        public PeopleRepository(Context context)
        {
            this.context = context;
            this.context.Database.EnsureCreated();
            this.context.People.Load();
        }
 
 
    }
    public class ProductsRepository : IRepository<Product>
    {
        private readonly Context context;
 
        public ProductsRepository(Context context)
        {
            this.context = context;
            this.context.Database.EnsureCreated();
            this.context.Products.Load();
        }
    }

namespace Repositories
{
    public class Authorized
    {
        public Authorized(Context context) =>  this.context = context;
        private readonly Context context;
 
        public bool IsAuthorized { get; private set; }

namespace ************
{
    public interface IAuthorized
    {
        bool IsAuthorized { get; }
 
        event EventHandler<IsAuthorizedChangedEventArgs>? AuthorizedChanged;
 
        void Authorize(string? name);
    }
}

    public ObservableCollection<ProductData> ProductDataList
    {
        get => (ObservableCollection<ProductData>)PropertyDescriptorHelper.GetValue(ProductDataList, "ProductDataList");
        set => PropertyDescriptorHelper.SetValue(ProductDataList, "ProductDataList", value);
    }

 private Command<string> CommandString { get; set; } = new();

            foreach (var res in CommandProduct.GetProductCollection())
                ProductDataList.Add(new ProductData() { Id = res.Id, Name = res.Name, Description = res.Description });