AllowImplicitDestinationInheritance(true) Combines all settings, including those that are not recommended for use by child type

[bill2004158]

Sample Code:

    public class Animal { }
    public class Dog : Animal { }
    public class Bird : Animal { }


    public class AnimalDto { }
    public class DogDto : AnimalDto { }
    public class BirdDto : AnimalDto { }

    class Program
    {
        static void Main(string[] args)
        {
            var config = new TypeAdapterConfig();
            config.NewConfig<AnimalDto, Animal>().MapWith((s) => s is BirdDto ? new Bird() : new Dog());
            config.AllowImplicitDestinationInheritance = true;

            var d = new DogDto();
            var a = d.Adapt<Dog>(config);
        }
    }

[DocSvartz]

Hi, @bill2004158. This isn't supposed to work that way.
Polymorphism works the other way around: a variable in a child class can be assigned to a parent class.

MapWith - This is a custom object transformation function. It replaces Mapster's work.

Expression<Func<AnimalDto, Animal>> expressionMapWith = (s) => s is BirdDto ? new Bird() : new Dog(); // result is type Animal 

Dog Dto2 = (Dog)new Animal(); // Unable to cast

Expression<Func<DogDto, Dog>> expression = (s) => s is BirdDto ? new Bird() : new Dog(); // Unable to cast

[bill2004158]

hi @DocSvartz ,
we have factory to create the instance of Animal.
while in Mapping config, we don't register the concrete class.
thus "AllowImplicitDestinationInheritance = true" is used.

if create config for each concrete class,
then there will be many "NewConfig<,>()".
which will be hard to manage.

[DocSvartz]

Does Animal require a special constructor?
Or do the field names in it and its heirs not match?

[bill2004158]

Expression<Func<AnimalDto, Animal>> expressionMapWith = (s) => s is BirdDto ? new Bird() : new Dog(); // result is type Animal
-->
result is type Animal,
but the real type is Bird or Dog.
which could be cause to Dog in correct condition?

Expression<Func<DogDto, Dog>> expression = (s) => s is BirdDto ? new Bird() : new Dog(); // Unable to cast
-->
correct, but it defined "NewConfig<AnimalDto, Animal>()".
thus, the Expression will work:
Expression<Func<AnimalDto, Animal>> expression = (s) => s is BirdDto ? new Bird() : new Dog(); // it works

[bill2004158]

Does Animal require a special constructor?
-->
Animal could be a abstract class, or interface,
thus cannot create instance of it.

[DocSvartz]

correct, but it defined "NewConfig<AnimalDto, Animal>()".
thus, the Expression will work:
Expression<Func<AnimalDto, Animal>> expression = (s) => s is BirdDto ? new Bird() : new Dog(); // it works

And it will work if you ask for a conversion function for these types

var a = d.Adapt<AnimalDto, Animal>(config);

var a = d.Adapt<Dog>(config); // Adapt<Object, Animal> - where the actual type for d is determined at runtime

[DocSvartz]

result is type Animal,
but the real type is Bird or Dog.
which could be cause to Dog in correct condition?

but the real type is Bird or Dog.

Yes, and this would be an anonymous union type if C# were a functional language.
But C# is not a functional language, so the result can be a specific type, in this case it common parent type.

[DocSvartz]

I'm not quite sure what you need.
If you simply need to copy mapping settings from a parent class further clasess down the hierarchy,

Then it works simply like this.

[TestMethod]
public void AllowImplicitDestinationInheritance()
{
    var config = new TypeAdapterConfig();
    config.AllowImplicitDestinationInheritance = true;
    config.NewConfig<AnimalDto, Animal>()
        .Map(dest=>dest.AnimalValue,src=>src.AnimalValueDto);
    
    var d = new DogDto() { AnimalValueDto = "Hello" };
    var a = d.Adapt<Dog>(config);

    var birdDto = new BirdDto { AnimalValueDto = "Hello bird", BirdValue = "Twitter" };

    var bird = birdDto.Adapt<Bird>(config);

    a.ShouldBeOfType<Dog>();
    a.AnimalValue.ShouldBe("Hello");

    bird.ShouldBeOfType<Bird>();
    bird.AnimalValue.ShouldBe("Hello bird");
    bird.BirdValue.ShouldBe("Twitter");

}

public abstract class Animal { public string AnimalValue { get; set; } }
public class Dog : Animal { }
public class Bird : Animal 
{ 
    public string BirdValue {  get; set; }
}


public class AnimalDto { public string AnimalValueDto { get; set; } }
public class DogDto : AnimalDto { }
public class BirdDto : AnimalDto 
{
    public string BirdValue { get; set; }
}

[DocSvartz]

The root of the hierarchy can be an abstract type.

public abstract class Animal { public string AnimalValue { get; set; } }

Most likely, you're trying to validate such a configuration with .Compile() and getting an error.

 var config = new TypeAdapterConfig();
 config.AllowImplicitDestinationInheritance = true;
 config.NewConfig<AnimalDto, Animal>()
     .Map(dest=>dest.AnimalValue,src=>src.AnimalValueDto)
    // .Include<DogDto,Dog>();


 config.Compile(); // error

config.NewConfig<AnimalDto, Animal>()
.Map(dest=>dest.AnimalValue,src=>src.AnimalValueDto)
.Include<DogDto,Dog>(); // add include with any child that can be instantiated

config.Compile(); // compile no error

[bill2004158]

a = d.Adapt<AnimalDto, Animal>(config);

var a = d.Adapt<AnimalDto, Animal>(config); //works
var b = d.Adapt<Animal>(config); //works
var c = d.Adapt<Dog>(config); // Exception: Unable to cast object of type
var e = d.Adapt<DogDto, Dog>(config); // Exception: Unable to cast object of type