Question

I’m writing a simple movie database which has a three tier stack of service layer, data access layer and SQL DB.

I’m using LINQ to SQL to access the DB and return a Film from the Film table in the DB. This will then be returned as a Film object from the DataContracts in the service layer.

I thought this would work ok, but its resulted in some awkward code which doesn’t look right. Can someone sanity check this please?

Is it best practice to map every LINQ result to it’s DataContract?

public static class DBConnection
{
    private static RMDB_LINQDataContext _db;

    static DBConnection()
    {
        _db = new RMDB_LINQDataContext();
    }


    public static RMDB.DTO.Film GetFilm(string name)
    {
        var LINQ_film = from film in _db.GetTable<Film>()
                        where film.name == name
                        select film;

        if (LINQ_film.ToList().Count != 1)
        {
            // TODO - faultException
        }
        else
        {
            foreach (Film f in LINQ_film.ToList())
            {
                // Yuck
                return new RMDB.DTO.Film(f.name, 
                    f.releaseDate.GetValueOrDefault(), "foo", f.rating.GetValueOrDefault());
            }
        }

        return null;
    }

Answer 1

this is a bit neater and more efficient as your formulation performs the query twice

    public static List<Film> GetFilm(string name)
    {
        var LINQ_film = from film in _db.GetTable<Film>()
                        where film.name == name
                        select new Film(film.name,
                                        film.releaseDate.GetValueOrDefault(), 
                                        "foo", 
                                        film.rating.GetValueOrDefault());

        var list = LINQ_film.ToList();
        if (list.Count != 1)
        {
            // TODO - faultException
        }

        return list;
    }

Copying one instance of a type to another is standard practice when mapping from a domain object to a DTO. It may seem like a lot more work but it is a purely memory based mapping and provides a layer of isolation between your business layer and your clients. Without it clients will be impacted by refactoring of the business layer