Creating an instance of a derived class from an instance of its base class

[The-Futurist]

It seems the only way to do this is to use composition and then forward every member. Is there really no way to do this for example:

    public class EnhancedStudent : Student
    {
        public EnhancedStudent(Student _student)
        {
            base = _student; // wouldn't this be nice...
        }

        public DateTime CreatedDateTime
        { 
            get
            {
                return DateTime.Parse(base.CreatedDateTime); 
            }
        }

    }

The use case here is that instances of Student are created by some other system, I get them but want to enhance them by (for example) adding DateTime property that is computed from the Student string property.

The class Student as well as its instantiation, is all done outside of my world (its created by generated OData code).

If Student has 100 properties, I really think its silly to manually redefine all of them in the derived class, as forwards, a real maintenance nightmare.

The assignment:

base = student;

would only be permitted within a constructor and the RHS expression must be the same type as the base, that becomes a kind of shorthand for:

base.field1 = student.field1;
base.field2 = student.field2;
// etc, etc
base.field123 = student.field123;

I refer to fields because that's all we care about and setting all the fields in the base from the fields in the source object is always safe, by definition the values in all the fields (even private) of a Student can never be invalid for some other instance of a Student.

Thus base = student means - literally - copy every field (irrespective of field's access modifier) from the supplied instance to the new instance (or even do something akin to a memcpy for the entire block of memory within which the fields are situated).

[HaloFour]

You can write a helper method to shallow-copy the fields via reflection. A source generator could write that for you. The compiler itself couldn't emit that code because you wouldn't have access to the private fields of Student from EnhancedStudent, and if Student is defined in a different assembly the schema could be different at runtime.

[jnm2]

I wonder if the runtime impl of object.MemberwiseClone would always just work if the clone was of a derived type

[The-Futurist]

Yes, I think thats the best practical solution here, I coded a generic field copier based on cached reflection delegates so its easy to use.

But I can't help seeing this as something the language itself could do for us. I understand the concerns about possible invalid states, but that doesn't go away when we generically reflect, so something like base = source seems reasonable.

[HaloFour]

The language could do anything. It probably shouldn't, though. I personally don't think that this is a safe pattern, especially through attempting to emulate a copy constructor. You can't avoid the allocation, even if Student was already EnhancedStudent. Plus, you decapitate the source if it happened to be any other derived type of Student. Personally, I don't think this pattern fits with OOP. More like composition, but that should use delegation, not copy state.

[franchyd]

Your example would be easily solved with an extension method.

[The-Futurist]

Please elaborate...

[martin-steinhoefer]

Extensions (the new ones) could provide an alternative solution. However, that might require managing of state in sort of dictionary (ConditionalWeakTable?) by you. You could keep an associated object containing all the additional state for every Student instance you get. Either the instance or that object provides you with the state you need to implement extension properties...
Downside is, there is no overriding of existing members.

[franchyd]

The example doesn't even track state, it could be solved today as an extension method:

        public static DateTime CreatedDateTime(this Student @this) => DateTime.Parse(@this.CreatedDateTimeStr);

Or in the future as an extension property:

    extension(Student source) // extension members for Student 
    {
        public DateTime CreatedDateTime => DateTime.Parse(source.CreatedDateTimeStr);
    }

[timcassell]

It won't work, because they want to hide the base property, which extensions do not support.

[franchyd]

Combine with the banned API analyzer

[huoyaoyuan]

It is not possible. A valid state of fields of base class may not be valid state for derived class. Example:

class Base
{
    private int a;

    public virtual int A
    {
        get => a;
        set => a = value;
    }
}

class Derived : Base
{
    public override int A
    {
        get => base.A;
        set
        {
            if (value < 0) throw new Exception();
            base.A = value;
        }
    }
}

You should not be able to create a Derived from a Base with negative a.

This is the common case of classes, and PODs are special. The proposed features are more suitable to records.
Class is not plain aggregation of fields. There are semantics attached.

[martin-steinhoefer]

What about this code?

class Base
{
    private int a;

    protected Base(Base other) => a = other.a;

    public virtual int A
    {
        get => a;
        set => a = value;
    }
}

Then a derived class could be instantiated by

class Derived : Base
{
    public Derived(Base other) : base(other) { }
    
    // possibly overriding property A, even throwing on setting a negative value
}

If one sticks to the best practice not to call virtual members in .ctor, then perhaps having a copy-.ctor in the base class would solve the problem?

[huoyaoyuan]

It's not about ctor. It means that any state of base class, directly created or modified later, may not be acceptable for derived class.
Another example is:

class Base(string? a)
{
    public readonly string? A = a;
}

class Derived(string a) : Base(a ?? throw new ArgumentNullException())
{
}

[martin-steinhoefer]

You are right, in general there is no guarantee that state of an instance of a base class is valid in the context of a derived class. And as there is no general solution to verify that state (in order to check whether it would fit for derived class), there is no general solution to the problem.

The copy-.ctor approach is limited to use cases, where either the derived class does not introduce own restrictions on the state of base class or any of such restrictions can be proven using the given instance of the base class (those should be enforced in derived .ctor then).
However, in those cases it seems an elegant way to solve the problem. The benefit is, that this does not require composition (which introduces additional problems).

I'm aware of the fact, that this requires presence of a copy-.ctor (which is also not guaranteed).

[The-Futurist]

This all arose because a vendor's OData service is flawed, fails to include a time zone in Edm.DateTimeOffset OData members, that causes MS OData code to (justifiably) throw a format exception. The most reasonable "fix" is to edit the OData metadata file and replace that date type with string. Then regen the code and it works, but we lose the date type and need to convert the string ourselves when we need it.

Hence the custom derived classes, created as the need is encountered and letting us access all the original properties but "hide" the date members with members that have the correct date type.

[The-Futurist]

I got Copilot to draft the code:

public class B
{
    public int BaseInt;
    public string BaseString;
}

public class D : B
{
    public double DerivedDouble;

    public D(B source)
    {
        FieldCopier<D>.PopulateBase(source, this);
    }
}

public static class FieldCopier<TTarget>
    where TTarget : class
{
    private static readonly List<(Func<object, object> getter, Action<TTarget, object> setter)> _fieldAccessors;

    static FieldCopier()
    {
        _fieldAccessors = new List<(Func<object, object>, Action<TTarget, object>)>();

        Type baseType = typeof(TTarget).BaseType!;
        var fields = baseType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

        foreach (var field in fields)
        {
            var baseParam = Expression.Parameter(typeof(object), "baseInstance");
            var baseCast = Expression.Convert(baseParam, baseType);
            var fieldAccess = Expression.Field(baseCast, field);
            var getter = Expression.Lambda<Func<object, object>>(
                Expression.Convert(fieldAccess, typeof(object)),
                baseParam
            ).Compile();

            var targetParam = Expression.Parameter(typeof(TTarget), "target");
            var valueParam = Expression.Parameter(typeof(object), "value");
            var targetFieldAccess = Expression.Field(Expression.Convert(targetParam, baseType), field);
            var assign = Expression.Assign(targetFieldAccess, Expression.Convert(valueParam, field.FieldType));
            var setter = Expression.Lambda<Action<TTarget, object>>(assign, targetParam, valueParam).Compile();

            _fieldAccessors.Add((getter, setter));
        }
    }

    public static void PopulateBase(object baseInstance, TTarget target)
    {
        foreach (var (getter, setter) in _fieldAccessors)
        {
            setter(target, getter(baseInstance));
        }
    }
}

I'll road test this later...

[The-Futurist]

Here's the final code that seems to work fine:

public static class FieldCopier
{
    private static readonly ConcurrentDictionary<Type, List<(Func<object, object> getter, Action<object, object> setter)>> _cache
        = new();

    public static void PopulateBase(object baseInstance, object target)
    {
        var targetType = target.GetType();

        var accessors = _cache.GetOrAdd(targetType, type =>
        {
            var baseType = type.BaseType!;
            var list = new List<(Func<object, object>, Action<object, object>)>();

            var fields = baseType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            foreach (var field in fields)
            {
                // Getter
                var baseParam = Expression.Parameter(typeof(object), "baseInstance");
                var baseCast = Expression.Convert(baseParam, baseType);
                var fieldAccess = Expression.Field(baseCast, field);
                var getter = Expression.Lambda<Func<object, object>>(Expression.Convert(fieldAccess, typeof(object)), baseParam).Compile();

                // Setter
                var targetParam = Expression.Parameter(typeof(object), "target");
                var valueParam = Expression.Parameter(typeof(object), "value");
                var targetCast = Expression.Convert(targetParam, baseType);
                var targetField = Expression.Field(targetCast, field);
                var assign = Expression.Assign(targetField, Expression.Convert(valueParam, field.FieldType));
                var setter = Expression.Lambda<Action<object, object>>(assign, targetParam, valueParam).Compile();

                list.Add((getter, setter));
            }

            return list;
        });

        foreach (var (getter, setter) in accessors)
        {
            var value = getter(baseInstance);
            setter(target, value);
        }
    }
}

We just do this in the derived class constructor:

public ProjectedStudent(Student source)
{
    FieldCopier.PopulateBase(source, this);
}