实体类调用泛型父类中的静态方法中执行CRUD——第二版

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;

namespace WebHub {
    public abstract class HubContext<DB, T>
        where DB : DbContext, new()
        where T : class {
        public static void Remove(object idOrObj) {
            using (var db = new DB()) {
                if (idOrObj.GetType() == typeof(T)) {
                    db.Set<T>().Remove(idOrObj as T);
                    db.SaveChanges();
                } else {
                    var t = db.Set<T>().Find(idOrObj);
                    db.Set<T>().Remove(t);
                    db.SaveChanges();
                }
            }
        }
        public static T Add(T t) {
            using (var db = new DB()) {
                db.Set<T>().Add(t);
                db.SaveChanges();
                return t;
            }
        }
        public static T Add(T t, Action failCallback) {
            using (var db = new DB()) {
                db.Set<T>().Add(t);
                try {
                    db.SaveChanges();
                } catch (Exception) {
                    failCallback();
                    return default(T);
                }
                return t;
            }
        }
        public static TR Execute<TR>(object id, Func<T, TR> func) {
            var props = typeof(T).GetProperties();
            using (var db = new DB()) {
                var t = db.Set<T>().Find(id);
                if (t == null) {
                    return default(TR);
                }//TODO:if no "ToList()" below, won't work.WHY?
                var oldValues = props.Select(p => p.GetValue(t, null) ?? string.Empty).ToList();
                TR r;
                try {
                    r = func(t);
                } catch {
                    return default(TR);
                }
                var newValues = props.Select(p => p.GetValue(t, null) ?? string.Empty).ToList();

                for (int i = 0; i < props.Count(); i++) {
                    if (newValues[i].GetHashCode() != oldValues[i].GetHashCode()) {
                        db.SaveChanges();
                    }
                }
                return r;
            }
        }

        public static int Execute(object id, Action<T> action) {
            var props = typeof(T).GetProperties();
            using (var db = new DB()) {
                var t = db.Set<T>().Find(id);
                if (t == null) {
                    return 0;
                }
                var oldValues = props.Select(p => p.GetValue(t, null) ?? string.Empty).ToList();
                try {
                    action(t);
                } catch {
                    return 0;
                }
                var newValues = props.Select(p => p.GetValue(t, null) ?? string.Empty).ToList();
                for (int i = 0; i < props.Count(); i++) {
                    if (newValues[i].GetHashCode() != oldValues[i].GetHashCode()) {
                        var r = db.SaveChanges();
                        return r;
                    }
                }
                return 0;
            }
        }
        public static T First() {
            using (var db = new DB()) {
                var r = db.Set<T>().FirstOrDefault();
                return r;
            }
        }
        public static T First(object id) {
            using (var db = new DB()) {
                return db.Set<T>().Find(id);
            }
        }
        public static T First(Func<T, bool> predicate) {
            using (var db = new DB()) {
                var r = db.Set<T>().FirstOrDefault(predicate);
                return r;
            }
        }
        public static T First<P>(Func<T, bool> predicate, Func<T, P> orderby) {
            var r = First(predicate, orderby, false);
            return r;
        }
        public static T First<P>(Func<T, bool> predicate, Func<T, P> orderby, bool desc) {
            using (var db = new DB()) {
                T r;
                if (desc) {
                    r = db.Set<T>().Where(predicate).OrderByDescending(orderby).FirstOrDefault();
                } else {
                    r = db.Set<T>().Where(predicate).OrderBy(orderby).FirstOrDefault();
                }
                return r;
            }
        }
        public static int Count() {
            using (var db = new DB()) {
                return db.Set<T>().Count();
            }
        }
        public static int Count(Func<T, bool> prediacate) {
            using (var db = new DB()) {
                return db.Set<T>().Count(prediacate);
            }
        }
        public static IEnumerable<T> All() {
            using (var db = new DB()) {
                var r = db.Set<T>().ToList();
                return r;
            }
        }
        public static bool Exists(object id) {
            using (var db = new DB()) {
                var r = db.Set<T>().Find(id);
                return r != null;
            }
        }
        public static bool Exists(Func<T, bool> where) {
            using (var db = new DB()) {
                var r = db.Set<T>().Any(where);
                return r;
            }
        }
        public static IEnumerable<T> Find(Func<T, bool> where) {
            using (var db = new DB()) {
                var rr = db.Set<T>().Where(where).ToList();
                return rr;
            }
        }
        public static IEnumerable<T> Find<P>(Func<T, bool> where, Func<T, P> orderby) {
            using (var db = new DB()) {
                var r = db.Set<T>().Where(where).OrderBy(orderby).ToList();
                return r;
            }
        }
        public static IEnumerable<T> Find(Func<T, bool> where, int skip, int take) {
            using (var db = new DB()) {
                return db.Set<T>().Where(where).Skip(skip).Take(take).ToList();
            }
        }
        public static IEnumerable<T> Find(Func<T, bool> where, int skip, int take, out int all) {
            using (var db = new DB()) {
                all = db.Set<T>().Count(where);
                return db.Set<T>().Where(where).Skip(skip).Take(take).ToList();
            }
        }
        public static IEnumerable<T> Find<P>(Func<T, bool> where, Func<T, P> orderby, int skip, int take) {
            using (var db = new DB()) {
                var r = db.Set<T>().Where(where).OrderBy(orderby).Skip(skip).Take(take).ToList();
                return r;
            }
        }
        public static IEnumerable<T> Find<P>(Func<T, bool> where, Func<T, P> orderby, int skip, int take, out int all) {
            using (var db = new DB()) {
                all = db.Set<T>().Count(where);
                var r = db.Set<T>().Where(where).OrderBy(orderby).Skip(skip).Take(take).ToList();
                return r;
            }
        }
        public static IEnumerable<T> Find<P>(Func<T, bool> where, Func<T, P> orderby, DataPager p) {
            using (var db = new DB()) {
                p.Total = db.Set<T>().Count(where);
                var r = db.Set<T>().Where(where).OrderBy(orderby).Skip(p.Current * p.Size).Take(p.Size).ToList();
                return r;
            }
        }
    }
}