InMemoryDbSet - Actually implements the "Find" Method

InMemoryDbSet

    public class InMemoryDbSet<T> : IDbSet<T> where T : class
    {
        private readonly HashSet<T> _set;
        private readonly IQueryable<T> _queryableSet;

        public Expression Expression
        {
            get { return _queryableSet.Expression; }
        }

        public Type ElementType
        {
            get { return _queryableSet.ElementType; }
        }

        public IQueryProvider Provider
        {
            get { return _queryableSet.Provider; }
        }

        public ObservableCollection<T> Local
        {
            get { return new ObservableCollection<T>(_queryableSet); }
        }

        public InMemoryDbSet()
            : this(Enumerable.Empty<T>())
        {

        }

        private InMemoryDbSet(IEnumerable<T> entities)
        {
            _set = new HashSet<T>();

            entities.ToList().ForEach(p => _set.Add(p));

            _queryableSet = _set.AsQueryable();
        }

        public T Create()
        {
            throw new NotImplementedException();
        }

        public T Add(T entity)
        {
            _set.Add(entity);
            return entity;
        }

        public T Attach(T entity)
        {
            _set.Add(entity);
            return entity;
        }

        public T Remove(T entity)
        {
            _set.Remove(entity);
            return entity;
        }

        public T Find(params object[] keyValues)
        {
            if (keyValues.Length != 1)
                throw new Exception("not implemented");

            var type = typeof(T);
            var prop = type.GetProperty(type.Name + "Id");
            var getter = prop.GetGetMethod();

            var keyType = keyValues[0].GetType();
            if (getter.ReturnType != keyType)
                throw new Exception("mismatch keytype");
            if (getter.ReturnType == typeof(Int32))
                return this.FirstOrDefault(t => (int)getter.Invoke(t, null) == (int)keyValues[0]);
            else if (getter.ReturnType == typeof(Guid))
                return this.FirstOrDefault(t => (Guid)getter.Invoke(t, null) == (Guid)keyValues[0]);
            else
                throw new Exception("unknown keytype");
            
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _queryableSet.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public TDerivedEntity Create<TDerivedEntity>() where TDerivedEntity : class, T
        {
            throw new NotImplementedException();
        }
        
    }