Advice on using the Factory Pattern for converting a collection of model objects to one of DTOs and vice versa

Question

I'm trying to convert a collection of model objects that share a common parent, into one of DTOs. Likewise, I want to reverse the procedure - taking a collection of DTOs with a common parent into one of model objects.

From what I've read, a Factory Pattern seems to be what I'm looking for. I also have a Producer class that handles the conversion between object model and DTO by calling the relevant factory method.

There are a few limitations:

1. This is an open source library, and I don't want to add methods to existing classes. Otherwise a visitor pattern would have worked. Please correct me if I'm wrong.
2. Similarly, I don't want to add any additional packages to this project. From what I understand, AutoMapper would have been one of the ways to go about this.
3. I'm new(ish) to C# and design patterns, so I apologize if I am doing something that doesn't make sense.

Here is some sample code representing what I've tried so far. I used some references from online to get an idea, but something about it doesn't seem right. There was another way mentioned here: Is a switch statement applicable in a factory method? c#, but I'm not sure if that is transferrable to this scenario.

Any critique or suggestions is welcome.

Example Usage

Animal pet1 = new Pigeon("Pidgey", 100, false);
Animal pet2 = new Rattlesnake("Ekans", 20.0, true);

IList<Animal> myPets = new List<Animal>() { pet1, pet2 };

AnimalDTOProducer dtoProducer = new AnimalDTOProducer(new AnimalDTOFactory());
IList<AnimalDTO> myDTOs = new List<AnimalDTO>();

myDTOs = dtoProducer.ConvertAnimalCollection(myPets);

Models

public abstract class Animal
{
    public Animal(string name)
    {
        Name = name;
    }

    public string Name { get; set; }
    // business logic
}

public abstract class Bird : Animal
{
    public Bird(string name, int maxAltitude, bool isReal)
        : base(name)
    {
        Name = name;
        MaxAltitude = maxAltitude;
        IsReal = isReal;
    }

    public int MaxAltitude { get; set; }
    public bool IsReal { get; set; }
    // business logic
}

public class Pigeon : Bird
{
    public Pigeon(string name, int maxAltitude, bool isReal)
        : base(name, maxAltitude, isReal)
    {
    }
    // business logic
}

public abstract class Snake : Animal
{
    public Snake(string name, double length, bool isPoisonous)
        : base(name)
    {
        Name = name;
        Length = length;
        IsPoisonous = isPoisonous;
    }

    public double Length { get; set; }
    public bool IsPoisonous { get; set; }
    // business logic
}

public class Rattlesnake : Snake
{
    public Rattlesnake(string name, double length, bool isPoisonous)
        : base(name, length, isPoisonous)
    {
    }
    // business logic
}

DTOs

public abstract class AnimalDTO { }

public class PigeonDTO : AnimalDTO
{
    public string Name { get; set; }
    public int MaxAltitude { get; set; }
    public bool IsReal { get; set; }
}

public class RattlesnakeDTO : AnimalDTO
{
    public string Name { get; set; }
    public double Length { get; set; }
    public bool IsPoisonous { get; set; }
}

Factories

public interface IFactory { }

public interface IAnimalFactory : IFactory
{
    Animal CreateAnimal(AnimalDTO DTO);
}

public interface IAnimalDTOFactory : IFactory
{
    AnimalDTO CreateAnimalDTO(Animal animal);
}

public class AnimalFactory : IAnimalFactory
{
    public Animal CreateAnimal(AnimalDTO DTO)
    {
        switch (DTO)
        {
            case PigeonDTO _:
                var pigeonDTO = (PigeonDTO)DTO;
                return new Pigeon(pigeonDTO.Name, pigeonDTO.MaxAltitude, pigeonDTO.IsReal);
            case RattlesnakeDTO _:
                var rattlesnakeDTO = (RattlesnakeDTO)DTO;
                return new Rattlesnake(rattlesnakeDTO.Name, rattlesnakeDTO.Length, rattlesnakeDTO.IsPoisonous);
            // And many more ...
            default:
                return null;
        }
    }
}

public class AnimalDTOFactory : IAnimalDTOFactory
{
    public AnimalDTO CreateAnimalDTO(Animal animal)
    {
        switch (animal)
        {
            case Pigeon _:
                var _pigeon = (Pigeon)animal;
                return new PigeonDTO()
                {
                    Name = _pigeon.Name,
                    MaxAltitude = _pigeon.MaxAltitude,
                    IsReal = _pigeon.IsReal
                };
            case Rattlesnake _:
                var _rattlesnake = (Rattlesnake)animal;
                return new RattlesnakeDTO()
                {
                    Name = _rattlesnake.Name,
                    Length = _rattlesnake.Length,
                    IsPoisonous = _rattlesnake.IsPoisonous
                };
            // And many more ...
            default:
                return null;
        }
    }
}

Producers

public interface IProducer { }

public interface IAnimalProducer : IProducer
{
    Animal ProduceAnimalFromDTO(AnimalDTO DTO);
}

public interface IAnimalDTOProducer : IProducer
{
    AnimalDTO ProduceAnimalDTOFromAnimal(Animal animal);
}

public class AnimalProducer : IAnimalProducer
{
    private IAnimalFactory factory;

    public AnimalProducer(IAnimalFactory factory)
    {
        this.factory = factory;
    }

    public IList<Animal> ConvertAnimalDTOCollection(IList<AnimalDTO> DTOCollection)
    {
        IList<Animal> result = new List<Animal>();
        foreach (AnimalDTO DTO in DTOCollection)
        {
            var dto = ProduceAnimalFromDTO(DTO);
            if (dto != null)
                result.Add(dto);
        }

        return result;
    }

    public Animal ProduceAnimalFromDTO(AnimalDTO animalDTO)
    {
        return this.factory.CreateAnimal(animalDTO);
    }
}

public class AnimalDTOProducer : IAnimalDTOProducer
{
    private IAnimalDTOFactory factory;

    public AnimalDTOProducer(IAnimalDTOFactory factory)
    {
        this.factory = factory;
    }

    public IList<AnimalDTO> ConvertAnimalCollection(IList<Animal> collection)
    {
        IList<AnimalDTO> result = new List<AnimalDTO>();
        foreach (Animal animal in collection)
        {
            var _animal = ProduceAnimalDTOFromAnimal(animal);
            if (_animal != null)
                result.Add(_animal);
        }

        return result;
    }

    public AnimalDTO ProduceAnimalDTOFromAnimal(Animal animal)
    {
        return this.factory.CreateAnimalDTO(animal);
    }
}

UPDATE 1

As recommended by sjb-sjb and ChiefTwoPencils in the comments, I eliminated the switch statements from the respective factories. The result looks like this:

public class AnimalFactory : IAnimalFactory
{
    public Animal CreateAnimal(AnimalDTO DTO)
    {
        Type srcType = DTO.GetType();
        Type modelType = Type.GetType(Regex.Replace(srcType.FullName, @"(DTO)$", ""));
        IList<PropertyInfo> props = new List<PropertyInfo>(srcType.GetProperties());
        var propVals = props.Select(prop => prop.GetValue(DTO, null)).ToArray();
        
        Animal animal = (Animal)Activator.CreateInstance(modelType, propVals);

        return animal;
    }
}

public class AnimalDTOFactory : IAnimalDTOFactory
{
    public AnimalDTO CreateAnimalDTO(Animal animal)
    {
        Type srcType = animal.GetType();
        Type dtoType = Type.GetType($"{srcType.FullName}DTO");
        AnimalDTO dto = (AnimalDTO)Activator.CreateInstance(dtoType, new object[] { });
        foreach (PropertyInfo dtoProperty in dtoType.GetProperties())
        {
            PropertyInfo srcProperty = srcType.GetProperty(dtoProperty.Name);
            if (srcProperty != null)
            {
                dtoProperty.SetValue(dto, srcProperty.GetValue(animal));
            }
        }
        return dto;
    }
}

The one thing I forgot to mention in the original question was that the constructor for the model may have more arguments than the DTO object has properties. That, and the order of arguments may not be the same. I think in pseudo-code, a solution will look something like this:

void AssignParamsToConstructor() 
{
    // Extract constructer parameters with names into an ordered list
    // Match DTO properties with extracted parameters via name and type
    // Fill any missing parameters with a default value or null
    // Pass the final list of parameters as an array to Activator.CreateInstance method
}

I will be researching on a way to resolve this for the time being, but any pointers will be welcome.

UPDATE 2

Okay, so I found a kind of hacky solution for the previous problem regarding calling the Model constructor with missing or out-of-order arguments.

I created a helper class that creates an ordered argument array based on a combination of the Model constructor arguments and the DTO properties. This array can then be passed to Activator.CreateInstance without causing any issues.

Here is the updated AnimalFactory.CreateAnimal method:

public Animal CreateAnimal(AnimalDTO DTO)
{
    Type srcType = DTO.GetType();
    Type modelType = Type.GetType(Regex.Replace(srcType.FullName, @"(DTO)$", ""));
    object[] propVals = Helpers.GenerateConstructorArgumentValueArray(modelType, DTO);
    Animal animal = (Animal)Activator.CreateInstance(modelType, propVals);
    return animal;
}

And here is the helper class:

public static class Helpers
{
    public static object[] GenerateConstructorArgumentValueArray(Type type, object obj)
    {
        IList<(string, Type)> ctorArgTypes = new List<(string, Type)>();
        IList<(string, object)> propVals = new List<(string, object)>();

        // Get constructor arguments
        ctorArgTypes = GetConstructorArgumentsAndTypes(type);

        // Get object properties
        propVals = GetObjectPropertiesAndValues(obj);

        // Create args array
        IList<object> paramVals = new List<object>();

        foreach (var ctorArg in ctorArgTypes)
        {
            object val;

            string _name = ctorArg.Item1.ToLower();
            (string, object) _namedProp = propVals.Where(prop => prop.Item1.ToLower() == _name).FirstOrDefault();
            if (_namedProp.Item2 != null)
            {
                val = _namedProp.Item2;
            }
            else
            {
                val = ctorArg.Item2.IsValueType ? Activator.CreateInstance(ctorArg.Item2) : null;  
            }
            paramVals.Add(val);
        }

        return paramVals.ToArray();
    }

    private static IList<(string, Type)> GetConstructorArgumentsAndTypes(Type type)
    {
        List<(string, Type)> ctorArgs = new List<(string, Type)>();

        TypeInfo typeInfo = type.GetTypeInfo();
        ConstructorInfo[] ctors = typeInfo.DeclaredConstructors.ToArray();
        ParameterInfo[] ctorParams = ctors[0].GetParameters();

        foreach (ParameterInfo info in ctorParams)
        {
            ctorArgs.Add((info.Name, info.ParameterType));
        }

        return ctorArgs;
    }

    private static IList<(string, object)> GetObjectPropertiesAndValues(object obj)
    {
        List<(string, object)> props = new List<(string, object)>();

        PropertyInfo[] propInfo = obj.GetType().GetProperties();
        foreach (PropertyInfo info in propInfo)
        {
            string name = info.Name;
            object val = info.GetValue(obj);

            props.Add((name, val));
        }

        return props;
    }
}

I'll have to look at this later to see how it can be improved on. For the time being however, it does its job.

I would appreciate any comments or input if you have any. I will keep updating this post until I find an absolute solution.

Answer 1

So I worked out a solution that seems to achieve my original goal.

The reason it was difficult to solve at first was due to the original Factory class having too many responsibilities. It had to map the properties and create a new object. Separating these made it easy to implement the Generic Factory suggested by this post:

https://web.archive.org/web/20140414013728/http://tranxcoder.wordpress.com/2008/07/11/a-generic-factory-in-c

I created a simple mapper that would automatically map Entity and DTO properties. The easier solution is to use an AutoMapper like grandaCoder suggested. My situation required otherwise so a custom mapper was the way to go. I also tried to minimize calls to System.Reflection so the performance wouldn't suffer too much.

The end result is a Factory that can convert between any Entity and DTO object, maps properties between them, and can instantiate an Entity class with no default / empty constructor.

I ended up making a lot more changes to the original post, so I uploaded the end result to github: https://github.com/MoMods/EntityDTOFactory

I am open to any additional ideas / criticisms on the final solution. This is my first time solving this kind of problem, so it's very likely there are some better ideas out there.

Thanks again for the help and suggestions!

Answer 2

I would not reinvent the wheel on this common scenario.

https://automapper.org/

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

OR

https://github.com/MapsterMapper/Mapster

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

.......

Learn how to use one of these frameworks.

Below is mapster..........."performance" numbers.......which is how I found it (someone told me to lookout for automapper performance)

Answer 3

The switch statement can be avoided using reflection:

    public AnimalDTO ToDTO( Animal src)
    {
        Type srcType = src.GetType();
        Type dtoType = Type.GetType(srcType.Name + "DTO");
        AnimalDTO dto = (AnimalDTO)Activator.CreateInstance(dtoType, new object[] { }); 
        foreach (PropertyInfo dtoProperty in dtoType.GetProperties()) {
            PropertyInfo srcProperty = srcType.GetProperty(dtoProperty.Name);
            if (srcProperty != null) {
                dtoProperty.SetValue(dto, srcProperty.GetValue(src));
            }
        }
        return dto;
    }

To get a FromDTO method, just reverse the roles of src and dto in ToDTO.