using System;

public class Program

{

    public class Test 

    {

        public int A { get; private set; }

        public int B { get; }

        public Test(int A, int B) {

            this.A = A;

            this.B = B;

        }

        //Option A: Works for overriding any access level property.

        //But it's more verbose, need to map every property manually. The verbosity is only on the object itself though, and not everywhere where we use the object.

        public Test(Test original, int B) : this(original.A, B) {}

        //Option B: Doesn't work for readonly properties. If we use this, we would need to change the readonly to private setters instead if we need to override the prop.

        //But gives us one line copy of entire object, you don't need to extend the copy method if if you add a new property.

        public Test Clone() {

            return (Test)this.MemberwiseClone();

        }

        public Test Clone(int A) {

            var clone = Clone();

            clone.A = A;

            return clone;

        }

        //Both options have an issue if we want to create two different overrides for same type. E.g. now one method to override A and another B, both are int. It will complain that methods have identical signature.

        //Option A: Ignore until we actually need to do something about it.

        //Option B: When we need to do something about it. The clone method name can be changed, to e.g. CloneA and CloneB. To work for constructor option, the clone method would look like this:

        public Test CloneB(int B) {

            return new Test(this.A, B);

        }

        //Option C: When we need to do something about it. Default values. If value is default, use original, if value is not default, override.

        //This will allow a lot more override options, the only thing that is left is we actually want to override a value into null/0/false

        private static T Resolve<T>(T originalValue, T newValue) => newValue == default ? originalValue : newValue;

        public Test(Test original, int A = default, int B = default) : this(Resolve(original.A, A), Resolve(original.B, B)) {}

        //Option D: If we reach the case where we have multiple properties of same type, both of them need to be overriden, but not at the same time, and there are cases when we override to a default value, then something like this:

        private static T ResolveV2<T>(T originalValue, T newValue, bool force) => newValue == default && !force ? originalValue : newValue;

        public Test(Test original, int A = default, bool forceA = false, int B = default, bool forceB = false) : this(ResolveV2(original.A, A, forceA), ResolveV2(original.B, B, forceB)) {}

        //To use it simply new Test(original, B:66) || new Test(original, A:0, forceA: true), etc.

        //Ends up being relatively complex, but I would rather have one more complex place deep on the object itself, than having very verbose and/or complex logic all over the place.

        //And for most of our copy and override needs we won't reach a need for this level.

        public override string ToString() {

            return $"{A} {B}";

        }

    }

    public static void Main()

    {

        var test = new Test(1,2);

        Console.WriteLine($"Original {test}\n");

        var overridePrivate = test.Clone(A: 66);

        Console.WriteLine($"Private prop overriden {overridePrivate}");

        Console.WriteLine($"Original did not change {test}\n");

        var overrideReadOnly = new Test(test, B: 66);

        Console.WriteLine($"ReadOnly prop overriden {overrideReadOnly}");

        Console.WriteLine($"Original did not change {test}\n");

    }

}