O景逸SUVM框架 EF – code first 的包装

五 、里面分别封装了
扩张、删除、修改、查询多样基础的操作,并且各个操作都说不上海南大学学量的重载(尤其是询问)便于适应越多不断变化项目;还有局地是便捷的操作,IsExist
那里间接回到数据是或不是留存。

BeanUtils工具类
行使BeanUitls公共,给类中的成员变量注入(赋)值

Code first 是Microsoft Entity
Framework中的一种方式,CodeFirst不会有可视化的界面来开始展览拖动编辑DataBase-Entity,但会以2个类来展开对数据表关系的叙述,以及对具有实体类的叙说,优势在于,代码特别黄参简,文件目录越发分明,也越来越有利维护。

<!–
schema约束文书档案的利用
1.每贰个schema约束文书档案,都必须有1个命名空间(namespace)
起名要求:环球唯一
应用域名(网址)命名:http://www.itcast.cn/web01/01
bean-schema.xsd文档的中命名空间
targetNamespace=”http://www.itcast.cn/bean
2.在xml文档中声称命名空间
暗许表明:
xmlns=”http://www.itcast.cn/bean
<bean></bean>
展现注解:
xmlns:my=”http://www.itcast.cn/bean
<my:bean></my:bean>
3.评释schema约束文书档案的岗位
先评释官方文书档案的职位
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance
依据官方文书档案评释自定义schema文书档案的岗位
xsi:schemaLocation=”http://www.itcast.cn/bean bean-schema.xsd”
http://www.itcast.cn/bean:命名空间
bean-schema.xsd:schema文书档案的职位
–>

此地说美赞臣下:

  1. Document对象
    a) Element e = getRootElement() 获得根成分
  2. Element对象
    a) Element [] eleArr = elements(…)
    获得钦点名称的具有子成分。能够不内定名称
    b) element(…) 得到内定名称第三个子元素。能够不内定名称
    c) getName() 获得当前元素的要素名
    d) attributeValue(…) 获得内定属性名的属性值
    e) elementText(…) 得到钦定名称子成分的文本值
    f) getText() 获得当前成分的文书内容
    操作步骤:
    1.创制dom4j宗旨对象SAXReader
    2.运用SAXReader中read方法读取xml文书档案,生成Document对象
    3.选择Document中方法getRootElement获取根成分Element
    4.应用Element中的方法elements获取具有bean元素
    5.遍历包括bean成分的成团,获取每1个bean成分
    6.行使Element中的方法attributeValue获取bean成分上品质的值
    7.用到Element中的方法elements获取具有property成分
    8.遍历蕴涵property元素的集结,获取每贰个property成分
    9.运用Element中的方法attributeValue获取property成分上质量的值
    10.接纳Element中的方法getText获取获取property成分上文本值

    1 public class UseDom4jParseXML {
    2 public static void main(String[] args) throws Exception {
    3 //1.成立dom4j大旨对象SAXReader
    4 SAXReader sax = new SAX里德r();
    5 //2.使用SAXReader中read方法读取xml文书档案,生成Document对象
    6 Document docu = sax.read(“bean.xml”);
    7 //3.使用Document中艺术getRootElement获取根成分Element
    8 Element rootElement = docu.getRootElement();
    9 //4.使用Element中的方法elements获取具有bean元素 10 List beanElementList = rootElement.elements();
    11 //5.遍历包罗bean成分的成团,获取每多个bean元素 12 for (Element beanElement : beanElementList) {
    13 String beanName = beanElement.getName();
    14 System.out.println(beanName);
    15 //6.使用Element中的方法attributeValue获取bean成分上品质的值
    16 String idValue = beanElement.attributeValue(“id”);
    17 System.out.println(“\tbean成分的属性id:”+idValue);
    18 String classNameValue = beanElement.attributeValue(“className”);
    19 System.out.println(“\tbean成分的属性className:”+classNameValue);
    20 //7.使用Element中的方法elements获取具有property元素 21 List propertyElementList = beanElement.elements();
    22 //8.遍历包涵property元素的成团,获取每三个property成分 23 for (Element propertyElement : propertyElementList) {
    24 System.out.println(“\t\t”+propertyElement.getName());
    25 //9.使用Element中的方法attributeValue获取property成分上性能的值
    26 String nameValue = propertyElement.attributeValue(“name”);
    27 System.out.println(“\t\t\tproperty成分的属性name:”+nameValue);
    28 String valueValue = propertyElement.attributeValue(“value”);
    29 System.out.println(“\t\t\tproperty成分的质量value:”+valueValue);
    30 //10.使用Element中的方法getText获取获取property成分上文本值
    31 String text = propertyElement.getText();
    32 System.out.println(“\t\t\tproperty成分的公文:”+text);
    33 }
    34 }
    35 }
    36 }

 

<!–
动用dtd约束文书档案的手续:
1.每种dtd约束文书档案中都会有一行代码以<!DOCTYPE开端,复制过来放在xml文档中
a.!DOCTYPE:固定的dtd约束文书档案的格式
b.beans:规定xml文书档案中的根成分只好叫beans
c.SYSTEM:系统,dtd约束文档来源本地的操作系统
d.”bean.dtd”:约束文书档案的职分,我们采用的自律文书档案在方今文件夹下,能够使用”bean.dtd”
2.依据根成分的名字,写出根成分
3.鼠标放在根成分上/恐怕按f2,依照提示写出xml文档
?:代表成分只好出现0次照旧1回
+:代表成分能冒出二遍要么二遍上述
*:代表成分能出现0次,1遍照旧三回上述(任意次数)
():一组数据
|:采用涉及,只可以在七个要素之间接选举用二个
,顺序关系 规定:a,b,c 写xml文书档案只好依据a,b,c顺序编写
–>

直白用实体关系类进行操作,最终SaveChanges,无可厚非,当然能够了,可是,对于叁个追求越发方便,越发空虚的程序员来说,无限的包裹就像是是一种追求吧,废话不多说,那里向来上EF_Helper_DG的代码->

.<!–
需求:
把以下内容以文件的花样展现出来,可以运用转义字符
<bean id=”abc”>
<property name=”haha” value=”123″></property>
<property name=”haha” value=”123″></property>
<property name=”haha” value=”123″></property>
</bean>
能够动用CDATA区完毕
CDATA区:里边的剧情都会以文件的不二法门展现出来
格式:
<![CDATA[
私自的剧情(都以文本)
]]>
–>

4、Log_DG 那里直接封装了EF操作的错误音讯,一般在try
catch中调用,对错误举行日志的叙述,便于后续的谬误查找。

<!–
1.每个schema文书档案都会有2个根成分的初阶标签<beans…>,把开首标签复制过来,添加3个得了标签
2.鼠标放在根成分上/f2,根据提醒写出xml文书档案
–>

具体内容,参考类详情吧,后续更新修改,敬请期待! –柒小
二〇一五年7月21五日22:34:01

使用dom4j解析xml文档
* 1.SAXReader对象(dom4j核心类)
a) read(…) 加载执行xml文书档案

 1 namespace QX_Frame.DAL.Service
 2 {
 3     using System.Data.Entity;
 4     using QX_Frame.Model;
 5 
 6     public partial class DBEntity_DG : DbContext
 7     {
 8         public DBEntity_DG()
 9             : base("name=DBEntity_DG")
10         {
11         }
12 
13         public virtual DbSet<tb_Class> tb_Class { get; set; }
14         public virtual DbSet<tb_User> tb_User { get; set; }
15 
16         protected override void OnModelCreating(DbModelBuilder modelBuilder)
17         {
18             modelBuilder.Entity<tb_Class>()
19                 .Property(e => e.Name)
20                 .IsFixedLength();
21 
22             modelBuilder.Entity<tb_Class>()
23                 .HasMany(e => e.tb_User)
24                 .WithRequired(e => e.tb_Class)
25                 .HasForeignKey(e => e.ClassId)
26                 .WillCascadeOnDelete(false);
27 
28             modelBuilder.Entity<tb_User>()
29                 .Property(e => e.Name)
30                 .IsFixedLength();
31         }
32     }
33 }

<!–
xml转义字符:能够把一部分有所独特意义的字符,使用转义字符表示出来
< <
> >
” "
‘ '
& &
供给:1<3 == 5>7 在xml中的写法
–>

⑦ 、恰到十二分的out
输出参数,有限支撑了在必要插入并且要求插入的结果必要的选用。

 

捌 、查询的分页协理,不必再写繁琐的分页,那里一度对分页实行了支撑。

 1 public class Demo01BeanUtils {
 2     @Test
 3     public void demo03() throws Exception{
 4         /*
 5          * BeanUitls中的方法populate给成员变量一起注入多个值
 6          * populate(Object bean, Map<String,String[]> properties)       
 7          *         将Map数据封装到指定Javabean中,一般用于将表单的所有数据封装到javabean
 8          *         相当于遍历Map集合,根据Map集合的key(属性名),依次使用Map集合value,给成员变量注入值
 9          * 
10          *     参数:
11          *         Object bean:要赋值的JavaBean对象
12          *         Map<String,String[]> properties:Map集合
13          *             key:String,成员变量的名字(属性名)
14          *             value:String[],字符串类型的数组
15          *                 如果成员变量是一个数组,那么就会把value数组的所有值赋值给成员变量
16          *                 如果成员变量不是一个数组,那么就会使用value数组的第一个值,赋值给成员变量
17          * 数组创建的方式:
18          *     动态初始化:
19          *         String[] arr = new String[数组的长度];
20          *     静态初始化:
21          *         String[] arr = new String[]{元素值1,元素值2,...};
22          *         String[] arr = {元素值1,元素值2,...}; 数组的定义和赋值必须写在一行
23          */
24         //创建JavaBean对象
25         User u = new User();
26         //创建Map集合,key是String类型,value是String类型的数组
27         Map<String,String[]> properties = new HashMap<String,String[]>();
28         properties.put("id", new String[]{"123","456"});
29         properties.put("username", new String[]{"root","admin"});
30         properties.put("password", new String[]{"root","123456"});
31         properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
32         //使用BeanUtils中的populate给多个成员变量注入多个值
33         BeanUtils.populate(u, properties);
34         
35         System.out.println(u);
36     }
37     
38     @Test
39     public void demo02() throws Exception{
40         /*
41          * static void setProperty(Object obj,String name,Object value)    设置属性值
42          *         相当于调用了JavaBean中的setXXX方法
43          * static String getProperty(Object obj,String name)    获得属性值
44          *         相当于调用了JavaBean中的getXXX方法
45          * 方法的参数:
46          *         Object obj:要赋值/获取值的JavaBean对象
47          *         String name:成员变量的名字(属性名)
48          *         Object value:给成员变量赋的实际使用的值
49          * 
50          * BeanUtils工具类可以操作的数据类型有:基本数据类型,基本数据类型的包装类,String类型,以上3种类型的一维数组
51          * 不管属性是什么数据类型,使用BeanUtils工具类都可以使用字符格式的数类型来赋值(内部会把字符串转换为基本类型,相当于使用了
52          * 包装类中的方法parseXXX())
53          */
54         //创建JavaBean对象
55         User u = new User();
56         //使用BeanUtils中的setProperty方法给成员变量注入值
57         BeanUtils.setProperty(u, "id", "123");
58         BeanUtils.setProperty(u, "username", "root");
59         BeanUtils.setProperty(u, "password", "root");
60         System.out.println(u);
61         
62         //使用BeanUtils中的getProperty方法获取属性值
63         String id = BeanUtils.getProperty(u, "id");
64         System.out.println(id);
65         String username = BeanUtils.getProperty(u, "username");
66         System.out.println(username);
67         System.out.println(BeanUtils.getProperty(u, "password"));
68     }
69     
70     @Test
71     public void demo01(){
72         //不使用工具类,给成员变量赋值/获取值
73         User u = new User();
74         u.setId(Integer.parseInt("123"));
75         u.setUsername("root");
76         u.setPassword("root");
77         
78         System.out.println(u.getId());
79         System.out.println(u.getUsername());
80         System.out.println(u.getPassword());
81     }
82 }

  1 /*
  2  * 创建MyBeanUtils工具类,增强populate方法
  3  */
  4 public class MyBeanUtils {
  5     //把构造方法私有,不让外界通过创建对象的方式调用方法
  6     private MyBeanUtils() {
  7     }
  8     
  9     /*
 10      * 定义一个方法(让用户使用自己定义的populate方法不用处理异常)
 11      *     1.参数传递JavaBean对象的Class文件对象
 12      *     2.内部通过反射创建Javabean对象
 13      *     3.调用BeanUtils工具类的方法populate
 14      *     4.对populate方法的异常进行try...catch处理
 15      *     5.把对象返回给用户
 16      *     6.把参数Class对象增加一个泛型,让用户传递什么类型的JavaBean,就返回什么类型的JavaBean
 17      * 
 18      * 定义含有泛型的方法:调用方法时确定数据类型
 19      *         修饰符 <定义泛型> 返回值类型 方法名(参数<使用泛型>){
 20      *             方法体
 21      *         }
 22      * 
 23      * 
 24      * 方法的参数:
 25      *         Class clazz
 26      *         Map<String,String[]> properties
 27      * 方法的返回值类型:
 28      *         Object
 29      */
 30     public static <E> E populate03(Class<E> clazz, Map<String,String[]> properties){
 31         try {
 32             //2.内部通过反射创建Javabean对象
 33             E obj = clazz.newInstance();
 34             //3.调用BeanUtils工具类的方法populate
 35             BeanUtils.populate(obj, properties);
 36             //5.把对象返回给用户
 37             return obj;
 38         } catch (Exception e) {
 39             //4.对populate方法的异常进行try...catch处理
 40             e.printStackTrace();
 41             //把编译异常,转换为运行时异常,给成员变量注入值失败,让程序停止下来
 42             throw new RuntimeException("注入值失败");
 43         }
 44     }
 45     
 46     /*
 47      * 定义一个方法(让用户使用自己定义的populate方法不用处理异常)
 48      *     1.参数传递JavaBean对象的Class文件对象
 49      *     2.内部通过反射创建Javabean对象
 50      *     3.调用BeanUtils工具类的方法populate
 51      *     4.对populate方法的异常进行try...catch处理
 52      *     5.把对象返回给用户
 53      * 
 54      * 方法的参数:
 55      *         Class clazz
 56      *         Map<String,String[]> properties
 57      * 方法的返回值类型:
 58      *         Object
 59      */
 60     public static Object populate02(Class clazz, Map<String,String[]> properties){
 61         try {
 62             //2.内部通过反射创建Javabean对象
 63             Object obj = clazz.newInstance();
 64             //3.调用BeanUtils工具类的方法populate
 65             BeanUtils.populate(obj, properties);
 66             //5.把对象返回给用户
 67             return obj;
 68         } catch (Exception e) {
 69             //4.对populate方法的异常进行try...catch处理
 70             e.printStackTrace();
 71             //把编译异常,转换为运行时异常,给成员变量注入值失败,让程序停止下来
 72             throw new RuntimeException("注入值失败");
 73         }
 74         
 75     }
 76     
 77     /*
 78      * 定义一个方法(让用户使用自己定义的populate方法不用处理异常)
 79      *     1.调用BeanUtils工具类的方法populate
 80      *     2.对populate方法的异常进行try...catch处理
 81      * 
 82      * 方法的参数:
 83      *         Object bean
 84      *         Map<String,String[]> properties
 85      * 方法的返回值类型:
 86      *         void
 87      */
 88     public static void populate01(Object bean, Map<String,String[]> properties){
 89         try {
 90             //1.调用BeanUtils工具类的方法populate
 91             BeanUtils.populate(bean, properties);
 92         } catch (Exception e) {
 93             //2.对populate方法的异常进行try...catch处理
 94             e.printStackTrace();
 95             //把编译异常,转换为运行时异常,给成员变量注入值失败,让程序停止下来
 96             throw new RuntimeException("注入值失败");
 97         } 
 98     }
 99 }
100 package cn.itcast.dmeo03.MyBeanUtils;
101 
102 import java.util.HashMap;
103 import java.util.Map;
104 
105 import org.junit.Test;
106 
107 import cn.itcast.dmeo01.bean.User;
108 
109 /*
110  * 使用自定义工具类MyBeanUtils
111  */
112 public class UseMyBeanUtils {
113     @Test
114     public void demo03(){
115         //创建Map集合,key是String类型,value是String类型的数组
116         Map<String,String[]> properties = new HashMap<String,String[]>();
117         properties.put("id", new String[]{"123"});
118         properties.put("username", new String[]{"root","admin"});
119         properties.put("password", new String[]{"root","123456"});
120         properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
121         //调用MyBeanUtils工具类中的方法populate02
122         User u = MyBeanUtils.populate03(User.class, properties);
123         System.out.println(u);
124     }
125     
126     @Test
127     public void demo02(){
128         //创建Map集合,key是String类型,value是String类型的数组
129         Map<String,String[]> properties = new HashMap<String,String[]>();
130         properties.put("id", new String[]{"123"});
131         properties.put("username", new String[]{"root","admin"});
132         properties.put("password", new String[]{"root","123456"});
133         properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
134         //调用MyBeanUtils工具类中的方法populate02
135         User u = (User) MyBeanUtils.populate02(User.class, properties);
136         System.out.println(u);
137     }
138     
139     @Test
140     public void demo01(){
141         //创建JavaBean对象
142         User u = new User();
143         //创建Map集合,key是String类型,value是String类型的数组
144         Map<String,String[]> properties = new HashMap<String,String[]>();
145         properties.put("id", new String[]{"123"});
146         properties.put("username", new String[]{"root","admin"});
147         properties.put("password", new String[]{"root","123456"});
148         properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
149         //调用MyBeanUtils工具类中的方法populate01
150         MyBeanUtils.populate01(u, properties);
151         System.out.println(u);
152     }
153 }

 1 /*
 2  * 综合案例:XML+dom4j+反射+BeanUtils
 3  *     1.使用xml存储JavaBean的全类名和属性名属性值
 4  *     2.使用dom4j解析xml
 5  *     3.使用反射技术根据解析出的全类名创建JavaBean对象
 6  *     4.使用BeanUtils中的方法setProperty给成员变量注入值
 7  */
 8 public class UseDom4jparseXMLToJavaBean {
 9     public static void main(String[] args) throws Exception {
10         //2.使用dom4j解析xml
11         //获取dom4j的核心类SAXReader
12         SAXReader sax = new SAXReader();
13         //使用SAXReader中的read读取xml,创建Document对象
14         Document docu = sax.read("src/cn/itcast/dmeo05/domain/data.xml");
15         //使用Document中的方法getRootElement获取根元素
16         Element rootElement = docu.getRootElement();
17         //使用Element中的方法elements获取所有的bean元素,放入集合中
18         List<Element> beanElementList = rootElement.elements();
19         //遍历beanElementList集合
20         for (Element beanElement : beanElementList) {
21             //获取beanElement上的变的属性className
22             String className = beanElement.attributeValue("className");
23             //3.使用反射技术根据解析出的全类名创建JavaBean对象
24             Class clazz = Class.forName(className);
25             Object obj = clazz.newInstance();
26             //使用Element中的方法elements获取所有的property元素,放入集合中
27             List<Element> propertyElementList = beanElement.elements();
28             //遍历propertyElementList集合
29             for (Element propertyElement : propertyElementList) {
30                 //获取propertyElement上的属性name(属性名)和value(属性值)
31                 String name = propertyElement.attributeValue("name");
32                 String value = propertyElement.attributeValue("value");
33                 //4.使用BeanUtils中的方法setProperty给成员变量注入值
34                 BeanUtils.setProperty(obj, name, value);
35             }
36             //打印JavaBean对象
37             System.out.println(obj);
38         }
39     }
40 
41 }
  1 using LinqKit; //AsExpandable() in linqkit.dll
  2 using System;
  3 using System.Collections.Generic;
  4 using System.IO;
  5 using System.Linq;
  6 using System.Linq.Expressions;
  7 using System.Data.Entity;
  8 using QX_Frame.Helper_DG_Framework_4_6;
  9 
 10 namespace QX_Frame.DAL.Service
 11 {
 12     /*  time:2016-10-30 15:26:05
 13         author:qixiao
 14           */
 15 
 16     #region The EF_DBEntity_DG visual Interface
 17 
 18     public interface IEF_DBEntity_DG
 19     {
 20         Boolean IsAdd<T>(T entity);
 21         Boolean IsAdd<T>(T entity, out T outEntity);
 22         Boolean IsAdd<T>(List<T> entities);
 23 
 24         Boolean IsUpdate<T>(T entity);
 25         Boolean IsUpdate<T>(T entity, out T outEntity);
 26 
 27         Boolean IsDelete<T>(T entity);
 28         Boolean IsDelete<T>(List<T> entities);
 29         Boolean IsDelete<T>(Expression<Func<T, bool>> deleteWhere);
 30 
 31         T selectSingle<T>(Expression<Func<T, Boolean>> selectWhere);
 32 
 33         List<T> selectAll<T>();
 34         List<T> selectAll<T>(out int Count);
 35         List<T> selectAll<T>(Expression<Func<T, T>> orderBy, Boolean isDESC = false);
 36         List<T> selectAll<T>(Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
 37         List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere);
 38         List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, out int Count);
 39         List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, Boolean isDESC = false);
 40         List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
 41 
 42         List<T> selectAllPaging<T>(int pageIndex, int pageSize);
 43         List<T> selectAllPaging<T>(int pageIndex, int pageSize, out int Count);
 44         List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere);
 45         List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere, out int Count);
 46         List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, T>> orderBy, Boolean isDESC = false);
 47         List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
 48         List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, Boolean isDESC = false);
 49         List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
 50     }
 51 
 52     #endregion
 53 
 54     public abstract class EF_DBEntity_DG
 55     {
 56         /*the singleton DBEntity_DG */
 57         /// <summary>
 58         /// The DBEntity_DG is must be named: DBEntity_DG
 59         /// </summary>
 60         private volatile static DBEntity_DG db = null;
 61 
 62         #region The Singleton to new DBEntity_DG 
 63         private static readonly object lockHelper = new object();
 64         static EF_DBEntity_DG()
 65         {
 66             if (db == null)
 67             {
 68                 lock (lockHelper)
 69                 {
 70                     if (db == null)
 71                         db = new DBEntity_DG();
 72                 }
 73             }
 74             //close the Validate of EF OnSaveEnabled
 75             db.Configuration.ValidateOnSaveEnabled = false;
 76         }
 77         #endregion
 78 
 79         /// <summary>
 80         /// Give the Error Log support
 81         /// </summary>
 82         /// <param name="logText">LogText</param>
 83         /// <param name="isAppend">The Log Text isAppend or Cover</param>
 84         private static void Log_DG(string logText, string logTitle = "DBEntity_DG Error", Boolean isAppend = true)
 85         {
 86             string LogLocation_DG = @"Log_QX_Frame/Log_QX_Frame_Error/";
 87             try
 88             {
 89                 LogLocation_DG = Config_Helper_DG.AppSetting_Get("Log_Location_Error_DG");
 90             }
 91             catch (Exception)
 92             {
 93                 LogLocation_DG = @"Log_QX_Frame/Log_QX_Frame_Error/";
 94             }
 95             if (!Directory.Exists(LogLocation_DG))
 96             {
 97                 Directory.CreateDirectory(LogLocation_DG);
 98             }
 99             using (StreamWriter log = new StreamWriter(LogLocation_DG + "Log_" + DateTime.Now.Year + DateTime.Now.Month + DateTime.Now.Day + ".Log", isAppend))
100             {
101                 log.WriteLine();
102                 log.WriteLine(DateTime_Helper_DG.Get_DateTime_Now_24HourType() + "   -------" + logTitle + " Log !--------------------");
103                 log.WriteLine();
104                 log.WriteLine(logText);
105             }
106         }
107 
108         #region Add 
109 
110         public static Boolean IsAdd<T>(T entity) where T : class
111         {
112             try
113             {
114                 db.Entry<T>(entity).State = EntityState.Added;
115                 return db.SaveChanges() > 0;
116             }
117             catch (Exception ex)
118             {
119                 Log_DG(ex.ToString());
120                 return false;
121             }
122         }
123         public static Boolean IsAdd<T>(T entity, out T outEntity) where T : class
124         {
125             try
126             {
127                 db.Entry<T>(entity).State = EntityState.Added;
128                 outEntity = entity;
129                 return db.SaveChanges() > 0;
130             }
131             catch (Exception ex)
132             {
133                 Log_DG(ex.ToString());
134                 outEntity = default(T);
135                 return false;
136             }
137         }
138         public static Boolean IsAdd<T>(List<T> entities) where T : class
139         {
140             try
141             {
142                 db.Set<T>().AddRange(entities);
143                 return db.SaveChanges() > 0;
144             }
145             catch (Exception ex)
146             {
147                 Log_DG(ex.ToString());
148                 return false;
149             }
150         }
151 
152         #endregion
153 
154         #region Update
155 
156         public static Boolean IsUpdate<T>(T entity) where T : class
157         {
158             try
159             {
160                 if (db.Entry<T>(entity).State == EntityState.Detached)
161                 {
162                     db.Set<T>().Attach(entity);
163                     db.Entry<T>(entity).State = EntityState.Modified;
164                 }
165                 return db.SaveChanges() > 0;
166             }
167             catch (Exception ex)
168             {
169                 Log_DG(ex.ToString());
170                 return false;
171             }
172         }
173         public static Boolean IsUpdate<T>(T entity, out T outEntity) where T : class
174         {
175             try
176             {
177                 db.Set<T>().Attach(entity);
178                 db.Entry<T>(entity).State = EntityState.Modified;
179                 outEntity = entity;
180                 return db.SaveChanges() > 0;
181             }
182             catch (Exception ex)
183             {
184                 Log_DG(ex.ToString());
185                 outEntity = default(T);
186                 return false;
187             }
188         }
189 
190         #endregion
191 
192         #region Delete
193 
194         public static Boolean IsDelete<T>(T entity) where T : class
195         {
196             try
197             {
198                 db.Set<T>().Attach(entity);
199                 db.Entry<T>(entity).State = EntityState.Deleted;
200                 return db.SaveChanges() > 0;
201             }
202             catch (Exception ex)
203             {
204                 Log_DG(ex.ToString());
205                 return false;
206             }
207         }
208         public static Boolean IsDelete<T>(List<T> entities) where T : class
209         {
210             try
211             {
212                 db.Set<T>().RemoveRange(entities);
213                 return db.SaveChanges() > 0;
214             }
215             catch (Exception ex)
216             {
217                 Log_DG(ex.ToString());
218                 return false;
219             }
220         }
221         public static Boolean IsDelete<T>(Expression<Func<T, bool>> deleteWhere) where T : class
222         {
223             try
224             {
225                 List<T> entitys = db.Set<T>().AsExpandable().Where(deleteWhere).ToList();
226                 entitys.ForEach(m => db.Entry<T>(m).State = EntityState.Deleted);
227                 return db.SaveChanges() > 0;
228             }
229             catch (Exception ex)
230             {
231                 Log_DG(ex.ToString());
232                 return false;
233             }
234         }
235         #endregion
236 
237         #region Select 
238 
239         public static Boolean IsExist<T>(Expression<Func<T, Boolean>> selectWhere) where T : class
240         {
241             try
242             {
243                 return db.Set<T>().AsExpandable().Where(selectWhere).ToList().FirstOrDefault<T>() == null ? false : true;
244             }
245             catch (Exception ex)
246             {
247                 Log_DG(ex.ToString());
248                 return default(Boolean);
249             }
250         }
251         public static T selectSingle<T>(Expression<Func<T, Boolean>> selectWhere) where T : class
252         {
253             try
254             {
255                 return db.Set<T>().AsExpandable().Where(selectWhere).ToList().FirstOrDefault<T>();
256             }
257             catch (Exception ex)
258             {
259                 Log_DG(ex.ToString());
260                 return default(T);
261             }
262         }
263         public static List<T> selectAll<T>() where T : class
264         {
265             try
266             {
267                 return db.Set<T>().AsExpandable().ToList();
268             }
269             catch (Exception ex)
270             {
271                 Log_DG(ex.ToString());
272                 return default(List<T>);
273             }
274         }
275         public static List<T> selectAll<T>(out int Count) where T : class
276         {
277             try
278             {
279                 Count = db.Set<T>().AsExpandable().Count();
280                 return db.Set<T>().AsExpandable().ToList();
281             }
282             catch (Exception ex)
283             {
284                 Log_DG(ex.ToString());
285                 Count = 0;
286                 return default(List<T>);
287             }
288         }
289         public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, Boolean isDESC = false) where T : class
290         {
291             try
292             {
293                 if (isDESC)
294                     return db.Set<T>().AsExpandable().OrderByDescending(orderBy).ToList();
295                 else
296                     return db.Set<T>().AsExpandable().OrderBy(orderBy).ToList();
297             }
298             catch (Exception ex)
299             {
300                 Log_DG(ex.ToString());
301                 return default(List<T>);
302             }
303         }
304         public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, out int Count, Boolean isDESC = false) where T : class
305         {
306             try
307             {
308                 Count = db.Set<T>().AsExpandable().Count();
309                 if (isDESC)
310                     return db.Set<T>().AsExpandable().OrderByDescending(orderBy).ToList();
311                 else
312                     return db.Set<T>().AsExpandable().OrderBy(orderBy).ToList();
313             }
314             catch (Exception ex)
315             {
316                 Log_DG(ex.ToString());
317                 Count = 0;
318                 return default(List<T>);
319             }
320         }
321         public static List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere) where T : class
322         {
323             try
324             {
325                 return db.Set<T>().AsExpandable().Where(selectWhere).ToList();
326             }
327             catch (Exception ex)
328             {
329                 Log_DG(ex.ToString());
330                 return default(List<T>);
331             }
332         }
333         public static List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, out int Count) where T : class
334         {
335 
336             try
337             {
338                 var list = db.Set<T>().AsExpandable().Where(selectWhere);
339                 Count = list.Count();
340                 return list.ToList();
341             }
342             catch (Exception ex)
343             {
344                 Log_DG(ex.ToString());
345                 Count = 0;
346                 return default(List<T>);
347             }
348         }
349         public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, Boolean isDESC = false) where T : class
350         {
351             try
352             {
353                 if (isDESC)
354                     return db.Set<T>().AsExpandable().Where(selectWhere).OrderByDescending(orderBy).ToList();
355                 else
356                     return db.Set<T>().AsExpandable().Where(selectWhere).OrderBy(orderBy).ToList();
357             }
358             catch (Exception ex)
359             {
360                 Log_DG(ex.ToString());
361                 return default(List<T>);
362             }
363         }
364         public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, out int Count, Boolean isDESC = false) where T : class
365         {
366             try
367             {
368                 var list = db.Set<T>().AsExpandable().Where(selectWhere);
369                 Count = list.Count();
370                 if (isDESC)
371                     return list.OrderByDescending(orderBy).ToList();
372                 else
373                     return list.OrderBy(orderBy).ToList();
374             }
375             catch (Exception ex)
376             {
377                 Log_DG(ex.ToString());
378                 Count = 0;
379                 return default(List<T>);
380             }
381         }
382 
383         public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, Boolean isDESC = false) where T : class
384         {
385             try
386             {
387                 var list = db.Set<T>().AsExpandable();
388                 if (isDESC)
389                     return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
390                 else
391                     return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
392             }
393             catch (Exception ex)
394             {
395                 Log_DG(ex.ToString());
396                 return default(List<T>);
397             }
398         }
399         public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, out int Count, Boolean isDESC = false) where T : class
400         {
401             try
402             {
403                 var list = db.Set<T>().AsExpandable();
404                 Count = list.Count();
405                 if (isDESC)
406                     return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
407                 else
408                     return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
409             }
410             catch (Exception ex)
411             {
412                 Log_DG(ex.ToString());
413                 Count = 0;
414                 return default(List<T>);
415             }
416         }
417         public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, Boolean isDESC = false) where T : class
418         {
419             try
420             {
421                 var list = db.Set<T>().AsExpandable().Where(selectWhere);
422                 if (isDESC)
423                     return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
424                 else
425                     return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
426             }
427             catch (Exception ex)
428             {
429                 Log_DG(ex.ToString());
430                 return default(List<T>);
431             }
432         }
433         public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, out int Count, Boolean isDESC = false) where T : class
434         {
435             try
436             {
437                 var list = db.Set<T>().AsExpandable().Where(selectWhere);
438                 Count = list.Count();
439                 if (isDESC)
440                     return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
441                 else
442                     return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
443             }
444             catch (Exception ex)
445             {
446                 Log_DG(ex.ToString());
447                 Count = 0;
448                 return default(List<T>);
449             }
450         }
451 
452         #endregion
453     }
454 }

叁 、使用泛型,泛型在援助类的第二不必多说了啊,写帮忙类不用泛型…啧啧啧。

本文为七小站主原创小说,转发请证明出处:http://www.cnblogs.com/qixiaoyizhan/ 且在小说页面显明地点给出原版的书文链接,不然保留追究法律权利的职务。

DBEntity_DG(习惯性地起名)

首先示例性地来四个实体关系类,以便于后边的声援类的对照,当然,这一个类也是少不了的。

接下来,大家来上正菜 EF_DBEntity_DG

六 、全数的准绳采纳lambda说明式的章程,lambda表明式是比较流行相比方便的规则度量圭表筛选方式之一,在未来会越多地利用lambda表明式进行操作,在C#6.0决定是得到了十分大的协助。

1、IEF_DBEntity_DG
援助类的接口,当然我从不继续这几个接口,这一个接口只是本人今后纪念的时候看的,并从未实际利用价值,只当作表达性的文字,不喜勿碰哈。

二 、选用单例格局,那里不做过多表明,单例的介绍铺天盖地,我只是说,使用的时候,供给在这里改动两处对应到实体关系类上。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图