C# Linq-to-SQL: Refectoring this Generic GetByID method

Answer 1

What if you rework this to use GetTable().Where(...), and put your filtering there?

That would be more efficient, since the Where extension method should take care of your filtering better than fetching the entire table into a list.

Answer 2

Some thoughts...

Just remove the ToList() call, SingleOrDefault works with an IEnumerably which I presume table is.

Cache the call to e.GetType().GetProperties().First() to get the PropertyInfo returned.

Cant you just add a constraint to T that would force them to implement an interface that exposes the Id property?

Answer 3

Maybe executing a query might be a good idea.

public static T GetByID(int id)
    {
        Type type = typeof(T);
        //get table name
        var att = type.GetCustomAttributes(typeof(TableAttribute), false).FirstOrDefault();
        string tablename = att == null ? "" : ((TableAttribute)att).Name;
        //make a query
        if (string.IsNullOrEmpty(tablename))
            return null;
        else
        {
            string query = string.Format("Select * from {0} where {1} = {2}", new object[] { tablename, "ID", id });

            //and execute
            return dbcontext.ExecuteQuery<T>(query).FirstOrDefault();
        }
    }

Answer 4

I have brought great shame upon myself. I should've tested an actual run instead of just posting code willy-nilly.

Answer 5

What you need is to build an expression tree that LinqToSQL can understand. Assuming your "id" property is always named "id":

public virtual T GetById<T>(short id)
        {
            var itemParameter = Expression.Parameter(typeof(T), "item");
            var whereExpression = Expression.Lambda<Func<T, bool>>
                (
                Expression.Equal(
                    Expression.Property(
                        itemParameter,
                        "id"
                        ),
                    Expression.Constant(id)
                    ),
                new[] { itemParameter }
                );
            var table = DB.GetTable<T>();
            return table.Where(whereExpression).Single();
        }

This should do the trick. It was shamelessly borrowed from this blog. This is basically what LinqToSQL does when you write a query like

var Q = from t in Context.GetTable<T)()
        where t.id == id
        select t;

You just do the work for LTS because the compiler cannot create that for you, since nothing can tell enforce that T has an "id" property, and you cannot map an arbitrary "id" property from an interface to the database.

==== UPDATE ====

OK, here's a simple implementation for finding the PK name, assuming there is only one (not a composite PK), and assuming all is well type-wise (that is, your pK is compatible with the "short" type you use in the GetById function):

public virtual T GetById<T>(short id)
            {
                var itemParameter = Expression.Parameter(typeof(T), "item");
                var whereExpression = Expression.Lambda<Func<T, bool>>
                    (
                    Expression.Equal(
                        Expression.Property(
                            itemParameter,
                            GetPrimaryKeyName<T>()
                            ),
                        Expression.Constant(id)
                        ),
                    new[] { itemParameter }
                    );
                var table = DB.GetTable<T>();
                return table.Where(whereExpression).Single();
            }


    public string GetPrimaryKeyName<T>()
            {
                var type = Mapping.GetMetaType(typeof(T));

                var PK = (from m in type.DataMembers
                          where m.IsPrimaryKey
                          select m).Single();
                return PK.Name;
            }

Answer 6

System.NotSupportedException: The member 'MusicRepo_DataContext.IHasID.ID' has no supported translation to SQL.

Hi, the simple workaround to your initial problem is to specify an Expression. See below, works like a charm for me.

public interface IHasID
{
    int ID { get; set; }
}
DataContext [View Code]:

namespace MusicRepo_DataContext
{
    partial class Artist : IHasID
    {
        [Column(Name = "ArtistID", Expression = "ArtistID")]
        public int ID
        {
            get { return ArtistID; }
            set { throw new System.NotImplementedException(); }
        }
    }
}

Cheers, Dan