开发笔记 第581页

[转载]使用sqlite扩展，避免在sql语句中使用不易看懂和难以维护的数字或名称缩写 – 达叔 – 博客园.

[转载]程序员，你应该知道_知识库_博客园.

[转载]简单利用Memcached进行缓存层设计 – Jeff Wong – 博客园.

正在考虑web应用缓存层的设计，参考了不少资料，估计还是需要用到相对成熟应用广泛的分布式缓存Memcached。在.net平台上早就有相对成熟的Memcached客户端产品，如BeITMemcached和EnyimMemcached，业余时间看了一下源码，自己分析并调用一下并不困难。这里简单介绍一下利用Memcached的一个简单的缓存层设计，示例代码基于EnyimMemcached，下面以贴代码为主。

一、公共缓存接口

分析ASP.NET web caching的缓存类，我们大致可以抽象出如下几个接口方法：

namespace DotNet.Common.EnyimCache
{
///
/// memcached公共缓存调用方法接口(读)
///
public interface ICacheReaderService
{

///
/// 返回指定key的对象
///
///
<span> </span> ///
object Get(string key);

///
/// 返回指定key的对象
///
///
///
<span> </span> ///
T Get(string key);

///
/// 是否存在
///
///
<span> </span> ///
bool isExists(string key);
}

///
/// memcached公共缓存调用方法接口(写)
///
public interface ICacheWriterService
{
///
/// 缓存有效间隔时间 (以分钟为单位)
///
int TimeOut { set; get; }

///
/// 添加指定key的对象
///
///
<span> </span> ///
<span> </span> void Add(string key, object obj);

///
/// 添加指定key的对象
///
///
///
<span> </span> ///
<span> </span> void Add(string key, T obj);

///
/// 移除指定key的对象
///
///
<span> </span> bool Remove(string key);

///
/// 修改指定key的对象
///
///
<span> </span> ///
bool Modify(string key, object destObj);

///
/// 清空缓存
///
///
bool Release();
}
}

看命名就知道，增删改查是也。根据个人使用缓存的经验，修改操作通常是不需要的，如果确实需要修改缓存数据，直接删除然后添加就是改了。

还有，你可能会问，这里为什么要定义两个接口？原因主要是考虑到读操作（查询）是经常使用的，而写操作（增删改）相对较少，所以也把它们设计成读写分离的方式。

二、缓存服务实现

这里就需要调用Memcached客户端封装好的调用方法，实现增删改查等方法。

using System;

namespace DotNet.Common.EnyimCache
{
using Enyim.Caching.Memcached;

public class CacheReaderService : BaseService, ICacheReaderService
{

public int TimeOut
{
get;
set;
}

public CacheReaderService()
{

}

public object Get(string key)
{
object obj = null;
Client.TryGet(key, out obj);
return obj;
}

public T Get(string key)
{
object obj = Get(key);
T result = default(T);
if (obj != null)
{
result = (T)obj;
}
return result;
}

public bool isExists(string key)
{
object obj = Get(key);
return (obj == null) ? false : true;
}
}

public class CacheWriterService : BaseService, ICacheWriterService
{
public int TimeOut
{
get;
set;
}

public CacheWriterService()
{

}

public CacheWriterService(int timeOut)
{
this.TimeOut = timeOut;
}

public void Add(string key, object obj)
{
if (TimeOut > 0)
{
Client.Store(StoreMode.Add, key, obj, DateTime.Now.AddMinutes(TimeOut));
}
else
{
Client.Store(StoreMode.Add, key, obj);
}
}

public void Add(string key, T obj)
{
if (TimeOut > 0)
{
Client.Store(StoreMode.Add, key, obj, DateTime.Now.AddMinutes(TimeOut));
}
else
{
Client.Store(StoreMode.Add, key, obj);
}
}

public bool Remove(string key)
{
return Client.Remove(key);
}

public bool Modify(string key, object destObj)
{
return Client.Store(StoreMode.Set, key, destObj);
}

///
/// 清空缓存 TO DO
///
///
public bool Release()
{
throw new NotImplementedException();
}
}
}

基类里初始化一个MemcachedClient示例Client，这个Client的方法里封装了较多的函数。查看源码可以知道，它们本质上都是 向Memcached服务端发送相关指令（run command），然后解析返回的二进制数据，如果您熟悉memcached所使用的协议，理解起来应该会相当简单。本文示例只使用了客户端提供的几个方 法。

同时要注意，在实现具体缓存服务的时候，CacheWriterService有两个构造函数，其中带参数的是为缓存显式指定过期时间。这个参数在实际应用中通常需要配置，显然是比较灵活一些的。

备注：在接口中有一个函数Release，本来的目标是清空所有的缓存数据，但是客户端没有直接提供对应的函数，如果您有好的方法，请不吝赐教。

三、简单的读写测试

贴一下字符串、时间、单个类和集合的增删改查示例代码：

ICacheWriterService writer = CacheBuilder.GetWriterService();//writer 使用memcached默认过期时间
ICacheReaderService reader = CacheBuilder.GetReaderService();//reader

#region 字符串

string strKey = "hello";

bool isOK = writer.Remove(strKey); //移除
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

writer.Add(strKey, "hello world"); //添加
Console.WriteLine("Add key {0}, value:hello world", strKey);

bool isExists = reader.isExists(strKey);//是否存在
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

string result = reader.Get(strKey) as string;//查询
Console.WriteLine("Get key {0}:{1}", strKey, result);

bool isModify = writer.Modify(strKey, "Hello Memcached!");//修改
Console.WriteLine("Modify key {0}, value:Hello Memcached. The result is:{1}", strKey, isModify);

result = reader.Get(strKey);
Console.WriteLine("Generic get key {0}:{1}", strKey, result);

isOK = writer.Remove(strKey);
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

isExists = reader.isExists(strKey);
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

result = reader.Get(strKey) as string;
Console.WriteLine("Get key {0}:{1}", strKey, result);

result = reader.Get(strKey);
Console.WriteLine("Generic get key {0}:{1}", strKey, result);
Console.WriteLine();
Console.WriteLine("===========================================");
Console.Read();

#endregion

#region 时间

DateTime dtNow = DateTime.Now;
strKey = "datetime";
isOK = writer.Remove(strKey); //移除
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

writer.Add(strKey, dtNow); //添加
Console.WriteLine("Add key {0}, value:{1}", strKey, dtNow);

isExists = reader.isExists(strKey);//是否存在
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

DateTime dt = (DateTime)reader.Get(strKey);//查询
Console.WriteLine("Get key {0}:{1}", strKey, dt);

dt = reader.Get(strKey);
Console.WriteLine("Generic get key {0}:{1}", strKey, dt);

isOK = writer.Remove(strKey);
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

isExists = reader.isExists(strKey);
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey));

Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get(strKey));//default(datetime)
Console.WriteLine();
Console.WriteLine("===========================================");

Console.Read();

#endregion

#region 类

dtNow = DateTime.Now;
Province province = new Province(13579, "江苏", dtNow, dtNow);

strKey = string.Format("{0}_{1}", province.GetType().Name, province.Id);//省
isOK = writer.Remove(strKey); //移除
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

writer.Add(strKey, province); //添加
Console.WriteLine("Add key {0}, value:{1}", strKey, dtNow);

isExists = reader.isExists(strKey);//是否存在
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

Province queryProvince = (Province)reader.Get(strKey);//查询
Console.WriteLine("Get key {0}:{1}", strKey, queryProvince.ProvinceName);

queryProvince = reader.Get
(strKey);
Console.WriteLine("Generic get key {0}:{1}", strKey, queryProvince.ProvinceName);

isOK = writer.Remove(strKey);
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

isExists = reader.isExists(strKey);
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey));

Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get
(strKey));
Console.WriteLine();
Console.WriteLine("===========================================");

Console.Read();

#endregion

#region 集合(列表)

dtNow = DateTime.Now;
IList listCities = new List();
City city = new City(135, province.Id, "南京", "210000", dtNow, dtNow);
listCities.Add(city);
city = new City(246, province.Id, "苏州", "215000", dtNow, dtNow);
listCities.Add(city);

strKey = string.Format("List_{0}_{1}_{2}", province.GetType().Name, province.Id, city.GetType().Name);//省份对应城市
isOK = writer.Remove(strKey); //移除
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

writer.Add(strKey, listCities); //添加
Console.WriteLine("Add key {0}, value:", strKey);
foreach (var item in listCities)
{
Console.WriteLine("CityId:{0} CityName:{1}", item.Id, item.CityName);
}

isExists = reader.isExists(strKey);//是否存在
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

IList queryCities = reader.Get(strKey) as IList;//查询
Console.WriteLine("Get key {0}:", strKey);
foreach (var item in queryCities)
{
Console.WriteLine("CityId:{0} CityName:{1}", item.Id, item.CityName);
}

queryCities = reader.Get>(strKey);
Console.WriteLine("Generic get key {0}:", strKey);
foreach (var item in queryCities)
{
Console.WriteLine("CityId:{0} CityName:{1}", item.Id, item.CityName);
}

isOK = writer.Remove(strKey);
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

isExists = reader.isExists(strKey);
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey));

Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get>(strKey));
Console.WriteLine();
Console.WriteLine("===========================================");

Console.Read();

#endregion

#region 集合(字典)

dtNow = DateTime.Now;
IDictionary dictCities = new Dictionary();
city = new City(123, province.Id, "镇江", "212000", dtNow, dtNow);
dictCities.Add(city.Id, city);
city = new City(321, province.Id, "扬州", "225000", dtNow, dtNow);
dictCities.Add(city.Id, city);

strKey = string.Format("Dictionary_{0}_{1}_{2}", province.GetType().Name, province.Id, city.GetType().Name);//省份对应城市
isOK = writer.Remove(strKey); //移除
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

writer.Add(strKey, dictCities); //添加
Console.WriteLine("Add key {0}, value:", strKey);
foreach (var item in dictCities)
{
Console.WriteLine("CityId:{0} CityName:{1}", item.Key, item.Value.CityName);
}

isExists = reader.isExists(strKey);//是否存在
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

IDictionary queryDictCities = reader.Get(strKey) as IDictionary;//查询
Console.WriteLine("Get key {0}:", strKey);
foreach (var item in queryDictCities)
{
Console.WriteLine("CityId:{0} CityName:{1}", item.Key, item.Value.CityName);
}

queryDictCities = reader.Get>(strKey);
Console.WriteLine("Generic get key {0}:", strKey);
foreach (var item in queryDictCities)
{
Console.WriteLine("CityId:{0} CityName:{1}", item.Key, item.Value.CityName);
}

isOK = writer.Remove(strKey);
Console.WriteLine("Removed key {0}:{1}", strKey, isOK);

isExists = reader.isExists(strKey);
Console.WriteLine("Key {0} exists:{1}", strKey, isExists);

Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey));

Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get>(strKey));
Console.WriteLine();
Console.WriteLine("===========================================");

Console.Read();

#endregion

这里就不贴全部代码了，文章最后有示例可以下载。

在我的简单测试中，对常见基础数据类型如（字符串、数组、数字和时间）、集合（列表和字典）都有良好的表现，对datatable和dataset同样表现不俗，但是不太建议直接缓存这两种重粒度的类型。

在显式指定过期时间的示例中，指定过期时间是一分钟，但是memcached实际过期时间有时候好像会多于一分钟，估计是系统内部的延迟。

在本地计算机上进行10万次循环添加缓存的过程中，发现系统内存果然增加的非常厉害。然后查询性能并没有显著下降，也许和我的单机测试环境有关，所以我认为测试结果并没有说服力，要知道，memcached的优势是它的分布式缓存实现。

有人发现如何保证缓存系统的键唯一也非常令人头疼。同样的缓存框架，不同项目不同开发者如何保证自己程序添加的缓存键唯一呢？有一种简单方法就是通 过拼接字符串成为有意义的主键，比如按照项目名、命名空间、类名、数据库中的主键组合构成主键等等。当然了，在查询的时候也要自己封装特定格式的字符串主 键。个人感觉确实是一个行之有效的方法。

demo下载：SimpleCacheApp

[转载]Entity Framework之深入分析 – 小城岁月 – 博客园. EF虽然是一个晚生畸形的ORM框架，但功能强大又具有灵活性的，给了开发人员一定的发挥空间。因为微软出发点总是好的，让开发变得简单，但实际上不是所有的事情都这么理想。这里顺便推荐马丁大叔的书《企业应架构模式》。 本节主要深入分析EF的分层问题，下面是本节的已列出的要探讨内容。

• 领域模型的概念
• DbContext与Unit of Work 的概念
• DbContext 创建实例及线程安全问题
• 不要随便using或Dispose DbContext
• DbContext的SaveChanges事务
• Repository与UnitOfWork引入
• DbContext T4模板的应用
• EDM文件是放在DAL层还是Model层中？
• EF MVC项目分层

一、领域模型的概念

领域模型：是描述业务用例实现的对象模型。它是对业务角色和业务实体之间应该如何联系和协作以执行业务的一种抽象。 业务对象模型从业务角色内部的观点定义了业务用例。定义很商业，很抽象，也很理解。一个商业的概念被引入进来之后，引发很多争议和思考。而 DomainObject  在我们实际的项目又演化成大致下面几种 1.纯事务脚本对象（只有字段的set,get)，没有任何业务（包括没有导航属性），可以以理解为贫血的领域模型。 2.带有自身业务的对象，例如验证业务，关联导航等。 3.对象包含量了大量的业务，而这些业务中并不是所有业务都和它相关。 尤其是第2种，界限很难划分，怎么判断这个业务是自身的，还是其它的？ 或者是否重用度高呢？ 第一种和第三种在之前的项目都使用过，目前个人觉得EF现在走的是第2种路线，EF在生成Model模型后，依然可以对模型进行业务修改。我们也不必在这 样上面纠结太多，项目怎么做方便就怎么去实现。比如纯净的POCO我可以当DTO或VO使用；而第3种情况，我们在微软的DataSet时，也是大量使用 的。想详细了解这段的可以参照这篇讨论

二、DbContext与Unit of Work 的概念

在马丁大叔中书看我们可以准看到Unit of Work 的定义：维护受业务事务影响的对象列表，并协调变化的写入和并发问题的解决。即管理对象的CRUD操作，以及相应的事务与并发问题等。Unit of Work的是用来解决领域模型存储和变更工作，而这些数据层业务并不属于领域模型本身具有的。而DbContext其实就是一个Unit of work ，只是如果直接使用这个DbContext 的话，那DbContext所有的业务都是直接暴露的，当然这是看是否项目需要了。可以看出微软的EF DbContext借用了Unit of work的思想。

三、DbContext 创建实例及线程安全问题

1. DbContext不适合创建成单例模式，例如A对象正在编辑，B对象编辑完了提交，导致正在编辑的A对象也被提交了，但是A的改可能要取消的，但是最终都被提交到数据库中了。 2. 如果DbContext创建过多的实例，就要控制好并发的问题，因为不同实例的DbContext可能会对同一条记录进行修改。 3. DbContext线程安全问题，同一实例的DbContext被不同线程调用会引发第一条场景的情况。不同线程使用不同实例的DbContext时又会引发第二种场景的情况。 第一种情况很难控制，而第二种情况可以采用乐观并发锁来解决，其次就是尽量避免对一记录的写操作。

四、不要随便using或Dispose DbContext

我们先来看一段代码：

 BlogCategory cate = null; using (DemoDBEntities context = new DemoDBEntities()) { //context.Configuration.LazyLoadingEnabled = false; DbSet set = context.Set(); cate = set.Find(2); }  //肯定会出错 因为DbContext被释放了 无法延迟加载对象 BlogArticle blog = cate.BlogArticle.First(); 

当我们在使用延迟加载的时候，如果使用using或dispose 释放掉DbContext后，就无法延迟加载导航属性。为什么？我们来看一下DbContext是如何加载对象以及导航属性的。 将上面的代码修改一下:

static void Main(string[] args)
{
BlogCategory cate = null;
using (DemoDBEntities context = new DemoDBEntities())
{
//context.Configuration.LazyLoadingEnabled = false;
DbSet set = context.Set();
cate = set.Find(2);

//肯定会出错 因为DbContext被释放了 无法延迟加载对象
BlogArticle blog = cate.BlogArticle.First();
}

Console.ReadLine();
}

我们打开SQL Server Profiler 来监视一上面的代码执行情况

可以看如果DbContext如果在第一次读取BlogCategory被释放后，那在加载导航属性的时候肯定不会执行成功。

另外一点：为什么很多人一定要using 或dispose掉DbContext ?

是担心数据库连接没有释放？还是担心DbContext占用过多资源呢？

首先担心数据库连接没有释放肯定是多余的，因为DbContext在SaveChanges完成后会释放掉打开的数据库连接，我们来反编译一下SaveChages的源码看看:

public virtual int SaveChanges(SaveOptions options)
{
this.OnSavingChanges();
if ((SaveOptions.DetectChangesBeforeSave & options) != SaveOptions.None)
{
this.ObjectStateManager.DetectChanges();
}
if (this.ObjectStateManager.SomeEntryWithConceptualNullExists())
{
throw new InvalidOperationException(Strings.ObjectContext_CommitWithConceptualNull);
}
bool flag = false;
int objectStateEntriesCount = this.ObjectStateManager.GetObjectStateEntriesCount(EntityState.Modified | EntityState.Deleted | EntityState.Added);
using (new EntityBid.ScopeAuto(" %d#, affectingEntries=%d", this.ObjectID, objectStateEntriesCount))
{
EntityConnection connection = (EntityConnection) this.Connection;
if (0 >= objectStateEntriesCount)
{
return objectStateEntriesCount;
}
if (this._adapter == null)
{
IServiceProvider providerFactory = connection.ProviderFactory as IServiceProvider;
if (providerFactory != null)
{
this._adapter = providerFactory.GetService(typeof(IEntityAdapter)) as IEntityAdapter;
}
if (this._adapter == null)
{
throw EntityUtil.InvalidDataAdapter();
}
}
this._adapter.AcceptChangesDuringUpdate = false;
this._adapter.Connection = connection;
this._adapter.CommandTimeout = this.CommandTimeout;
try
{
this.EnsureConnection();
flag = true;
Transaction current = Transaction.Current;
bool flag2 = false;
if (connection.CurrentTransaction == null)
{
flag2 = null == this._lastTransaction;
}
using (DbTransaction transaction = null)
{
if (flag2)
{
transaction = connection.BeginTransaction();
}
objectStateEntriesCount = this._adapter.Update(this.ObjectStateManager);
if (transaction != null)
{
transaction.Commit();
}
}
}
finally
{
if (flag)
{
this.ReleaseConnection();
}
}
if ((SaveOptions.AcceptAllChangesAfterSave & options) == SaveOptions.None)
{
return objectStateEntriesCount;
}
try
{
this.AcceptAllChanges();
}
catch (Exception exception)
{
if (EntityUtil.IsCatchableExceptionType(exception))
{
throw EntityUtil.AcceptAllChangesFailure(exception);
}
throw;
}
}
return objectStateEntriesCount;
}

可以看到DbContext 每次打开  EntityConnection 最后都会 finally 时 通过this.ReleaseConnection() 释放掉连接，所以这个担心是多余的。

其次DbContext 是否占用过多的资源呢？DbContext确实占用了资源，主要体现在DbContext的Local属性上，每一次的增删改查，Loacl都会从数据库 中加载数据，而这些数据在SaveChanges之后并没有释放掉。因此释放DbContext 是需要的，但是这样又会影响到延迟加载。这样的话，我们可以通过重载SaveChanges，在SaveChanges之后清除掉Local中的数据。但 是这样做为什么有问题，我也不知道，有待考证。上一节中有介绍重载SaveChanges 清除Local 数据阻止查询数据更新。

五、DbContext的SaveChanges自带事务与分布式事务

通过反编译可以看到单实例DbContext的SaveChanges方式默认开启了事务，当同时更新多条记录时，有一条失败就会RollBack。模拟测试代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EF.Model;
using EF.DAL;
using System.Data.Entity;
using System.Collections;
using System.Transactions;
namespace EF.Demo
{
class Program
{
static void Main(string[] args)
{
BlogCategory cate = null;
DemoDBEntities context = new DemoDBEntities();

//DemoDBEntities context2 = new DemoDBEntities();
try
{
//using (TransactionScope scope = new TransactionScope())
//{
//context.Configuration.LazyLoadingEnabled = false;
DbSet set = context.Set();

cate = new BlogCategory();
cate.CateName = "2010-7";
cate.CreateTime = DateTime.Now;

cate.BlogArticle.Add(new BlogArticle() { Title = "2011-7-15" });
set.Add(cate);

//由于没设置Title字段,并且CreateTime字段不能为空，故会引发异常
context.Set().Add(new BlogArticle { BlogCategory_CateID = 2 });
int a = context.SaveChanges();

//    context2.Set().Add(new BlogArticle { BlogCategory_CateID = 2 });
//    int b = context2.SaveChanges();

//    scope.Complete();
//}
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}

Console.ReadLine();
}
}
}

通过SQL SERVER Profile 监视到没有一句SQL语句被执行，SaveChanges事务是预执新所有操作成功后才会更新到数据库中。

我们再来测试一下分布式事务，创建的Context2用于模拟代表其它数据库:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EF.Model;
using EF.DAL;
using System.Data.Entity;
using System.Collections;
using System.Transactions;
namespace EF.Demo
{
class Program
{
static void Main(string[] args)
{
BlogCategory cate = null;
DemoDBEntities context = new DemoDBEntities();

DemoDBEntities context2 = new DemoDBEntities();
try
{
using (TransactionScope scope = new TransactionScope())
{
//context.Configuration.LazyLoadingEnabled = false;
DbSet set = context.Set();

cate = new BlogCategory();
cate.CateName = "2010-7";
cate.CreateTime = DateTime.Now;

cate.BlogArticle.Add(new BlogArticle() { Title = "2011-7-15" });
set.Add(cate);
//实例1 对数据库执行提交
int a = context.SaveChanges();

//实例2 模拟其它数据库提交 时间字段为空，无法更新成功
context2.Set().Add(new BlogArticle { Title="2011-7-16", BlogCategory_CateID = 2 });
int b = context2.SaveChanges();

scope.Complete();
}
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}

Console.ReadLine();
}
}
}

通过SQL SERVER Profile 监视，虽然context实际执行了两条SQL记录，但是context2的SQL没有执行成功，导致事务回滚，所有操作都被没有执行成功。

六、Repository与UnitOfWork引入

Repository是什么？ 马丁大叔的书上同样也有解释：它是衔接数据映射层和域之间的一个纽带，作用相当于一个在内存中的域对象映射集合，它分离了领域对象和数据库访问代码的细 节。Repository受DomainObject驱动，Repository用于实现不属于DomainObject的自身相关的，但又受 DomainObject约束的业务。如CRUD操作就不是领域模型要关注的业务，但是领域模型最终要映射为数据关系保存到数据库中。一个领域模型要有对 应的Repository来处理与数据层衔接过程。但不是所有的DomainObject对Repository约束是相同的，可能这个领域对象没有对应 Repository删除操作，而别外一个却有，所以我们经常使用的泛型Repository<T> 是不合适的。但是为了代码简洁重用，大家根据实际情况还是使用了简洁的IRepository<T>接口，就像我们有时为了简单直接把 POCO当DTO或VO使用了。如果不引入Repository，我觉得没有必要实现DAL层，因为DbContext本身就是DAL层，然后只要为 DbContext定义好接IDAL接口从而必免与BLL层的耦合。从这里就可以看出Repository与DAL的区别，一个受域业务驱动出现的，一个 是出于解除耦合出现的。

UnitOfWork 工作单元，前面已经介绍过。为了减少业务层频繁调用DbContext的SaveChanges同步数据库操作（将多个对象的更新一次提交，减少与数据库 交互过程），又要保证DbContext对业务层封闭，所以我们要增加一个对业务层开放的接口。想一想如果把SaveChanges的方法下放到每个 Repository中或者DAL中，那业务层在协调多个Repository事务操作时，就会频繁的写数据库。而分离了Repository中的所有 SaveChanges （或者撤销以及完成单元工作后销毁等操作）后，并通过接口在业务层统一调用，这样既大大提高了效率，也体现了一个完整的单元工作 业务。

七、DbContext T4模板的应用

在Model First中，我们借助于EDMX 和T4模板完成了DbContext和Model的初步设计。但是微软提供的这些模板不能满足用户的所有需求，这个时候我就要修改T4 来生成我们想要的代码。

T4模板应用非常广泛，很多ORM工具的模板也在使用的T4模板，T4也可以生成HTML，JS等多种语言。T4模板支持多种语言书写，可读性很强，也容易上手。

DbContext模板 一共分为两个 DemoDB.DbContext.tt （unit of work)和DemoDb.tt (model) 。前一节我们介绍了如何修改DemoDb.tt 模板 使我们POCO模型继承POCOEntity，这一节再修改一下DemoDb.DbContext.tt模板 使其继承IUnitOfWork接口。

首先我们在Model层中增加IUnitOfWork接口如下:

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

namespace EF.Model
{
public interface IUnitOfWork
{
//事务提交
int Save();
}
}

我们再修改DemoDb.DbContext.tt模板：

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#><#@  output extension=".cs"#><#

var loader = new MetadataLoader(this);
var region = new CodeRegion(this);
//---------------------------------------------------这里导入了DemoDB.edmx映射文件---------------add by mecity
var inputFile = @"DemoDB.edmx";
//---------------------------------------------------映射文件转为集合方便模板篇历生成代码--------add by mecity
var ItemCollection = loader.CreateEdmItemCollection(inputFile);

Code = new CodeGenerationTools(this);
EFTools = new MetadataTools(this);
ObjectNamespace = Code.VsNamespaceSuggestion();
ModelNamespace = loader.GetModelNamespace(inputFile);

EntityContainer container = ItemCollection.GetItems().FirstOrDefault();
if (container == null)
{
return string.Empty;
}
#>
//------------------------------------------------------------------------------
//
// <#=GetResourceString("Template_GeneratedCodeCommentLine1")#>
//
// <#=GetResourceString("Template_GeneratedCodeCommentLine2")#>
// <#=GetResourceString("Template_GeneratedCodeCommentLine3")#>
//
//------------------------------------------------------------------------------

<# if (!String.IsNullOrEmpty(ObjectNamespace)) { #>
namespace <#=Code.EscapeNamespace(ObjectNamespace)#>
{
<#     PushIndent(CodeRegion.GetIndent(1)); } #>
using System;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
//---------------------------------------------------这加加入对EF.Model命名空间的引用---------------add by mecity
using EF.Model;
<# if (container.FunctionImports.Any()) { #>
using System.Data.Objects;
<# } #>

//---------------------------------------------------这里加入对IUnitOfWork接口继承---------------add by mecity
<#=Accessibility.ForType(container)#> partial class <#=Code.Escape(container)#> : DbContext,IUnitOfWork
{
public <#=Code.Escape(container)#>()
: base("name=<#=container.Name#>")
{
<#         WriteLazyLoadingEnabled(container); #>
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
throw new UnintentionalCodeFirstException();
}

//---------------------------------------------------这里加入对IUnitOfWork接口方法的实现---------------add by mecity
public int Save()
{
return base.SaveChanges();
}

注意T4模板中加了注释的地方，保存模板后，就会重新创建DemoDBEntities，看一下模板修改后生成后的代码:

//------------------------------------------------------------------------------
//
//    此代码是根据模板生成的。
//
//    手动更改此文件可能会导致应用程序中发生异常行为。
//    如果重新生成代码，则将覆盖对此文件的手动更改。
//
//------------------------------------------------------------------------------

namespace EF.DAL
{
using System;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
//---------------------------------------------------这加加入对EF.Model命名空间的引用---------------add by mecity
using EF.Model;

//---------------------------------------------------这里加入对IUnitOfWork接口继承---------------add by mecity
public partial class DemoDBEntities : DbContext,IUnitOfWork
{
public DemoDBEntities()
: base("name=DemoDBEntities")
{
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
throw new UnintentionalCodeFirstException();
}

//---------------------------------------------------这里加入对IUnitOfWork接口方法的实现---------------add by mecity
public int Save()
{
return base.SaveChanges();
}

public DbSet BlogArticle { get; set; }
public DbSet BlogCategory { get; set; }
public DbSet BlogComment { get; set; }
public DbSet BlogDigg { get; set; }
public DbSet BlogTag { get; set; }
public DbSet BlogMaster { get; set; }
}
}

八、EDM文件是放在DAL层还是Model层中？

记得我第一篇EF介绍中将EDMX文件和Model放在一起，这样做有一定风险，按照领域模型的概念，Model中这些业务对象被修改的可能性非常 高，并且每个业务对象的修改的业务都可能不同，因此修改DemoDB.tt模板满足所有对象是不实现的， 并且意外保存EDMX文件时，也会导致Model手动修改的内容丢失。因此EDMX不适合和Model放在一起，最好移至到DAL层或 Repository层。DAL中的DemoDb.DbContext.tt模板生成代码是相对固定的（只有一个DemoDBEntities类），因此 对DemoDb.DbContext.tt模板的修改基本可以满足要求。见上节T4应用。我们可以先在DAL中的EDMX完成POCO对象的初步生成与映 射关系工作后，再移至到Model中处理。

九、EF MVC项目分层

就目前CodePlex上的微软项目NorthwindPoco/Oxite/Oxite2）以及其它开源的.net mvc EF项目分层来看，大致结构如下

View   视图

Controller 控制器

IService  Controller调用具体业务的接口

Service   IService的具体实现 ，利用IOC注入到Controller

Repository 是IRepository 的具体实现，利用IOC注入到Service

Model+IRepository  因为IRepository接口对应的是DoaminModel约束业务，并且都是直接开放给Service 调用的，所以放在一个类库下也容易理解，当然分开也无影响。

VO/DTO  ViewObject与DTO 传输对象类库

当然这只是参考，怎么合理分层还是依项目需求，项目进度，资源情况以及后期维护等情况而定。

[转载]在Godaddy空间上部署ASP.NET MVC3 + EntityFramework4.1 + MySQL应用程序 – Miles Chen – 博客园.

[转载]SQL SERVER本地管理员和SA帐号都无法访问的问题和解决方案 – 陈希章 – 博客园.

[转载]asp.net中web.config配置节点大全详解 – 亚逊 – 博客园.

web.config 文件查找规则：

(1)如果在当前页面所在目录下存在web.config文件，查看是否存在所要查找的结

点名称，如果存在返回结果并停止查找。

(2)如果当前页面所在目录下不存在web.config文件或者web.config文件中不存在

该结点名，则查找它的上级目录，直到网站的根目录。

(3)如果网站根目录下不存在web.config文件或者web.config文件中不存在该节点

名则在%windir%”Microsoft.NET”Framework”v2.0.50727″CONFIG”web.config文件中查找。

(4) 如果在%windir%”Microsoft.NET”Framework”v2.0.50727″CONFIG”web.config

文件中不存在相应 结点，则在%

windir%”Microsoft.NET”Framework”v2.0.50727″CONFIG”machine.config文件 中查找。

(5)如果仍然没有找到则返回null。

在ASP.NET应用程序运行过程中，如果web.config文件发生更改就会导致相应的应

用程序重新启动，这时存储在服务器内存中的用户会话信息 就会丢失（如存储在内存中的

Session）。

(一) appSetings配置节

<appSettings>节点主要用来存储ASP.NET应用程序的一些配置信息，比如上传文件

的保存路径等

<appSettings>

<add key=”ImageType” value=”.jpg;.bmp;.gif;.png;.jpeg”/> <!–允许

上传的图片格式类型–>

</appSettings>

string fileType=ConfigurationManager.AppSettings[“FileType “];

(二) <connectionStrings>节点

<connectionStrings> 节点主要用于配置数据库连接的，我们可以

<connectionStrings>节点中增加任意个节点来保存数据库连接字符串，将来在代码中 通

过代码的方式动态获取节点的值来实例化数据库连接对象，这样一旦部署的时候数据库连

接信息发生变化我们仅需要更改此处的配置即可，而不必因为数据库连接 信息的变化而需

要改动程序代码和重新部署

<connectionStrings>

<add name=”AspNetStudyConnectionString1″ connectionString=”Data

Source=(local);Initial Catalog=AspNetStudy;User ID=sa;Password=sa”/>

</connectionString>

string connectionString = ConfigurationManager.ConnectionStrings

[“AspNetStudyConnectionString1”].ConnectionString;

(三)<compilation>节点

<compilation>节点配置 ASP.NET 使用的所有编译设置。默认的Debug属性为

“true”，即允许调试，在这种情况下会影响网站的性能，所以在程序编译完成交付使用

之后应将其设为“false”。

(四)<authentication>节点

设置asp.net身份验证模式，有四种身份验证模式，它们的值分别如下：

Windows 使用Windows身份验证，适用于域用户或者局域网用户。

Forms 使用表单验证，依靠网站开发人员进行身份验证。

Passport 使用微软提供的身份验证服务进行身份验证。

None 不进行任何身份验证。

(五)<customErrors>节点

<customErrors>节点用于定义 一些自定义错误信息的信息。此节点有Mode和

defaultRedirect两个属性，其中defaultRedirect属性是一个可选属性，表示应 用程序发

生错误时重定向到的默认URL，如果没有指定该属性则显示一般性错误。Mode属性是一个必

选属性，它有三个可能值，它们所代表的意义分别如下：

On 表示在本地和远程用户都会看到自定义错误信息。

Off 禁用自定义错误信息，本地和远程用户都会看到详细的错误信息。

RemoteOnly 表示本地用户将看到详细错误信息，而远程用户将会看到自定义错误

信息。

这 里有必要说明一下本地用户和远程用户的概念。当我们访问asp.net应用程时所使用的

机器和发布asp.net应用程序所使用的机器为同一台机器时成为 本地用户，反之则称之为

远程用户。在开发调试阶段为了便于查找错误Mode属性建议设置为Off，而在部署阶段应将

Mode属性设置为On或者 RemoteOnly，以避免这些详细的错误信息暴露了程序代码细节从而

引来黑客的入侵。

(六)<error>子节点

在<customErrors>节点下还包含有< error>子节点，这个节点主要是根据服务器的

HTTP错误状态代码而重定向到我们自定义的错误页面，注意要使<error>子节点 下的配置

生效，必须将<customErrors>节点节点的Mode属性设置为“On”。下面是一个例子：

<customErrors mode=”On” defaultRedirect=”GenericErrorPage.htm”>

<error statusCode=”403″ redirect=”403.htm” />

<error statusCode=”404″ redirect=”404.htm” />

</customErrors>

(七)<httpHandlers>节点

<httpHandlers>节点用于根据用户请求的URL和HTTP谓词将用户的请求交给相应的

处理程序。可以在配置级别的任何层次配置此节点，也就是说可以针对某个特定目录下指

定的特殊文件进行特殊处理。

<httpHandlers>

<add path=”*.rules” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.xoml” verb=”*”

type=”System.ServiceModel.Activation.HttpHandler, System.ServiceModel,

Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089″

validate=”false”/>

<add path=”trace.axd” verb=”*”

type=”System.Web.Handlers.TraceHandler” validate=”true”/>

<add path=”WebResource.axd” verb=”GET”

type=”System.Web.Handlers.AssemblyResourceLoader” validate=”true”/>

<add path=”*.axd” verb=”*” type=”System.Web.HttpNotFoundHandler”

validate=”true”/>

<add path=”*.aspx” verb=”*”

type=”System.Web.UI.PageHandlerFactory” validate=”true”/>

<add path=”*.ashx” verb=”*”

type=”System.Web.UI.SimpleHandlerFactory” validate=”true”/>

<add path=”*.asmx” verb=”*”

type=”System.Web.Services.Protocols.WebServiceHandlerFactory,

System.Web.Services, Version=2.0.0.0, Culture=neutral,

PublicKeyToken=b03f5f7f11d50a3a” validate=”false”/>

<add path=”*.rem” verb=”*”

type=”System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory,

System.Runtime.Remoting, Version=2.0.0.0, Culture=neutral,

PublicKeyToken=b77a5c561934e089″ validate=”false”/>

<add path=”*.soap” verb=”*”

type=”System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory,

System.Runtime.Remoting, Version=2.0.0.0, Culture=neutral,

PublicKeyToken=b77a5c561934e089″ validate=”false”/>

<add path=”*.asax” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.ascx” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.master” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.skin” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.browser” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.sitemap” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.dll.config” verb=”GET,HEAD”

type=”System.Web.StaticFileHandler” validate=”true”/>

<add path=”*.exe.config” verb=”GET,HEAD”

type=”System.Web.StaticFileHandler” validate=”true”/>

<add path=”*.config” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.cs” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.csproj” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.vb” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.vbproj” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.webinfo” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.licx” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.resx” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.resources” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.mdb” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.vjsproj” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.java” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.jsl” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.ldb” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.ad” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.dd” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.ldd” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.sd” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.cd” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.adprototype” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.lddprototype” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.sdm” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.sdmDocument” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.mdf” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.ldf” verb=”*” type=”System.Web.HttpForbiddenHandler”

validate=”true”/>

<add path=”*.exclude” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.refresh” verb=”*”

type=”System.Web.HttpForbiddenHandler” validate=”true”/>

<add path=”*.svc” verb=”*”

type=”System.ServiceModel.Activation.HttpHandler, System.ServiceModel,

Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089″

validate=”false”/>

<add path=”*” verb=”GET,HEAD,POST”

type=”System.Web.DefaultHttpHandler” validate=”true”/>

<add path=”*” verb=”*”

type=”System.Web.HttpMethodNotAllowedHandler” validate=”true”/>

</httpHandlers>

从上面的配置中可以看出，针对*.mdf、*.ldf文件的Get或者Post请求都会交给

System.Web.HttpForbiddenHandler来处理，处理的结果就是用户不能查看或者下载相关的

文件。如果我们某个文件夹下的文件或 者某个类型的文件不允许用户下载，可以在

</httpHandlers>节点中增加相应的子节点。

下面我们以一个例子来说明<httpHandlers>节点的用法，在我们的asp.net应用程

序中建立一个IPData目录，在IPData目录中创建一个IPData.txt文件，然后在Web.config

中添加以下配置：

<httpHandlers>

<add path=”IPData/*.txt” verb=”*”

type=”System.Web.HttpForbiddenHandler”/>

</httpHandlers>

(九)<httpRuntime>节点

<httpRuntime>节点用于对 ASP.NET HTTP 运行库设置。该节可以在计算机、站点

、应用程序和子目录级别声明。

例如下面的配置控制用户最大能上传的文件为40M（40*1024K），最大超时时间为60秒，最

大并发请求为100个

<httpRuntime maxRequestLength=”40960″ executionTimeout=”60″

appRequestQueueLimit=”100″/>

(十)<pages>节点

<pages>节点用于表示对特定页设置，主要有三个属性，分别如下：

buffer 是否启用了 HTTP 响应缓冲。

enableViewStateMac 是否应该对页的视图状态运行计算机身份验证检查 (MAC)，

以放置用户篡改，默认为false，如果设置为true将会引起性能的降低。

validateRequest 是否验证用户输入中有跨站点脚本攻击和SQL注入式漏洞攻击，

默认为true，如果出现匹配情况就会发HttpRequestValidationException 异常。对于包含

有在线文本编辑器页面一般自行验证用户输入而将此属性设为false。

<pages buffer=”true” enableViewStateMac=”true” validateRequest=”false”/>

(十一)<sessionState>节点

<sessionState>节点用于配置当前asp.net应用程序的会话状态配置。以下就是一

个常见配置：

<sessionState cookieless=”false” mode=”InProc” timeout=”30″ />

上面的节点配置是设置在asp.net应用程序中启用Cookie，并且指定会话状态模式

为在进程中保存会话状态，同时还指定了会话超时为30分钟。

<sessionState>节点的Mode属性可以是以下几种值之一：

Custom 使用自定义数据来存储会话状态数据。

InProc 默认值。由asp.net辅助进程来存储会话状态数据。

Off 禁用会话状态。

SQLServer 使用进程外SQL Server数据库保存会话状态数据。

StateServer 使用进程外 ASP.NET 状态服务存储状态信息。

一般默认情况下使用InProc模式来存储会话状态数据，这种模式的好处是存取速度

快，缺点是比较占用内存，所以不宜在这种模式下存储大型的用户会话数据

(十二)<globalization>节点

用于配置应用程序的全球化设置。此节点有几个比较重要的属性，分别如下：

fileEncoding 可选属性。设置.aspx、.asmx 和 .asax 文件的存储编码。

requestEncoding 可选属性。设置客户端请求的编码，默认为UTF-8.

responseEncoding 可选属性。设置服务器端响应的编码，默认为UTF-8.

以下就是asp.net应用程序中的默认配置：

<globalization fileEncoding=”utf-8″ requestEncoding=”utf-8″

responseEncoding=”utf-8″/>

(十三)web.config文件读写

public void SetAppSetting(string key, string value)

{

AppSettingsSection appSetting = (AppSettingsSection)config.GetSection

(“appSettings”);

if (appSetting.Settings[key] == null)//如果不存在此节点，则添加

{

appSetting.Settings.Add(key, value);

}

else//如果存在此节点，则修改

{

appSetting.Settings[key].Value = value;

}

}

[转载]Doodle.CMS模板引擎之代码下载 – imfunny – 博客园.

[转载]VS2008 条件断点 – fangyukuan – 博客园.

条件成立触发断点

先设置一个普通断点。断下来的时候再设置它的条件。如下图：

在Breakpoints窗口中找到这个断点，右键选择Condition…如下图：

输入条件，这样就会在这个条件成立的时候，才触发断点。

内存改变时触发断点

有时候想知道一个指针什么时候被改变了。可以用这种方法。

先在指针处断下来。如下图：

然后在watch窗口查看 【指针变量本身存放的内存地址】。如下图第二个即：&g_p。注意不是g_p。

复制这个地址，然后的Breakpoints窗口中打开New->New Data Breakpoint如下图：

把这个地址写上，如下图：

这样再运行，当指针改变的时候，就会触发断点了。如下图：

方煜宽

2011.07.13

转载请保留连接

本文地址：http://www.cnblogs.com/fangyukuan/archive/2011/07/13/2105395.html

[转载]SQLite 入门教程（四）增删改查，有讲究 – 左洸 – 博客园.

增删改查操作，其中增删改操作被称为数据操作语言 DML，相对来说简单一点。 查操作相对来说复杂一点，涉及到很多子句，

所以这篇先讲增删改操作，以例子为主，后面再讲查操作。

一、插入数据 INSERT INTO 表（列…） VALUES（值…）

根据前面几篇的内容，我们可以很轻送的创建一个数据表，并向其中插入一些数据，不多说，看例子：

myqiao@ubuntu:~/My Documents/db$ sqlite3 test.db
-- Loading resources from /home/myqiao/.sqliterc
SQLite version 3.7.4
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .tables
sqlite>
sqlite> CREATE TABLE Teachers(
...> Id integer PRIMARY KEY,
...> Name text NOT NULL,
...> Age integer CHECK(Age>22),
...> Country text DEFAULT 'USA');
sqlite> .tables
Teachers
sqlite>
sqlite> INSERT INTO Teachers VALUES(1,'Alice',25,'CHN');
sqlite> INSERT INTO Teachers VALUES(2,'Bob',25,'BRA');
sqlite> INSERT INTO Teachers(Id,Name,Age,Country) VALUES(3,'Charls',33,'USA');
sqlite> INSERT INTO Teachers(Name,Age) VALUES('Jhon',43);
sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               CHN
2     Bob              25               BRA
3     Charls           33               USA
4     Jhon             43               USA
sqlite>

很简单，创建了一个 Teachers 表并向其中添加了四条数据，设定了一些约束，其中有自动增加的主键、默认值等等。

二、修改数据 UPDATE 表 SET 列 = ‘新值’ 【WHERE 条件语句】

UPDATE 语句用来更新表中的某个列，如果不设定条件，则所有记录的这一列都被更新； 如果设定了条件，则符合条件的记录的这一列被更新， WHERE 子句被用来设定条件，如下例：

sqlite>
sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               CHN
2     Bob              25               BRA
3     Charls           33               USA
4     Jhon             43               USA
sqlite>
sqlite>
sqlite> UPDATE Teachers SET Country='China';
sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               China
2     Bob              25               China
3     Charls           33               China
4     Jhon             43               China
sqlite>
sqlite>
sqlite> UPDATE Teachers SET Country='America' WHERE Id=3;
sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               China
2     Bob              25               China
3     Charls           33               America
4     Jhon             43               China
sqlite>
sqlite>
sqlite> UPDATE Teachers SET Country='India' WHERE Age<30; sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               India
2     Bob              25               India
3     Charls           33               America
4     Jhon             43               China
sqlite>

三、删除数据 DELETE FROM 表 【WHERE 条件语句】

如果设定 WHERE 条件子句，则删除符合条件的数据记录；如果没有设定条件语句，则删除所有记录

sqlite>
sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               India
2     Bob              25               India
3     Charls           33               America
4     Jhon             43               China
sqlite>
sqlite>
sqlite> DELETE FROM Teachers WHERE Age>30;
sqlite> SELECT * FROM Teachers;
Id    Name             Age              Country
----  ---------------  ---------------  ---------------
1     Alice            25               India
2     Bob              25               India
sqlite>
sqlite>
sqlite> DELETE FROM Teachers;
sqlite> SELECT * FROM Teachers;
sqlite>

四、查找数据 SELECT 列… FROM 表

为了后面的练习，需要一些样本数据。 首先将下面的 SQL 语句保存到 data.SQL 文件中

BEGIN TRANSACTION;
CREATE TABLE Cars(Id integer PRIMARY KEY, Name text, Cost integer);
INSERT INTO Cars VALUES(1,'Audi',52642);
INSERT INTO Cars VALUES(2,'Mercedes',57127);
INSERT INTO Cars VALUES(3,'Skoda',9000);
INSERT INTO Cars VALUES(4,'Volvo',29000);
INSERT INTO Cars VALUES(5,'Bentley',350000);
INSERT INTO Cars VALUES(6,'Citroen',21000);
INSERT INTO Cars VALUES(7,'Hummer',41400);
INSERT INTO Cars VALUES(8,'Volkswagen',21600);
COMMIT;

BEGIN TRANSACTION;
CREATE TABLE Orders(Id integer PRIMARY KEY, OrderPrice integer CHECK(OrderPrice>0),
Customer text);
INSERT INTO Orders(OrderPrice, Customer) VALUES(1200, "Williamson");
INSERT INTO Orders(OrderPrice, Customer) VALUES(200, "Robertson");
INSERT INTO Orders(OrderPrice, Customer) VALUES(40, "Robertson");
INSERT INTO Orders(OrderPrice, Customer) VALUES(1640, "Smith");
INSERT INTO Orders(OrderPrice, Customer) VALUES(100, "Robertson");
INSERT INTO Orders(OrderPrice, Customer) VALUES(50, "Williamson");
INSERT INTO Orders(OrderPrice, Customer) VALUES(150, "Smith");
INSERT INTO Orders(OrderPrice, Customer) VALUES(250, "Smith");
INSERT INTO Orders(OrderPrice, Customer) VALUES(840, "Brown");
INSERT INTO Orders(OrderPrice, Customer) VALUES(440, "Black");
INSERT INTO Orders(OrderPrice, Customer) VALUES(20, "Brown");
COMMIT;

然后在在终端执行命令 .read data.sql，将数据导入到数据库中

sqlite>
sqlite> .tables
Friends
sqlite> .read data.sql
sqlite> .tables
Cars      Orders    Teachers
sqlite>

可以看到，Cars 表和 Orders 表已经导入到数据库中，现在可以查询了

sqlite>
sqlite> SELECT * FROM Cars;
Id    Name             Cost
----  ---------------  ---------------
1     Audi             52642
2     Mercedes         57127
3     Skoda            9000
4     Volvo            29000
5     Bentley          350000
6     Citroen          21000
7     Hummer           41400
8     Volkswagen       21600
sqlite> SELECT * FROM Orders;
Id    OrderPrice       Customer
----  ---------------  ---------------
1     1200             Williamson
2     200              Robertson
3     40               Robertson
4     1640             Smith
5     100              Robertson
6     50               Williamson
7     150              Smith
8     250              Smith
9     840              Brown
10    440              Black
11    20               Brown
sqlite>

五、 限制返回数量 SELECT 列… FROM 表 LIMIT 数量 OFFSET 位置

有时候数据库中的数据太多，全部返回可不行，可以限制返回的数量，还可以设定返回的起始位置，如下：

sqlite>
sqlite> SELECT * FROM Cars LIMIT 4;
Id    Name             Cost
----  ---------------  ---------------
1     Audi             52642
2     Mercedes         57127
3     Skoda            9000
4     Volvo            29000
sqlite>
sqlite> SELECT * FROM Cars LIMIT 4 OFFSET 2;
Id    Name             Cost
----  ---------------  ---------------
3     Skoda            9000
4     Volvo            29000
5     Bentley          350000
6     Citroen          21000
sqlite>

六、 别名 SELECT 列 AS 别名，列 AS 别名 FROM

我们可以给返回数据集中的某些列起一个比较直观的名字，比如把 Cost 改为”Price Of Car”

sqlite>
sqlite> SELECT Name , Cost AS 'Price Of Car' FROM Cars;
Name  Price Of Car
----  ---------------
Audi  52642
Merc  57127
Skod  9000
Volv  29000
Bent  350000
Citr  21000
Humm  41400
Volk  21600
sqlite>

七、 条件查询 SELECT 列 FROM 表 【WHERE 条件语句】

一般的条件语句都是大于、小于、等于之类的，这里有几个特别的条件语句

LIKE

---

• LIKE 用通配符匹配字符串
• 下划线 _ 匹配一个字符串
• 百分号 % 匹配多个字符串
• LIKE 匹配字符串时不区分大小写

sqlite>
sqlite> SELECT * FROM Cars WHERE Name Like '____';
Id    Name             Cost
----  ---------------  ---------------
1     Audi             52642
sqlite>
sqlite> SELECT * FROM Cars WHERE Name Like '%en';
Id    Name             Cost
----  ---------------  ---------------
6     Citroen          21000
8     Volkswagen       21600
sqlite>
sqlite> SELECT * FROM Cars WHERE Name Like '%EN';
Id    Name             Cost
----  ---------------  ---------------
6     Citroen          21000
8     Volkswagen       21600
sqlite>

GLOB

---

• GLOB 用通配符匹配字符串
• 下划线 ? 匹配一个字符串
• 百分号 * 匹配多个字符串
• LIKE 匹配字符串时,区分大小写

BETWEEN 值1 AND 值2

---

返回两个值之间的数据集合。下面的语句查询价格在 20000 到 55000 之间的车，都是好车啊。

sqlite>
sqlite> SELECT * FROM Cars WHERE Cost BETWEEN 20000 AND 55000;
Id    Name             Cost
----  ---------------  ---------------
1     Audi             52642
4     Volvo            29000
6     Citroen          21000
7     Hummer           41400
8     Volkswagen       21600
sqlite>

IN （集合）

---

对应列的值必须在集合中。下面的语句查找奥迪和悍马的价格。

sqlite>
sqlite> SELECT * FROM Cars WHERE Name IN ('Audi','Hummer');
Id    Name             Cost
----  ---------------  ---------------
1     Audi             52642
7     Hummer           41400
sqlite>

八、 排序 ORDER BY 列 ASC (DESC)

指定某个列进行排序，ASC 为升序，DESC 为降序。下面的语句查询汽车品牌和价格，并以价格排序

sqlite>
sqlite> SELECT Name, Cost FROM Cars ORDER BY Cost DESC;
Name  Cost
----  ---------------
Bent  350000
Merc  57127
Audi  52642
Humm  41400
Volv  29000
Volk  21600
Citr  21000
Skod  9000
sqlite>

九、 区分 DISTINCT 列

有一些字段的值可能会出现重复，比如订单表中，一个客户可能会有好几份订单，因此客户的名字会重复出现。

到底有哪些客户下了订单呢？下面的语句将客户名字区分出来。

sqlite>
sqlite> Select * FROM Orders;
Id    OrderPrice       Customer
----  ---------------  ---------------
1     1200             Williamson
2     200              Robertson
3     40               Robertson
4     1640             Smith
5     100              Robertson
6     50               Williamson
7     150              Smith
8     250              Smith
9     840              Brown
10    440              Black
11    20               Brown
sqlite>
sqlite> SELECT DISTINCT Customer FROM ORDERS;
Customer
---------------
Black
Brown
Robertson
Smith
Williamson
sqlite>

十、 分组 GROUP BY 列

分组和前面的区分有一点类似。区分仅仅是为了去掉重复项，而分组是为了对各类不同项进行统计计算。

比如上面的例子，我们区分出 5 个客户，这 5 个客户一共下了 11 个订单，说明很多客户都下了不止一个订单。

下面的语句统计每个客户在订单上总共花费了多少钱。

sqlite>
sqlite> SELECT sum(OrderPrice) AS Total, Customer FROM Orders GROUP BY Customer;
Total            Customer
---------------  ---------------
440              Black
860              Brown
340              Robertson
2040             Smith
1250             Williamson
sqlite>

这里 Sum 是 SQLite 内置的统计函数，在这个例子中用来求每个顾客的订单价格的和。

统计结果也可以设定返回条件，但是不能用 WHERE 子句，而是用 HAVING 子句，如下例，返回订单总额大于 1000 的顾客。

sqlite>
sqlite> SELECT sum(OrderPrice) AS Total, Customer FROM Orders
...>         GROUP BY Customer HAVING sum(OrderPrice)>1000;
Total            Customer
---------------  ---------------
2040             Smith
1250             Williamson
sqlite>

十一、 逻辑运算符

有的查询涉及的条件语句很复杂，是有好几个条件语句经过逻辑运算得来的，一共有三种逻辑运算符：

• AND
• OR
• NOT

一般稍微了解点编程知识的应该都没问题。