Given a base and extended class, is casting always needed for base class methods that return objects of the base class type?

Question

Assume this base class:

public class BaseClass {
    public BaseClass Clone() { 
        /* Returns a full copy of the object. */ 
   }

    /* Constructors here */
}

And this derived class:

public class ExtendedBaseClass : BaseClass {
    /* ... */

   /* Constructors here */
}

If I understand correctly, if an instance of ExtendBaseClass, calls Clone, an object of type BaseClass will be returned. So, this will fail because an explicit cast is missing:

BaseClass bc = new();
ExtendedBaseClass ebc = bc.Clone();

I have two questions:

Is my understanding correct?
Is there a way to prevent an explicit cast from being needed when Clone() is called?

@KevinKrumwiede an explicit cast will obviously work. I'm specifically asking if there's a way to implement this that does *not* require an explicit cast. — chrisxfire, Apr 30 '22 at 03:26
How would that work even with a cast? The object you're cloning is type `BaseClass`, not type `ExtendedBaseClass`. A cast would enable the code to compile but it will throw an `InvalidCastException` at run time. — user18387401, Apr 30 '22 at 03:34
It will obviously *not* work, so I guess that's a no, you didn't try it. — Kevin Krumwiede, Apr 30 '22 at 03:36
@KevinKrumwiede So for methods in a base class that return objects of the base class, what should I do? Do I have to re-implement those methods? — chrisxfire, Apr 30 '22 at 03:42
Your question points to an important misunderstanding in how you think inheritance and/or casting works. I'd review those subjects. Object cloning is messy, and there's no single right way to do it. For example, do you want a deep copy or a shallow copy? [This Q&A](https://stackoverflow.com/questions/21116554/proper-way-to-implement-icloneable) discusses some of the issues and possible solutions. It's worth asking why you want to clone an object in the first place. — Kevin Krumwiede, Apr 30 '22 at 03:48
I see why you come to that conclusion. I should have asked my question differently (I'm working with someone else's implementation of Clone). Thanks for your help. — chrisxfire, Apr 30 '22 at 14:28

score 1 · Answer 1 · answered Apr 30 '22 at 03:32

It depends on how the copy is done - an ExtendedClass is a BaseClass, so if Clone looks at the runtime type and creates a new instance of that same type, then the object returned from Clone will be an ExtendedClass. But, you will need a cast to tell the compiler that the object is an ExtendedClass, otherwise the compiler will treat it as a BaseClass for method binding and other operations.

Or, make BaseClass and Clone generic:

public class BaseClass<T> where T:BaseClass<T> {
    public T Clone() { 
        /* Returns a full copy of the object. */ 
   }

    /* Constructors here */
}

public class ExtendedBaseClass : BaseClass<ExtendedBaseClass> {
    /* ... */

   /* Constructors here */
}

ExtendedBaseClass original;
ExtendedBaseClass copy = original.Clone();

Then the compiler will know that Clone returns an ExtendedBaseClass and you won't need a cast.

Note that this is still not fool-proof, since technically you can define

public class ExtendedBaseClass2 : BaseClass<ExtendedBaseClass> {
    /* ... */

   /* Constructors here */
}

and Clone will return an ExtendedBaseClass.

Julio Cachay · Answer 2 · 2022-04-30T13:06:28.853

To cast to the derived class, the initial object that was created should be of that class.

This will throw an invalid cast exception

SomeBase c = new SomeBase();
var d = (SomeDerived)c; // invalid cast exception

This will work

SomeBase a = new SomeDerived();
var b = (SomeDerived)a;

This is one way, if you are using C# 9.

Covariant return types c# 9

Support covariant return types. Specifically, permit the override of a method to declare a more derived return type than the method it overrides,

Try in net fiddle


using System;
                   
public class Program
{
   public static void Main()
   {
       var a = new Derived("XYZ");
       var b = a.Clone();
       Console.WriteLine(b.Name);
       
   }
   
  public abstract class BaseClass
  {
      public abstract BaseClass Clone();
  }
  public class Derived : BaseClass
  {
      public Derived(string name)
      {
          Name = name;
      }
      public string Name {get;}
       public override Derived Clone()
       {
         return new Derived(this.Name);
       }
  }
}

Given a base and extended class, is casting always needed for base class methods that return objects of the base class type?

2 Answers2