摘要：大多数使用.net框架组件工作的开发人员的一个核心工作是实现数据访问功能，他们建立的数据访问层（data access layer）是应用程序的精华部分。本文概述了使用visual studio .net和.net框架组件建立数据访问层需要考虑的五个想法。这些技巧包括通过使用基类（base class）利用面相对象技术和.net框架组件基础结构，使类容易继承，在决定显示方法和外部界面前仔细地检验需求。
如果你正在建立以数据为中心（data-centric）的.net框架组件应用程序，你最终必须建立数据访问层。也许你知道在.net框架组件中建立自己的代码有很多好处。因为它支持实现和接口（interface）继承，你的代码更容易重复使用，特别是被使用不同的框架组件兼容（framework-compliant）语言的开发人员使用。本文我将概述为基于.net框架组件的应用程序建立数据访问层的五条规则。
开始前，我必须提醒你建立的任何基于本文讨论的规则的数据访问层必须与传统windows平台上开发人员喜欢的多层或者n层应用程序兼容。在这种结构中，表现层包含web窗体、windows窗体、调用与数据访问层的工作相应的事务层的xml服务代码。该层由多个数据访问类（data access classe）组成。换句话说，在事务处理协调不是必要的情况下，表现层将直接调用数据访问层。这种结构是传统的模型-视列表-控制程序（model-view-controller，mvc）模式的变体，在多种情况下被visual studio .net和它暴露的控件采用。
规则1：使用面向对象特性
最基本的面向对象事务是建立一个使用实现继承的抽象类。这个基类可以包括你的所有数据访问类通过继承能够使用的服务。如果那些服务足够了，它们就能通过在整个组织的基类分布实现重复使用。例如最简单的情况是基类能够为衍生类处理连接的建立过程，如列表1所示。
imports system.data.sqlclient
namespace acme.data
public mustinherit class dalbase : implements idisposable
private _connection as sqlconnection
protected sub new(byval connect as string)
_connection = new sqlconnection(connect)
end sub
protected readonly property connection() as sqlconnection
get
return _connection
end get
end property
public sub dispose() implements idisposable.dispose
_connection.dispose()
end sub
end class
end namespace
列表1.简单基类
在列表中可以看到，对dalbase类作了mustinherit标记（c#中的抽象），以确保它在继承关系中使用。接着该类在公共构造函数中包括了一个实例化的私有sqlconnection对象，它接收连接字符串作为一个参数。当来自idisposable接口的dispose方法确保连接对象已经被配置了的时候，受保护的（protected）connection属性允许衍生类访问该连接对象。
即使在下面简化的例子中你也能开始看到抽象基类的用处：
public class webdata : inherits dalbase
public sub new()
mybase.new(configurationsettings.appsettings("connectstring"))
end sub
public function getorders() as dataset
dim da as new sqldataadapter("usp_getorders", me.connection)
da.selectcommand.commandtype = commandtype.storedprocedure
dim ds as new dataset()
da.fill(ds)
return ds
end function
end class
在这种情况下，webdata类继承自dalbase，结果就是不必担心实例化sqlconnection对象，而是通过mybase关键字（或者c#中的基关键字）简单地把连接字符串传递给基类。webdata类的getorders方法能使用me.connection（在c#中是this.connection）访问受保护的属性。虽然这个例子相对简单，但是你将在规则2和3中看到基类也提供了其它的服务。
当数据访问层必须在com+环境中运行时抽象的基类很有用。在这种情况下，因为允许组件使用com+的必要代码复杂得多，所以更好的方式是建立一个如列表2所示的服务组件（serviced component）基类。
transaction(transactionoption.supported), _
eventtrackingenabled(true)> _
public mustinherit class dalservicedbase : inherits servicedcomponent
private _connection as sqlconnection
protected overrides sub construct(byval s as string)
_connection = new sqlconnection(s)
end sub
protected readonly property connection() as sqlconnection
get
return _connection
end get
end property
end class
列表2.服务组件基类
在这段代码中，dalservicedbase类包含的基本功能与列表1中的相同，但是加上了从system.enterpriseservices名字空间的servicedcomponent的继承，并且包括了一些属性，指明组件支持对象构造、事务和静态跟踪。接着该基类仔细地捕捉组件服务管理器（component services manager）中的构造字符串并且再次建立和暴露sqlconnection对象。我们要注意的是当一个类继承自dalservicedbase时，它也继承了属性的设置。换句话说，一个衍生类的事务选项也设置为supported。如果衍生类想重载这种行为，它能在类的层次重新定义该属性。
此外，衍生类在适当情况下应该有利于自身重载和共享方法。使用重载的方法（一个方法有多个调用信号）在本质上有两种情况。首先，它们在一个方法需要接受多种类型的参数时使用。框架组件中的典型例子是system.convert类的方法。例如tostring方法包含18个接受一个参数的重载方法，每个重载方法的类型不同。其次，重载的方法用于暴露参数数量不断增长的信号，而不是不同类型的必要参数。在数据访问层中这类重载变得效率很高，因为它能用于为数据检索和修改暴露交替的信号。例如getorders方法可以重载，这样一个信号不接受参数并返回所有订单，但是附加的信号接受参数以表明调用程序希望检索特定的顾客订单，代码如下：
public overloads function getorders() as dataset
public overloads function getorders(byval customerid as integer) as dataset
这种情况下的一个好的实现技巧是抽象getorders方法的功能到一个能被每个重载信号调用的私有的或者受保护的方法中。
共享方法（c#中的静态方法）也能用于暴露数据访问类的所有实例能够访问的字段、属性和方法。尽管共享成员不能与使用组件服务（component services）的类一起使用，但是对于在数据访问类的共享构造函数中检索并被所有实例读取的只读数据是有用的。使用共享成员读/写数据时要小心，因为为了访问该共享数据，执行的多个线程可能会竞争。
规则2：坚持设计指导
随visual studio .net一起发布的在线文档中有一个叫"类库开发人员的设计指导（design guidelines for class library developers）"的主题，它覆盖了类、属性和方法的名字转换，是重载的成员、构造函数和事件的补充模式。你必须遵循名字转换的主要原因之一是.net框架组件提供的跨语言（cross-language）继承。如果你在visual basic .net中建立一个数据访问层基类，你想确保使用.net框架组件兼容的其它语言的开发人员能继承它并容易理解它怎样工作。通过坚持我概述的指导方针，你的名字转换和构造就不会是语言特定的（language specific）。例如，你可能注意到在本文例子的代码中第一个词小写，并加上intercaps是用于方法的参数的，每个词大写是用于方法的，基类使用base标志来标识它是一个抽象类。
可以推测.net框架组件设计指导都是普通设计模式，像gang of four （addison-wesley, 1995）写的design patterns记载的一样。例如.net框架组件使用了observer模式的一个变体，叫做event模式，在类中暴露事件时你必须遵循它。
规则3：利用基础结构（infrastructure）
.net框架组件包括一些类和构造，它们能辅助处理通常的与基础结构相关的事务，例如装置和异常处理。通过基类把这些概念与继承组合起来将非常强大。例如，你能考虑一下system.diagnostics名字空间中暴露的跟踪功能。除了提供trace和debug类外，该名字空间还包括衍生自switch和tracelistener的类。switch类的booleanswitch和traceswitch能被配置用于打开和关闭应用程序和配置文件，在traceswitch中可以暴露多层次跟踪。tracelistener类的textwritertracelistener和eventlogtracelistener分别将trace和debug方法的输入定位到文本文件和事件日志。
这样作的结果是给基类添加了跟踪功能，使衍生类记录消息日志更简单。接着应用程序能使用配置文件控制是否允许跟踪。你能包括一个booleanswitch类型的私有变量并在构造函数中实例化它来给列表1中的dalbase添加这个功能：
public sub new(byval connect as string)
_connection = new sqlconnection(connect)
_dalswitch = new booleanswitch("dal", "data access code")
end sub
传递给booleanswitch的参数包括名字和描述。接着你能添加一个受保护的属性打开和关闭开关，也能添加一个属性使用trace对象的writelineif方法格式化并写入跟踪消息：
protected property tracingenabled() as boolean
get
return _dalswitch.enabled
end get
set(byval value as boolean)
_dalswitch.enabled = value
end set
end property
protected sub writetrace(byval message as string)
trace.writelineif(me.tracingenabled, now & ": " & message)
end sub
通过这种途径，衍生类自己并不知道开关（switch）和监听（listener）类，当数据访问类产生一个有意义的信号时能够简单地调用writetrace方法。
type="system.diagnostics.textwritertracelistener"
initializedata="dallog.txt" />
列表3.跟踪的配置文件
为了建立一个监听器并打开它，需要使用应用程序配置文件。列表3显示了一个简单的配置文件，它能够打开刚才显示的数据访问类开关，并通过mylistener调用textwritertracelistener把输出定位到文件dallog.txt中。当然，你能通过从tracelistener类衍生程序化地建立监听器并把该监听器直接包含在数据访问类中。
public class dalexception : inherits applicationexception
public sub new()
mybase.new()
end sub
public sub new(byval message as string)
mybase.new(message)
end sub
public sub new(byval message as string, byval innerexception as
exception)
mybase.new(message, innerexception)
end sub
'在这儿添加自定义成员
public connectstring as string
end class
列表4.自定义异常类
你从中收益的第二个基础结构是结构化异常处理（seh）。在最基本的层次，数据访问类能够暴露它的衍生自system.applicationexception 的exception（异常）对象并能进一步暴露自定义成员。例如，列表4中显示的dalexception对象能用于包装数据访问类中的代码产生的异常。接着基类能暴露一个受保护的方法包装该异常，组装自定义成员，并把它发回给调用程序，如下所示：
protected sub throwdalexception(byval message as string, _
byval innerexception as exception)
dim newmine as new dalexception(message, innerexception)
newmine.connectstring = me.connection.connectionstring
me.writetrace(message & "{" & innerexception.message & "}")
throw newmine
end sub
使用这种方法，衍生类能简单地调用受保护的方法，传递进去一个特定的数据异常（典型的有sqlexception或者 oledbexception），该异常被截取并添加了从属于特定数据域的消息。基类在dalexception中包装该异常并把它发回到调用程序。这就允许调用程序用一个catch语句轻易地捕捉所有来自数据访问类的异常。
作为选择之一，你可以看一看msdn上发布的"exception management application block overview"。该框架组件通过一系列对象结合了异常和应用程序日志记录。实际上，通过从.net 框架组件提供的baseapplicationexception类衍生的自定义异常类能够简单地插入该框架组件。
规则4：仔细选择外部界面
在你设计数据访问类的方法时，需要考虑它们怎样接受和返回数据。对大多数开发人员来说，主要有三个选择：直接使用ado.net对象、使用xml、使用自定义类。
如果直接暴露ado.net对象，你能使用一到两个编程模型。第一个包括数据集和数据表对象，它们对不连接数据访问很有用。有很多关于数据集和与它关联的数据表的文章，但是当你必须使用从下层数据存储断开的数据时它才最有用处。换句话说，数据集能在应用程序各层之间传递，即使那些层在物理上是分布式的，当业务和数据服务层放置在同一群服务器上并且与表现服务分开时也能使用。此外，数据集对象是通过基于xml的web服务返回数据的理想方法，因为它们是可串行化的，因此能在soap回应消息中返回。
这与使用实现idatareader接口的类（例如sqldatareader 和oledbdatareader）访问数据不同。数据阅读器（data reader）用只向前的，只读的方式访问数据。两者之间最大的不同是数据集和数据表对象能在应用程序域之间传递，通过传递值（by value）实现，然而数据阅读器能在各处传递，但是一般通过引用（by reference）实现。在列表5中，read和getvalues在服务器过程中执行并且它们的返回值复制到客户端。
该图显示了数据阅读器怎样存活在应用程序域中，它在那儿它被建立，并且对它的所有访问结果都在客户端和服务器应用程序域之间的循环之中。这意味着当数据访问方法在相同的应用程序域运行时，应该返回数据阅读器作为调用者。
使用数据阅读器时有两个问题需要考虑。首先，当你从数据访问类的一个方法返回数据阅读器时，你必须考虑与数据阅读器关联的连接对象的生存期。默认情况是当调用程序通过数据阅读器重复时连接仍然是忙的，不幸的是当调用程序结束后，连接仍然打开，因此它不返回到连接池（如果允许连接池）。但是，当通过传递commandbehavior.closeconnection 枚举给command对象的executereader方法，连接的close方法被调用时，你能命令数据阅读器关闭它的连接。
其次，为了把表现层从特定的框架组件数据提供程序（例如sqlclient或者oledb）中分离出来，调用代码应该使用idatareader接口（例如sqldatareader）而不是具体类型来引用返回值。通过这种方法，如果应用程序后端从oracle移植到 sql server，或者数据访问类的一个方法的返回类型改变了，表现层也不需要更改。
如果你希望数据访问类返回xml，你可以从system.xml名字空间中的xmldocument和xmlreader中选择一个，它与数据集和idatareader类似。换句话说，当数据从数据源断开时你的方法应该返回一个xmldocument（或者xmldatadocument），然而xmlreader可用于访问xml数据的流。
最后，你也能决定与公共属性一起返回自定义类。这些类可以使用serialization（串行化）属性标记，这样它们就能跨越应用程序域复制。另外，如果你从方法中返回多个对象，就需要强化类型（strongly typed）的集合类。
imports system.xml.serialization
_
public class book : implements icomparable
public productid as integer
public isbn as string
public title as string
public author as string
public unitcost as decimal
public description as string
public pubdate as date
public function compareto(byval o as object) as integer _
implements icomparable.compareto
dim b as book = ctype(o, book)
return me.title.compareto(b.title)
end function
end class
public notinheritable class bookcollection : inherits arraylist
default public shadows property item(byval productid as integer) _
as book
get
return me(indexof(productid))
end get
set(byval value as book)
me(indexof(productid)) = value
end set
end property
public overloads function contains(byval productid as integer) as _
boolean
return (-1 <> indexof(productid))
end function
public overloads function indexof(byval productid as integer) as _
integer
dim index as integer = 0
dim item as book
for each item in me
if item.productid = productid then
return index
end if
index = index + 1
next
return -1
end function
public overloads sub removeat(byval productid as integer)
removeat(indexof(productid))
end sub
public shadows function add(byval value as book) as integer
return mybase.add(value)
end function
end class
列表6.使用自定义类
上列表（列表6）包含了一个简单的book类和与它关联的集合类的例子。你能注意到book类用serializable做了标记，使它跨越应用程序域能使用"by value"语法。该类实现了icomparable接口，因此当它包含在一个集合类中的时候，默认情况下它将按title排序。bookcollection类从system.collections名字空间的arraylist衍生，并且为了将该集合限制到book对象而隐藏了item属性和add方法。
通过使用自定义类你完全地控制了数据的表现、开发人员的效率并且没有依赖ado.net的调用。但是这种途径需要更多的代码，因为.net框架组件没有包含任何与对象相关的技术映射。在这种情况下，你应该在数据访问类中建立一个数据读取器并使用它来组合自定义类。
规则5：抽象.net框架组件数据提供程序
最后一条规则说明了为什么和怎样抽象数据访问类内部使用的.net框架组件数据提供程序（data provider）。先前我说过ado.net编程模型暴露了特定的.net框架组件数据提供程序，包括sqlclient、oledb和其它msdn online web站点上可用的。但是这种设计的结果是提高性能，为数据提供程序暴露特定数据源功能的能力，它强迫你决定使用那种数据提供程序编码。换句话说，开发人员典型地会选择使用sqlclient或oledb，接着在各自的名字空间直接对它们的类进行编程。
如果你想改变.net框架组件数据提供程序，你必须重新编写数据访问方法。为了避免这种情况发生，你可以使用abstract factory设计模式。使用这种模式，你能建立一个简单的类，它暴露方法来建立主要的.net框架组件数据提供程序对象（command、connection、data adapter和parameter），而那些对象基于传递给构造函数的.net框架组件数据提供程序的信息。列表7中的代码就是这样一个简单的类。
public enum providertype :int {sqlclient = 0, oledb = 1}
public class providerfactory {
public providerfactory(providertype provider) {
_ptype = provider;
_initclass();
}
public providerfactory() {
_initclass();
}
private providertype _ptype = providertype.sqlclient;
private bool _ptypeset = false;
private type[] _contype, _comtype, _parmtype, _datype;
private void _initclass() {
_contype = new type[2];
_comtype = new type[2];
_parmtype = new type[2];
_datype = new type[2];
// 为提供程序初始化类型
_contype[(int)providertype.sqlclient] = typeof(sqlconnection);
_contype[(int)providertype.oledb] = typeof(oledbconnection);
_comtype[(int)providertype.sqlclient] = typeof(sqlcommand);
_comtype[(int)providertype.oledb] = typeof(oledbcommand);
_parmtype[(int)providertype.sqlclient] = typeof(sqlparameter);
_parmtype[(int)providertype.oledb] = typeof(oledbparameter);
_datype[(int)providertype.sqlclient] = typeof(sqldataadapter);
_datype[(int)providertype.oledb] = typeof(oledbdataadapter);
}
public providertype provider {
get {
return _ptype;
}
set {
if (_ptypeset) {
throw new readonlyexception("provider already set to "
+ _ptype.tostring());
}
else {
_ptype = value;
_ptypeset = true;
}
}
}
public idataadapter createdataadapter(string commandtext,idbconnection
connection) {
idataadapter d;
idbdataadapter da;
d = (idataadapter)activator.createinstance(_datype[(int)_ptype],
false);
da = (idbdataadapter)d;
da.selectcommand = this.createcommand(commandtext, connection);
return d; }
public idataparameter createparameter(string paramname, dbtype
paramtype) {
idataparameter p;
p = (idataparameter)activator.createinstance(_parmtype[(int)_ptype],
false);
p.parametername = paramname;
p.dbtype = paramtype;
return p;
}
public idataparameter createparameter(string paramname, dbtype
paramtype, object value) {
idataparameter p;
p = (idataparameter)activator.createinstance(_parmtype[(int)_ptype],
false);
p.parametername = paramname;
p.dbtype = paramtype;
p.value = value;
return p;
}
public idbconnection createconnection(string connect) {
idbconnection c;
c = (idbconnection)activator.createinstance(_contype[(int)_ptype],
false);
c.connectionstring = connect;
return c;
}
public idbcommand createcommand(string cmdtext, idbconnection
connection) {
idbcommand c;
c = (idbcommand)activator.createinstance(_comtype[(int)_ptype],
false);
c.commandtext = cmdtext;
c.connection = connection;
return c;
}
}
列表7. providerfactory
为了使用该类，数据访问类的代码必须对多个.net框架组件数据提供程序实现的接口（包括idbcommand、idbconnection、idataadapter和idataparameter）进行编程。例如，为了使用一个参数化存储过程的返回值来填充数据集，必须在数据访问类的某个方法中有下面的代码：
dim _pf as new providerfactory(providertype.sqlclient)
dim cn as idbconnection = _pf.createconnection(_connect)
dim da as idataadapter = _pf.createdataadapter("usp_getbook", cn)
dim db as idbdataadapter = ctype(da, idbdataadapter)
db.selectcommand.commandtype = commandtype.storedprocedure
db.selectcommand.parameters.add(_pf.createparameter("@productid",dbtype.int32, id))
dim ds as new dataset("books")
da.fill(ds)
典型的情况是你在类的层次声明providerfactory变量并在数据访问类的构造函数中实例化它。另外，它的构造函数与从配置文件中读取的提供程序一起组装，而不应该是硬代码。你可以想象，providerfactory是数据访问类的一个重大的补充，并且能被包括进部件，分发给其它的开发人员。
结论
在web服务时代将建立越来越多的应用程序操作来自独立的应用程序层的数据。如果你遵循一些基本规则并形成习惯，编写数据访问代码将更快、更容易，并且更能重新使用，把你的错误保存到服务器，允许你保持数据独立。
新闻热点
疑难解答
图片精选
