DTO to specific object conversion pattern

Question

The architecture: Win8 app + local Web API Self-Host share a common "Contracts" project.

The Web API returns very general contract types (IEnumerable etc.).

Within the Win8 app I want to convert these contracts to concrete MVVM compatible model objects which use ObservableCollection for example instead of IEnumerables.

I would have loved to use AutoMapper for this task but it is not compatible with the WinRT.

Answer 1

Thank you for your suggestions.

I solved it in a non-generic fashion, for every model I do have a specific converter that does the job. What do you think?

using Project.Contracts;
using Project.Models;

namespace Project.Converters.Contracts
{
    public static class ProductConverter
    {
        public static ProductContract ToContract(this Product model)
        {
            if (model == null)
            {
                return new ProductContract();
            }

            return new ProductContract
            {
                Id = model.Id,
                Name = mode.Name,
                Tags = model.Tags.ToContracts()
            };
        }

        public static ICollection<ProductContract> ToContracts(this IEnumerable<Product> models)
        {
            if (models == null)
            {
                return new Collection<ProductContract>();
            }

            return models.Select(m => m.ToContract()).ToList();
        }

        public static Product ToModel(this ProductContract contract)
        {
            if (contract == null)
            {
                return new Product();
            }

            return new Product
            {
                Id = contract.Id,
                Name = contract.Name,
                Tags = contract.Tags.ToModels()
            };
        }

        public static ObservableCollection<Product> ToModels(this IEnumerable<ProductContract> contracts)
        {
            if (contracts == null)
            {
                return new ObservableCollection<Product>();
            }

            return new ObservableCollection<Product>(contracts.Select(c => c.ToModel()));
        }
    }
}