实体类调用泛型父类中的静态方法中执行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 = ; 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 ;
                 }
                 var oldValues = props.Select(p => p.GetValue(t, null) ?? string.Empty).ToList();
                 try {
                     action(t);
                 } catch {
                     return ;
                 }
                 var newValues = props.Select(p => p.GetValue(t, null) ?? string.Empty).ToList();
                 for (int i = ; i < props.Count(); i++) {
                     if (newValues[i].GetHashCode() != oldValues[i].GetHashCode()) {
                         var r = db.SaveChanges();
                         return r;
                     }
                 }
                 return ;
             }
         }
         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;
             }
         }
     }
 }