Sixdegreeoffreedomdynamicloadsimulationdevice/Client/IViewModel/ViewModels/ViewModelBase{TModel}.cs

using CommunityToolkit.Mvvm.ComponentModel;
using EventBus;
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace IViewModel.ViewModels
{
    public abstract class ViewModelBase<TModel>:ViewModelBase where TModel : IModel.IModel
    {
        public ViewModelBase(TModel model) : this()
        {
            UpDateModel(model);
        }
        
        private List<FieldInfo> AllFields = new List<FieldInfo>();
        private List<(string, IReadOnlyList<string>)> AllProperties = new List<(string, IReadOnlyList<string>)>();
        public ViewModelBase()
        {
            if (typeof(TModel).IsAnsiClass && !typeof(TModel).IsAbstract)
            {
                Model = Activator.CreateInstance<TModel>();
                AllFields = typeof(TModel).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).ToList();
                GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                    .Where(x => x.GetCustomAttribute<PropertyAssociationAttribute>() != null)
                    .ToList()
                    .ForEach(x =>
                    {
                        var att = x.GetCustomAttribute<PropertyAssociationAttribute>();
                        if (att == null || att.Names.Count == 0) return;
                        AllProperties.Add((x.Name, att.Names));
                    });
            }
        }
        [AllowNull]
        private TModel model = default;

        public virtual TModel Model { get => model; set => SetProperty(ref model, value); }
        public virtual void ReceiveServiceModel(TModel model)
        {
            if (typeof(TModel).IsAbstract || typeof(TModel).IsInterface) return;
            if (lastModel != null)
            {
                lastModel = (TModel)model.Clone();
            }
            UpDateModel(model);
        }
        public virtual void UpDateModel(TModel model)
        {
            if (typeof(TModel).IsAbstract || typeof(TModel).IsInterface) return;
            List<string> changedNames = new List<string>();

            if (model == null || AllFields.Count == 0) return;
            if (Model == null)
            {
                changedNames = AllFields.Select(x => x.Name).ToList();
            }
            else
            {
                AllFields.ForEach(x =>
                {
                    var lastvalue = x.GetValue(Model);
                    var fieldvalue = x.GetValue(model);
                    if (!Equals(lastvalue, fieldvalue))
                    {
                        changedNames.Add(x.Name);
                    }
                });
            }
            Model = model;
            if (changedNames.Count == 0) return;
            List<string> nochanged = new List<string>();
            changedNames.ForEach(x =>
            {
                bool state = false;
                AllProperties.ForEach(y =>
                {
                    if (y.Item2.Contains(x))
                    {
                        OnPropertyChanged(y.Item1);
                        state = true;
                    }
                });
                if (!state) nochanged.Add(x);
            });
            if (nochanged.Count == 0) return;
            RefreshUI(nochanged);
        }



        [AllowNull]
        protected TModel lastModel;
        protected virtual void RefreshUI(List<string> changedNames)
        {

        }
    }
}