La manière la plus propre de mapper l'entité à DTO avec Linq Select?

J'ai essayé de venir avec un chiffon propre et réutilisable pour cartographier les entités de leur Otd. Voici un exemple de ce que je suis venu et où je suis bloqué.

Entités

public class Person
{
    public int ID { get; set; }
    public string Name { get; set; }
    public Address Address { get; set; }
    //Other properties not included in DTO
}

public class Address
{
    public int ID { get; set; }
    public string City { get; set; }
    //Other properties not included in DTO
}

Otd

public class PersonDTO
{
    public int ID { get; set; }
    public string Name { get; set; }
    public AddressDTO Address { get; set; }
}

public class AddressDTO
{
    public int ID { get; set; }
    public string City { get; set; }
}

Expressions

C'est ainsi que j'ai commencé à gérer la cartographie. Je voulais une solution qui ne serait pas l'exécution de la requête avant de la cartographie. J'ai été dit que si vous passez une Func<in, out> au lieu de Expression<Func<in, out>> qu'il va exécuter la requête avant de la cartographie.

public static Expressions
{
    public static Expression<Func<Person, PersonDTO>> = (person) => new PersonDTO()
    {
        ID = person.ID,
        Name = person.Name,
        Address = new AddressDTO()
        {
            ID = person.Address.ID,
            City = person.Address.City
        }
    }
}

Un problème, c'est que j'ai déjà une expression qui associe un Address à un AddressDTO j'ai donc le code dupliqué. Cela permettra également de se briser si person.Address est null. Cela devient malpropre très rapide surtout si je veux afficher les autres entités liées à la personne dans cette même DTO. Il devient un nid des oiseaux de imbriqués les mappages.

J'ai essayé ce qui suit, mais Linq ne sais pas comment le gérer.

public static Expressions
{
    public static Expression<Func<Person, PersonDTO>> = (person) => new PersonDTO()
    {
        ID = person.ID,
        Name = person.Name,
        Address = Convert(person.Address)
    }

    public static AddressDTO Convert(Address source)
    {
        if (source == null) return null;
        return new AddressDTO()
        {
            ID = source.ID,
            City = source.City
        }
    }
}

Existe-il des solutions élégantes que je suis absent?

source d'informationauteur Jeff

  1. 5

    Suffit d'utiliser AutoMapper.

    Exemple:

    Mapper.CreateMap<Address, AddressDTO>();
Mapper.CreateMap<Person, PersonDTO>();

    Votre requête s'exécute lors de la cartographie est effectuée mais, si il ya des champs de l'entité que vous n'êtes pas intéressé utiliser Project().To<> qui est disponible à la fois pour NHibernate et EntityFramework. Il va effectivement faire un select sur les champs spécifiés dans la configuration des correspondances.

  2. 6

    Si vous voulez créer des mappages manuellement, puis vous pouvez utiliser Select sur la collection de la manière suivante:

    Des données de test:

        var persons = new List<Person>
    {
        new Person() {ID = 1, Name = "name1", Address = new Address() {ID = 1, City = "city1"}},
        new Person() {ID = 2, Name = "name2", Address = new Address() {ID = 2, City = "city2"}},
        new Person() {ID = 3, Name = "name3", Address = new Address() {ID = 1, City = "city1"}}
    };

    Méthodes de cartographie:

        public static PersonDTO ToPersonDTOMap(Person person)
    {
        return new PersonDTO()
        {
            ID = person.ID,
            Name = person.Name,
            Address = ToAddressDTOMap(person.Address)
        };
    }

    public static AddressDTO ToAddressDTOMap(Address address)
    {
        return new AddressDTO()
        {
            ID = address.ID,
            City = address.City
        };
    }

    De l'utilisation réelle:

    var personsDTO = persons.Select(x => ToPersonDTOMap(x)).ToList();

    Gardez à l'esprit que si c'était une vraie requête ne serait pas exécuté tant qu'il était IQueryable, il serait exécuté une fois que vous le concrétiser (à l'aide de ToList() par exemple).

    Cependant, je suis d'envisager d'utiliser un cadre de travail qui pourrait le faire (le mapping) pour vous automatiquement (si votre cartographie sont aussi simples que l'exemple fourni par(.

  3. 1

    Vous pouvez soit utiliser AutoMapper ou écrire des méthodes d'extension comme celles-ci:

    public static class PersonMapper
{
    public static PersonDTO ConvertToDTO(this Person person)
    {
        return new PersonDTO { ID = person.ID, Name = person.Name, Address = person.Address.ConvertToDTO() };
    }

    public static IEnumerable<PersonDTO> ConvertToDTO(this IEnumerable<Person> people)
    {
        return people.Select(person => person.ConvertToDTO());
    }
}

public static class AddressMapper
{
    public static AddressDTO ConvertToDTO(this Address address)
    {
        return new AddressDTO { ID = address.ID, City = address.City };
    }

    public static IEnumerable<AddressDTO> ConvertToDTO(this IEnumerable<Address> addresses)
    {
        return addresses.Select(address => address.ConvertToDTO());
    }
}

    Vous pouvez mapper un Person objet d'un PersonDTO objet comme ceci:

    public class Program
{
    static void Main(string[] args)
    {
        Person person = new Person { ID = 1, Name = "John", Address = new Address { ID = 1, City = "New Jersey" } };
        PersonDTO personDTO = person.ConvertToDTO();
        Console.WriteLine(personDTO.Name);
    }
}