第二：

alter   procedure  AllProce
@tablename   varchar ( 200 ) ,    -- 表名
@strGetFields   varchar ( 200 )  =   ' * ' ,   -- 查询列名
@PageIndex   int   =   1  ,          -- 页码
@pageSize   int   =   15 ,          -- 页面大小
@strWhere    varchar ( 100 )  =   '' ,      -- 查询条件
@strOrder   varchar ( 100 )  =   '' ,  -- 排序列名
@intOrder   bit   =   0 ,         -- 排序类型  1为升序
@CountAll   bigint  output               -- 返回纪录总数用于计算页面数    
as
begin
declare   @strSql   varchar ( 500 )   -- 主语句
declare   @strTemp   varchar ( 100 )  -- 临时变量
declare   @strOrders   varchar ( 50 )  -- 排序语句
declare   @table   varchar ( 70 )

declare     @SQL     nvarchar ( 1000 )
declare     @R   bigint
set     @SQL =   N ' select @R=count(*) from   ' + convert ( nvarchar ( 200 ), @TableName )
exec   SP_EXECUTESQL    @SQL ,  N '  @R BIGINT OUTPUT ' ,   @R  OUTPUT
set     @CountAll =    @R
if   @intOrder   =   0
begin
     -- 为0是升序
     set   @strTemp   =   ' >(select max '
     set   @strOrders   =    '  order by   ' + @strOrder + '  asc  '
end
else
begin
     -- 否则为降序
     set   @strTemp   =   ' <(select min '
     set   @strOrders   =   '  order by   ' + @strOrder + '  desc  '
end
if   @PageIndex   = 1          -- 第一页直接读出纪录
begin
     if   @strWhere   =   ''
     begin
          set   @strSql   =   ' select top  ' + str ( @pageSize ) + '   ' + @strGetFields + '  from  ' + @tablename + '   ' + @strOrders
      end
     else   
     begin
          set   @strSql   =   ' select top  ' + str ( @pageSize ) + '   ' + @strGetFields +   '  from  ' + @tablename + '  where  ' + @strWhere + '   ' + @strOrders
    
     end
end
else
begin
     set   @strSql   =   ' select top ' + str ( @pageSize ) + '   ' + @strGetFields + '  from  ' + @tablename + '  where  ' + @strOrder + '   ' + @strTemp + '  ( ' + @strOrder + ' ) '
                   + '  from (select top  ' + str (( @pageIndex - 1 ) * @pageSize ) + '   ' + @strGetFields + '  from  ' + @tablename +   '   ' + @strOrders +   ' ) as tempTable )  ' + @strOrders
         
     if   @strWhere   !=   '   '
     begin
        set   @strSql   =   ' select top  ' + str ( @pageSize ) +   '   ' + @strGetFields + '  from  ' + @tablename +   '  where  ' + @strOrder +   '   ' + @strTemp + '  ( ' + @strOrder + ' )  '
                    + '  from(select top  ' + str (( @pageIndex - 1 ) * @pageSize ) + '   ' + @strGetFields + '  from  ' + @tablename + '  where  ' + @strWhere + '   '   + @strOrders + ' ) as tempTable) where  ' + @strWhere + '   ' + @strOrders
   
     end
end  
exec ( @strSql )    
end
GO

下载链接

• 下载CodeSmith 30天免费试用用专业版
• 下载最新的 .NetTiers模板
• 观看本文章的相关视频演示

介绍

通过本文你可以学习到如何利用微软企业库、CodeSmith、.NetTiers模板在少于15分钟内快速构建数据访问层。

从现在起我们把数据访问层（Data Access Layer）简称为DAL，它是程序中和数据库进行交互的层。手写DAL层代码是非常枯燥无味，浪费时间的重复活动，还有可能在编译程序的时候出现好多漏洞。

我们需要确保已经安装了SQL Server的Northwind数据库，但是这个例子也可以运行在其它任何数据库上。当然了，看完文章后你将不会再单调无味的浪费时间去为你的应用程序写DAL层代码了，而是更快、更简单。

如果你看完这篇文章你将会在1分钟内使用最佳实践来创建一个数据访问层（其它14分钟是用来第一次下载所需的软件）。

代码生成概述

代码生成，或者使用工具软件生成代码，不是一个新的概念。实际上，代码生成已经很普遍了。本篇文章我们用CodeSmith来生成DAL层的代码以及T-SQL脚本。

CodeSmith是一个开发者常用工具，它可以使用模板来输出你想要的格式代码。你可以使用模板来生成任何你想要的代码，功能特别强大，本文就是用了一个.NetTiers模板。

第一步 安装软件

首先我们就是下载CodeSmith和.NetTiers，其中前者是30天试用版（当然网上也有破解工具，当前最新版是3.2，是for .net 2.0的，我们下载3.1或者3.0版就行）

下载并安装CodeSmith

http://www.codesmithtools.com/

CodeSmith已经内置了好多模板，并且我们一会儿会让它包含进我们需要的.NetTiers模板，安装好CodeSmith，我们下载.NetTiers模板库。

为CodeSmith下载.NetTiers模板库

http://cstemplates.sourceforge.net

在上面的地址里下载最新的.NetTiers模板库安装文件。

最后一步就是确保你安装了SQL Server数据库并且准备好连接到数据库的连接字符串。

第二步– CodeSmith

打开CodeSmith，我们先快速熟悉一下它的用法。

前文介绍过CodeSmith是一个模板驱动的工具。在CodeSmith的右边有一个模板浏览器窗口，它可以让你快速使用你已经安装的模板，见下图。

我们先来学习一下使用模板，双击Hashtable.cst模板。

Hashtable.cst是用来生成强类型集合的hashtable类型的模板。我们再来快速看一下CodeSmith的另一个窗口，属性窗口。

属性窗口可以让你来设置模板的属性，如果使用Hashtable.cst模板，我们需要设置ClassName,ItemType和KeyType属性。举个例子，我们要创建一个Person对象的集合，并且使用integer类型键来访问的PersonCollection集合。你需要把在属性窗口里把ClassName设置成PersonCollection,ItemType设置成Person，KeyType设置成int。点击工具栏里的run按钮，就可以生成你需要的强类型集合的源码了。

你看一下Hashtable.cst你就会发现它有点儿像ASP.NET的语法，其实CodeSmith模板就是使用类似ASP.NET的形式来生成你想要的代码，只不过是ASP.NET是用来生成HTML代码的，而CodeSmith是用来生成你需要的源代码的。

你要记住的一点是CodeSmith不会自动生成你需要的代码，但你可以自己定义模板来生成所有你想要的代码。

第三步 –生成数据访问层

我们已经基本理解了CodeSmith的用法，现在来演示如何使用.NetTiers模板。

记住，CodeSmith允许你快速的生成代码，并且很少会有手写代码造成的错误。.NetTiers模板生成的代码也是微软推荐的数据访问的最佳实践。

First we need to add the .NetTiers templates to the CodeSmith Template Explorer:

首先我们需要把.Nettiers模板添加到模板浏览器窗口。

1. 在模板浏览器点击打开目录图标并浏览包含模板的目录
2. 选择.NetTiers的安装目录，我的安装目录是是C:\Program Files\SerialCoder\NetTiers 0.9.2 - Caribert\Templates\
3. 选择后就会在模板浏览器窗口里添加一个文件夹，展开它并选中NetTiers.cst模板
4. 现在我们来配置数据连接字符串，打开NetTiers.cst模板，在属性窗口里点击SourceDataBase属性后面的对话框。
   
5. 在这个窗口里你可以新创建一个自己的数据源，如下图。
   
6. 测试一下连接是否成功，点击OK按钮关闭此窗口，然后选择你刚才创建的数据源名字。
7. 最后，这是EntireDatabase属性为True，NameSpace属性为Demo,OutputDirectory属性为你想输出的目录，当然你需要提前创建好要生成代码的目录。

至此，你已经完成了NetTiers.cst模板的所有属性设置，它看起来应该如下图。

当然我们没有告诉你所有的关于.NetTiers的属性设置，但是对于生成扑通的DAL层代码已经足够了，点击工具栏里Run按钮（小箭头）就可以生成代码了。

注意：你建立的数据表一定要设置主建哦，如果没有主建，这个表就不会生成响应的代码，你点了Run按钮后会弹出一个报表，你可以看到都生成了哪些表的相关代码。

第四步 – 查看生成的代码

用Visual Studio .NET打开你刚才设置的代码输出目录里（我设置的是c:\NetTiers\Northwind_Demo\ directory）的Demo.sln解决方案。

我们来快速看一下解决方案包含的项目和文件。

You should find 3 projects within the solution:

你会看到有解决方案里包含3个项目

• Demo –此项目包含了你要和数据库交互的主要的类。
• Demo.DataAccessLayer –  此类库包含了实际的数据库操作执行代码
• Demo.DataAccessLayer.SqlClient –此类库包含了微软推荐的访问数据库的设计模式和最佳实践(Microsoft Patterns & Practices classes)的代码。

第五步–编译、完成

接下来，我们用Visual Studio来编译项目。

祝贺你，你现在已经有了一个使用微软推荐的访问数据库的最佳实践的数据库访问层

现在你就可以在其它项目里使用你的DAL层了，举个例子，你需要获取，更新和删除一条员工的记录。

using Demo.DataAccessLayer.SqlClient;

// Select by primary key

Employee employee = SqlDataRepository.EmployeeProvider.GetByEmployeeID(13);

employee.FirstName = "John";

employee.LastName = "Doe";

// Save changes

SqlDataRepository.EmployeeProvider.Save(employee);

// Delete record

SqlDataRepository.EmployeeProvider.Delete(employee);

关于更多生成DAL层的信息，参考下面的.NetTiers的链接。

http://cstemplates.sourceforge.net/nettiers-manual-v1.html

记住，你的数据访问层的代码都是通过模板生成的。如果你修改了数据库的结构，你只需要简单的通过模板重新生成一下DAL层代码就行了。（当然了，如果你在重新生成代码前修改了一下生成的代码，再重新生成就给你覆盖了，这个怎么办呢，比较麻烦，你可以写一个继承自自动生成类的子类，在那里重写相关的方法，或者在.NET 2.0里使用多文件类）另外你可以根据你的想法扩展你的模板，包括注释，命名约定，模式等等。

小节

CodeSmith可以根据你的模板生成任何你想要的代码，本文向你演示了如何在短短几分钟内使用.NetTiers模板来在你应用程序中创建使用访问数据库最佳实践的数据库访问层。

你可以在这里查看视频演示：

http://community.codesmithtools.com/r.ashx?id=1

CodeSmith 3.1的一个新特征就是可以计算代码行。它可以保守的计算CodeSmith生成的代码。

这里可以看到.NetTiers生成了91,559行代码。假设一个很厉害的程序员一小时可以写60行代码，写完这些代码需要1，800小时。加入一个厉害的程序员你每小时要付给它接近60美元，CodeSmith和.NetTiers帮你公司节省了1,800小时的时间和109,000美元。（好像夸张了点儿哦。）

现在获取一个CodeSmith并发挥它的威力吧。

CodeSmith和.NetTiers 相关资源

如果你对CodeSmith有一些问题，可以访问它的社区来获取解决: http://community.codesmithtools.com. CodeSmith社区里有好多人写的模板并共享给每个人下载，你可以去看看有没有自己需要的。

如果你想想购买CodeSmith，可以访问它的网站http://www.codesmithtools.com. 你可以获取一个授权来免除30天试用的限制。如果你还有问题，可以给它们的售后支持邮箱发email sales@codesmithtools.com.

如果你对.NetTiers模板有问题，可以访问下面的论坛:

http://community.codesmithtools.com/forums/16/ShowForum.aspx

英文链接：

Build a Data Access Layer in less than 15 minutes

http://community.codesmithtools.com/blogs/tutorials/archive/2006/02/13 /nettiers.aspx

另外借此贴调查一下各位的持久层用的都是什么呀，NHibernate, ibatis.net，DAAB,SPL，SQLHelper,CMP还是其它的，我想以后在项目中主要用一下企业库里的DAAB，不知道适合适合企业开发，它有那些缺点呀。

Anders Hejlsberg谈C#、Java和C++中的泛型

原著：Bill Venners、Bruce Eckel  2004.2.26
原文：http://www.artima.com/intv/generics.html翻译：lover_P
出处：http://www.cstc.net.cn/docs/docs.php?id=258

[人物介绍]

    Anders Hejlsberg，微软著名工程师，带领他的小组设计了C#（读作：C-Sharp）程序设计语言。Hejlsberg第一次登上软件界历史舞台是在80年代早期，因为他为MS-DOS和CP/M设计了Pascal编译器。当时，还是一个小公司的Borland很快雇用了他，并买下了他的编译器，改称Turbo Pascal。在Borland，Hejlsberg继续开发Turbo Pascal，并最终带领他的小组设计了Turbo Pascal的替代品：Delphi。1996年，在进入Borland 13年后，Hejlsberg加入了微软。最初，他做Visual J++和Windows Fundatioin Classes（WFC）的架构师。随后，Hejlsberg成为C#的首席设计师和.NET Framework的关键参与者。目前，Anders Hejlsberg还在领导着C#程序设计语言的继续开发。

    Bruce Eckel，Think in C++（C++编程思想）和Think in Java（Java编程思想）的作者。

    Bill Venners，Artima.com的主编。

[内容]

• 泛型概述
• C#中的泛型
• C#泛型和java泛型的比较
• C#泛型和C++模板的比较
• C#泛型中的约束

泛型概述

    Bruce Eckel：您能对泛型做一个快速的介绍么？

    Anders Hejlsberg：泛型其实就是能够向你的类型中加入类型参数的一种能力，也称作参数化的类型或参数多态性。最著名的例子就是List集合类。一个List是一个易于增长的数组。它有一个排序方法，你可以为 它做索引，等等。现在，如果没有参数化的类型，那么不论使用数组还是使用List都不是很好。如果你使用数组，你能获得强类型，因为你可以声明一个Customer类型的数组，但你失去了可增长性和那些方便的方法；如果你使用一个List，你能够得到所有的便利，但你失去了强类型。你难以说出一个List是什么（类型的）List，它只是一个Object的List【译注：“什么类型的List”指的是List存放的元素是什么类型的】。这会给你带来麻烦 ，因为类型只能在运行形时进行检查，也就是说在编译时不会进行类型检查。就算你硬要把一个Customer放进一个List并试图从中得到一个String，编译器也不会不高兴。在运行之前你根本无法发现它不能工作。同时，当你将简单类型【译注：指值类型】放入List时，还必须对它们进行装箱。正是由于这些问题，你不得不在List和数组之间徘徊，你经常要很痛苦地决定应该使用哪一个。

    泛型的伟大之处在于你现在可以尽情地享受你的蛋糕了，因为你能够定义一个List<T>（读作：List of T）【译注：中文可以说成“T类型的List”】。当你使用List时，你居然能够说出它是什么类型的List，并且你将获得强类型，编译器会为你检查它的类型。这些只是直觉上的好处，它还有其它许多优点。当然，你并不是只能将它用于List，Hastable、Dictionary（将键影射到值上的数据结构）——所有你想调用的都行。你可能想将String影射到Customer、将int影射到Order，在这些情况下你都能获得强类型。

C#中的泛型

    Bill Venners：泛型在C#中是如何工作的呢？

    Anders Hejlsberg：在没有泛型的C#中，你只能写class List {...}；而在带有泛型的C#中，你可以写class List<T> {...}，这里的T是一个类型参数。在List<T>中，你可以把T就当作一个类型来用。当它实际用来建立一个List对象时，你要写List<int>或List<Customer>。这样你就从List<T>构造了一个新的类型，看起来就好像你用你的类型变量替换了所有的类型参数。所有的T都变成了int或Customer，你无须进行向下转换，它们是强类型的，任何时候都会被检查。

    在CLR（Common Language Runtime，公共语言运行时）中，当你编译List<T>或其它泛型类型时，它们和普通类型一样被转换为IL（Intermediate Language，中间语言）和元数据。IL和元数据带有附加信息，可以知道这是一个类型参数，当然，原则上泛型类型的编译和其它类型一样。在运行时，当你的应用程序第一次引用List<T>时，系统会看看你是否已经使用过List<int>。如果没有，它会调用JIT将带有int类型变量的List<T>编译为IL和元数据。当JIT即时编译IL时，同样会替换类型参数。

    Bruce Eckel：所以它是在运行时被实例化的。

    Anders Hejlsberg：它确实是在运行时实例化。它在需要的时候才产生特定的原生代码（native code）。字面上，当你说List<T>时，你会得到一个int类型的List。如果泛型类型中使用的是T类型的数组，它会变成int类型的数组。

    Bruce Eckel：这个类会在某一时刻被垃圾收集器收集么？

    Anders Hejlsberg：是也不是，这是一个正交的问题。它会在该程序集中建立一个类，这个类在程序集中会一直存在。如果你终止了程序集，这个类会消失，和其它类一样。

    Bruce Eckel：但如果我的程序中声明了一个List<int>和一个List<Cat>，但我从未使用过List<Cat>……

    Anders Hejlsberg：……那么系统不会实例化List<Cat>。当然，下面的情况除外。如果你使用NGEN产生一个镜像，也就是说如果你预先生成了一个原生代码的镜像，会预先实例化。但是如果你在一般的环境下运行，则这个实例化是纯需求驱动（demand driven）的，会尽可能地延迟【译注：正如上面所说，直到使用时才进行实例化】。

    实际上，我们所要进行实例化的所有类型都是值类型——如List<int>、List<long>、List<double>、List<float>——我们为每一个都建立一份唯一的可执行原生代码的拷贝。因此，List<int>有它自己的代码，List<long>有它自己的代码，List<float>有它自己的代码。对于所有的引用类型我们共享它们的代码，因为它们在表现上是一样的，它们只是一些指针。

    Bruce Eckel：因此你只需要转换。

    Anders Hejlsberg：不，实际上是不需要的。我们可以共享原生镜像，但他们实际上具有独立的VTable。我要指出的是，我们只是尽量对代码进行有意义的共享，但我们很清楚，为了效率，有很多代码是不能共享的。典型的就是值类型，你会很关心List<int>中到底是不是int。你肯定不希望将它们被装箱为Object。对值类型进行装箱是一种共享的方法，但对它们进行装箱开销会很大。

    Bill Venners：对于引用类型，所不同的只是类。List<Elephant>不同于List<Orangutan>，但他们实际上共享了所有方法的代码。

    Anders Hejlsberg：是的。作为实现的细节，它们实际上共享了相同的原生代码。

C#泛型和java泛型的比较

    Bruce Eckel：如何比较C#中的泛型和java中的泛型呢？

    Adners hejlsberg：Java的泛型最初是基于Martin Odersky和其它人一起做的称作Pizza的一个项目的。Pizza后改名为GJ，然后成为JSR，最后以被Java语言收容而告终。这种泛型以能够在原有的VM（Virtual Machine，虚拟机）上运行为关键设计目标。也就是说，你不必修改你的VM，但它会带来很多限制。这些限制并不会很快出现，但很快你就会说：“嗯，这有点陌生。”

    例如，使用Java泛型，我觉得你实际上不会获得任何的执行效率，因为当你编译一个Java泛型类时，编译器会将所有的类型参数替换为Object。当然，如果你尝试建立一个List<int>，你就需要对所有的int进行装箱。因此，这会有很大的开销。另外，为了让VM高兴，编译器必须为所有的类型插入类型转换。如果一个List是Object的，而你想将这些Object视为Customer，就必须将Object转换为Customer，以让类型检查器满意。而它在实现这些的时候，真的只是为你插入所有这些类型转换。因此，你只是尝到了语法上的甜头，却没有获得任何执行效率。所以我觉得这是（泛型的）Java实现的头号问题。

    第二号问题，我觉得也是一个很严重的问题，这就是由于Java泛型是依靠消除所有的类型参数来实现的，你就无法在运行时获得一个和编译时同样可靠的表现。当你在Java中反射一个泛型的List的时候，你无法得知这是个List什么类型的List。它只是一个List。因为你失去了类型信息，任何由代码生成方案或基于反射的方案所产生的动态类型都将无法工作。唯一让我认为清晰的趋势就是，越来越多的东西将不能运行，就是因为你丢掉了类型信息。但在我们的实现中，所有这些信息都是可用的。你可以使用反射来获得List<T>对象的System.Type。但你还不能建立它的一个实例，因为你并不知道T是什么。但是接下来你可以使用反射来获得int的Sytem.Type。然后你就可以请求反射将这两个System.Type结合起来并建立一个List<int>，然后你还能获得List<int>的另一个System.Type。因此，所有你在编译期间能做的在运行时同样可以。

C#泛型和C++模板的比较

    Bruce Eckel：如何比较C#泛型和C++模板呢？

    Anders Hejlsberg：我认为对C#泛型和C++模板之间的区别最好的理解是：C#泛型更像类，只不过它带有类型参数；C++模板接近宏，只不过它看起来像类。

    C#泛型和C++模板之间最大的区别在于类型检查发生的时机和如何进行实例化。首先，C#在运行时进行实例化。而C++在编译时，或者可能是连接时进行实例化。不管怎么说，C++是在程序运行前进行实例化。这是第一点不同。第二点不同是当你编译泛型类型时，C#会进行强类型检查。对于一个非约束的类型参数，如List<T>，能够在类型为T的值上执行的方法仅仅是那些能够在Object类型中找到的方法，因为只有这些方法是我们能够保证存在的。在C#中，我们要保证在一个类型参数上执行的所有操作都能成功。

    C++正相反。在C++中，你可以在类型参数所指定的类型的变量上执行你想做的任何操作。但是一旦你对它进行了实例化，它就有可能无法工作，你将会得到一些含义模糊的错误信息。例如，如果你有一个类型参数T，而x和y是T类型的变量，然后你执行x+y，如果你对两个T定义了一个operator+还好说，否则你就只能得到一些没意义的错误消息。因此，从某种意义上说，C++模板实际上是无类型的，或者说是弱类型的。而C#泛型是强类型的。

C#泛型中的约束

    Bruce Eckel：约束是如何在C#泛型中工作的呢？

    Anders Hejlsberg：在C#泛型中，我们能够为类型参数施加约束。以我们的List<T>为例，你可以说class List<T> where T : IComparable。这意味着T必须实现IComparable接口。

    Bruce Eckel：有意思。在C++中，约束是隐式的。

    Anders Hejlsberg：是的。在C#中我们也可以这样做。譬如我们有一个Dictionary<K, V>，它有一个Add()方法，这个方法带有K key和V value参数。Add()方法的实现将希望能够将传递进来的key和Dictionary中已经存在的key进行比较，而且它希望使用一个称作IComparable的接口。唯一的途径就是将key参数转换为IComparable接口，然后调用CompareTo方法。当然，当你这么做的时候，你就为K类型和key参数建立了一个隐式的约束。如果传递进来的key没有实现IComparable接口，你会得到一个运行时错误。这在你的所有方法中都有可能出现，因为你的约定没有要求key必须实现IComparable接口。当然，你还得为运行时类型检查付出代价，因为你实际上进行了动态类型转换。

    使用约束，你可以消除代码中的动态检查，而在编译时或装载时进行。当你要求K必须实现IComparable接口时，会发生很多事情。对于K类型的值，你现在可以直接访问接口方法而无需类型转换。因为程序在语义上可以保证它实现了这个接口。无论什么时候你尝试建立这个类型的一个实例时，编译器都会检查这些类型是否实现了这个接口，如果没有实现，会给你一个编译错误。如果你使用的是反射，你会得到一个异常。

    Bruce Eckel：你是说编译器和运行时（都会进行检查）？

    Anders Hejlsberg：编译器会检查它，但你仍有可能在运行时通过反射来做这些，因此系统还会检查它。正像我前面说的，编译时可以做的任何事都可以在运行是通过反射来做。

    Bruce Eckel：我可以做一个函数模板，换句话说，一个带有不知道类型的参数的函数？你为约束添加了强类型检查，但我是不是能像C++模板那样得到一个弱类型模板？ 例如，我能否写一个函数，它带有两个参数A a和B b，并在代码中写a+b？我能不能说我不在乎对于A和B是否有operator+，因为它们是弱类型的？

    Anders Hejlsberg：你真正要问的问题应该是这在约束中如何说吧？约束，和其他特性一样，最终将可以是任意复杂的。当你考虑它的时候，约束只是一个模式匹配机制。你可能希望能够说“这个类型参数必须有一个带有两个参数的构造器、实现了operator+、有这个静态方法、有那两个实例方法、等等”。问题是，你希望这种模式匹配机制有多复杂？

    从没有任何东西到完全模式匹配是一个整个的连续体。没有任何东西（的模式匹配）太小了，不能说明问题；而完全模式匹配又太复杂了，因此我们需要在中间找一个平衡点。我们允许你将约束指定为一个类、一个或多个接口，以及一些构造器约束。譬如，你可以说：“这个类型必须实现IFoo和IBar”或“这个类型必须继承基类X”。一旦你这么做了，在编译时和运行时都会检查这个约束是否为真。这个约束所隐含的任何方法对于类型参数所指定的类型的值都是直接有效的。

    现在，在C#中，运算符是静态成员。因此，运算符不能是接口的成员，因此接口约束不能带给你operator+。你只能通过类约束获得operator+，你可以说这个类型参数必须继承自比如说Number类，并且Number类对于两个Nubmer有operator+。但你不能抽象地说“必须有一个operator+”，我们无法知道这句话的具体含义。

    Bill Venners：你通过类型进行约束，而不是签名。

    Anders Hejlsberg：是的。

    Bill Venners：因此这个类型必须扩展一个类或实现一个接口。

    Anders Hejlsberg：是的。而且我们还能够走得更远。实际上我们也想过再走远一些，但这会变得相当复杂。而且增加的复杂性与所得到的相比很不值得。如果你想做的事情在约束系统中不直接支持，你可以使用一个工厂模式。例如你有一个Martix<T>，而在这个Martix（矩阵）中，你可能想定义一个“点乘”【译注：矩阵上的一种乘法运算，另一种称为“叉乘”】方法。这意味着你最终将要考虑如何将两个T相乘，但你不能将这说成是一个约束，至少当T不是int、double或float时你不能这么说。但你可以让你的Martix带有一个Calculator<T>作为参数，而在Calculator<T>中，有一个称为Multiply的方法。你可以在其中进行实现，并将结果传递给Martix。

    Bruce Eckel：而且Calculator也是一个参数化的类型。

    Anders Hejlsberg：是的。这有些像工厂模式，还有很多方法可以做到，这也许不是你最喜欢的方法，但做任何事情都要付出代价。

    Bruce Eckel： 是呀，我开始认为C++模板是一种弱类型机制。而当你想其中添加了约束后，你从弱类型走向了强类型。但这一定会带来更多的复杂性。这就是代价吧。

    Anders Hejlsberg： 关于类型你可以认为它是一个标尺。这个标尺定得越高，程序员的日子就会越不好过，但更高的安全性随之而来。但你可以把这个标尺向任何一个方向调节。