Передать параметры между двумя экземплярами класса

namespace CommonCore
{
    /// <summary>Базовый интерфейс копирования объекта.</summary>
    public interface ICopy : ICloneable
    {
        /// <summary>Копирует значения из текущего объекта в целевой.</summary>
        /// <param name="target">Целевой объект в который копируются значения.</param>
        /// <returns>Возвращает целевой объект.
        /// Сделано для удобства соединения методов в цепочку.</returns>
        object CopyTo(object target);
 
        /// <summary>Копирует значения в текущий объект из объекта-источника.</summary>
        /// <param name="source">Объект источник из которого копируются значения.</param>
        /// <returns>Возвращает текущий объект.
        /// Сделано для удобства соединения методов в цепочку.</returns>
        object CopyFrom(object source);
    }
}

namespace CommonCore
{
    /// <summary>Дженерик интерфейс клонирования.</summary>
    /// <typeparam name="T">Тип клонируемого объекта.</typeparam>
    public interface ICloneable<T> : ICloneable
    {
        /// <summary>Создаёт клон текущего объекта.</summary>
        /// <returns>Возвращает клон в джененрик типе.</returns>
        new T Clone();
    }
 
}

namespace CommonCore
{
    /// <summary>Дженерик интерфейс копирования объекта.</summary>
    /// <typeparam name="T">Тип копируемого объекта.</typeparam>
    public interface ICopy<T> : ICopy, ICloneable<T>
    {
        /// <inheritdoc cref="ICopy.CopyTo(object)"/>
        T CopyTo(T target);
 
        /// <inheritdoc cref="ICopy.CopyFrom(object)(object)"/>
        T CopyFrom(T source);
    }
 
}

using System.Diagnostics.CodeAnalysis;
using System.Reflection;
 
namespace CommonCore
{
    /// <summary>Методы расширения для клонирования и копирования объектов.</summary>
    public static class CopyHelper
    {
        /// <summary>Создаёт клон экземпляра класса <typeparamref name="T"/>.</summary>
        /// <typeparam name="T">Тип экземпляров.</typeparam>
        /// <param name="obj">Исходный экземпляр.</param>
        /// <returns>Возвращает новый экземпляр типа <typeparamref name="T"/>
        /// являющийся копией исходного экземпляра.</returns>
        /// <remarks>Если класс <typeparamref name="T"/> реализует интерфейс <see cref="ICloneable"/>,
        /// то копия создаётся методом <see cref="ICloneable.Clone"/>.
        /// Иначе - методом 
        /// <a href="https://docs.microsoft.com/ru-ru/dotnet/api/system.object.memberwiseclone?view=net-5.0">
        /// Object.MemberwiseClone()</a>.</remarks>
        public static T Clone<T>([DisallowNull] this T obj)
        {
            if (obj is ICloneable cln && cln.Clone() is T t)
                return t;
 
            return (T)MemberwiseCloneHandler(obj);
        }
 
        /// <summary>Делегат метода <see cref="object.MemberwiseClone"/>.</summary>
        public static readonly Func<object, object> MemberwiseCloneHandler
            = (Func<object, object>)(typeof(object).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance)?
            .CreateDelegate(typeof(Func<object, object>))
            ?? throw new Exception("Куда-то пропал метод object.MemberwiseClone()."));
 
        /// <inheritdoc cref="ICopy.CopyTo(T)"/>
        /// <typeparam name="T">Тип копируемого объекта.</typeparam>
        /// <param name="source">Текущий объект из которого копируются значения.</param>
        /// <remarks>Неглубокое копирование!</remarks>
        public static T CopyTo<T>([DisallowNull] this T source, T target)
        {
            foreach (var field in GetFields(source.GetType()))
            {
                field.SetValue(target, field.GetValue(source));
            }
            return target;
        }
 
 
        /// <inheritdoc cref="ICopy.CopyFrom(object)(T)"/>
        /// <typeparam name="T">Тип копируемого объекта.</typeparam>
        /// <param name="target">Текущий объект в который копируются значения.</param>
        /// <remarks>Неглубокое копирование!</remarks>
        public static T CopyFrom<T>([DisallowNull] this T target, T source)
        {
            foreach (var field in GetFields(target.GetType()))
            {
                field.SetValue(target, field.GetValue(source));
            }
            return target;
        }
 
        // Словарь типов со списком их полей для которых разрешено чтение и запись.
        private static readonly Dictionary<Type, List<FieldInfo>> fields = new ();
 
        // Метод получения для типа списка полей для которых разрешено чтение и запись. 
        private static List<FieldInfo> GetFields(Type type)
        {
            if (!fields.TryGetValue(type, out var fieldsList))
            {
                fieldsList = type
                    .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField | BindingFlags.GetField)
                    .ToList();
                fields.Add(type, fieldsList);
            }
            return fieldsList;
        }
    }
}

    public delegate void CopierHandler(InitializeBase source, InitializeBase target);
    public abstract class InitializeBase
    {
        // Инициализаторы для производных типов.
        private static readonly Dictionary<Type, CopierHandler> types = new();
 
        protected static CopierHandler? GetInitializer(Type type)
        {
            if (type?.IsAssignableTo(typeof(InitializeBase)) != true)
                throw new ArgumentException($"Только для производных от \"{typeof(InitializeBase).FullName}\".", nameof(type));
            if (!types.TryGetValue(type, out var handler))
            {
                Type? baseType = type.BaseType;
                if (baseType != null && baseType != typeof(InitializeBase))
                    handler = GetInitializer(baseType);
 
                foreach (var pi in type.GetProperties(/* нужные параметры */))
                {
                    // Обработка PropertyInfo их атрибутов и потом создание и запоминания делега копирования.
                    Action<object, object> setter = pi.SetMethod?.CreateDelegate<Action<object, object>>()
                                                    ?? throw new NullReferenceException($"Нет cеттера у свойства \"{pi.Name}\"");
                    Func<object, object> getter = pi.GetMethod?.CreateDelegate<Func<object, object>>()
                                                    ?? throw new NullReferenceException($"Нет геттера у свойства \"{pi.Name}\"");
                    handler += (s, t) => setter(t, getter(s));
 
                    types.Add(type, handler);
                }
            }
            return handler;
        }
 
        protected void Initialize(InitializeBase source)
        {
            GetInitializer(GetType())?.Invoke(this, source);
        }
    }

public class One
{
    static readonly int num = 123;
    public int Number;
}
 
 
public class Two : One
{
    static readonly double val = 45.67
    public double Value;
}

One one = new {Number = 8888};
Two two = new {Number = 77777, Value = 0.999};

public class One : Attribut
{
    static readonly int num = 123;
    public int Number;
}
 
[One(Number = 222)]
public class Two : One
{
    static readonly double val = 45.67
    public double Value;
}
Two two = new Two();
Conslole.WriteLine(two.Number)
//Out 222

public class Two : One
{
    static readonly double val = 45.67
    public double Value;
    public Two() => Number = 222;
}