从子类到父类的隐式对话

Question

suppose I have two following classes

public class Animal
{
    public string name { get; set; }
}

public class Cat: Animal
{
   public int age { get; set; }
   public string type { get; set; }
}

and now I want to convert my derived class "Cat" match property(eg Name) to my base class "Animal" with implicit conversion as following way.

            Cat cat = new Cat();
            cat.name = "diana";
            cat.age = 2;
            cat.type = "Siamese-American Shorthair";

            Animal animal = new Animal();

            animal = (Animal)cat;
             // or
            animal = cat as Animal;

so while doing above coding it will work fine and will get name property implicit in Animal class object but if I check object of Animal class that is animal actually contains the object of Cat class that is cat and not actually get the object of Animal class.

So please help me to come over this situation so I can directly implicit convert my child class property to my matched class property with proper parent class object.

Answer 1

A cat will always be a cat, even if you are only looking at animals. You cannot remove the actual type of an object; casting it to a parent type will only affect the variable you store it to but the underlying object remains the same.

Cat cat = new Cat(); // cat is a cat

Animal catAnimal = cat; // a cat is also an animal
Console.WriteLine(catAnimal.GetType()); // still a cat

Cat newCat = (Cat)catAnimal;

Console.WriteLine(newCat == cat); // the same cat
Console.WriteLine(animal == cat); // the same cat

Answer 2

First , this is not an implicit conversion, but an explicit one. An implicit conversion example is this:

int x = 123;
string y = "asdf" + x; // this is the implicit conversion.

Second , you can't "uncat" the cat. it will still be a cat even if your reference is of type object ,

Third , any object from any class will keep the properties and fields of it's parent class, unless they are declared as private , so casting a cat to an animal to get it's name property is redundant.

So, can such a cast be useful?
The answer is yes, it might, in the following situations:

• Your derived class hides base class functionality using the new keyword.
• Your derived class explicitly implements an interface , and the implicit implementation is different then the explicit one.

Here are examples of these situations:

Casting an object to it's base class to use a property or method is when the property or method in the derived class is declared as new :

public class Base {

    internal virtual string X() {
        return "Base";
    }
}
public class Derived1 : Base
{
    internal new string X()
    {
        return "Derived 1";
    }
}

public class Derived2 : Base 
{
    internal override string X()
    {
        return "Derived 2";
    }
}

Derived1 a = new Derived1();
Base b = new Derived1();
Base c = new Derived2();
Console.WriteLine("Derived1 as Derived1: "+ a.X()); // Derived1 as Derived1: Derived 1
Console.WriteLine("Derived1 as Base: " + b.X()); // Derived1 as Base: Base
Console.WriteLine("Derived2 as Base: " + c.X()); // Derived2 as Base: Derived 2

See fiddle here

Casting an object to one of the interfaces it implements, when the class overloads the explicit implementation with an implicit one.

public interface IBlabla {
    string bla();
}

public class BlaBla : IBlabla 
{
    public string bla() {
        return "implicit";
    }

    string IBlabla.bla()
    {
        return "EXPLICIT";
    }
}

BlaBla Myclass = new BlaBla();    
Console.WriteLine(Myclass.bla()); // implicit
Console.WriteLine(((IBlabla)Myclass).bla()); // EXPLICIT

See fiddle here

Answer 3

You cannot change an objects type. As Yuval Itzchakov already mentioned you need to create an instance of type Animal . You may only create some kind of copy-constructor for your Animal-class that copied all properties and variables from the given Animal to the new one:

public Animal(Animal animal) {
    this.Name = animal.Name;
    // further variables and properties to reset the state exactly to the state of the given animal
}

Now you can create an instance of type Animal from every derived type like so:

Animal ani = new Animal(cat);

However that still sounds like a design-flaw (propbably an XY-problem ) to me. If you need to access the Name -property of your cat you won´t need to cast to its base-type.

Answer 4

If you really wanted to, you could do something along the lines of

 internal class Program
{
    public class Animal
    {
        public string Name { get; set; }           
    }

    public class Cat : Animal
    {
        public int Age { get; set; }
        public string Type { get; set; }
    }

    public static void Main()
    {
        var cat = new Cat();
        cat.Name = "Puss";

        var animal = cat.ToBaseClass<Animal, Cat>();

        Debug.Assert(!(animal is Cat));
        Debug.Assert(animal.Name == "Puss");

    }
}

public static class ReflectionHelper
{
    public static TBase ToBaseClass<TBase, TDerived>(this TDerived from) 
        where TBase : new()
        where TDerived : TBase
    {
        var result = new TBase();

        foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(result))
        {
            propertyDescriptor.SetValue(result, propertyDescriptor.GetValue(from));
        }

        return result;
    }
}

... but it would be pretty ugly ;)

Answer 5

Thanks to all of you who help me to solve my problem and I take everyone answers and comments very seriously. I have also find another solutions which may be useful to someone. As this questions is regarding conversion with same property from child to parents class, we can use AutoMapper which can do conversion for any class from child to parent class or parent to child class. For that first you can download or update AutoMapper from nuget at give link and add as reference in your project or application.

https://www.nuget.org/packages/AutoMapper/

Now as per my question if I want to convert property from child to parent class than coding using AutoMapper functionality would be as below.

     Mapper.CreateMap<Cat, Animal>();
     Animal animal = Mapper.Map<Animal>(cat);

I hope this solutions will work for you as it has solved my issues.