Help me with architectural question

Here is the simple snippet:

 public interface IRepository<T>
  {
    T Get(int id);
  }

  public class Repository<T> : IRepository<T>开发者_开发问答; where T : class 
  {
    private readonly IRepositoryContext _repositoryContext;
    private IObjectSet<T> _objectSet;

  public Repository(IRepositoryContext repositoryContext)
  {
    _repositoryContext = repositoryContext; 
    _objectSet = repositoryContext.GetObjectSet<T>();    
  }

   public virtual T Get(int id)
   {
       return ObjectSet.First(x=> x.Id == id) 
      // that wouldn't work because there is no guarantee that T entity has Id property
   }

Now, as you can see I can instantiate Repository for any entity object and use methods defined (although in the example we have only Get(). But I can't use any constrains in expressions, unless I create non-abstract classes for each entity of T based on IRepository<T> and then implement methods the way I want.

But what if I need to use a method like Get which implementation stays the same for probably all entities (every entity has an Id).

How to do that?

I thought, I could create an abstract entity in EF data model designer, mapped to nothing, and mark that as the base type for all other entities, but It's asking for a mapping i.e. table. I tried to go with a complex type instead - that wouldn't let me inherit from it.

So, show me please the most efficient way to achieve that

---

That's not really the repository's role to know whether there's an ID or not in your object.

Most repositories implement the Single method like this

public T Single( Expression<Func<T, bool>> predicate ) {
    return ObjectSet.Single<T>( predicate );
}

---

The best way to do what you're asking would probably be to build a custom expression. Something like this:

public Expression<Func<T, bool>> GetIdEqualsExpression(int id)
{
    var idProp = typeof(T).GetProperty("ID");
    var param = Expression.Parameter(typeof(T), "t");
    return Expression.Lambda<Func<T, bool>>(
        Expression.Equal(Expression.PropertyOrField(param, "ID"),
        Expression.Constant(id)), param);
}

public virtual T Get(int id)
{
   return ObjectSet.AsQueryable().Single(GetIdEqualsExpression(id));
}

That said, Bertrand makes a good point in stating that maybe it should be the responsibility of the calling code to provide the expression, so you don't risk runtime exceptions.

---

You can use an interface:

public interface IEntity { int Id { get; } }

then instead of "where T : class" you can do "where T : IEntity" and any object will have a retrievable Id.

---

If every entity has the Id property, you could create an interface which exposes the Id property make each entity implement the interface.

//Let's call the interface IIDInterface
public interface IIDInterface
{
    int Id { get; }
}

// Now, suppose one of your entity classes is called: EntityOne
public class EntityOne : IIDInterface            
{
    // .. class constructors etc.

    // the IIDInterface interface method implementation
    public int Id
    {
        get
        {
            // getter implementation goes here
        }
    }

    // .. other members of the class
}

Then you could cast to the interface in the implementation of Get and if the cast succeeds use the .Id property. The Get function becomes:

public virtual T Get(int id)
{
    if(T is IIDInterface)
       return ObjectSet.First(x => ((IIDInterface)x).Id == id) 
    return default(T);
}

EDIT

Another solution could be to use reflection and use the Id property of the T object if it has one. But doing that might be slower and I think the overhead is unnecessary unless you can't modify the entity objects to implement the IIDInterface interface (i.e. if you don't own them)