EF查询数据库框架的搭建

一个简单的EF查询框架除了运行项目外，大概需要5个类库项目，当然这个不是一定要这样做，这可以根据自己的需要设置有多少个项目。这里介绍的方法步骤只适合EF零基础的人看看就是了。

在开始之前，先建立一个运行项目，不管是MVC还是winfrom项目，只要能运行就OK，这是为了在后面能测试EF框架的地方。

一、模型项目。这个项目主要负责与数据库映射的，里面的类都是数据库表的实体。

首先在解决方案中建一个文件夹EFModel，这里将会收纳所有的与EF查询有关的项目，这样做只是为了将他们与运行项目分开而已，没有什么特别的意思。

在EFModel中建立一个类库，命名为DBModel，然后在这个类库中创建一个EF

添加之后，选择从数据库生成

在这里，服务器名可以输入数据库所在的服务器的ip，然后测试一下链接，看是否成功。在下面的链接到数据库中选择你要链接的数据库

下一步后，如果没有什么特别设置，就直接完成就可以了。然后看看生成的App.config文件，在connectionStrings节点下就是数据库的链接字符串了

由于没有选择任何的表，因此在数据库模型中就是空的，这时需要添加新的模型来映射数据库中的表，打开model.edmx,然后右键：

下面这一步最好选择是，否则在后面运行程序的时候可能会出现：基础提供程序在 Open 上失败。的错误

找到要添加的表，然后点完成

最后保存model，就能看到在model.tt下添加了一个实体类。至此，模型项目就完成了，如果以后需要添加新的实体类，也从数据库更新模型就是了。

这种模式下，必须是先在数据库中把表建好，然后才能添加实体类，如果需要对已经添加了实体类的表做结构上的修改，那么在数据库中完成修改后，需要在model.edmx中先删除原来的实体，然后重新添加一次才行。

二、增删改查公用方法的接口项目IDAO

建立一个类库项目EF.IDAO,添加两个引用

然后添加接口IBaseDao，

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace  EF.IDAO
{
   public interface IBaseDao<T>
                 where T:class,
                 new ()//约束T类型必须可以实例化
   {
       //根据条件获取实体对象集合
       IQueryable<T> LoadEntites(Func<T,bool> whereLambda );

       //根据条件获取实体对象集合分页
       IQueryable<T> LoadEntites(Func<T,bool> whereLambda, int pageIndex, int pageSize,out int totalCount);

       //增加
       T AddEntity(T entity);

       //更新
       T UpdateEntity(T entity);

       //删除
       bool DelEntity(T entity);

       //根据条件删除
       bool DelEntityByWhere(Func<T, bool> whereLambda);
   }
}

此时基接口中的CRUD方法就定义完成。接下来我们需要使用T4模版生成所有的实体类接口并实现IBaseDao接口。

添加名为IDaoExt的T4模板

加入如下代码：

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#@ output extension=".cs" #>
<#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\\DBModel\\Model.edmx";//指定edmx实体模型所在的路径

EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);

#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DBModel;//引用Domain的命名空间

namespace EF.IDAO //实体类接口所在的命名空间
{
<#
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name)) //遍历edmx模型中映射的实体对象
{#>
    public interface I<#=entity.Name#>Dao:IBaseDao<<#=entity.Name#>> //生成实体对象接口，这里生成的接口的名称是根据模型中的实体类名来设置的，而实体的类名是在建数据库表名的时候设置的名称
    {
    }
<#};#>
}

其中，有注释的地方是需要根据自己的情况修改的地方（后面项目中的文本模板文件也是如此）。保存文件，然后就可以在IDaoExt.tt下生成了一个文件IDaoExt.cs，这个文件中有一个接口，这个接口就是上面添加的实体所对应的接口。它是根据模板IDaoExt.tt来生成的，因此每当添加了新的实体后，都需要重新保存一次这些tt文件。当然，也可以不用这个模板文件来生成对应的接口，那样的话就需要手动的添加了，这根据自己的爱好决定用哪种方式。

在项目中建一个局部接口IDBSession，注意，是局部接口，要用到关键字partial。

namespace EF.IDAO
{
    public partial interface IDBSession
    {
        int SaveChange();//用于在业务逻辑层对提交进行管理
    }
}

这个接口主要是提供实体类接口的访问属性，以实现对数据访问层的封装。建一个文本模板IDBSession.tt

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#@ output extension=".cs" #>
<#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\\DBModel\\Model.edmx";

EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);

#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DBModel;
using EF.IDAO;

namespace EF.IDAO
{
  public partial interface IDBSession
  {
    <#foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
    {#>
        I<#=entity.Name#>Dao <#=entity.Name#>Dao { get; set; }
    <#};#>
 }
}

保存之后，就自动生成了IDBSession的局部接口了

再添加一个接口IDBSessionFactory，为业务逻辑层提供统一访问入口：

namespace EF.IDAO
{
   public interface IDBSessionFactory
    {
        IDBSession GetCurrentDBSession();
    }
}

该接口中定义GetCurrentDBSession()方法，其作用是通过该接口方法获取需要的实体对象。至此，这个项目基本上完成了，在这里添加了如下文件：

三、增删改查等方法的实现项目DAO

建好项目后添加如下引用：

创建ObjectContextFactory类，用来获取EF上下文。当网站访问量增大时，为避免EF产生的脏数据问题，我们使用System.Runtime.Remoting.Messaging 命名空间下的CallContext来解决线程内上下文唯一。

namespace EF.DAO
{
    public class ObjectContextFactory
    {
        public static DbContext GetCurrentObjectContext()
        {
            //从CallContext数据槽中获取EF上下文
            DbContext objectContext = CallContext.GetData(typeof(ObjectContextFactory).FullName) as DbContext;
            if (objectContext == null)
            {
                //如果CallContext数据槽中没有EF上下文，则创建EF上下文，并保存到CallContext数据槽中
                objectContext = new DBContent();//当数据库替换为MySql等，只要在此处EF更换上下文即可。这里的DBContent是model.context.cs中的局部类
                CallContext.SetData(typeof(ObjectContextFactory).FullName, objectContext);
            }
            return objectContext;
        }
    }
}

创建BaseDao类，实现IBaseDao中定义方法，用于所有实体类继承此基类。但是，这个类和接口IBaseDao没有任何的关系，他们之间的联系体现在这个类的派生类实现了IBaseDao这个接口

namespace EF.DAO
{
    public class BaseDao<T> where T : class, new()
    {
        DbContext objectContext = ObjectContextFactory.GetCurrentObjectContext() ;//获取EF上下文

        /// <summary>
        /// 加载实体集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public virtual IQueryable<T> LoadEntites(Func<T, bool> whereLambda)
        {
            return objectContext.Set<T>().Where<T>(whereLambda).AsQueryable<T>();
        }

        /// <summary>
        /// 分页加载数据
        /// </summary>
        /// <param name="whereLambda">过滤条件</param>
        /// <param name="pageIndex">页码</param>
        /// <param name="pageSize">页大小</param>
        /// <param name="totalCount">总记录数</param>
        /// <returns></returns>
        public virtual IQueryable<T> LoadEntites(Func<T, bool> whereLambda, int pageIndex, int pageSize, out int totalCount)
        {
            var tmp = objectContext.Set<T>().Where<T>(whereLambda);
            totalCount = tmp.Count();

            return tmp.Skip<T>(pageSize * (pageIndex - 1))//跳过行数，最终生成的sql语句是Top(n)
                      .Take<T>(pageSize) //返回指定数量的行
                      .AsQueryable<T>();
        }

        /// <summary>
        /// 添加实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns>返回更新后的实体</returns>
        public virtual T AddEntity(T entity)
        {
            objectContext.Set<T>().Add(entity);
            objectContext.SaveChanges();
            return entity;
        }

        /// <summary>
        /// 更新实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns>返回更新后的实体</returns>
        public virtual T UpdateEntity(T entity)
        {
            objectContext.Set<T>().Attach(entity);
            objectContext.Entry<T>(entity).State = EntityState.Modified;//将附加的对象状态更改为修改
            objectContext.SaveChanges();
            return entity;
        }

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual bool DelEntity(T entity)
        {
            objectContext.Set<T>().Attach(entity);
            objectContext.Entry<T>(entity).State = EntityState.Deleted;//将附加的实体状态更改为删除
            if (objectContext.SaveChanges() > 0)
            {
                return true;//删除成功
            }
            else
            {
                return false;//删除失败
            }
        }

        /// <summary>
        /// 根据条件删除对象
        /// </summary>
        /// <param name="whereLambda">条件</param>
        /// <returns></returns>
        public virtual bool DelEntityByWhere(Func<T, bool> whereLambda)
        {
            var tmp = objectContext.Set<T>().Where<T>(whereLambda);//根据条件从数据库中获取对象集合
            foreach (var entity in tmp)
            {
                objectContext.Entry<T>(entity).State = EntityState.Deleted;//标记对象为删除状态删除
            }
            if (objectContext.SaveChanges() > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}

使用T4模板生成所有实体对象的实现，生成所有的实体类继承自BaseDao并实现各自的接口。创建一个模板文件DaoExt

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#@ output extension=".cs" #>
<#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\\DBModel\\Model.edmx";

EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DBModel;
using EF.IDAO;

namespace EF.DAO
{
<#
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{#>
    public partial class <#=entity.Name#>Dao:BaseDao<<#=entity.Name#>>,I<#=entity.Name#>Dao
    {

    }
<#};#>
}

创建文本模板DBSessionExt，来生成DBSession实现接口IDBSession

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\\DBModel\\Model.edmx";

EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);

#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EF.IDAO;
using System.Data.Entity;

namespace EF.DAO
{
  public partial class DBSession : IDBSession
  {
  private DbContext _efContext;

        //EF上下文 这段代码是因为要实现IDBSession接口中的SaveChange方法而写的，因为每次保存这个文本模板时，如果没有这段代码那么在生成的类中就会缺少SaveChange方法的实现，从而导致编译不过
        public DbContext EfContext
        {
            get
            {
                if (_efContext == null)
                {
                    _efContext = ObjectContextFactory.GetCurrentObjectContext();
                }
                return _efContext;
            }
            set { _efContext = value; }
        }

        public int SaveChange()
        {
            return EfContext.SaveChanges();//调用SaveChanges()方法提交操作
        }
    <#foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
    {#>
        private I<#=entity.Name#>Dao _<#=entity.Name#>Dao;
        public I<#=entity.Name#>Dao <#=entity.Name#>Dao
        {
            get
            {
                if (_<#=entity.Name#>Dao == null)
                {
                    _<#=entity.Name#>Dao = new <#=entity.Name#>Dao();
                }
                return _<#=entity.Name#>Dao;
            }
            set { _<#=entity.Name#>Dao = value; }
        }
    <#}#>
 }
}

添加一个类DBSessionFactory，实现接口IDBSessionFactory

namespace EF.DAO
{
    public class DBSessionFactory : IDBSessionFactory
    {
        public IDBSession GetCurrentDBSession()
        {
            IDBSession dbSession = CallContext.GetData(typeof(DBSessionFactory).FullName) as DBSession;
            if (dbSession == null)
            {
                dbSession = new DBSession();
                CallContext.SetData(typeof(DBSessionFactory).FullName, dbSession);
            }
            return dbSession;
        }
    }
}

至此，我们就已经完成了对数据访问层的封装，当数据库中的表或字段有更新时，我们只需要重新运行一下相应T4模版，就可以实现与数据库保存一致。一共添加了如下文件

四、业务逻辑层的封装

创建名为EF.IBLL的程序集，主要用于业务逻辑层接口定义

创建接口IBaseService，这个接口和IBaseDao一模一样的，但是这个接口是业务逻辑层的，而IBaseDao是数据访问层的。所以可以将IBaseDao直接拷过来换个名字就行了

创建名为IServiceExt的T4模版，用于自动生成所有实体对象的接口，并继承自IBaseService接口

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\\DBModel\\Model.edmx";

EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DBModel;

namespace EF.IBLL
{
<#
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{#>
    public interface I<#=entity.Name#>Service : IBaseService<<#=entity.Name#>>
    {
    }
<#};#>
}

至此，业务逻辑层定义完成

五、实现业务逻辑层，对数据访问层的调用

创建项目EF.BLL,创建名为BaseService基类。该基类中实现了对数据访问层的调用，也实现了增删改查

步骤： 1、先将IDBSessionFactory封装为属性，用于获取IDBSession

2、再将IDBSession封装为属性,用于获取EF上下文对象

3、定义IBaseDao类型的CurrentDao属性，用于属性获取具体的实体对象

4、定义抽象方法 SetCurrentDao()，用于子类设置实现，为CurrentDao属性赋具体的实体对象

namespace EF.BLL
{
    public abstract class BaseService<T> where T : class, new()
    {
        //构造函数
        public BaseService()
        {
            //调用SetCurrentDao()方法，要求子类必须实现
            SetCurrentDao();
        }

        //获取EF实体工厂
        IDBSessionFactory _dbSessionFactory;
        IDBSession _dbSession;

        public IDBSessionFactory DbSessionFactory
        {
            get
            {
                if (_dbSessionFactory == null)
                {
                    _dbSessionFactory = new DBSessionFactory();
                }
                return _dbSessionFactory;
            }
            set { _dbSessionFactory = value; }
        }

        public IDBSession DbSession
        {
            get
            {
                if (_dbSession == null)
                {
                    _dbSession = DbSessionFactory.GetCurrentDBSession();//通过数据访问层提供的工厂获取EF实体对象
                }
                return _dbSession;
            }
            set { _dbSession = value; }
        }
        //数据访问层基接口类型可以接收数据访问层的所有实体Dao
        public IBaseDao<T> CurrentDao { get; set; }

        //该方法用于子类实现，其作用是设置相应的实体Dao
        public abstract void SetCurrentDao();

    }
}

在实现增加和更新方法时，我们这时调用DBSessin中封装的SaveChanges()方法进行提交，主要目的是实现业务层控制提交。由于EF具有延迟加载特性，因此我们利用此特性，实现批量操作时，一次提交数据库，以提高程序性能，因此我们这时需要将BaseDao中的增加和更新方法中的SaveChange()方法注视掉。

基类BaseService剩下的代码：

 //以下是CRUD实现

        public virtual IQueryable<T> LoadEntites(Func<T, bool> whereLambda)
        {
            return this.CurrentDao.LoadEntites(whereLambda);
        }

        public virtual IQueryable<T> LoadEntites(Func<T, bool> whereLambda, int pageIndex, int pageSize, out int totalCount)
        {
            return this.CurrentDao.LoadEntites(whereLambda, pageIndex, pageSize, out totalCount);
        }

        public virtual T AddEntity(T entity)
        {
            var tmp = this.CurrentDao.AddEntity(entity);
            this.DbSession.SaveChange();
            return tmp;
        }

        public virtual T UpdateEntity(T entity)
        {
            var tmp = this.CurrentDao.UpdateEntity(entity);
            this.DbSession.SaveChange();
            return tmp;
        }

        public virtual bool DelEntity(T entity)
        {
            return this.CurrentDao.DelEntity(entity);
        }

        public virtual bool DelEntityByWhere(Func<T, bool> whereLambda)
        {
            return this.DelEntityByWhere(whereLambda);
        }

至此，BaseService业务逻辑层基类就封装完成，接下来使用T4模版自动生成所有实体。

创建名为ServiceExt的T4模版

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\\DBModel\\Model.edmx";

EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EF.IBLL;
using DBModel;

namespace EF.BLL
{
<#
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{#>
    public partial class <#=entity.Name#>Service : BaseService<<#=entity.Name#>>, I<#=entity.Name#>Service
    {
       public override void SetCurrentDao()
       {
           this.CurrentDao = this.DbSession.<#=entity.Name#>Dao;
       }
    }
<#};#>
}

这时我们就对业务逻辑层封装完成。

现在需要建一个运行项目，来测试是否真的可以访问数据库了。项目建好后，添加DBModel,IBLL,BLL的引用。将DBModel中app.config里面的字符串链接复制到运行项目中的web.config中

然后在要访问数据库的方法中通过下面的代码来实现：

 EF.IBLL.IN_CommodityService ics = new EF.BLL.N_CommodityService();
           IList<DBModel.N_Commodity> lis = ics.LoadEntites(t => t.Id_bigint < 200).ToList();
           int s = lis.Count;

也就是说，所有对数据库的访问都是通过EF.IBLL中的实体接口来实现的。

总结：整个数据访问的框架就分为业务逻辑层（EF.IBLL,EF.BLL），数据访问层(EF.IDAO,EF.DAO)和实体(DBModel)三个部分。在创建实体的时候，要注意EF版本的选择，目前来说最好是选择5.0版本的，因为EntityFramework的版本为5.0，否则可能会出现意想不到的错误。还有就是在选择数据连接的时候，对于是否在字符串中包括敏感数据，选择是就行了，这也是为了避免出现不可预知的错误。每次更新了实体的时候，都要重新保存一次所有的文本模板文件，以便能自动生成实体类和接口。

以上介绍的一些对数据库的访问的方法都是linq方式的，有时候我们需要通过sql语句来实现对数据库的访问，这种方式在另一篇随笔再详细的介绍。

时间： 2024-10-08 20:04:25

EF查询数据库框架的搭建的相关文章

EF查询出来的model,与自已创建的modl,取值进行更新

/// <summary> ///创建人:蒋云峰 ///日 期:2019/12/23 ///描 述:更新实体,与数据库实体进行对比 /// </summary> public class JyfUpdateModel { /// <summary> /// 当dataBaseObj与newObj具有相同的属性名时,如果newObj的这个属性没有值,则把dataBaseObj中的属性值赋值为newObj的这个属性 /// 主要用于更新,防止清空掉原有的数据 /// <

用Zend框架的模式查询数据库

说道这个知识点,想一下都有点心酸,我可是把这个知识点的视屏看看整整六遍才算把基本的流程以及要点搞明白,看着是用框架方便了许多,但如果是搞不明白,他就会把你搞死,不诉苦了,还是先说一下具体的操作流程吧. 首先,既然要去查询数据库,而且是用框架的方式,就必须改掉那种面向过程,单层结构的方式,应该充分利用mvc的思想,就是说,在模型,视图,还有控制器,让他们分工明确,,首先要建立一个数据库的表类,那必然就应该放在modle里面了,注意的就是既然要使用框架里面的方法,那么就必须要继承该方法类,该方法类就

架构搭建----基于DDD领域驱动设计的WCF+EF+WPF分层框架（2）

写在最前面:转载请注明出处 目录置顶: 关于项目--------------------基于DDD领域驱动设计的WCF+EF+WPF分层框架(1) 架构搭建--------------------基于DDD领域驱动设计的WCF+EF+WPF分层框架(2) WCF服务端具体实现---------基于DDD领域驱动设计的WCF+EF+WPF分层框架(3) WCF客户端配置以及代理-----基于DDD领域驱动设计的WCF+EF+WPF分层框架(4) Domain具体实现------------基于DD

基于“MVC”框架集设计模式，利用 DBHelper实现查询数据库功能

利用 DBHelper实现查询数据库功能 (1)连接好mysql数据库,如果无法连接,先打开mysql服务.新建一个数据库,名字为text,在新建一个数据表,名字为user,添加三个字段:用户ID.用户名和密码. (2)新建 web 项目UserManager,根据MVC模型的设计,建立四个包:beans.DAO.DBHelper.servlet.将所需要的DBHelper导入新建Web项目的DBHelper中,注意要使数据库名字保持一致.将mysql-connector-java-5.1.24

asp.net mvc 简单项目框架的搭建过程（一）对Bll层和Dal层进行充分解耦

学习asp.net 已经有近三个月的时间了,在asp.net mvc上花的时间最多,但个人真是有些菜,不得不说,asp.net mvc的水真的还是蛮深的.目前在公司实习,也见过公司几个项目的代码了.对项目的代码始终停留在一知半解的地步,能改一些简单的bug,但关于项目的来龙去脉始终云里雾里.对于asp.net mvc的架构始终看不懂.因此,照着传智博客的学习视频,学了一下简单的架构搭建.真个架构的搭建我看了将近两遍视频,才稍稍有些头绪,今天在这里记录一下,一方面加深理解,一方面如果以后忘记了,还

【Hibernate】hibernate框架的搭建

1, Hibernate 是什么 Hibernate框架简化了java应用程序与数据库交互的开发. Hibernate是一个开源,轻量级的ORM(对象关系映射)工具. 2,Hibernate框架的优点 Hibernate框架有很多优点.它们分别如下: 开源和轻量级: Hibernate框架是根据LGPL许可证和轻量级的开源工具. 快速性能: Hibernate框架的性能很快,因为缓存在Hibernate框架内部使用. hibernate框架中有两种类型的缓存:一级缓存和二级缓存.一级缓存默认是启

EF查询视图只得到一条记录

1.出错结果:数据库表视图有多条数据,在使用EF框架进行查询时却只得到一条数据(注:拦截EF得到的sql语句在数据库进行查询并没有任务问题). 2.出错原因:该视图中没有ID或者主键,EF查询时进行反射默认都是同一条数据. 3.总结:EF框架查询视图时需要注意加入ID或者主键 以上仅是个人简单分析.

自己动手写Android数据库框架

前言 相信不少开发人员跟我一样,每次都非常烦恼自己写数据库,并且那些数据库语句也经常记不住.当然网上也有非常多非常好的数据库框架,你能够直接拿来用,可是 非常多时候我们的项目.特别是一个小型的Andrond应用原本用到的数据库结构比較简单,不是必需去用那些有点臃肿的框架.当然,即使你用那些框架.当你遇到问题时,你是否也得去改动它?你要改动别人的框架必须的读懂他人的设计代码.所以无论从那个角度出发,你都得掌握简单的数据库操作.那么这篇博客就从简单的数据库操作来学习Android数据库相关知识点.然

Entity Framework 4.1 之八：绕过 EF 查询映射

原文名称:Entity Framework 4.1: Bypassing EF query mapping (8) 原文地址:http://vincentlauzon.wordpress.com/2011/04/21/entity-framework-4-1-bypassing-ef-query-mapping-8/ 看到 Entity Framework 4.1 推荐英文教程,为了帮大家看起来方便一些,简单翻译一下.这是一个系列,共有 8 篇,这是第 8 篇. Entity Framework