2005年11月10日

前一章讨论了数据类型和它们的用法。现在我们转移到C#中至关重要的结构——类。没有了类,就连简单的C#程序都不能编译。这一章假定你知道了一个类的基本组成部分:方法、属性、构造函数和析构函数。 C#在其中增加了索引和事件。

在这一章中,你学到下列有关类的话题。
。 使用构造函数和析构函数
。给类写方法
。给一个类增加属性存取标志
。实现索引
。创建事件并通过代表元为事件关联客户
。应用类、成员和存取修饰符。

5.1
构造函数和析构函数

在你可以访问一个类的方法、属性或任何其它东西之前, 第一条执行的语句是包含有相应类的构造函数。甚至你自己不写一个构造函数,也会有一个缺省的构造函数提供给你。

class TestClass
{
public TestClass(): base() {} //
由编译器提供
}

一个构造函数总是和它的类名相同,但是,它没有声明返回类型。总之,构造函数总是public的,你可以用它们来初始化变量。

public TestClass()
{
//
在这给变量
//
初始化代码等等。
}

如果类仅包含静态成员(能以类型调用,而不是以实例调用的成员),你可以创建一个private的构造函数。

private TestClass() {}
尽管存取修饰符在这一章的后面将要大篇幅地讨论,但是private意味着从类的外面不可能访问该构造函数。所以,它不能被调用,且没有对象可以自该类定义被实例化。并不仅限于无参数构造函数——你可以传递初始参数来初始化成员。
public TestClass(string strName, int nAge) { … }

作为一个C/C++程序员,你可能习惯于给初始化写一个附加的方法,因为在构造函数中没有返回值。当然,尽管在C#中也没有返回值,但你可以引发一个自制的异常,以从构造函数获得返回值。更多有关异常处理的知识在第七章 "异常处理"中有讨论。但是,当你保留引用给宝贵的资源,应该想到写一个方法来解决:一个可以被显式地调用来释放这些资源。问题是当你可以在析构函数(以类名的前面加"~"的方式命名)中做同样的事情时,为何还要写一个附加的方法.
public ~TestClass()
{
//
清除
}

你应该写一个附加方法的原因是垃圾收集器,它在变量超出范围后并不会立即被调用,而仅当间歇期间或内存条件满足时才被触发。当你锁住资源的时间长于你所计划的时间时,它就会发生。因此,提供一个显式的释放方式是一个好主意,它同样能从析构函数中调用。
public void Release()
{
//
释放所有宝贵的资源
}

public ~TestClass()
{
Release();
}

调用析构函数中的释放方法并不是必要的——总之,垃圾收集会留意释放对象。但没有忘记清除是一种良好的习惯。

5.2
方法

既然对象能正确地初始化和结束,所剩下来的就是往类中增加功能。在大多数情况下,功能的主要部分在方法中能得到实现。你早已见过静态方法的使用,但是,这些是类型()的部分,不是实例(对象)。为了让你迅速入门,我把这些方法的烦琐问题安排为三节:
。方法参数
。改写方法
。方法屏蔽

5.2.1
方法参数

因方法要处理更改数值,你多多少少要传递值给方法,并从方法获得返回值。以下三个部分涉及到由传递值和为调用者获取返回结果所引起的问题。

。输入参数
。引用参数
。输出参数

5.2.1.1
输入参数

你早已在例子中见过的一个参数就是输入参数。你用一个输入参数通过值传递一个变量给一个方法——方法的变量被调用者传递进来的值的一个拷贝初始化。清单5.1 示范输入参数的使用。
清单 5.1 通过值传递参数

1: using System;
2:
3: public class SquareSample
4: {
5: public int CalcSquare(int nSideLength)
6: {
7: return nSideLength*nSideLength;
8: }
9: }
10:
11: class SquareApp
12: {
13: public static void Main()
14: {
15: SquareSample sq = new SquareSample();
16: Console.WriteLine(sq.CalcSquare(25).ToString());
17: }
18: }

因为我传递值而不是引用给一个变量,所以当调用方法时(见第16),可以使用一个常量表达式 (25)。整型结果被传回给调用者作为返回值,它没有存到中间变量就被立即显示到屏幕上。输入参数按C/C++程序员早已习惯的工作方式工作。如果你来自VB,请注意没有能被编译器处理的隐式ByValByRef——如果没有设定,参数总是用值传递。这点似乎与我前面所陈述的有冲突:对于一些变量类型,用值传递实际上意味着用引用传递。迷惑吗? 一点背景知识也不需要:COM中的东西就是接口,每一个类可以拥有一个或多个接口。一个接口只不过是一组函数指针,它不包含数据。重复该数组会浪费很多内存资源;所以,仅开始地址被拷贝给方法,它作为调用者,仍然指向接口的相同指针。那就是为什么对象用值传递一个引用。

5.2.1.2
引用参数

尽管可以利用输入参数和返回值建立很多方法,但你一想到要传递值并原地修改它(也就是在相同的内存位置),就没有那么好运了。这里用引用参数就很方便。

void myMethod(ref int nInOut)
因为你传递了一个变量给该方法(不仅仅是它的值),变量必须被初始化。否则,编译器会报警。

清单 5.2 显示如何用一个引用参数建立一个方法。

清单 5.2 通过引用传递参数

1: // class SquareSample
2: using System;
3:
4: public class SquareSample
5: {
6: public void CalcSquare(ref int nOne4All)
7: {
8: nOne4All *= nOne4All;
9: }
10: }
11:
12: class SquareApp
13: {
14: public static void Main()
15: {
16: SquareSample sq = new SquareSample();
17:
18: int nSquaredRef = 20; //
一定要初始化
19: sq.CalcSquare(ref nSquaredRef);
20: Console.WriteLine(nSquaredRef.ToString());
21: }
22: }

正如所看到的,所有你要做的就是给定义和调用都加上ref限定符。因为
变量通过引用传递,你可以用它来计算出结果并传回该结果。但是,在现
实的应用程序中,我强烈建议要用两个变量,一个输入参数和一个引用参
数。

5.2.1.3
输出参数

传递参数的第三种选择就是把它设作一个输出参数。正如该名字所暗示,
一个输出参数仅用于从方法传递回一个结果。它和引用参数的另一个区别
在于:调用者不必先初始化变量才调用方法。这显示在清单5.3中。

清单 5.3 定义一个输出参数

1: using System;
2:
3: public class SquareSample
4: {
5: public void CalcSquare(int nSideLength, out int
nSquared)
6: {
7: nSquared = nSideLength * nSideLength;
8: }
9: }
10:
11: class SquareApp
12: {
13: public static void Main()
14: {
15: SquareSample sq = new SquareSample();
16:
17: int nSquared; //
不必初始化
18: sq.CalcSquare(15, out nSquared);
19: Console.WriteLine(nSquared.ToString());
20: }
21: }


5.2.2
改写方法
面向对象设计的重要原则就是多态性。不要理会高深的理论,多态性意味
着:当基类程序员已设计好用于改写的方法时,在派生类中,你就可以重
定义(改写)基类的方法。基类程序员可以用
virtual
关键字设计方法:
virtual void CanBOverridden()
当从基类派生时,所有你要做的就是在新方法中加入override关键字:
override void CanBOverridden()
当改写一个基类的方法时,你必须明白,不能改变方法的访问属性——在
这章的后面,你会学到更多关于访问修饰符的知识。除了改写基类方法的
事实外,还有另一个甚至更重要的改写特性。当把派生类强制转换成基类
类型并接着调用虚拟方法时,被调用的是派生类的方法而不是基类的方
法。
((BaseClass)DerivedClassInstance).CanBOverridden();
为了演示虚拟方法的概念,清单 5.4 显示如何创建一个三角形基类,它
拥有一个可以被改写的成员方法(ComputeArea)。

清单 5.4 改写一个基类的方法
1: using System;
2:
3: class Triangle
4: {
5: public virtual double ComputeArea(int a, int b, int
c)
6: {
7: // Heronian formula
8: double s = (a + b + c) / 2.0;
9: double dArea = Math.Sqrt(s*(s-a)*(s-b)*(s-c));
10: return dArea;
11: }
12: }
13:
14: class RightAngledTriangle:Triangle
15: {
16: public override double ComputeArea(int a, int b,
int c)
17: {
18: double dArea = a*b/2.0;
19: return dArea;
20: }
21: }
22:
23: class TriangleTestApp
24: {
25: public static void Main()
26: {
27: Triangle tri = new Triangle();
28: Console.WriteLine(tri.ComputeArea(2, 5, 6));
29:
30: RightAngledTriangle rat = new RightAngledTriangle();
31: Console.WriteLine(rat.ComputeArea(3, 4, 5));
32: }
33: }

基类Triangle定义了方法ComputeArea。它采用三个参数,返回一个double结果,且具有公共访问性。从Triangle类派生出的是RightAngledTriangle,它改写了ComputeArea 方法,并实现了自己的面积计算公式。两个类都被实例化,且在命名为TriangleTestApp的应用类的Main() 方法中得到验证。我漏了解释第14行:
class RightAngledTriangle : Triangle
在类语句中冒号(:)表示RightAngledTriangle从类 Triangle派生。那就是你所必须要做的,以让C#知道你想把 Triangle当作RightAngledTriangle的基类。当仔细观察直角三角形的ComputeArea方法时,你会发现第3个参数并没有用于计算。但是,利用该参数就可以验证是否是“直角”。如清单5.5所示。

清单 5.5 调用基类实现

1: class RightAngledTriangle:Triangle
2: {
3: public override double ComputeArea(int a, int b, int c)
4: {
5: const double dEpsilon = 0.0001;
6: double dArea = 0;
7: if (Math.Abs((a*a + b*b – c*c)) > dEpsilon)
8: {
9: dArea = base.ComputeArea(a,b,c);
10: }
11: else
12: {
13: dArea = a*b/2.0;
14: }
15:
16: return dArea;
17: }
18: }

该检测简单地利用了毕达哥拉斯公式,对于直角三角形,检测结果必须为0。如果结果不为0,类就调用它基类的 ComputeArea来实现。
dArea = base.ComputeArea(a,b,c);
例子的要点为:通过显式地利用基类的资格检查,你就能轻而易举地调用基类实现改写方法。当你需要实现其在基类中的功能,而不愿意在改写方法中重复它时,这就非常有帮助。

5.2.3
方法屏蔽
重定义方法的一个不同手段就是要屏蔽基类的方法。当从别人提供的类派生类时,这个功能特

别有价值。看清单 5.6,假设BaseClass由其他人所写,而你从它派生出 DerivedClass

清单 5.6 Derived Class 实现一个没有包含于 Base Class中的方法

1: using System;
2:
3: class BaseClass
4: {
5: }
6:
7: class DerivedClass:BaseClass
8: {
9: public void TestMethod()
10: {
11: Console.WriteLine("DerivedClass::TestMethod");
12: }
13: }
14:
15: class TestApp
16: {
17: public static void Main()
18: {
19: DerivedClass test = new DerivedClass();
20: test.TestMethod();
21: }
22: }

在这个例子中, DerivedClass 通过TestMethod()实现了一个额外的功能。但是,如果基类的

开发者认为把TestMethod()放在基类中是个好主意,并使用相同的名字实现它时,会出现什么问题

呢?(见清单5.7

清单 5.7 Base Class 实现和 Derived Class相同的方法

1: class BaseClass
2: {
3: public void TestMethod()
4: {
5: Console.WriteLine("BaseClass::TestMethod");
6: }
7: }
8:
9: class DerivedClass:BaseClass
10: {
11: public void TestMethod()
12: {
13: Console.WriteLine("DerivedClass::TestMethod");
14: }
15: }

在优秀的编程语言中,你现在会遇到一个真正的大麻烦。但是,C#会给你提出警告:
hiding2.cs(13,14): warning CS0114: ‘DerivedClass.TestMethod()’ hides inherited member ‘BaseClass.TestMethod()’. To make the current method override that implementation, add the override keyword. Otherwise add the new keyword.
hiding2.cs(13,14):警告 CS0114:’DerivedClass.TestMethod()’ 屏蔽了所继承的成员
BaseClass.TestMethod()’
。要想使当前方法改写原来的实现,加上 override关键字。否则加上新的关键字。)
具有了修饰符new

———————————————-
 5.3 类属性
有两种途径揭示类的命名属性——通过域成员或者通过属性。前者是作为具有公共访问性的成员变量而被实现的;后者并不直接回应存储位置,只是通过 存取标志(accessors)被访问。当你想读出或写入属性的值时,存取标志限定了被实现的语句。用于读出属性的值的存取标志记为关键字get,而要修改属性的值的读写符标志记
set。在你对该理论一知半解以前,请看一下清单5.9中的例子,属性SquareFeet被标上了getset的存取标志。
清单 5.9 实现属性存取标志
1: using System;
2:
3: public class House
4: {
5: private int m_nSqFeet;
6:
7: public int SquareFeet
8: {
9: get { return m_nSqFeet; }
10: set { m_nSqFeet = value; }
11: }
12: }
13:
14: class TestApp
15: {
16: public static void Main()
17: {
18: House myHouse = new House();
19: myHouse.SquareFeet = 250;
20: Console.WriteLine(myHouse.SquareFeet);
21: }
22: }

House
类有一个命名为SquareFeet的属性,它可以被读和写。实际的值存储在一个可以从类内部访问的变量中——如果你想当作一个域成员重写它,你所要做的就是忽略存取标志而把变量重新定义为:
public int SquareFeet;
对于一个如此简单的变量,这样不错。但是,如果你想要隐藏类内部存储结构的细节时,就应该采用存取标志。在这种情况下,set 存取标志给值参数中的属性传递新值。(可以改名,见第10行。)除了能够隐藏实现细节外,你还可自由地限定各种操作:
get
set:允许对属性进行读写访问。
get only
:只允许读属性的值。
set only
:只允许写属性的值。
除此之外,你可以获得实现在set标志中有效代码的机会。例如,由于种种原因(或根本没有原因),你就能够拒绝一个新值。最好是没有人告诉你它是一个动态属性——当你第一次请求它后,它会保存下来,故要尽可能地推迟资源分配。

5.4
索引

你想过象访问数组那样使用索引访问类吗 ?使用C#的索引功能,对它的期待便可了结。

语法基本上象这样:
属性 修饰符 声明 { 声明内容}

具体的例子为
public string this[int nIndex]
{
get { … }
set { … }
}

索引返回或按给出的index设置字符串。它没有属性,但使用了public修饰符。声明部分由类型stringthis 组成用于表示类的索引。getset的执行规则和属性的规则相同。(你不能取消其中一个。) 只存在一个差别,那就是:你几乎可以任意定义大括弧中的参数。限制为,必须至少规定一个参数,允许ref out 修饰符。this关键字确保一个解释。索引没有用户定义的名字,this 表示默认接口的索引。如果类实现了多个接口,你可以增加更多个由InterfaceName.this说明的索引。

为了演示一个索引的使用,我创建了一个小型的类,它能够解析一个主机名为IP地址——或一个IP地址列表(http://www.microsoft.com为例 )。这个列表通过索引可以访问,你可以看一下清单

5.10
的具体实现。

清单 5.10 通过一个索引获取一个IP地址

1: using System;
2: using System.Net;
3:
4: class ResolveDNS
5: {
6: IPAddress[] m_arrIPs;
7:
8: public void Resolve(string strHost)
9: {
10: IPHostEntry iphe = DNS.GetHostByName(strHost);
11: m_arrIPs = iphe.AddressList;
12: }
13:
14: public IPAddress this[int nIndex]
15: {
16: get
17: {
18: return m_arrIPs[nIndex];
19: }
20: }
21:
22: public int Count
23: {
24: get { return m_arrIPs.Length; }
25: }
26: }
27:
28: class DNSResolverApp
29: {
30: public static void Main()
31: {
32: ResolveDNS myDNSResolver = new ResolveDNS();
33: myDNSResolver.Resolve("http://www.microsoft.com");
34:
35: int nCount = myDNSResolver.Count;
36: Console.WriteLine("Found {0} IP’s for hostname", nCount);
37: for (int i=0; i < nCount; i++)
38: Console.WriteLine(myDNSResolver[i]);
39: }
40: }

为了解析主机名,我用到了DNS类,它是System .Net 名字空间的一部分。但是,由于这个名字空间并不包含在核心库中,所以必须在编译命令行中引用该库:
csc /r:System.Net.dll /out:resolver.exe dnsresolve.cs
解析代码是向前解析的。在该 Resolve方法中,代码调用DNS类的静态方法GetHostByName,它返回一个IPHostEntry对象。结果,该对象包含有我要找的数组——AddressList数组。在退出Resolve 方法之前,在局部的对象实例成员m_arrIPs中,存储了一个AddressList array的拷贝(类型IPAddress 的对象存储在其中)。具有现在生成的数组 ,通过使用在类ResolveDNS中求得的索引,应用程序代码就可以在第3738行列举出IP地址。(在第6 "控制语句",有更多有关语句的信息。) 因为没有办法更改IP地址,所以仅给索引使用了get存取标志。为了简单其见,我忽略了数组的边界溢出检查。

5.4
事件

当你写一个类时,有时有必要让类的客户知道一些已经发生的事件。如果你是一个具有多年编程经验的程序员,似乎有很多的解决办法,包括用于回调的函数指针和用于ActiveX控件的事件接收(event sinks)。现在你将要学到另外一种把客户代码关联到类通知的办法——使用事件。事件既可以被声明为类域成员(成员变量),也可以被声明为属性。两者的共性为,事件的类型必定是代表元,而函数指针原形和C#的代表元具有相同的含义。每一个事件都可以被0或更多的客户占用,且客户可以随时关联或取消事件。你可以以静态或者以实例方法定义代表元,而后者很受C++程序员的欢迎。既然我已经提到了事件的所有功能及相应的代表元,请看清单5.11中的例子。它生动地体现了该理论。

清单5.11 在类中实现事件处理
1: using System;
2:
3: //
向前声明
4: public delegate void EventHandler(string strText);
5:
6: class EventSource
7: {
8: public event EventHandler TextOut;
9:
10: public void TriggerEvent()
11: {
12: if (null != TextOut) TextOut("Event triggered");
13: }
14: }
15:
16: class TestApp
17: {
18: public static void Main()
19: {
20: EventSource evsrc = new EventSource();
21:
22: evsrc.TextOut += new EventHandler(CatchEvent);
23: evsrc.TriggerEvent();
24:
25: evsrc.TextOut -= new EventHandler(CatchEvent);
26: evsrc.TriggerEvent();
27:
28: TestApp theApp = new TestApp();
29: evsrc.TextOut += new EventHandler
(theApp.InstanceCatch);
30: evsrc.TriggerEvent();
31: }
32:
33: public static void CatchEvent(string strText)
34: {
35: Console.WriteLine(strText);
36: }
37:
38: public void InstanceCatch(string strText)
39: {
40: Console.WriteLine("Instance " + strText);
41: }
42: }

4行声明了代表元(事件方法原形),它用来给第8行中的EventSource类声明TextOut事件域成员。你可以观察到代表元作为一种新的类型声明,当声明事件时可以使用代表元。该类仅有一个方法,它允许我们触发事件。请注意,你必须进行事件域成员不为null的检测,因为可能会出现没有客户对事件感兴趣这种情况。TestApp类包含了Main 方法,也包含了另外两个方法,它们都具备事件所必需的信号。其中一个方法是静态的,而另一个是实例方法。EventSource 被实例化,
而静态方法CatchEvent被预关联上了 TextOut事件:
evsrc.TextOut += new EventHandler(CatchEvent);
从现在起,当事件被触发时,该方法被调用。如果你对事件不再感兴趣,简单地取消关联:
evsrc.TextOut -= new EventHandler(CatchEvent);
注意,你不能随意取消关联的处理函数——在类代码中仅创建了这些处理函数。为了证明事件处理函数也和实例方法一起工作,余下的代码建立了TestApp 的实例,并钩住事件处理方法。事件在哪方面对你特别有用?你将经常在ASP+中或使用到WFC (Windows Foundation Classes)时,涉及到事件和代表元。

5.5
应用修饰符

在这一章的学习过程中,你已经见过了象publicvirtual等修饰符。欲以一种易于理解的方法概括它们,我把它们划分为三节:

。类修饰符
。成员修饰符
。存取修饰符

5.5.1
类修饰符

到目前为止,我还没有涉及到类修饰符,而只涉及到了应用于类的存取修饰符。但是,有两个修饰符你可以用于类:
abstract
——关于抽象类的重要一点就是它不能被实例化。只有不是抽象的派生类才能被实例化。派生类必须实现抽象基类的所有抽象成员。你不能给抽象类使用sealed 修饰符。
sealed
——密封 类不能被继承。使用该修饰符防止意外的继承,在.NET框架中的类用到这个修饰符。要见到两个修饰符的运用,看看清单5.12 ,它创建了一个基于一个抽象类的密封类(肯定是一个十分极端的例子)。

清单 5.12 抽象类和密封类

1: using System;
2:
3: abstract class AbstractClass
4: {
5: abstract public void MyMethod();
6: }
7:
8: sealed class DerivedClass:AbstractClass
9: {
10: public override void MyMethod()
11: {
12: Console.WriteLine("sealed class");
13: }
14: }
15:
16: public class TestApp
17: {
18: public static void Main()
19: {
20: DerivedClass dc = new DerivedClass();
21: dc.MyMethod();
22: }
23: }

5.5.2
成员修饰符

与有用的成员修饰符的数量相比,类修饰符的数量很少。我已经提到了一些,这本书即将出现的例子描述了其它的成员修饰符。以下是有用的成员修饰符:
abstract
——说明一个方法或存取标志不能含有一个实现。它们都是隐式虚拟,且在继承类中,你必须提供 override关键字。
const
——这个修饰符应用于域成员或局部变量。在编译时常量表达式被求值,所以,它不能包含变量的引用。
event
——定义一个域成员或属性作为类型事件。用于捆绑客户代码到类的事件。
extern
——告诉编译器方法实际上由外部实现。第10章 “和非受管代码互相操作” 将全面地涉及到外部代码。
override
——用于改写任何基类中被定义为virtual的方法和存取标志。要改写的名字和基类的方法必须一致。
readonly
——一个使用 readonly修饰符的域成员只能在它的声明或者在包含它的类的构造函数中被更改。
static
——被声明为static的成员属于类,而不属于类的实例。你可以用static 于域成员、方法、属性、操作符甚至构造函数。
virtual
——说明方法或存取标志可以被继承类改写。

5.5.3
存取修饰符

存取修饰符定义了某些代码对类成员(如方法和属性)的存取等级。你必须给每个成员加上所希望的存取修饰符,否则,默认的存取类型是隐含的。
你可以应用4个 存取修饰符之一:
public
——任何地方都可以访问该成员,这是具有最少限制的存取修饰符。
protected
——在类及所有的派生类中可以访问该成员,不允许外部访问。
private
——仅仅在同一个类的内部才能访问该成员。甚至派生类都不能访问它。
internal
——允许相同组件(应用程序或库)的所有代码访问。在.NET组件级别,你可以把它视为public,而在外部则为private
为了演示存取修饰符的用法,我稍微修改了Triangle例子,使它包含了新增的域成员和一个新的派生类(见清单 5.13)。

清单 5.13 在类中使用存取修饰符

1: using System;
2:
3: internal class Triangle
4: {
5: protected int m_a, m_b, m_c;
6: public Triangle(int a, int b, int c)
7: {
8: m_a = a;
9: m_b = b;
10: m_c = c;
11: }
12:
13: public virtual double Area()
14: {
15: // Heronian formula
16: double s = (m_a + m_b + m_c) / 2.0;
17: double dArea = Math.Sqrt(s*(s-m_a)*(s-m_b)*(s-m_c));
18: return dArea;
19: }
20: }
21:
22: internal class Prism:Triangle
23: {
24: private int m_h;
25: public Prism(int a, int b, int c, int h):base(a,b,c)
26: {
27: m_h = h;
28: }
29:
30: public override double Area()
31: {
32: double dArea = base.Area() * 2.0;
33: dArea += m_a*m_h + m_b*m_h + m_c*m_h;
34: return dArea;
35: }
36: }
37:
38: class PrismApp
39: {
40: public static void Main()
41: {
42: Prism prism = new Prism(2,5,6,1);
43: Console.WriteLine(prism.Area());
44: }
45: }

Triangle
类和 Prism 类现在被标为 internal。这意味着它们只能在当前组件中被访问

欢迎您加入C#的世界! 这一章将把您引进C#的天地,并回答一些相关的问题,如:您为什么要使用C#C++C#的主要有什么不同点,以及为什么C#使开发更容易而且还使您感到很有趣。

为什么是另外一种编程语言?
 必须回答的一个问题:当您已经使用C++VB从事企业开发时,为什么还要学习另一种语言? 市场式的回答就是:"在企业计算领域,C#将会变成为用于编写"下一代窗口服务"(Next Generation WindowsServices,简写为NGWS )应用程序的主要语言。" 这一章将对用参数请求提供支持,并陈列了C#的一些功能。这一章会使您开胃的。
 C#语言自C/C++演变而来。但是,它现代、简单、完全面向对象和类型安全。如果您是C/C++程序员,学习曲线将会很平坦。许多C#语句直接借用您所喜爱的语言,包括表达式和操作符。假如不仔细看,简直会把它当成C++
 关于C#最重要的一点:它是现代的编程语言。它简化和现代化了C++在类、名字空间、方法重载和异常处理等领域。屏弃了C++的复杂性,使它更易用、更少出错。
 对C#的易用有贡献的是减少了C++的一些特性,不再有宏、模板和多重继承。特别对企业开发者来说,上述功能只会产生更多的麻烦而不是效益。
 使编程更方便的新功能是严格的类型安全、版本控制、垃圾收集(garbage collect)等等。所有的这些功能的目标都是瞄准了开发面向组件的软件。

 在继续呈现出更多的功能之前,我想停下来并在下面说明C#至关重要的各种要素。

        
简单
        
现代
        
面向对象
        
类型安全
        
版本控制
        
兼容
        
灵活


简单

 C#具有C++所没有的一 个优势就是学习简单。该语言首要的目标就是简单。很多功能(还不如说是缺少了C++的一些功能)有助于C#全方位的简单。
 在C#中,没有C++中流行的指针。默认地,您工作在受管理的代码中,在那里不允许如直接存取内存等不安全的操作。我想没有C++程序员可以声称,从没有使用指针访问过不属于他们的内存。
 与指针&戏剧性&密切相关的是&愚蠢的&操作。在C++中,有::.、和>操作符,它们用于名字空间、成员和引用。对于新手来说,操作符至今仍是学习的一道难关。C#弃用其它操作符,仅使用单个操作符&&现在一个程序员所需要理解的就是嵌套名字的注解了。
 您不必记住基于不同处理器架构的隐含的类型,甚至各种整型的变化范围。C#使用统一的类型系统,屏弃了C++多变的类型系统。这种系统充许您把各种类型作为一个对象查看,它是一个原始类型还是一个full-blown 类。和其它编程语言相比,由于加框(boxing)和消框(unboxing)的机制,把简单类型当作对象处理并不能获得性能的改善。
稍后将详细解释加框和消框,但基本上仅当需要时才使用对象访问简单类型这种技术。
 首先,老练的程序员可能不喜欢它,但是整型和布尔型如今终归是两种完全不同的数据类型。这就意味着原来if语句中错误的赋值现在会被编译出错,因为if语句只接受布尔类型的值。再也不会出现误用赋值符为比较符这样的错误!
 C#同时也解决了存在于C++中已经有些年头的多余东西(redundancies)。这种多余包括常数预定义,不同字符类型等。鉴于多余表单已经从该语言中消失,故一般在C#中都可以使用表单了。

现代

 您投入学习C#的努力是一笔大投资,因为C#是为编写NGWS 应用程序的主要语言而设计。您 将会发现很多自己用C++可以实现或者很费力实现的功能,在C#中不过是一部分基本的功能而已。
 对于企业级的编程语言来说,新增的金融数据类型很受欢迎。您用到了一种新的十进制数据类型,它专用于金融计算方面。如果不喜欢这种现成简单的类型,根据您应用程序的特殊需求,可以很容易地创建出新的一种数据类型。
 我已经提到,指针不再是您编程武器的一部分。不要太惊讶,全面的内存管理已经不是您的任务。运行时NGWS提供了一个垃圾收集器,负责C#程序中的内存管理。因内存和应用程序都受到管理,所以很必要增强类型
安全,以确保应用的稳定性。
 对于C++程序员,异常处理的切不是新的东西,但它是C#的主要功能。C#的异常处理与C++的不同点在于它是交叉语言的(运行时的另一个功能)。在没有C#之前,您必须处理怪异的HRESULTs,但现在由于使用了基于异常的健壮的出错处理, 这一切都 结束了。
 对于现代的应用程序,安全是首要的,C#也不会例外。它提供了元数据语法,用于声明下述NGWS安全模式的能力和许可。元数据是NGWS运行时的一个关键的概念,下一章将涉及到它更深的含义。

面向对象

 您不会预料一种新语言不支持面向对象的功能吧? C#当然支持所有关键的面向对象的概念,如封装、继承和多态性。完整的C#类模式构建在NGWS运行时的虚拟对象系统(VOSVirtual Object System)的上层,VOS将在下章描述。对象模式只是基础的一部分,不再是编程语言的一部分。
 您一开始必须关注的事,就是不再有全局函数、变量或者是常量。所有的东西都封装在类中,包括事例成员(通过类的事例对象可以访问)或都静态成员(通过数据类型)。这些使C#代码更加易读且有助于减少潜在的命名冲突。
 定义类中的方法默认是非虚拟的(它们不能被派生类改写)。主要论点是,这样会消除由于偶尔改写方法而导致另外一些原码出错。要改写方法,必须具有显式的虚拟标志。这种行为不但缩减速了虚拟函数表,而且还确保正确版本的控制。
 使用C++编写类,您可以使用访问权限(access modifiers) 给类成员设置不同的访问等级。C#同样支持privateprotected public三种访问权限 ,而且还增加了第四种:internal。有关访问权限 的详细情况将在第五章 "" 中说明。
 您曾经创建了多少个类是从多基类派生出来的(ATL 程序员,您的投票不计在内!) ? 大多数情况,仅需从一个类派生出。多基类惹出的麻烦通常比它们解决的问题还多。那就是为什么C#仅允许一个基类。如果您觉得需要多重继承,可以运用接口。
 一个可能出现的问题:在C#中不存在指针,如何模仿它? 这个问题的答案很有代表性,它提供了对NGWS运行时事件模式的支持。再次,我将把对它的全面解释放到第五章。

类型安全

 我再次选指针作为一个例子。在C++中拥有一个指针,您能自由地把它强制转换成为任何类型,包括干出诸如把一个int*(整型指针)强制转换成一个double *(双精度指针)这样的傻事。只要内存支持这种操作,它就"干过"。这并不是您所想象的企业级编程语言的类型安全。
 纲要性的问题,C#实施最严格的类型安全,以保护自己及垃圾收集器(garbage collector)。所以必须遵守C#中一些相关变量的规则:
 您不能使用没有初始化的变量。对于对象的成员变量,编译器负责清零。而局部变量,则由您负责清零。当您使用一个没有初始化的变量时,编译器会教您怎么做。优点是能够避免由于使用不经初始化的变量计算结果而导致的错误,而您还不知道这些奇怪的结果是如何产生的。
 C#取消了不安全的类型转换。不能把一个整型强制转换成一个引用类型(如对象),而当向下转换时,C#验证这种转换是正确的。(也就是说,派生类真的是从向下转换的那个类派生出来的。)
 边界检查是C#的一部分。再也不会出现这种情况:当数组实际只定义了n-1个元素,却超额地使用了n个元素。
 算术运算有可能溢出终值数据类型的范围。C#允许在语句级或应用程序级检测这些运算。在允许检测溢出的情况下,当溢出发生时将会抛出一个异常。
 在C#中,被传递的引用参数是类型安全的。

版本可控(Versionable)

 在过去的几年中,几乎所有的程序员都至少有一次不得不涉及到众所周知的"DLL地狱"。该问题起因于多个应用程序都安装了相同DLL名字的不同版本。有时,老版本的应用程序可以很好地和新版本的DLL一起工作,但是更多的时候它们会中断运行。现在的版本问题真是令人头痛。
 就象您将在第八章"C#写组件"所看到的,NGWS runtime 将对您所写的应用程序提供版本支持。C#可以最好地支持版本控制。尽管C#不能确保正确的版本控制,但是它可以为程序员保证版本控制成为可能。有这种支持,一个开发人员就可以确保当他的类库升级时,仍保留着对已存在的客户应用程序的二进制兼容。

兼容

 C#并没有存在于一个封闭的世界中。它允许使用最先进的NGWS的通用语言规定(Common Language Specification,简写为CLS)访问不同的APICLS规定了一个标准,用于符合这种标准的语言的内部之间的操作。为了加强CLS的编译,C#编译器检测所有的公共出口编译,并在通不
过时列出错误。
 当然,您也想能够访问旧一点的COM对象。NGWS运行时提供对COM透明的访问。如何集成原来的代码将在第10"非管理代码的内部操作"有介绍。
 OLE 自动化是一种特殊的动物。任一个使用C++创建OLE自动化项目的人已经喜欢上各种各样的自动化数据类型。有个好消息就是C#支持它们,而没有烦锁的细节。
 最后,C#允许您 用C 原型的API进持内部操作。可以从您的应用程序访问任何DLL中的入口点(C的原型)。用于访问原始API的功能称作平台调用服务(Plaform Invocation Services ,缩写PInovke),第10章将展示使用C API进行内部操作的一些例子。

灵活

 上一部分的最后一段有可能提醒了程序员。您可能会问:"难道就没有我要传递指针的API?" 您是正确的。不是仅有少数的这种API,而是很多(有点保守的估计)。这种对原始WIN32代码的访问有时导致对非安全类指定指针的使用(尽管它们中的一些由于受COMPInvoke的支持可以解决)
 尽管C#代码的缺省状态是类型安全的,但是您可以声明一些类或者仅声明类的的方法是非安全类型的。这样的声明允许您使用指针、结构,静态地分配数组。安全码和非安全码都运行在同一个管理空间,这样暗示着当从安全码调用非安全码时不会陷入列集(marshaling)

小结
 C#语言从CC++演变而来,它是给那些愿意牺牲C++一点底层功能,以获得更方便和更产品化的企业开发人员而创造的。C#现代、简单、面向对象和类型安全。尽管它借鉴了CC++的许多东西,但是在一些诸如名字空间、类、方法和异常处理等特定领域,它们之间还存在着巨大的差异。
 C#为您提供了方便的功能,如垃圾收集、类型安全、版本控制,等等。
仅有的"代价"就是,代码操作默认是类型安全的,不允许指针。光是类型安全就可以搞定了。但是,如果您需要指针,仍可以通过非安全码使用它们,而且当调用非安全码时,不能含有列集。

.NET框架
  .NET框架是一个多语言组件开发和执行环境,他提供了一个跨语言的统一编程环境。.NET框架的目的是便于开发人员更容易地建立Web应用程序和Web服务,使得Internet上的各应用程序之间,可以使用Web服务进行沟通。开发人员可以将远端应用程序提供的服务和单机应用程序的服务结合在一起,组成一个应用程序。例如:一个B2C的电子商务网站可以按这种方式组成在线交易,使用Microsoft Passport服务来验证用户身份,使用合作厂商的信用卡处理服务。从层次上来看,.NET框架又包括三个主要组成部分:公共语言运行时(CLR:Common Language Runtime)、服务框架(Services Framework)和上层的两类应用模板——传统的Windows应用程序模板(Win Forms)和基于ASP.NET的面向Web的网络应用程序模板(Web Forms和Web Services)。其结构如下图所示。 


.NET框架提供统一的编程模式:不论什么语言和编程模式都是用一样的API,结构下图所示。
 

.NET框架提供统一的编程API:NET Framework 类库。结构如下图所示。
 


微软Web服务中心产品经理JohnMontgomery说:
* “只需要简单地用一DotNet框架便可以消除各种异类框架之间的差别,将他们合并成为一个整体。
*  现在开发人员可以自由地选择他们喜欢的编程语言了!”

.NET提供了一个运行环境,叫做公共语言运行时(CLR)。CLR管理代码的执行并使开发过程变得更加简单。CLR是一种受控的执行环境,其功能通过编译器与其他工具共同展现。以“运行时”为目标的代码称为受控代码(Managed Code)。受控代码指向的对象在执行过程中完全被CLR所控制。在执行过程中,CLR提供自动内存管理、调试支持、增强的安全性及与受控代码(如COM组件)的互操作性。凡是符合CLS(公共语言规范)的程序语言(如C#Visual Basic.NET等)所开发的程序都可以在任何有CLR的操作系统上执行。在某种程度上,CLRJava的虚拟机有异曲同工之妙。

运行语言特点是交叉语言集成、自描述组件、简单配制和版本化及集成安全服务。

    运行语言使用一种新的能表达大部分现代编程语言语义的通用类型系统,通用类型系统定义了一套标准类型及生成新标准的规则。运行语言知道怎样生成、执行这些类型。编译器和解释器使用运行语言服务定义类型、管理对象、进行方法调用,而不是使用工具或特定于语言的方法。

类型系统的主要设计目的是使多种语言能深度集成。用一种语言所写的代码能继承用另一种语言所写的类的实现,用一种语言所写的代码抛出的异常能被用另一种语言写的代码捕获,像调试和剖析之类的操作会在完全封闭下工作,而不用考虑代码所用的语言。这就意味着编写可重用类库的开发者,不再需要为每一种编程语言或编译器生成一个版本,并且类库的开发者不再受到为他们使用的编程语言开发的库的限制。

    自描述组件——现在Microsoft .NET框架上已成为可能,简化了开发和配制,并提高了系统的可靠性。许多由运行语言提供的服务是由元数据及用于补充可执行代码的信息所驱动。因为所有的信息都储存在一起,只有可执行的(代码)才被称为自描述组件。

    自描述组件的一个主要优点是,使用它们并不需要其它文件。类的定义不需要单独的头文件;通过检查原数据对类的定义可以从组件自身获得。跨语言或过程边界访问组件并不需要各自的IDL文件、类型文件或proxy/stubs;所必需的信息已存在于元数据之中。为识别开发者请示的服务属性,并不需要展开各自的配制信息。 最主要的是,由于元数据是在编译过程中由源代码生成,并与可执行代码储存在一起,它将永远和可执行部分同步。

除了改善对单个组件的配制,Microsoft .NET框架定义了一个应用程序配制模板,以解决定置应用程序安装和DLL版本化(通常被称为“DLL Hell”)这一复杂过程的问题,运行语言提供了支持这个模板的服务。

    Microsoft .NET框架 引入了组合体的概念。一个组合体是一组资源和类型,并包括有关这些资源和类型的元数据,也就是被作为一个单元配制的。元数据被称为组合体的名单,它包含象类型和资源表之类能被组合体外看得见的信息,这个名单也包括有关从属关系之类的信息,例如组合体建立时的版本号。开发人员可以指定版本策略,以指示运行语言是否装入系统上已安装的依赖于组合体的最新版本,装入一个指定版本,或在编译时使用的版本。

某软件组件的多个拷贝总可以存在于同样的操作系统上,然而,通常说来,只有其中的一个拷贝能被操作系统注册、调入内存、执行。对系统来说,定位和调入内存的策略是全局性。.NET Framework Common Language Runtime 增加了所必须的体系架构以支持管理组件定位和调入的每个应用程序策略,这通常被称为并行配制。

    组合体可以被一个应用程序私有,或被多个应用程序共享。一个组合体的多个版本可以同时配制在同一台机器上。应用程序配制信息定义了到何处去查找组合体,这样runtime就能为同时运行的两个不同的应用程序装入同一组合体的不同版本。这就消除了由组件版本的不兼容性引起的问题,提高了系统整体的稳定性。如果必要,管理员可以为配制时刻的组合体增加配制信息,例如一个不同的版本策略,但是编译时提供的原始信息永远不会丢失。

因为组合体是自描述的,所以并不需要在系统上进行显式注册。应用程序的配制简单到只需将文件拷贝到目录中既可(如果为了使应用程序能够运行,必须安装未经组织过的组件的话,情况会稍微复杂一点)。配制信息保存在可被任何文本编辑器编辑的XML文件中。

    最后,运行语言也提供完整的、普遍深入的安全服务,以确保未经授权的用户不能访问机器上的资源,并且代码不会执行未经允许的动作。这就提高了系统整体的安全性可靠性。 由于运行语言用于装入代码、生成对象、执行方法调用,所以当受控代码装入内存执行时,运行语言能进行安全检查,强化安全策略。

    Microsoft .NET框架不仅规定代码访问安全,还规定基于角色的安全。通过代码访问安全机制,开发人员能为应用程序指定完成工作所必需的权限。例如,代码或许需要写文件或访问环境变量的权力。这类信息和有关代码标志的信息一起存储在配制级上的。当代码装入内存及执行方法调用时,运行语言验证是否能给予代码所要求的权限。如果不能,将记录一条安全冲突信息。给予权限的策略,这被称为信任策略,是由系统管理员建立的,并且是建立在关于代码的证据基础之上,比如:代码是谁发布的,是从什么地方获得的,以及在组合体中找到的代码标志和它要求的权限。开发人员可以指定他们显然不需要的权限,以防止其它人恶意使用他们的代码。如果所需要的权限依赖直到运行时刻才会知道的信息,那么就可写入纲邻性的安全检查。

除了代码访问安全,运行语言还支持基于角色的安全。基于角色的安全建立同代码访问安全一样的权限模板,只是这些权限是建立在用户的身份之上,而不是建立在代码的标志之上。角色表明了用户所属的类,并且可以在开发和配制阶段定义。给予权限的策略被分配到每个预定义的角色。在运行时刻,用户的身份被确定,代码将代表这个身份运行。运行语言决定用户是哪个角色的成员,然后给予基于这个角色的权限。

.NET目标

Internet网络和分布式应用程序的开发提供一个新的开发平台

简化应用程序开发和部署

为构建Web Service提供一个标准平台

改善系统和应用程序之间的交互性和集成性

使应用程序对任何设备都能够进行访问

 .NET战略

.NET致力将手机,浏览器和门户应用程序集成到一起,形成一个统一的开发环境,结构如图1-1所示。

1-1 .NET的战略

 公共语言运行时(CLR)

.NET提供了一个运行环境,叫做公共语言运行时(CLR)。CLR管理代码的执行并使开发过程变得更加简单。CLR是一种受控的执行环境,其功能通过编译器与其他工具共同展现。以“运行时”为目标的代码称为受控代码(Managed Code)。受控代码指向的对象在执行过程中完全被CLR所控制。在执行过程中,CLR提供自动内存管理、调试支持、增强的安全性及与受控代码(如COM组件)的互操作性。凡是符合CLS(公共语言规范)的程序语言(如C#Visual Basic.NET等)所开发的程序都可以在任何有CLR的操作系统上执行。在某种程度上,CLRJava的虚拟机有异曲同工之妙。

运行语言特点是交叉语言集成、自描述组件、简单配制和版本化及集成安全服务。

运行语言使用一种新的能表达大部分现代编程语言语义的通用类型系统,通用类型系统定义了一套标准类型及生成新标准的规则。运行语言知道怎样生成、执行这些类型。编译器和解释器使用运行语言服务定义类型、管理对象、进行方法调用,而不是使用工具或特定于语言的方法。

类型系统的主要设计目的是使多种语言能深度集成。用一种语言所写的代码能继承用另一种语言所写的类的实现,用一种语言所写的代码抛出的异常能被用另一种语言写的代码捕获,像调试和剖析之类的操作会在完全封闭下工作,而不用考虑代码所用的语言。这就意味着编写可重用类库的开发者,不再需要为每一种编程语言或编译器生成一个版本,并且类库的开发者不再受到为他们使用的编程语言开发的库的限制。

自描述组件——现在Microsoft .NET框架上已成为可能,简化了开发和配制,并提高了系统的可靠性。许多由运行语言提供的服务是由元数据及用于补充可执行代码的信息所驱动。因为所有的信息都储存在一起,只有可执行的(代码)才被称为自描述组件。

自描述组件的一个主要优点是,使用它们并不需要其它文件。类的定义不需要单独的头文件;通过检查原数据对类的定义可以从组件自身获得。跨语言或过程边界访问组件并不需要各自的IDL文件、类型文件或proxy/stubs;所必需的信息已存在于元数据之中。为识别开发者请示的服务属性,并不需要展开各自的配制信息。 最主要的是,由于元数据是在编译过程中由源代码生成,并与可执行代码储存在一起,它将永远和可执行部分同步。

除了改善对单个组件的配制,Microsoft .NET框架定义了一个应用程序配制模板,以解决定置应用程序安装和DLL版本化(通常被称为“DLL Hell”)这一复杂过程的问题,运行语言提供了支持这个模板的服务。

Microsoft .NET框架 引入了组合体的概念。一个组合体是一组资源和类型,并包括有关这些资源和类型的元数据,也就是被作为一个单元配制的。元数据被称为组合体的名单,它包含象类型和资源表之类能被组合体外看得见的信息,这个名单也包括有关从属关系之类的信息,例如组合体建立时的版本号。开发人员可以指定版本策略,以指示运行语言是否装入系统上已安装的依赖于组合体的最新版本,装入一个指定版本,或在编译时使用的版本。

某软件组件的多个拷贝总可以存在于同样的操作系统上,然而,通常说来,只有其中的一个拷贝能被操作系统注册、调入内存、执行。对系统来说,定位和调入内存的策略是全局性。.NET Framework Common Language Runtime 增加了所必须的体系架构以支持管理组件定位和调入的每个应用程序策略,这通常被称为并行配制。

组合体可以被一个应用程序私有,或被多个应用程序共享。一个组合体的多个版本可以同时配制在同一台机器上。应用程序配制信息定义了到何处去查找组合体,这样runtime就能为同时运行的两个不同的应用程序装入同一组合体的不同版本。这就消除了由组件版本的不兼容性引起的问题,提高了系统整体的稳定性。如果必要,管理员可以为配制时刻的组合体增加配制信息,例如一个不同的版本策略,但是编译时提供的原始信息永远不会丢失。

因为组合体是自描述的,所以并不需要在系统上进行显式注册。应用程序的配制简单到只需将文件拷贝到目录中既可(如果为了使应用程序能够运行,必须安装未经组织过的组件的话,情况会稍微复杂一点)。配制信息保存在可被任何文本编辑器编辑的XML文件中。

最后,运行语言也提供完整的、普遍深入的安全服务,以确保未经授权的用户不能访问机器上的资源,并且代码不会执行未经允许的动作。这就提高了系统整体的安全性可靠性。 由于运行语言用于装入代码、生成对象、执行方法调用,所以当受控代码装入内存执行时,运行语言能进行安全检查,强化安全策略。

Microsoft .NET框架不仅规定代码访问安全,还规定基于角色的安全。通过代码访问安全机制,开发人员能为应用程序指定完成工作所必需的权限。例如,代码或许需要写文件或访问环境变量的权力。这类信息和有关代码标志的信息一起存储在配制级上的。当代码装入内存及执行方法调用时,运行语言验证是否能给予代码所要求的权限。如果不能,将记录一条安全冲突信息。给予权限的策略,这被称为信任策略,是由系统管理员建立的,并且是建立在关于代码的证据基础之上,比如:代码是谁发布的,是从什么地方获得的,以及在组合体中找到的代码标志和它要求的权限。开发人员可以指定他们显然不需要的权限,以防止其它人恶意使用他们的代码。如果所需要的权限依赖直到运行时刻才会知道的信息,那么就可写入纲邻性的安全检查。

除了代码访问安全,运行语言还支持基于角色的安全。基于角色的安全建立同代码访问安全一样的权限模板,只是这些权限是建立在用户的身份之上,而不是建立在代码的标志之上。角色表明了用户所属的类,并且可以在开发和配制阶段定义。给予权限的策略被分配到每个预定义的角色。在运行时刻,用户的身份被确定,代码将代表这个身份运行。运行语言决定用户是哪个角色的成员,然后给予基于这个角色的权限。

关键知识点:

?         .NET基础知识

?         .NET给我们带来了什么

?         使用C#编程

 

1.1 什么是.NET

根据微软的定义:

.NET is a "revolutionary new platform, built on open Internet protocols and standards, with tools and services that meld computing and communications in new ways".

即:.NET = 新平台 + 标准协议 + 统一开发工具

.NET作为新一代互联软件和服务战略,将使微软现有的软件在网络时代不仅适用于传统的个人计算机,而且能够满足呈现强劲增长的新设备的需要。到底什么是.NET呢?微软总裁兼首席执行官Steve Ballmer把它定义为:.NET代表一个集合,一个环境,一个可以作为平台支持下一代Internet的可编程结构。

.NET的最终目的就是让用户在任何地方、任何时间,以及利用任何设备都能访问所需的信息、文件和程序。用户不需要知道这些文件放在什么地方,只需要发出请求,然后只管接收就可以了。而所有后台的复杂性是完全屏蔽起来的。

为了实现这些功能,.NET 结构发表以后,微软便逐步调整其服务器软件的产品线,将原有的Server一一的升级更新,推出了许多新的Server,并将这些Server整合于.NET Enterprise Servers产品线中。

Windows 2000 Server(包含Advanced ServerDatacenter Server)。.NET结构中,最重要的革新就属于Web ServicesWeb Services构架在Web Server上,能够通过SOAP与用户端联系,并帮助用户端完成其提供的服务。在.NET Framework中,Web Services就是架构在Windows 2000 Servers中的IIS5.0上的。

Exchange 2000 ServerExchange 不是单纯的Email Server,它更是一套不折不扣的组信息平台。

SQL Server 2000SQL Server 提供完善数据处理功能。包含数据挖掘,XML的直接Internet支持。目前在Windows CE中推出了SQL Server 2000 Windows CE Edition

BizTalk Server 2000用于企业间交换商务信息,它利用XML作为企业内部及企业间文档传输的数据格式,可以屏蔽平台、操作系统不同的差异,使商业系统的集成成为可能。

Commerce Server 2000用于快速创建在线电子商务。

Mobile Information Server 为移动解决方案提供可靠而且具有伸缩性的平台。

2005年11月09日

初学编程的朋友往往喜欢收集一些很“奇妙”的编程技巧,然而,技巧的积累往往并没有提高程序质量,反而引导一些编程者一味追求奇和新,忘记了基本编程习惯的培养,不利于团队的合作,可能,这也是中国并不缺少聪明的程序员,但是缺少聪明的开发团队的一个原因吧。在ASP.NET的开发中,可以学习的技巧不少,但是,一些基本的编程习惯我们一定要养成,这样不但能根本上提高程序质量和开发效率,而且,也利于程序的阅读和团队开发。如果自己写的程序只有自己可以看懂或者只有几个人可以看懂,即使程序技巧神乎其技,对于程序的升级和维护都是致命问题。 

一、 错误(以外)的处理 
程序健壮性最基本要求就是程序错误的处理与捕捉,在ASP.NET中,错误的处理有和其他编程语言一样的机制,可以使用Try…Catch…Finally等方式,这一点和ASP相比具有较大的进步。而且,使用这些错误处理方法,可以大大提高程序的可读性和程序调试速度,在这几个优势结合的情况下,我们更加应该注意这一点。 
关于错误的处理,我们可以参考这篇文章(英文): 
http://www.123aspx.com/redir.aspx?res=28336 

二、 字符串的处理 
网页设计中,字符串的处理几乎是最常见的了。使用ASP.NET以后,字符串的处理比ASP的速度快,而且,在ASP.NET中,专门增加一个字符串处理类StringBulider,使用这个类可以完成一些常见的字符串操作,而最主要的,使用StringBuilder可以大大提高字符串处理速度。 
在ASP.NET中,最常见的就是使用“&”来连接两个字符串: 
Dim myOutputString As String = "My name is" 
Dim myInputString As String = " Alex" 
myOutputString = myOutputString & myInputString 
Response.Write(myoutputString) 
现在,我们来看看StringBuilder的使用,在使用StringBuilder的时候,我们对字符串可以做一些基本的操作,比如Append、Replace、Insert、Remove等,现在我们来看具体举例。 
(1)StringBuilder中Append的使用 
Append和其他语言的Append一样,就是在字符串最后增加其他字符。 
Dim sb as StringBuilder = New StringBuilder() 
sb.append( "<table border=’1′ width=’80%’>" ) 
For i = 0 To RowCount – 1 
sb.Append("<tr>") 
For k = 0 To ColCount – 1 
sb.Append("<td>") 
sb.Append( dt.Rows(i).Item(k, DataRowVersion.Current).toString()) 
sb.Append( "</td>" ) 
Next 
sb.Append("<tr>") 
Next 
sb.Append( "</table>") 
Dim strOutput as String = sb.ToString()  
lblCompany.Text = strOutput 
在以上的程序中,用Append方法实现了一个表格的输出,需要注意的一点是,StringBulider必须首先使用ToString()方法将其转化为String类型才可以直接输出。在以上的举例中,我们看到的全部是Append一个直接的字符串,其实,这个方法有一个很方便的功能,那就是可以直接Append其他类型的变量,比如可以直接Appemd一个Integer类型的数值,当然,我们输出以后自动转化为一个字符串: 
Sub Page_Load(Source As Object, E As EventArgs) 
Dim sb As System.Text.StringBuilder 
Dim varother As Integer 
varother=9999 
sb =new System.Text.StringBuilder() 
sb.append("<font color=’blue’>可以Append其他类型:</font>") 
sb.append(varother) 
Response.write(sb.toString()) 
End Sub 
(2)字符串中其他方法的使用 
我们还可以使用其他方法,我们来看看常见的: 
Insert方法,可以在指定位置插入其他字符,使用方法:Insert(插入位置,插入字符); 
Remove方法,可以在指定位置删除指定字数字符,使用方法:Remove(其实位置,字符数); 
Replace方法,可以替换指定字符,使用方法:replace(被替换字符串,替换字符串) 
字符串的具体介绍和使用方法可以参考以下文章(英文): 
http://aspfree.com/aspnet/stringbuilder.aspx 
http://msdn.microsoft.com/library/en-us/cpref/html/frlrfSystemTextStringBuilderClassTopic.asp 

三、 数据库链接Connection和DataReader的关闭 
在使用ASP编程的时候,我们就已经知道,在使用数据库连接以后,一定要将连接关闭,然后设置为NoThing。在Asp.NET中,我们仍然需要这样使用,不过,在ASP.NET中,由于使用了ADO.NET,所以,在一些相关的处理方面,实际还是有一些细微的区别,而这些区别,往往也就是我们设计的时候最需要注意的。现在,我们通过举例,来看看在常见的ADO.NET操作中,需要注意哪些问题。 
(1)举例一 
Dim myConnection As SqlConnection = new SqlConnection(ConfigurationSettings.AppSettings("DSN_pubs")) 
Dim myCommand As SqlCommand = new SqlCommand("Select pub_id, pub_name From publishers", myConnection) 
Dim myDataReader As SqlDataReader 
Try 
myConnection.Open() 
myDataReader = myCommand.ExecuteReader(CommandBehavior.CloseConnection) 
DropDownList1.DataSource = myDataReader 
DropDownList1.DataBind() 
Catch myException As Exception 
Response.Write("An error has occurred: " & myException.ToString()) 
Finally 
If Not myDataReader Is Nothing Then 
‘关闭DataReader 
myDataReader.Close() 
End If 
End Try 
在以上的举例中,我们注意到,这里只关闭了DataReader,并没有关闭Connection。为什么呢?仔细观察以上的ExecuteReader方法,原来,设置了ExecuteReader参数,当执行完ExecuteReader以后,会自动关闭Connection。所以,这样设置以后,就没有必要再手动关闭Connection了。

(2)举例二
Dim myConnection As SqlConnection = new SqlConnection(ConfigurationSettings.AppSettings("DSN_pubs"))
Dim myCommand As SqlCommand = new SqlCommand("Select pub_id, pub_name From publishers", myConnection)
Try
myConnection.Open()
DropDownList1.DataSource = myCommand.ExecuteReader()
DropDownList1.DataBind()
Catch myException As Exception
Response.Write("An error has occurred: " & myException.ToString())
Finally
If Not myConnection Is Nothing AndAlso ((myConnection.State And ConnectionState.Open) = ConnectionState.Open) Then
myConnection.Close()
End If
End Try
在以上的举例中,我们发现,居然没有关闭DataReader。为什么呢?其实上面的代码中,没有直接生成DataReader对象,当然也就无从关闭了。需要注意一点的是,在关闭Connection之前,程序首先判断Connection是否已经打开,如果没有打开,也就没必要关闭了。

四、使用Web.Config/Maching.Config保存常用数据
一些数据我们需要时常使用,比如使用ADO.NET的时候,最常见的就是数据库连接语句,在ASP中,我们常常将这些信息保存在Application中。当然,在ASP.NET中,也可以这样,不过,ASP.NET已经提供一个配置文件WEB.Config,所以,我们最好将这些信息保存在WEB.Config中,当然,我们也可以保存在Machine.Config中,不过,这样的话,整个网站都必须使用,所以,一般我们都使用Web.Config。现在,我们来看具体这个文件的使用。
(1)Web.Config文件的设置
首先,我们来看Web.Config的设置,我们在这个文件中增加设置以下两个项目,设置如下:
<configuration>
<appsettings>
<add key="dsn" value="myserver"/>
<add key="someotherkey" value="somevalue"/>
</appsettings>
</configuration>
(2)变量的使用
以上XML文件设置了dsn和someotherkey两个变量,现在我们看看程序中怎样使用:
<html>
<script language="VB" runat=server>
Sub Page_Load(Sender as Object, E as EventArgs)
Dim AppSettings as Hashtable = Context.GetConfig("appsettings")
DSN.Text = AppSettings("dsn")
SomeOther.Text = AppSettings("someotherkey")
End Sub
</script>
<body>
DSN Setting: <asp:label id="DSN" runat=server/>

Some Other Setting: <asp:label id="SomeOther" runat=server/>
</body>
</html>
上面的程序我们看到,使用这样定义的变量很简单也很方便。

五、使用.NET的方式调试程序
ASP程序的调试一直是编写ASP最难的地方,这一点,ASP程序员大概都深有体会,因为大家都是使用Response.write来调试。而这样调试最大的缺点是,当我们调试完毕,必须一个个来删除或者注释掉这些信息,想一想,如果程序代码达到几百行或者页面很多的程序,这样的工作是多么枯燥,最怕一点,忘记将这些调试用的write删除,可能在用户使用的时候就会出现一些不雅的调试信息。
使用ASP.NET以后,我们可以直接定义Trace来实现程序的调试。以上提到的麻烦可以轻松解决,熟悉,Trace可以通过具体页面和在Web.Config配置文件中来定义实现,这样,当程序调试完毕以后,直接将Trace设置为Off就可以了,这样,程序就不会有调试功能了。
(1)页面调试的实现
在一个具体的页面需要实现调试功能的时候,我们可以这样设置:
<%@ Page Language="VB" Trace="True" %>
(2)定义WEB.Config实现
在WEB.CONFIG中,我们也可以实现程序调试的打开:
<configuration>
<system.web>
<trace enabled="true" requestLimit="10" localOnly="false"/>
</system.web>
</configuration>
使用以上的设置打开Trace以后,我们在具体的程序中就可以使用Trace来调试程序了,比如:
Trace.Write("This is some custom debugging information")
或者调试程序变量:
Trace.Write("This is is my variable and it’s value is:" & myVariable.ToString())
以上设置我们可以看出,在ASP.NET中,程序调试功能已经很方便简单了,我们在程序设计中如果忽略这些特点,继续采用ASP的思维来设计程序,那么我们的程序不但效率没有提高,也增加了其他开发者合作的难度。

六、总结
以上的一些程序编写习惯,我们可以慢慢养成,在程序设计的时候,不要太在意程序是否最简洁灵活,对于一般开发者而言,程序规范化和可读性可能比追求程序的灵活性更加重要。在互联网资源越来越丰富的情况下,我们可以参考一些很规范的程序源代码来学习,当然,最好的莫过于微软自己的东西,我们可以参考以下网址:http://www.asp.net,关于更多的程序编写问题,我们可以参考以下网址:
http://www.gotdotnet.com/team/asp/ASP.NET%20Performance%20Tips%20and%20Tricks.aspx

在本篇文件中,我们将讨论编程人员在使用ASP.NET开发应用程序时需要注意的10个技巧,这些技巧涉及从缺省的控件、表单名的改变到StringBuilder类的使用,有助于编程人员能够尽快地适应.NET环境。

  1、在使用Visual Studio .NET时,除直接或非引用的对象外,不要使用缺省的名字。

  .NET带来的好处之一是所有的源代码和配置文件都是纯文本文件,能够使用Notepad或WordPad等任意的文本编辑器进行编辑。如果不愿意,我们并非一定要使用Visual Studio .NET作为集成开发环境。但使用了Visual Studio .NET,我们可以在Windows文件管理器中看到文件,或在Visual Studio .NET之外从文本编辑器中浏览文件的内容。

  使用Visual Studio .NET作为集成开发环境有许多好处,其中最显著的好处是它极大地提高了生产效率。使用Visual Studio. NET,我们能够在付出较小代价的情况下更快地开发软件。作为集成开发环境一部分的IntelliSense提供自动的代码完成、在输入方法或函数时提供动态帮助、语法错误的实时提示,以及其他能够提高生产效率的功能。

    象其他复杂的工具那样,在学会如何充分发挥它的作用和掌握其“习性”前,Visual Studio .NET也会使我们产生一种挫折感。有时,它象一个难以了解的黑盒子,会生成大量的文件和许多无用的代码。

  Visual Studio .NET的一个功能是,无论是类、控件或表单中的对象,它都能够为新对象提供缺省名字。例如,如果我们创建了一个新的ASP.NET Web Application,其缺省的名字将是WebApplication1。我们可以在“新工程”对话框中方便地改变该应用的名字,但同时改变的只是该应用程序的名字空间的名字及其所在的虚拟目录,源代码文件的缺省名字仍然是WebForm1.aspx和WebForm1.aspx.cs(C#工程)或WebForm1.aspx.vb(VB.NET工程)。

  我们可以在方案浏览器中改变ASPX和代码使用的文件名字,但Web页类的名字仍然将是WebForm1。如果在该Web表单上生成一个按钮,其缺省的名字将是Button1。事实上,所有控件的名字都是由控件的类型和数字组成的。

  我们能够,也应该将应用程序中所有的表单和控件的名字都修改成有意义的名字。对于较小的演示性程序而言,缺省的名字还能够胜任,但如果应用程序由多个表单,每个表单上有许多按钮和标签时,象frmStartup、frmDataEntry和frmReports这样的表单名就比Form1、Form2和Form3这样的名字更易于理解和维护。

  如果表单上控件要在代码的其他地方引用,使它有一个有意义的名字就更重要了。btnOK、btnCancel和btnPrint这样的名字使看代码的人更容易理解,因而,也比名字为Button1、Button2、Button3这样的控件更容易维护。

  修改一个工程中所有文件中出现的一个名字的一个好方法是,在Visual Studio .NET菜单中依次选择“编辑”->“发现和替换”->“替换”命令。

  在看二周前编写的代码时,我们经常就象第一次见到这些代码一样,因此使它们有一个有助于我们理解其含义的名字是十分有必要的。

  2、即使不使用Visual Studio .NET进行编程,使用代码支持文件也有利于提高应用程序的性能

  在Web应用程序、Web服务或Web控件等所有的ASP.NET Web工程中,Visual Studio .NET都使用代码支持文件。代码支持文件使工程具有更好的组织、模块性,更适合多人组成的开发团队。另外,它还会带来性能的提高。

  代码支持文件的内容被编译成一个组合文件中的类,一般是一个DLL文件,有时也可以是EXE文件。该文件驻留在应用程序的组合体高速缓冲区中,在应用程序启动时,可以立即得到它。

  如果代码是包含在<script>标记中或ASPX文件代码中,它仍然会被编译成一个Web页类。在这种情况下,每当该网页在应用程序对话中第一次加载时,都需要重新进行编译,被编译的类就会驻留在内存中。每当计算机启动、IIS停止、重新启动或者源代码、配置文件改变时,该文件必须重新编译。尽管不大,但这样引起的性能损耗也是相当可观的。

  3、尽量减少表单回送

  每当点击Web网页上的Button、LinkButton或ImageButton控件时,表单就会被发送到服务器上。如果控件的AutoPostBack属性被设置为true,如果CheckBox、CheckBoxList等控件的状态被改变后,也会使表单会发送回服务器。

  每次当表单被发送回服务器,就会被重新加载,启动Page_Load事件,执行Page_Load事件处理程序中的所有代码。把网页的初始化代码放在这里是最合适不过的了。我们经常会希望在每次加载网页时执行一些代码,而希望只有在网页第一次加载时执行另一些代码,甚至希望一些代码在除首次加载外的每次加载时执行。

  可以利用IsPostBack特性来完成这一功能。在网页第一次加载时,该属性的值是false。如果网页因回送而被重新加载,IsPostBack属性的值就会被设置为true。通过测试,可以在任意时候执行指定的代码。下面是相关的C#代码:
  protected void Page_Load(Object sender, EventArgs e)
  {

  // 网页每次加载时,执行的一些操作
  if (!IsPostBack)
  {

  // 网页第一次加载时执行的操作
  }
  else
  {
  // 回送时执行的操作
  }
  
  // 网页每次加载时执行的操作
  }
  我们希望尽量不引起回送(每次回送都会要求服务器进行一系列的操作),即使引起回送后。也希望能够执行尽量少的操作。大规模、浪费时间的操作(例如数据库查找)尤其应当避免,因为它们能够延长应用程序的响应时间。

  4、使用StringBuilder类

  字符串在.NET框架中是不可变的,这意味着改变字符串的操作符和方法会返回字符串的改变后的拷贝,这意味着性能还有提高的空间。当进行大量的字符串操作时,使用StringBuilder类就是一种比较好的选择了。

  下面的C#代码测试用二种方式从10000个子字符串中生成字符串所需要的时间。第一次使用了一个简单的字符串串联操作;第二次使用了StringBuilder类。要想查看结果字符串,可以去掉下面的代码中注解行的注解符号:
  <%@ Page Language="C#" %>
  
  <script runat="server">
  void Page_Load(Object Source, EventArgs E)
  {
  int intLimit = 10000;
  DateTime startTime;
  DateTime endTime;
  TimeSpan elapsedTime;
  string strSub;
  string strWhole = "";
  
  // 首先执行字符串连接操作
  startTime = DateTime.Now;
  for (int i=0; i < intLimit; i++)
  {
  strSub = i.ToString();
  strWhole = strWhole + " " + strSub;
  }
  endTime = DateTime.Now;
  elapsedTime = endTime – startTime;
  lblConcat.Text = elapsedTime.ToString();
  // lblConcatString.Text = strWhole;
  
  // 使用stringBuilder类进行同样的操作
  startTime = DateTime.Now;
  StringBuilder sb = new StringBuilder();
  for (int i=0; i < intLimit; i++)
  {
  strSub = i.ToString();
  sb.Append(" ");
  sb.Append(strSub);
  }
  endTime = DateTime.Now;
  elapsedTime = endTime – startTime;
  lblBuild.Text = elapsedTime.ToString();
  // lblBuildString.Text = sb.ToString();
  }
  
  </script>
  
  <html>
  <body>
  <form runat="server">
  
  <h1>String Concatenation Benchmark</h1>
  
  Concatenation:
  <asp:Label
  id="lblConcat"
  runat="server"/>
  
  <br/>
  
  <asp:Label
  id="lblConcatString"
  runat="server"/>
  
  <br/>
  <br/>
  
  StringBuilder:
  <asp:Label
  id="lblBuild"
  runat="server"/>
  
  <br/>
  
  <asp:Label
  id="lblBuildString"
  runat="server"/>
  
  </form>
  </body>
  </html>
  二种方式的差别是相当大的:使用StringBuilder类的Append方法的速度比使用字符串连接的速度快近200倍。

  5、只在必要时使用服务器端控件

  ASP.NET中新引入了一种在服务器端运行的被称作Web Server Controls的控件,在代码中,它们经常通过下面的语法被说明:
  <asp:TextBox id="txtLastName" size="40" runat="server" />
  它们有时也被称作ASP控件。服务器端控件是由runat属性指示的,它的值总是“server”。
  通过添加runat属性,一般的HTML控件可以被很方便地转换到服务器端运行,下面是一个简单的例子:
<input type="text" id="txtLastName" size="40" runat="server" />
  可以通过id属性中指定的名字,我们可以引用程序中的控件,可以通过编程的方式设置属性和获得值,因此,服务器端处理方式有较大的灵活性。
  这种灵活性是有一定代价的。每种服务器端控件都会消耗服务器上的资源。另外,除非控件、网页或应用程序明确地禁止view state,控件的状态是包含在view state的隐藏域中,并在每次回送中都会被传递,这会引起严重的性能下降。
  在这方面的一个很好的例子是,网页上控件表格的应用,如果不需要在代码中引用表格中的元素,则使用无需进行服务器端处理的HTML表格。我们仍然可以在HTML表格单元中放置服务器控件,并在代码中引用服务器控件。如果需要引用任意的表格元素,例如指定的单元,则整个表格必须是服务器控件。

  6. HyperLink控件、LinkButton控件的差别

  对于Web访问者而言,HyperLink、LinkButton控件是一样的,但它们在功能方面仍然有较大的差异。

  当用户点击控件时,HyperLink控件会立即将用户“导航”到目标URL,表件不会回送到服务器上。LinkButton控件则首先将表件发回到服务器,然后将用户导航到目标URL。如果在“到达”目标URL之前需要进行服务器端处理,则使用LinkButton控件;如果无需进行服务器端处理,则可以使用HyperLink控件。

  7、注释代码

  这一技巧并不是针对ASP.NET的,但它是一个良好的编程习惯。

  注释不仅仅应当说明代码会执行什么操作,还应当注明原因。例如,不要仅仅在注释中说明是在遍历数组,而是要说明遍历数组是根据某一算法计算一个值,除非算法是相当简单的,否则还应当对算法进行简要的说明。
  .NET工程中的不同的编程语言都有各自不同的注释符号,下面是一个简要的说明:
  HTML <!– 注释 –>
  JavaScript // 注释
  VBScript ‘ 注释
  VB.NET ‘ 注释
  C# // 注释
  /* 多行内容
  的注释
  */
  SQL — 注释
  
  在服务器控件的开始和结束标记中没有注释符号,但服务器能够忽略掉所有它不能识别的属性,因此我们能够通过使用没有定义的属性来插入注释。下面是一个例子:
  
  <asp:TextBox
  id="txtLastName"
  size="40"
  comment="这是我的注释"
  runat="server" />
  在Visual Studio .NET中对源代码进行注释非常简单。高亮度显示需要注释的行,然后按Ctrl+K+C组合键添加注释。要删除注释,只需高亮度显示被注释的代码,并按下Ctrl+K+U组合键。
  在C#工程中,我们还可以通过在每行的开始处使用///输入XML注释小节。在注释小节中,我们可以使用下面的XML标记组织注释:
  <summary></summary>
  <remarks></remarks >
  <param></param>
  <returns></returns>
  <newpara></newpara>
  要在Visual Studio .NET中查看这些XML注释的格式化的报告,我们可以首先选择“工具”菜单项,然后选择“建立注释Web网页”菜单项。

  8、使用trace方法和trace属性记录Page目录中网页的执行情况

  调试程序的一种古老的技术是在程序中的关健点插入输出语句,通常情况下,输出信息中会包含重要变量的值,相关信息可以输出到屏幕、日志文件或者数据库。

  在ASP.NET中,通过使用Page命令中的trace属性,这种调试技术的使用更简单了。Page命令是ASPX文件开始处的一行代码,它提供编译器的指示。Page命令中包含一个或多个属性,向编译器提供使用的编程语言、代码支持文件的位置或要继承的类的名字等信息。
  Page命令中的属性之一是trace,其值可能是true或false,下面是一个典型的Page命令,其中的trace属性的值是true:
  <%@ Page language="c#" trace="true" %>
  如果trace属性的值设置为true,由ASPX文件生成的Web页就会显示出来,除了网页本身外,关于该页的大量其他信息也会显示出来。这些信息以下面小节的形式显示在一张表格中:
  ·Request细节 提供Session ID、请求时间和请求的状态码。
  ·Trace Information 包含跟踪日志、网页生命周期中按时间先后顺序各个步骤的列表。另外,也可以向其中添加定制信息。
  ·控件树 以一种分层次的方式列出网页上的所有控件,包括每个控件以字节计算的大小。
  ·Cookies集合 列出该网页创建的所有Cookie。
  ·头部集合 HTTP头部以及它们的值。
  ·Server变量 与该网页相关的Server环境变量。
  包含在Trace Information小节中的跟踪日志是最有用的,在这里我们可以插入自己的跟踪命令。trace类中有2个方法能够在跟踪日志中插入命令:Trace.Write和Trace.Warn,除了Trace.Warn命令用红色字体显示、Trace.Write命令用黑色字体显示外,它们是相同的。下面是跟踪日志的一个屏幕快照,其中包含有几个Trace.Warn命令。
  跟踪日志中最方便的功能是我们可以在开发和测试过程中在整个代码中插入Trace.Write和Trace.Warn语句,而在最终交付应用程序时,可以通过改变Page命令中trace属性的值,禁止这些命令起作用,而无需在部署应用软件前删除这些输出语句。

  9、使用存储过程

  微软公司的SQL Server和其他现代关系数据库都使用SQL命令定义和处理查询。一个SQL语句或一系列SQL语句提交给SQL Server,SQL Server会对命令进行解析,然后创建一个查询计划并对它进行优化,然后执行该查询计划,这都需要大量的时间。
  存储过程是一系列被查询处理器预解析和优化的SQL命令,这些命令会被存储起来,可以得到快速地执行。存储过程也被称作sprocs,它可以接收输入参数,使一个单一的存储过程能够处理较大范围的特定的查询。
  因为sprocs是预先被解析的,对于复杂的查询更显得重要,其查询计划是预先优化的,因此调用查询过程比执行相同功能的SQL语句速度要快得多。

  10、使用.NET命令行

  .NET命令行工具在命令提示符窗口中运行。为了使命令能够执行,它必须驻留在命令提示符的当前目录中,或通过设置PATH环境变量。
  .NET SDK在“启动”菜单上安装一个菜单项,该菜单项能够打开一个正确设置了PATH环境变量的命令提示符窗口。我们可以通过依次点击“开始”->“程序”->“Microsoft Visual Studio .NET”->“Visual Studio .NET工具”->“Visual Studio .NET命令提示符”,启动命令提示符窗口。
   通过在将该菜单项从菜单上拖到桌面上时,同时按Ctrl+C键,就可以将该菜单项的快捷方式拷贝到桌面上,使用起来会非常方便。

在asp.net应用程序下找到web.config文件,在<system.web>前面加入下面的代码:
<?xml version="1.0" encoding="utf-8"?>
<configuration>

    <appSettings>
        <add key="ConnectionString" value="server=jeff;uid=sa;pwd=btk;database=msg" />
    </appSettings>
  
  <system.web>
……
  </system.web>
</configuration>  

在aspx文件里面建立连接:
public SqlDataReader GetReviews(int productID) {
    // 创建Connection和Command对象实例
    SqlConnection myConnection = new SqlConnection(System.Configuration.ConfigurationSettings.AppSettings["ConnectionString"]);
    SqlCommand myCommand = new SqlCommand("ReviewsList", myConnection);
    myCommand.CommandType = CommandType.StoredProcedure;
    // 参数
    SqlParameter parameterProductID = new SqlParameter("@ProductID", SqlDbType.Int, 4);
    parameterProductID.Value = productID;
    myCommand.Parameters.Add(parameterProductID);
    // 执行
    myConnection.Open();
    SqlDataReader result = myCommand.ExecuteReader(CommandBehavior.CloseConnection);
    // 返回结果
    return result;

2005年10月31日

 

 

第三部分  操作数据:SQL

 

 

          本部分内容

          n  SQL基础

          n  中级SQL

n               高级SQL


 

 

  

10  SQL基础

 

 

                 本章内容

          

                 SQL介绍

                 使用SELECT 语句从表中取数据

                 创建新表

                 字段属性

                 向表中添加数据

                 删除和修改表      

       

    为了建立交互站点,你需要使用数据库来存储来自访问者的信息。例如,你要建立一个职业介绍服务的站点,你就需要存储诸如个人简历,所感兴趣的工作等等这样的信息。创建动态网叶也需要使用数据库,如果你想显示符合来访者要求的最好的工作,你就需要从数据库中取出这份工作的信息。你将会发现,在许多情况下需要使用数据库。

    在这一章里,你将学会怎样使用“结构化查询语言”(SQL〕来操作数据库。SQL语言是数据库的标准语言。在Active Sever Pages 中,无论何时你要访问一个数据库,你就要使用SQL语言。因此,掌握好SQLASP编程是非常重要的。

    

    注意:

    你可以把“SQL”读作“sequel”,也可以按单个字母的读音读作SQL                        两种发音都是正确的,每种发音各有大量的支持者。在本书里,认为“SQL”读作“sequel”。

 

    通过这一章的学习,你将理解怎样用SQL实现数据库查询,你将学会怎样使用这种查询从数据表中取出信息,最后,你将学会怎样设计和建立自己的数据库。

           

    注意:

    通过下面几章对SQL的介绍,你将对SQL有足够的了解,从而可以有效地使用Active Sever Pages。但是,SQL是一种复杂的语言,本书不可能包括它的全部细节。要全面掌握SQL语言,你需要学习在Microsoft SQL Sever 中使用SQL。你可以到附近的书店去买一本Microsoft SQL Sever 6.5

 

SQL介绍:

    本书假设你是在SQL操作Microsoft SQL Sever 的数据库。你也可以用SQL操作许多其它类型的数据库。SQL是操作数据库的标准语言。(事实上,关于SQL语言有一个专门的ANSI标准〕

 

    注意:

    不要在你的站点上试图用Microsoft Access代替Microsoft SQL SeverSQL Sever可以同时服务于许多用户,如果你希望你的站点有较高的访问率,MS Access是不能胜任的。

 

    在学习SQL的细节之前,你需要理解它的两大特点。一个特点容易掌握,另一个掌握起来有点困难。

    第一个特点是所有SQL数据库中的数据都存储在表中。一个表由行和列组成。例如,下面这个简单的表包括name e-mail address

    Name                  Email Address

    ……………………………………………………….

    Bill Gates               billg@microsoft.com

    president Clinton         president@whitehouse.com

    Stephen Walther         swalther@somewhere.com

    这个表有两列(列也称为字段,域〕:NameEmail Address。有三行,每一行包含一组数据。一行中的数据组合在一起称为一条记录。

    无论何时你向表中添加新数据,你就添加了一条新记录。一个数据表可以有几十个记录,也可以有几千甚至几十亿个记录。虽然你也许永远不需要存储十亿个Email地址,但知道你能这样做总是好的,也许有一天你会有这样的需要。

    你的数据库很有可能包含几十个表,所有存储在你数据库中的信息都被存储在这些表中。当你考虑怎样把信息存储在数据库中时,你应该考虑怎样把它们存储在表中。

    SQL的第二个特点有些难于掌握。这种语言被设计为不允许你按照某种特定的顺序来取出记录,因为这样做会降低SQL Sever取记录的效率。使用SQL,你只能按查询条件来读取记录。

    当考虑如何从表中取出记录时,自然会想到按记录的位置读取它们。例如,也许你会尝试通过一个循环,逐个记录地扫描,来选出特定的记录。在使用SQL时,你必须训练自己,不要有这种思路。

    假如你想选出所有的名字是“Bill Gates”的记录,如果使用传统的编程语言,你也许会构造一个循环,逐个查看表中的记录,看名字域是否是“Bill Gates”。

    这种选择记录的方法是可行的,但是效率不高。使用SQL,你只要说,“选择所有名字域等于Bill Gates的记录”,SQL就会为你选出所有符合条件的记录。SQL会确定实现查询的最佳方法。

    建设你想取出表中的前十个记录。使用传统的编程语言,你可以做一个循环,取出前十个记录后结束循环。但使用标准的SQL查询,这是不可能实现的。从SQL的角度来说,在一个表中不存在前十个记录这种概念。

    开始时,当你知道你不能用SQL实现某些你感觉应该能实现的功能,你会受到挫折。你也许会以头撞墙甚至想写恶毒的信件给SQL的设计者们。但后来你会认识到,SQL的这个特点不仅不是个限制,反而是其长处。因为SQL不根据位置来读取记录,它读取记录可以很快。

    综上所述,SQL有两个特点:所有数据存储在表中,从SQL的角度来说,表中的记录没有顺序。在下一节,你将学会怎样用SQL从表中选择特殊的记录。

 

使用SQL从表中取记录。

    SQL的主要功能之一是实现数据库查询。如果你熟悉Internet 引擎,那么你已经熟悉查询了。你使用查询来取得满足特定条件的信息。例如,如果你想找到有ASP信息的全部站点,你可以连接到 Yahoo!并执行一个对Active Sever Pages的搜索。在你输入这个查询后,你会收到一个列表,表中包括所有其描述中包含搜索表达式的站点。

    多数Internet 引擎允许逻辑查询。在逻辑查询中,你可以包括特殊的运算符如ANDORNOT,你使用这些运算符来选择特定的记录。例如,你可以用AND来限制查询结果。如果你执行一个对Active Sever Pages  AND  SQL的搜索。你将得到其描述中同时包含Active Sever Pages SQL的记录。当你需要限制查询结果时,你可以使用AND

    如果你需要扩展查询的结果,你可以使用逻辑操作符OR。例如,如果你执行一个搜索,搜索所有的其描述中包含Active Sever Pages  OR  SQL的站点,你收到的列表中将包括所有其描述中同时包含两个表达式或其中任何一个表达式的站点。

    如果你想从搜索结果中排除特定的站点,你可以使用NOT。例如,查询“Active Sever Pages  AND NOT SQL”将返回一个列表,列表中的站点包含Active  Sever Pages,但不包含SQL。当必须排除特定的记录时,你可以使用NOT

    SQL执行的查询与用Internet搜索引擎执行的搜索非常相似。 当你执行一个SQL查询时,通过使用包括逻辑运算符的查询条件,你可以得到一个记录列表。此时查询结果是来自一个或多个表。

    SQL查询的句法非常简单。假设有一个名为email_table 的表,包含名字和地址两个字段,要得到Bill Gates e_mail地址,你可以使用下面的查询:

 

    SELECT email from email_table WHERE name="Bill Gates"

 

    当这个查询执行时,就从名为email_table的表中读取Bill Gatese_mail 地址。这个简单的语句包括三部分:

      SELECT语句的第一部分指名要选取的列。在此例中,只有email列被选取。当执行 时,只显示email列的值 billg@microsoft.com

      SELECTT语句的第二部份指明要从哪个(些)表中查询数据。在此例中,要查询的表名为email_table

      最后,SELECT语句的WHERE子句指明要选择满足什么条件的记录。在此例中,查询条件为只有name列的值为Bill Gates 的记录才被选取。

    Bill Gates很有可能拥有不止一个email地址。如果表中包含Bill Gates的多个email地址。用上述的SELECT语句可以读取他所有的email地址。SELECT语句从表中取出所有name字段值为Bill Gates 的记录的email 字段的值。

    前面说过,查询可以在查询条件中包含逻辑运算符。假如你想读取Bill Gates Clinton总统的所有email地址,你可以使用下面的查询语句:

 

    SELECT  email  FROM  email_table  WHERE  name="Bill Gates" OR

                                                   name="president  Clinton"

 

    此例中的查询条件比前一个复杂了一点。这个语句从表email_table中选出所有name列为Bill Gatespresident Clinton的记录。如果表中含有Bill Gatespresident Clinton的多个地址,所有的地址都被读取。

    SELECT语句的结构看起来很直观。如果你请一个朋友从一个表中为你选择一组记录,你也许以非常相似的方式提出你的要求。在SQL SELECT语句中,你“SELECT特定的列FROM一个表WHERE某些列满足一个特定的条件”。

    下一节将介绍怎样执行SQL查询来选取记录。这将帮助你熟悉用SELECT语句从表中取数据的各种不同方法。

 

使用ISQL执行SELECT查询

    当你安装SQL Sever时,你同时安装了一个叫作ISQL/w的应用程序。ISQL/w允许你执行交互的SQL查询。在把查询包括到你的ASP网页中之前,用ISQL/w对其进行测试是非常有用的。

 

    注意:

    在这本书的第一部份,你学习了怎样安装和配置Microsoft SQL Sever 。如果没有安装SQL Sever或者SQL Sever不能运行,请参阅第三章“安装和使用SQL Sever”。

 

    选择任务上SQL Sever程序组中的ISQL_w以启动该程序。程序启动时,首先会出现一个对话框,要求输入服务器信息和登录信息(见图10.1)。在Sever框中,输入你的SQL服务器的名字。如果服务器正运行在本地计算机上,服务器名字就是你计算机的名字。在登录信息框中,输入一个登录帐号和密码或选择使用“可信连接”,然后单击Connect按钮。

 

      101

 

 

 

    注意:

    如果你将SQL Sever配置为使用完整安全或混合安全,那么你可以使用可信连接。如果你使用标准安全,你则需要提供用户帐号和密码。要了解更多信息,参见第三章。

 

    如果一切正常,在你单击连接按钮后会出现一个查询窗口,如图10.2所示。(如果有异常,请参考第三章)

 

 

        10.2

 

 

    在执行查询之前,你需要选择数据库。安装 SQL Sever时你已为自己创建了一个数据库,SQL Sever还有许多系统数据库,如mastermodelmsdb,和tempdb

    方便的是,SQL Sever带有一个特殊的名为pubs的例子数据库。库 pubs中包含供一个虚拟的出版商使用的各个表。文档中所有的例子程序都是针对这个库来设计的。本书中的许多例子也使用这个数据库。

    在查询窗口顶部的DB下拉框中选择数据库pubs,这样你就选择了数据库。你所有的查询都将针对这个库中的各个表来执行。现在你可以执行你的第一个查询了。这真让人兴奋!

    你的第一个查询将针对一个名为autrors的表,表中包含所有为某个虚拟出版商工作的作者的相关数据。单击查询窗口并输入以下的语句:

 

    SELECT  phone  FROM authors WHERE au_name="Ringer"

 

    输入完成后,单击执行查询按钮(一个绿色三角形,看起来像VCR播放键)。单击此按钮后,任何出现在查询窗口中的语句均会被执行。查询窗口会自动变成结果显示窗口,你可以看到查询的结果(见图10.3)。

    你看到的查询结果也许与图10.3所示的不同。在SQL Sever的不同版本中,库pubs中的数据会有所不同。对SQL Sever 6.5来说,将会找到两条记录。结果显示窗口中应显示如下内容:

   

    phone

……………….

801 826_0752

801 826_0752

    (2 row(s)  affected)

 

 

 

  10.3

 

 

 

    你所执行的SELECT语句从表authors中取出所有名字为Ringer的作者的电话号码。你通过在WHERE子句中使用特殊的选择条件来限制查询的结果。你也可以忽略选择条件,从表中取出所有作者的电话号码。要做到这一点,单击Query标签,返回到查询窗口,输入以下的SELECT语句:

 

SELECT Phone  FROM authors

    这个查询执行后,会取出表authors中的所有电话号码(没有特定的顺序)。如果表authors中包含一百个电话号码,会有一百个记录被取出,如果表中有十亿个电话号码,这十亿条记录都会被取出(这也许需要一些时间)。

    authrs的字段包括姓,名字,电话号码,地址,城市,州和邮政编码。通过在SELECT语句的第一部份指定它们,你可以从表中取出任何一个字段。你可以在一个SELECT语句中一次取出多个字段,比如:

 

    SELECT au_fname ,au_lname, phone FROM authors

 

    这个SELECT语句执行后,将取出这三个列的所有值。下面是这个查询的结果的一个示例(为了节省纸张,只显示查询结果的一部分,其余记录用省略号代替):

 

    au_fname          au_lname                 phone

    ………………………………………………………………………….

    Johnson            White                    408  496_7223

    Marjorie            Green                    415  986_7020

    Cheryl               Carson                  415  548_7723

    Michael             OLeary                 408  286_2428

   

    (23 row(s)  affected)

 

    SELECT语句中,你需要列出多少个字段,你就可以列出多少。不要忘了把字段名用逗号隔开。你也可以用星号(*)从一个表中取出所有的字段。这里有一个使用星号的例子:

 

    SELECT  *  FROM  authors

 

    这个SELECT语句执行后,表中的所有字段的值都被取出。你会发现你将在SQL查询中频繁使用星号。

 

    技巧:

    你可以使用星号来查看一个表的所有列的名字。要做到这一点,只需要在执行完SELECT语句后看一下查询结果的列标题。

 

操作多个表

    到现在为止,你只尝试了用一句SQL查询从一个表中取出数据。你也可以用一个SELECT语句同时从多个表中取出数据,只需在SELECT语句的FROM从句中列出要从中取出数据的表名称即可:

       

    SELECT au_lname ,title  FROM  authors, titles  

 

    这个SELECT语句执行时,同时从表authors和表titles中取出数据。从表authors中取出所有的作者名字,从表titles中取出所有的书名。在ISQL/w程序中执行这个查询,看一下查询结果。你会发现一些奇怪的出乎意料的情况:作者的名字并没有和它们所著的书相匹配,而是出现了作者名字和书名的所有可能的组合,这也许不是你所希望见到的。

    出了什么差错?问题在于你没有指明这两个表之间的关系。你没有通过任何方式告诉SQL如何把表和表关联在一起。由于不知道如何关联两个表,服务器只能简单地返回取自两个表中的记录的所有可能组合。

    要从两个表中选出有意义的记录组合,你需要通过建立两表中字段的关系来关联两个表。要做到这一点的途径之一是创建第三个表,专门用来描述另外两个表的字段之间的关系。

    authors有一个名为au_id的字段,包含有每个作者的唯一标识。表titles有一个名为title_id的字段,包含每个书名的唯一标识。如果你能在字段au_id和字段title_id 之间建立一个关系,你就可以关联这两个表。数据库pubs中有一个名为titleauthor的表,正是用来完成这个工作。表中的每个记录包括两个字段,用来把表titles和表authors关联在一起。下面的SELECT语句使用了这三个表以得到正确的结果:

 

    SELECT  au_name,title FROM authors,titles,titleauthor 

                            WHERE  authors.au_id=titleauthor.au_id

                             AND    titles.title_id=titleauthor.title_id   

 

    当这个SELECT语句执行时,每个作者都将与正确的书名相匹配。表titleauthor指明了表authors和表titles的关系,它通过包含分别来自两个表的各一个字段实现这一点。第三个表的唯一目的是在另外两个表的字段之间建立关系。它本身不包含任何附加数据。

    注意在这个例子中字段名是如何书写的。为了区别表authors和表titles中相同的字段名au_id,每个字段名前面都加上了表名前缀和一个句号。名为author.au_id 的字段属于表authors,名为titleauthor.au_id的字段属于表titleauthor,两者不会混淆。

    通过使用第三个表,你可以在两个表的字段之间建立各种类型的关系。例如,一个作者也许写了许多不同的书,或者一本书也许由许多不同的作者共同完成。当两个表的字段之间有这种“多对多”的关系时,你需要使用第三个表来指明这种关系。

    但是,在许多情况下,两个表之间的关系并不复杂。比如你需要指明表titles和表publishers之间的关系。因为一个书名不可能与多个出版商相匹配,你不需要通过第三个表来指明这两个表之间的关系。要指明表titles和表publishers之间的关系,你只要让这两个表有一个公共的字段就可以了。在数据库pubs中,表titles和表publishers都有一个名为pub_id的字段。如果你想得到书名及其出版商的一个列表,你可以使用如下的语句:

    SELECT  title,pub_name  FROM  titles,publishers

                                WHERE titles.pub_id=publishers.pub_id

 

    当然,如果一本书是由两个出版商联合出版的,那么你需要第三个表来代表这种关系。

    通常,当你予先知道两个表的字段间存在“多对多”关系时,就使用第三个表来关联这两个表。反之,如果两个表的字段间只有“一对一”或“一对多”关系,你可以使用公共字段来关联它门。

 

操作字段

    通常,当你从一个表中取出字段值时,该值与创建该表时所定义的字段名联系在一起。如果你从表authors中选择所有的作者名字,所有的值将会与字段名au_lname相联系。但是在某些情况下,你需要对字段名进行操作。在SELECT语句中,你可以在缺省字段名后面仅跟一个新名字来取代它。例如,可以用一个更直观易读的名字Author Last Name来代替字段名au_lname

 

    SELECT au_lname "Author Last Name" FROM authors

 

    当这个SELECT语句执行时,来自字段au_lname的值会与“Author Last Name”相联系。查询结果可能是这样:

        

      Author Last Name

      …………………………………………………………………….. 

      White

      Green

      Carson

      OLeary

      Straight

     

      (23 row(s) affected)

 

注意字段标题不再是au_lname,而是被Author Last Name所取代。

    你也可以通过执行运算,来操作从一个表返回的字段值。例如,如果你想把表titles中的所有书的价格加倍,你可以使用下面的SELECT语句:

   

    SELECT  price*2 FROM titles      

 

    当这个查询执行时,每本书的价格从表中取出时都会加倍。但是,通过这种途径操作字段不会改变存储在表中的书价。对字段的运算只会影响SELECT语句的输出,而不会影响表中的数据。为了同时显示书的原始价格和涨价后的新价格,你可以使用下面的查询:

 

SELECT  price  "Original  price", price*2  "New price" FROM  titles

 

    当数据从表titles中取出时,原始价格显示在标题Original price下面,加倍后的价格显示在标题New price下面。结果可能是这样:

         

      original  price         new  price

      ……………………………………………………………….

19.99                                                           39.98

11.95                 23.90

2.99                                                              5.98

19.99                                                           39.98

(18 row(s)  affected)

       

    你可以使用大多数标准的数学运算符来操作字段值,如加(+),减(-),乘(*)和除(/)。你也可以一次对多个字段进行运算,例如:

 

     SELECT  price*ytd_sales "total revenue" FROM titles

 

    在这个例子中,通过把价格与销售量相乘,计算出了每种书的总销售额。这个SELECT语句的结果将是这样的:

      

      total  revenue

      ……………………………………………..

      81,859,05

      46,318,20

      55,978,78

      81,859,05

      40,619,68

     

      (18 row(s)  affected)

  

    最后,你还可以使用连接运算符(它看起来像个加号)来连接两个字符型字段:

 

      SELECT  au_fname+" "+au_lname   "author name" FROM authors

 

    在这个例子中,你把字段au_fname和字段au_lname粘贴在一起,中间用一个逗号 隔开,并把查询结果的标题指定为author name。这个语句的执行结果将是这样的:

 

       author  names

       …………………………………………………………

       Johnson White

       Marjorie Green

       Cheryl  Carson

      Michael OLeary

      Dean Straight

     

      (23 row(s)  affected)

 

    可以看到,SQL为你提供了对查询结果的许多控制。你应该在ASP编程过程中充分利用这些优点。使用SQL来操作查询结果几乎总是比使用有同样作用的脚本效率更高。

 

排序查询结果

    本章的介绍中曾强调过,SQL表没有内在的顺序。例如,从一个表中取第二个记录是没有意义的。从SQL的角度看来,没有一个记录在任何其他记录之前。

然而,你可以操纵一个SQL查询结果的顺序。在缺省情况下,当记录从表中取出时,记录不以特定的顺序出现。例如,当从表authors中取出字段au_lname时,查询结果显示成这样:

 

       au_lname

       …………………………………….

       White

       Green

       Carson

       OLeary

       Straight

      

       (23 row(s) affected)

  

    看一列没有特定顺序的名字是很不方便的。如果把这些名字按字母顺序排列,读起来就会容易得多。通过使用ORDER BY子句,你可以强制一个查询结果按升序排列,就像这样:

 

    SELECT au_lname FROM  authors  ORDER  BY  au_lname

 

    当这个SELECT语句执行时,作者名字的显示将按字母顺序排列。ORDER BY子句将作者名字按升序排列。

    你也可以同时对多个列使用ORDER BY子句。例如,如果你想同时按升序显示字段au_lname和字段au_fname,你需要对两个字段都进行排序:

 

    SELECT au_lname,au_fname FROM authors ORDER BY au_lname ,au_fname

 

    这个查询首先把结果按au_lname字段进行排序,然后按字段au_fname排序。记录将按如下的顺序取出:

 

      au_lname                         au_fname

      …………………………………………………………………….

      Bennet                           Abraham

      Ringer                            Albert

      Ringer                            Anne

      Smith                             Meander

     

      (23 row(s) affected)

 

    注意有两个作者有相同的名字Ringer。名为Albert Ringer的作者出现名为Anne Ringer的作者之前,这是因为姓Albert按字母顺序应排在姓Anne之前。

如果你想把查询结果按相反的顺序排列,你可以使用关键字DESC。关键字DESC把查询结果按降序排列,如下例所示:

    

       SELECT  au_lname,au_fname  FROM authors

              WHERE au_lname=Ringer ORDER BY  au_lname ,au_fname  DESC

 

    这个查询从表authors中取出所有名字为Ringer的作者记录。ORDER BY子句根据作者的名字和姓,将查询结果按降序排列。结果是这样的:

 

      au_lname                          au_fname

      ……………………………………………………………………………………….

      Ringer                             Anne

      Ringer                             Albert

      (2 row(s)  affectec)

 

    注意在这个表中,姓Anne出现在姓Albert之前。作者名字按降序显示。

你也可以按数值型字段对一个查询结果进行排序。例如,如果你想按降序取出所有书的价格,你可以使用如下的SQL查询:

 

       SELECT  price  FROM titles  ORDER BY  price  DESC

 

    这个SELECT语句从表中取出所有书的价格,显示结果时,价格低的书先显示,价格高的书后显示。

 

    警告:

    不是特别需要时,不要对查询结果进行排序,因为服务器完成这项工作要费些力气。这意味着带有ORDER BY 子句的SELECT语句执行起来比一般的SELECT语句花的时间长。

 

取出互不相同的记录

    一个表有可能在同一列中有重复的值。例如,数据库pubs的表authors中有两个作者的名字是Ringer。如果你从这个表中取出所有的名字,名字Ringer将会显示两次。

    在特定情况下,你可能只有兴趣从一个表中取出互不相同的值。如果一个字段有重复的值,你也许希望每个值只被选取一次,你可以使用关键字DISTINCT来做到这一点:

 

     SELCET  DISTINCT au_lname  FROM  authors   WHERE  au_lname="Ringer"

 

    当这个SELECT语句执行时,只返回一个记录。通过在SELECT语句中包含关键字DISTINCT,你可以删除所有重复的值。例如,假设有一个关于新闻组信息发布的表,你想取出所有曾在这个新闻组中发布信息的人的名字,那么你可以使用关键字DISTINCT。每个用户的名字只取一次——尽管有的用户发布了不止一篇信息。

    警告:

    如同ORDER BY子句一样,强制服务器返回互不相同的值也会增加运行开销。福气不得不花费一些时间来完成这项工作。因此,不是必须的时候不要使用关键字DISTINCT

 

创建新表

    前面说过,数据库中的所有数据存储在表中。数据表包括行和列。列决定了表中数据的类型。行包含了实际的数据。

    例如,数据库pubs中的表authors有九个字段。其中的一个字段名为为au_lname,这个字段被用来存储作者的名字信息。每次向这个表中添加新作者时,作者名字就被添加到这个字段,产生一条新记录。

    通过定义字段,你可以创建一个新表。每个字段有一个名字和一个特定的数据类型(数据类型在后面的“字段类型”一节中讲述),例如字段au_lname存储的是字符型数据。一个字段也可以存储其它类型的数据。

    使用SQL Sever,创建一个新表的方法是很多的。你可以可执行一个SQL语句或使用SQL事务管理器(SQL Enterprise Manager)来创建一个新表。在下一节里,你将学会如何用SQL语句来创建一个新表。

 

SQL创建新表

    注意:

    如果你还没有建立自己的数据库,现在就跳回到第三章创建这个库。你绝不能向master,tempdb或任何其他任何系统数据库中添加数据。

 

    SQL Sever程序组(在任务栏中)中启动ISQL/w程序。出现查询窗口后,从窗口顶部的下拉列表中选择你在第三章所创建的数据库。下一步,在查询窗口中键入下面的SQL语句,单击执行查询按钮,执行这个语句:

 

      CREATE  TABLE  guestbook (visitor VARCHAR(40),comments TEXT,entrydate

                                         DATETIME)

 

如果一切正常,你会在结果窗口中看到如下的文字(如果出现异常,请参阅第三章):

 

      This command dit not return data ,and it did not return any rows      

 

祝贺你,你已经建立了你的第一个表!

    你所创建的表名为guestbook,你可以使用这个表来存储来字你站点访问者的信息。你是用REEATE TABLE语句创建的这个表,这个语句有两部分:第一部份指定表的名子;第二部份是括在括号中的各字段的名称和属性,相互之间用逗号隔开。

    guestbook有三个字段:visitor,comments entrydatevisitor字段存储访问者的名字,comments字段存储访问者对你站点的意见,entrydate字段存储访问者访问你站点的日期和时间。

    注意每个字段名后面都跟有一个专门的表达式。例如,字段名comments后面跟有表达式TEXT。这个表达式指定了字段的数据类型。数据类型决定了一个字段可以存储什么样的数据。因为字段comments包含文本信息,其数据类型定义为文本型。

    字段有许多不同的数据类型。下一小节讲述SQL所支持的一些重要的数据类型。

 

字段类型

    不同的字段类型用来存放不同类型的数据。创建和使用表时,更你应该理解五种常用的字段类型:字符型,文本型,数值型,逻辑性和日期型。

 

字符型数据

    字符型数据非常有用。当你需要存储短的字符串信息时,你总是要用到字符型数据。例如,你可以把从HTML form的文本框中搜集到的信息放在字符型字段中。

    要建立一个字段用来存放可变长度的字符串信息,你可以使用表达式 VARCHAR。考虑你前面创建的表guestbook

 

     CREATE  TABLE  guestbook (visitor VARCHAR(40),comments TEXT,entrydate

                                         DATETIME)

 

    在这个例子中,字段visitor的数据类型为VARCHAR。注意跟在数据类型后面的括号中的数字。这个数字指定了这个字段所允许存放的字符串的最大长度。在这个例子中,字段visitor能存放的字符串最长为四十个字符。如果名字太长,字符串会被截断,只保留四十个字符。

    VARCHAR类型可以存储的字符串最长为255个字符。要存储更长的字符串数据,可以使用文本型数据(下一节中讲述)。

    另一种字符型数据用来存储固定长度的字符数据。下面是一个使用这种数据类型的例子:

 

     CREATE TABLE guestbook (visitor CHAR(40),comments TEXT,entrydate

                                         DATETIME)

 

    在这个例子中,字段visitor被用来存储四十个字符的固定长度字符串。表达式CHAR指定了这个字段应该是固定长度的字符串。

    VARCHAR型和CHAR型数据的这个差别是细微的,但是非常重要。假如你向一个长度为四十个字符的VARCHAR型字段中输入数据Bill Gates。当你以后从这个字段中取出此数据时,你取出的数据其长度为十个字符——字符串Bill Gates的长度。

    现在假如你把字符串输入一个长度为四十个字符的CHAR型字段中,那么当你取出数据时,所取出的数据长度将是四十个字符。字符串的后面会被附加多余的空格。

    当你建立自己的站点时,你会发现使用VARCHAR型字段要比CHAR型字段方便的多。使用VARCHAR型字段时,你不需要为剪掉你数据中多余的空格而操心。

    VARCHAR型字段的另一个突出的好处是它可以比CHAR型字段占用更少的内存和硬盘空间。当你的数据库很大时,这种内存和磁盘空间的节省会变得非常重要。

 

文本型数据

    字符型数据限制了字符串的长度不能超过255个字符。而使用文本型数据,你可以存放超过二十亿个字符的字符串。当你需要存储大串的字符时,应该使用文本型数据。

    这里有一个使用文本型数据的例子:

 

    CREATE  TABLE  guestbook (visitor VARCHAR(40),comments TEXT,entrydate

                                         DATETIME)

 

    在这个例子中,字段comments被用来存放访问者对你站点的意见。注意文本型数据没有长度,而上一节中所讲的字符型数据是有长度的。一个文本型字段中的数据通常要么为空,要么很大。

    当你从HTML form的多行文本编辑框(TEXTAREA)中收集数据时,你应该把收集的信息存储于文本型字段中。但是,无论何时,只要你能避免使用文本型字段,你就应该不适用它。文本型字段既大且慢,滥用文本型字段会使服务器速度变慢。文本型字段还会吃掉大量的磁盘空间。

    警告:

    一旦你向文本型字段中输入了任何数据(甚至是空值),就会有2K的空间被自动分配给该数据。除非删除该记录,否则你无法收回这部分存储空间。

 

数值型数据

    SQL Sever支持许多种不同的数值型数据。你可以存储整数、小数、和钱数。

    通常,当你需要在表中的存放数字时,你要使用整型(INT)数据。INT型数据的表数范围是从-21474836472147483647的整数。下面是一个如何使用INT型数据的例子:

 

       CREATE  TABLE  visitlog (visitor VARCHAR(40),numvisits  INT)

 

    这个表可以用来记录你站点被访问的次数。只要没有人访问你的站点超过2147483647次,nubvisits字段就可以存储访问次数。

    为了节省内存空间,你可以使用SMALLINT型数据。SMALLINT 型数据可以存储从-3276832768的整数。这种数据类型的使用方法与INT型完全相同。

    最后,如果你实在需要节省空间,你可以使用TINYINT型数据。同样,这种类型的使用方法也与INT型相同,不同的是这种类型的字段只能存储从0到255的整数。TINYINT型字段不能用来存储负数。

    通常,为了节省空间,应该尽可能的使用最小的整型数据。一个TINYINT型数据只占用一个字节;一个INT型数据占用四个字节。这看起来似乎差别不大,但是在比较大的表中,字节数的增长是很快的。另一方面,一旦你已经创建了一个字段,要修改它是很困难的。因此,为安全起见,你应该预测以下,一个字段所需要存储的数值最大有可能是多大,然后选择适当的数据类型。

    为了能对字段所存放的数据有更多的控制,你可以使用NUMERIC型数据来同时表示一个数的整数部分和小数部分。NUMERIC型数据使你能表示非常大的数——比INT型数据要大得多。一个NUMERIC型字段可以存储从-10381038范围内的数。NUMERIC型数据还使你能表示有小数部分的数。例如,你可以在NUMERIC型字段中存储小数3.14

    当定义一个NUMERIC型字段时,你需要同时指定整数部分的大小和小数部分的大小。这里有一个使用这种数据类型的例子:

    

       CREATE TABLE  numeric_data (bignumber  NUMERIC(28,0),

                                   fraction    NUMERIC (5,4) )

 

    当这个语句执行时,将创建一个名为numeric_data的包含两个字段的表。字段bignumber可以存储直到28位的整数。字段fraction可以存储有五位整数部分和四位小数部分的小数。

    一个NUMERIC型数据的整数部分最大只能有28位,小数部分的位数必须小于或等于整数部分的位数,小数部分可以是零。

    你可以使用INT型或NUMERIC型数据来存储钱数。但是,专门有另外两种数据类型用于此目的。如果你希望你的网点能挣很多钱,你可以使用MONEY型数据。如果你的野心不大,你可以使用SMALLMONEY型数据。MONEY型数据可以存储从-922337203685477.5808922337203685477.5807的钱数。如果你需要存储比这还大的金额,你可以使用NUMERIC型数据。

    SMALLMONEY型数据只能存储从-214748.3648214748.3647 的钱数。同样,如果可以的话,你应该用SMALLMONEY型来代替MONEY型数据,以节省空间。下面的例子显示了如何使用这两种表示钱的数据类型:

 

      CREATE TABLE products (product VARCHAR(40),price  MONEY,

                               Discount_price SMALLMONEY)     

 

    这个表可以用来存储商品的折扣和普通售价。字段price 的数据类型是MONEY,字段discount_price的数据类型是SMALLMONEY

 

存储逻辑值

    如果你使用复选框(CHECKBOX)从网页中搜集信息,你可以把此信息存储在BIT型字段中。BIT型字段只能取两个值:01。这里有一个如何使用这种字段的例子:

 

    CREATE  TABLE  opinion (visitor VARCHAR(40),good BIT)

 

    这个表可以用来存放对你的网点进行民意调查所得的信息。访问者可以投票表示他们是否喜欢你的网点。如果他们投YES,就在BIT型字段中存入1。反之,如果他们投NO,就在字段中存入0(在下一章里,你将学会如何计算投票)。

    当心,在你创建好一个表之后,你不能向表中添加BIT型字段。如果你打算在一个表中包含BIT型字段,你必须在创建表时完成。

 

存储日期和时间

    当你建立一个网点时,你也许需要记录在一段时间内的访问者数量。为了能够存储日期和时间,你需要使用DATETIME型数据,如下例所示:

 

    CREATE  TABL visitorlog( visitor VARCHAR (40), arrivaltime DATETIME ,

                               departuretime  DATETIME)

 

    这个表可以用来记录访问者进入和离开你网点的时间和日期。一个DATETIME型的字段可以存储的日期范围是从1753年1月1日第一毫秒到99991231日最后一毫秒。

    如果你不需要覆盖这么大范围的日期和时间,你可以使用SMALLDATETIME型数据。它与DATETIME型数据同样使用,只不过它能表示的日期和时间范围比DATETIME型数据小,而且不如DATETIME型数据精确。一个SMALLDATETIME型的字段能够存储从1900年1月1日到2079年6月6日的日期,它只能精确到秒。

    DATETIME型字段在你输入日期和时间之前并不包含实际的数据,认识这一点是重要的。在下一章,你将学习怎样使用大量的SQL函数来读取和操作日期和时间(参见下面的“缺省值”一节)。你也可以在VBScriptJScript 中使用日期和时间函数来向一个DATETIME型字段中输入日期和时间。

 

字段属性

    上一节介绍了如何建立包含不同类型字段的表。在这一节中,你将学会如何使用字段的三个属性。这些属性允许你控制空值,缺省值和标识值。

 

允许和禁止空值

    大多数字段可以接受空值(NULL)。当一个字段接受了空值后,如果你不改变它,它将一直保持空值。空值(NULL)和零是不同的,严格的说,空值表示没有任何值。

为了允许一个字段接受空值,你要在字段定义的后面使用表达式NULL。例如,下面的表中两个字段都允许接受空值:

     

      CREATE TABLE empty (empty1 CHAR (40) NULL,empty2 INT NULL(

  

    注意:

    BIT型数据不能是空值。一个这种类型的字段必须取0或者1。

 

    有时你需要禁止一个字段使用空值。例如,假设有一个表存储着信用卡号码和信用卡有效日期,你不会希望有人输入一个信用卡号码但不输入有效日期。为了强制两个字段都输入数据,你可以用下面的方法建立这个表:

     

      CREATE  TABLE creditcards (creditcard_number CHAR(20) NOT NULL,

                                 Creditcard_expire  DATETIME  NOT NULL)

    注意字段定义的后面跟有表达式NOT NULL。通过包含表达式NOT NULL,你可以禁止任何人只在一个字段中插入数据,而不输入另一个字段的数据。

    你将会发现,在你建设自己的网点过程中,这种禁止空值的能力是非常有用的。如果你指定一个字段不能接受空值,那么当你试图输入一个空值时,会有错误警告。这些错误警告可以为程序调试提供有价值的线索。

 

缺省值

    假设有一个存储地址信息的表,这个表的字段包括街道、城市、州、邮政编码和国家。如果你预计地址的大部分是在美国,你可以把这个值作为country字段的缺省值。

    为了在创建一个表时指定缺省值,你可以使用表达式DEFAULT。请看下面这个在创建表时使用缺省值的例子:

      

      CREATE TABLE addresses (street VARCHAR(60)  NULL,

                               city VARCHAR(40) NULL,

                               state VARCHAR(20) NULL

                               zip  VARCHAR(20) NULL,

                               country VARCHAR(30) DEFAULT  USA)

 

    在这个例子中,字段country的缺省值被指定为美国。注意单引号的使用,引号指明这是字符型数据。为了给非字符型的字段指定缺省值,不要把该值扩在引号中:

   

      CREATE TABLE orders(price  MONEY DEFAULT $38.00,

                           quantity INT DEFAULT 50,

                            entrydate DATETIME DEFAULT GETDATE())

 

    在这个CREATE TABLE语句中,每个字段都指定了一个缺省值。注意DATETIME型字段entrydate所指定的缺省值,该缺省值是函数Getdate()的返回值,该函数返回当前的日期和时间。

 

标识字段

    每个表可以有一个也只能有一个标识字段。一个标识字段是唯一标识表中每条记录的特殊字段。例如,数据库pubs中的表jobs包含了一个唯一标识每个工作标识字段:

   

      job_id   job_desc

      …………………………………………………………….

1                         New Hire Job not specified

2                         Chief Executive officer

3                         Bushness Operations Manager

4                         Chief Financial Officier

5                         Publisher

 

    字段job_id为每个工作提供了唯一的一个数字。如果你决定增加一个新工作,新增记录的job_id字段会被自动赋给一个新的唯一值。

    为了建立一个标识字段,你只需在字段定义后面加上表达式IDENTITY即可。你只能把NUMERIC型或INT型字段设为标识字段,这里有一个例子:

 

       CREATE TABLE visitorID (theID NUBERIC(18) IDENTITY,name VARCHAR(40))

  

    这个语句所创建的表包含一个名为theid的标识字段。每当一个新的访问者名字添加到这个表中时,这个字段就被自动赋给一个新值。你可以用这个表为你的站点的每一个用户提供唯一标识。

    技巧:

    建立一个标示字段时,注意使用足够大的数据类型。例如你使用TINYINT型数据,那么你只能向表中添加255个记录。如果你预计一个表可能会变得很大,你应该使用NUMERIC型数据。

 

    标识字段的存在会使你想尝试许多不可能的事情。例如,你也许想利用标识字段来对记录进行基于它们在表中位置的运算。你应该抛弃这种意图。每个记录的标识字段的值是互不相同的,但是,这并不禁止一个标识字段的标识数字之间存在间隔。例如,你永远不要试图利用一个表的标识字段来取出表中的前十个记录。这种操作会导致失败,比如说6号记录和7号记录根本不存在。

 

使用SQL事务管理器创建新表

    你可以使用前面几节所讲的方法创建新表。但是,使用事务管理器创建新表会更容易。这一节介绍如何使用这个程序创建新表。

    从任务栏的SQL Sever程序组中选择SQL Enterprise Manager,启动该程序,你会看到如图10.4所示的窗口。浏览服务管理器窗口中的树形结构,选择名为Database的文件夹。打开文件夹Database后,选择你在第三章中所建立的数据库。

    

注意:

    如果你还没有创建自己的数据库,回到第三章创建它。你决不要向master,tempdb或任何其它系统数据库中添加数据。

 

    在选择了数据库之后,你会看到一个名为Group/users的文件夹和一个名为objects的文件夹。打开文件夹objects,你会看到许多文件夹,其中一个名为Tables。用右键单击文件夹Tables并选择New table,就会出现如图10.5所示的窗口。

    你可以使用Manager  Tables窗口来创建一个新表。Manager Tables窗口有7个列:Key,Column,Name,Datatype,Size,NullsDefaultManager Tables窗口中的每一行标明表中一个字段的信息。

 

        10.4

           10.5

 

    要建立一个新表,你至少要输入一行信息。在名为Column  Name的列下面键入mycolumn。下一步,选择Datatype列,并从下拉列表中选择CHAR。当你在这两个列中输入信息后,窗口将是如图10.6所示的样子。

 

 10.6

 

    你已经建立了一个只有一个字段的简单的表。单击保存按扭保存这个新表。当要求你输入新表的名字时,输入mytable并单击OK。现在这个表已经保存到了你的数据库中。

如果你打开服务管理器窗口中的文件夹Tables,你会看到你所建立的新表被列出。你可以双击该表的图表来编辑它,这时Manager Tables窗口会重新出现,你可以增加新的字段并重新保存。

    SQL事务管理器可以做的工作,你都可以用SQL语句来实现。但是,事务管理器使得建表过程变得更加简单。

 

向表中添加数据

    下一章将讨论如何使用SQL向一个表中插入数据。但是,如果你需要向一个表中添加许多条记录,使用SQL语句输入数据是很不方便的。幸运的是,Microsoft  SQL Sever带有一个称为Microsoft Query 的客户端应用程序,这个程序使得向表中添加数据变得容易了。

    启动位于任务栏SQL Sever程序组中的Microsoft Query程序。从窗口顶部的菜单中选择File|New Query。这时会显示一个Select Data Source对话框(见图10.7)。选择你的数据源名字并单击Use

   

107

 

    输入你的登录帐号和密码后,程序要求你选择一个表和一个数据库。选择你在上一节中所建立的表(mytable ),单击按钮Add,然后单击按钮Close关闭该对话框。

    在窗口的左上角会出现一个对话框,框中是取自表mytable的一列字段名。你可以双击任何一个字段,把它添加到主窗口中。如果你双击星号(*)字符,所有的字段都会被添加到主窗口中。

    如果你的表中有记录,它们现在已经出现在主窗口的字段标题下面了。但是,因为你刚刚建立了这个表,表还是空的。要添加新记录,选择Records|Allow Editing,主窗口中就会出现一条新记录。输入一行数据完成这个记录,就向表中添加了一条新记录。

       

                108

 

    当你转到下一条新记录时,你向上一条记录中输入的值会自动被保存。如果你需要,你可以用Microsoft Query 向表中输入几百条记录。

 

删除和修改表

    你应该在建立表之前仔细设计它们,因为你在改变一个已经存在的表时会受到很大的限制。例如,一旦已经建立了一个表,你就不能删除表中的字段或者改变字段的数据类型。在这种情况你所能做的是删除这个表,然后重头开始(参见第十一章“中级SQL”中的“使用SQL创建记录和表”一节)。

    要删除一个表,你可以使用SQL语句DROP TABLE。例如,又从数据库中彻底删除表mytable,你要使用如下的语句:

   

       DROP TABLE mytable

 

    警告:

    使用DROP TABLE命令时一定要小心。一旦一个表被删除之后,你将无法恢复它。

 

    当你建设一个站点时,你很可能需要向数据库中输入测试数据。而当你准备向世界提供你的网点时,你会想清空表中的这些测试信息。如果你想清除表中的所有数据但不删除这个表,你可以使用TRUNCATE TABLE语句。例如,下面的这个SQL语句从表mytable中删除所有数据:

 

        TRUNCATE TABLE mytable

 

    虽然你不能删除和修改已经存在的字段,但你可以增加新字段。最容易的实现方法是使用SQL事务管理器中的Manager Tables窗口。你也可以使用SQL语句ALTER TABLE。下面是一个如何使用这种语句的例子:

 

     ALTER TABLE mytable ADD mynewcolumn INT NULL

 

    这个语句向表mytable中增加了一个新字段mynewcolumn。当你增加新字段时,你必须允许它接受空值,因为表中原来可能已经有了许多记录。

 

总结

    这一章向你介绍了SQL。使用SQL,你可以操作Microsoft  SQL Sever数据库。你已经学会了使用SELECT语句从数据库中取出数据,你还学会了怎样使用CREATE TABLE语句和SQL事务管理器来创建新表。最后,你学会了如何指明一系列重要的字段属性。

下一章将介绍如何使用索引来增强SQL查询的操作。还将通过许多其它的SQL语句和函数,使你的SQL知识得到进一步扩充。

 


 

第十一章  中级SQL

 

               本章内容

               ■创建索引

               SQL核心语句

               ■集合函数

其它常用的SQL表达式,

  函数,和过程

 


 

    第十章“SQL基础”向你初步介绍了SQL。你学会了如何用SELECT语句进行查询,你还学会了如何建立自己的表。在这一章里,你将加深你的SQL知识。你将学习如何建立索引来加快查询速度。你还将学会如果用更多的SQL语句和函数来操作表中的数据。

 

建立索引

    假设你想找到本书中的某一个句子。你可以一页一页地逐页搜索,但这会花很多时间。而通过使用本书的索引,你可以很快地找到你要搜索的主题。

    表的索引与附在一本书后面的索引非常相似。它可以极大地提高查询的速度。对一个较大的表来说,通过加索引,一个通常要花费几个小时来完成的查询只要几分钟就可以完成。因此没有理由对需要频繁查询的表增加索引。

    注意:

    当你的内存容量或硬盘空间不足时,也许你不想给一个表增加索引。对于包含索引的数据库,SQL Sever需要一个可观的额外空间。例如,要建立一个聚簇索引,需要大约1.2倍于数据大小的空间。要看一看一个表的索引在数据库中所占的空间大小,你可以使用系统存储过程sp_spaceused,对象名指定为被索引的表名。

 

聚簇索引和非聚簇索引

    假设你已经通过本书的索引找到了一个句子所在的页码。一旦已经知道了页码后,你很可能漫无目的翻寻这本书,直至找到正确的页码。通过随机的翻寻,你最终可以到达正确的页码。但是,有一种找到页码的更有效的方法。

    首先,把书翻到大概一半的地方,如果要找的页码比半本书处的页码小,就书翻到四分之一处,否则,就把书翻到四分之三的地方。通过这种方法,你可以继续把书分成更小的部分,直至找到正确的页码附近。这是找到书页的非常有效的一种方法。

SQL Sever的表索引以类似的方式工作。一个表索引由一组页组成,这些页构成了一个树形结构。根页通过指向另外两个页,把一个表的记录从逻辑上分成和两个部分。而根页所指向的两个页又分别把记录分割成更小的部分。每个页都把记录分成更小的分割,直至到达叶级页。

    索引有两种类型:聚簇索引和非聚簇索引。在聚簇索引中,索引树的叶级页包含实际的数据:记录的索引顺序与物理顺序相同。在非聚簇索引中,叶级页指向表中的记录:记录的物理顺序与逻辑顺序没有必然的联系。

    聚簇索引非常象目录表,目录表的顺序与实际的页码顺序是一致的。非聚簇索引则更象书的标准索引表,索引表中的顺序通常与实际的页码顺序是不一致的。一本书也许有多个索引。例如,它也许同时有主题索引和作者索引。同样,一个表可以有多个非聚簇索引。

    通常情况下,你使用的是聚簇索引,但是你应该对两种类型索引的优缺点都有所理解。

    每个表只能有一个聚簇索引,因为一个表中的记录只能以一种物理顺序存放。通常你要对一个表按照标识字段建立聚簇索引。但是,你也可以对其它类型的字段建立聚簇索引,如字符型,数值型和日期时间型字段。

    从建立了聚簇索引的表中取出数据要比建立了非聚簇索引的表快。当你需要取出一定范围内的数据时,用聚簇索引也比用非聚簇索引好。例如,假设你用一个表来记录访问者在你网点上的活动。如果你想取出在一定时间段内的登录信息,你应该对这个表的DATETIME型字段建立聚簇索引。

    对聚簇索引的主要限制是每个表只能建立一个聚簇索引。但是,一个表可以有不止一个非聚簇索引。实际上,对每个表你最多可以建立249个非聚簇索引。你也可以对一个表同时建立聚簇索引和非聚簇索引。

    假如你不仅想根据日期,而且想根据用户名从你的网点活动日志中取数据。在这种情况下,同时建立一个聚簇索引和非聚簇索引是有效的。你可以对日期时间字段建立聚簇索引,对用户名字段建立非聚簇索引。如果你发现你需要更多的索引方式,你可以增加更多的非聚簇索引。

    非聚簇索引需要大量的硬盘空间和内存。另外,虽然非聚簇索引可以提高从表中取数据的速度,它也会降低向表中插入和更新数据的速度。每当你改变了一个建立了非聚簇索引的表中的数据时,必须同时更新索引。因此你对一个表建立非聚簇索引时要慎重考虑。如果你预计一个表需要频繁地更新数据,那么不要对它建立太多非聚簇索引。另外,如果硬盘和内存空间有限,也应该限制使用非聚簇索引的数量。

 

索引属性

    这两种类型的索引都有两个重要属性:你可以用两者中任一种类型同时对多个字段建立索引(复合索引);两种类型的索引都可以指定为唯一索引。

    你可以对多个字段建立一个复合索引,甚至是复合的聚簇索引。假如有一个表记录了你的网点访问者的姓和名字。如果你希望根据完整姓名从表中取数据,你需要建立一个同时对姓字段和名字字段进行的索引。这和分别对两个字段建立单独的索引是不同的。当你希望同时对不止一个字段进行查询时,你应该建立一个对多个字段的索引。如果你希望对各个字段进行分别查询,你应该对各字段建立独立的索引。

    两种类型的索引都可以被指定为唯一索引。如果对一个字段建立了唯一索引,你将不能向这个字段输入重复的值。一个标识字段会自动成为唯一值字段,但你也可以对其它类型的字段建立唯一索引。假设你用一个表来保存你的网点的用户密码,你当然不希望两个用户有相同的密码。通过强制一个字段成为唯一值字段,你可以防止这种情况的发生。

 

SQL建立索引

    为了给一个表建立索引,启动任务栏SQL Sever程序组中的ISQL/w程序。进入查询窗口后,输入下面的语句:

 

       CREATE INDEX mycolumn_index ON mytable (myclumn)

 

    这个语句建立了一个名为mycolumn_index的索引。你可以给一个索引起任何名字,但你应该在索引名中包含所索引的字段名,这对你将来弄清楚建立该索引的意图是有帮助的。

    注意:

    在本书中你执行任何SQL语句,都会收到如下的信息:

    This  command did not return data,and it did not return any rows

这说明该语句执行成功了。

索引mycolumn_index对表mytablemycolumn字段进行。这是个非聚簇索引,也是个非唯一索引。(这是一个索引的缺省属性)

如果你需要改变一个索引的类型,你必须删除原来的索引并重建一个。建立了一个索引后,你可以用下面的SQL语句删除它:

 

DROP INDEX mytable.mycolumn_index

 

注意在DROP INDEX 语句中你要包含表的名字。在这个例子中,你删除的索引是mycolumn_index,它是表mytable的索引。

要建立一个聚簇索引,可以使用关键字CLUSTERED。)记住一个表只能有一个聚簇索引。(这里有一个如何对一个表建立聚簇索引的例子:

 

CREATE CLUSTERED INDEX mycolumn_clust_index ON mytable(mycolumn)

 

如果表中有重复的记录,当你试图用这个语句建立索引时,会出现错误。但是有重复记录的表也可以建立索引;你只要使用关键字ALLOW_DUP_ROW把这一点告诉SQL Sever即可:

 

CREATE CLUSTERED INDEX mycolumn_cindex ON mytable(mycolumn)

                     WITH ALLOW_DUP_ROW

 

这个语句建立了一个允许重复记录的聚簇索引。你应该尽量避免在一个表中出现重复记录,但是,如果已经出现了,你可以使用这种方法。

要对一个表建立唯一索引,可以使用关键字UNIQUE。对聚簇索引和非聚簇索引都可以使用这个关键字。这里有一个例子:

 

CREATE UNIQUE COUSTERED INDEX myclumn_cindex ON mytable(mycolumn)

 

这是你将经常使用的索引建立语句。无论何时,只要可以,你应该尽量对一个对一个表建立唯一聚簇索引来增强查询操作。

最后,要建立一个对多个字段的索引──复合索引──在索引建立语句中同时包含多个字段名。下面的例子对firstnamelastname两个字段建立索引:

 

CREATE INDEX name_index ON username(firstname,lastname)

 

这个例子对两个字段建立了单个索引。在一个复合索引中,你最多可以对16个字段进行索引。

 

用事务管理器建立索引

用事务管理器建立索引比用SQL语句容易的多。使用事务管理器,你可以看到已经建立的索引的列表,并可以通过图形界面选择索引选项。

使用事务管理器你可以用两种方式建立索引:使用Manage Tables窗口或使用Manage Indexes窗口。

    要用Manage Tables 窗口建立一个新索引,单击按钮Advanced Options(它看起来象一个前面有一加号的表)。这样就打开了Advanced Options对话框。这个对话框有一部分标名为Primary Key(见图11.1)。

 

111

 

要建立一个新索引,从下拉列表中选择你想对之建立索引的字段名。如果你想建立一个对多字段的索引,你可以选择多个字段名。你还可以选择索引是聚簇的还是非聚簇的。在保存表信息后,索引会自动被建立。在Manage Tables窗口中的字段名旁边,会出现一把钥匙。

你已经为你的表建立了“主索引”。主索引必须对不包含空值的字段建立。另外,主索引强制一个字段成为唯一值字段。

要建立没有这些限制的索引,你需要使用Manage Indexes窗口。从菜单中选择Manage|Indexes,打开Manage Indexes 窗口。在Manage Indexes 窗口中,你可以通过下拉框选择表和特定的索引。(见图11.2)。要建立一个新索引,从Index下拉框中选择New Index.,然后就可以选择要对之建立索引的字段。单击按钮Add,把字段加人到索引中。

 

112

 

你可以为你的索引选择许多不同的选项。例如,你可以选择该索引是聚簇的还是非聚簇的。你还可以指定该索引为唯一索引。设计好索引后,单击按钮Build,建立该索引。

 

注意:

唯一索引是指该字段不能有重复的值,而不是只能建立这一个索引。

 

SQL核心语句

在第十章,你学会了如何用SQL SELECT 语句从一个表中取数据。但是,到现在为止,还没有讨论如何添加,修改或删除表中的数据。在这一节中,你将学习这些内容。

 

插入数据

向表中添加一个新记录,你要使用SQL INSERT 语句。这里有一个如何使用这种语句的例子:

 

     INSERT mytable (mycolumn) VALUES (some data)

 

这个语句把字符串some data插入表mytablemycolumn字段中。将要被插入数据的字段的名字在第一个括号中指定,实际的数据在第二个括号中给出。

INSERT 语句的完整句法如下:

 

INSERT [INTO]  {table_name|view_name} [(column_list)] {DEFAULT VALUES |

                Values_list | select_statement}

 

如果一个表有多个字段,通过把字段名和字段值用逗号隔开,你可以向所有的字段中插入数据。假设表mytable有三个字段first_column,second_column,third_column。下面的INSERT语句添加了一条三个字段都有值的完整记录:

 

INSERT mytable (first_column,second_column,third_column)

        VALUES (some data,some more data,yet more data)

 

注意:

你可以使用INSERT语句向文本型字段中插入数据。但是,如果你需要输入很长的字符串,你应该使用WRITETEXT语句。这部分内容对本书来说太高级了,因此不加讨论。要了解更多的信息,请参考Microsoft SQL Sever 的文档。

 

如果你在INSERT 语句中只指定两个字段和数据会怎么样呢?换句话说,你向一个表中插入一条新记录,但有一个字段没有提供数据。在这种情况下,有下面的四种可能:

如果该字段有一个缺省值,该值会被使用。例如,假设你插入新记录时没有给字段third_column提供数据,而这个字段有一个缺省值some value。在这种情况下,当新记录建立时会插入值some value

如果该字段可以接受空值,而且没有缺省值,则会被插入空值。

如果该字段不能接受空值,而且没有缺省值,就会出现错误。你会收到错误信息:

The column in table mytable may not be null.

最后,如果该字段是一个标识字段,那么它会自动产生一个新值。当你向一个有标识字段的表中插入新记录时,只要忽略该字段,标识字段会给自己赋一个新值。

 

    注意:

    向一个有标识字段的表中插入新记录后,你可以用SQL变量@@identity来访问新记录

的标识字段的值。考虑如下的SQL语句:

 

     INSERT mytable (first_column) VALUES(some value)

 

     INSERT anothertable(another_first,another_second)

         VALUES(@@identity,some value)

 

    如果表mytable有一个标识字段,该字段的值会被插入表anothertableanother_first字段。这是因为变量@@identity总是保存最后一次插入标识字段的值。

字段another_first应该与字段first_column有相同的数据类型。但是,字段another_first不能是应该标识字段。Another_first字段用来保存字段first_column的值。

 

删除记录

要从表中删除一个或多个记录,需要使用SQL DELETE语句。你可以给DELETE 语句提供WHERE 子句。WHERE子句用来选择要删除的记录。例如,下面的这个DELETE语句只删除字段first_column的值等于’Delete Me’的记录:

 

DELETE mytable WHERE first_column=Deltet Me

 

DELETE 语句的完整句法如下:

 

       DELETE [FROM] {table_name|view_name}  [WHERE clause]

 

SQL SELECT 语句中可以使用的任何条件都可以在DELECT 语句的WHERE子句 中使用。例如,下面的这个DELETE语句只删除那些first_column字段的值为goodbyesecond_column字段的值为so long的记录:

 

DELETE mytable WHERE first_column=goodby OR second_column=so long

 

如果你不给DELETE 语句提供WHERE 子句,表中的所有记录都将被删除。你不应该有这种想法。如果你想删除应该表中的所有记录,应使用第十章所讲的TRUNCATE TABLE语句。

 

注意:

为什么要用TRUNCATE TABLE 语句代替DELETE语句?当你使用TRUNCATE TABLE语句时,记录的删除是不作记录的。也就是说,这意味着TRUNCATE TABLE 要比DELETE快得多。

 

更新记录

要修改表中已经存在的一条或多条记录,应使用SQL UPDATE语句。同DELETE语句一样,UPDATE语句可以使用WHERE子句来选择更新特定的记录。请看这个例子:

 

UPDATE mytable SET first_column=Updated! WHERE second_column=Update Me!

 

这个UPDATE 语句更新所有second_column字段的值为Update Me!的记录。对所有被选中的记录,字段first_column的值被置为Updated!

下面是UPDATE语句的完整句法:

 

UPDATE {table_name|view_name} SET [{table_name|view_name}]

       {column_list|variable_list|variable_and_column_list}

       [,{column_list2|variable_list2|variable_and_column_list2}

        [,{column_listN|variable_listN|variable_and_column_listN}]]

        [WHERE clause]

 

注意:

你可以对文本型字段使用UPDATE语句。但是,如果你需要更新很长的字符串,应使用UPDATETEXT语句。这部分内容对本书来说太高级了,因此不加讨论。要了解更多的信息,请参考Microsoft SQL Sever 的文档。

 

   

如果你不提供WHERE子句,表中的所有记录都将被更新。有时这是有用的。例如,如果你想把表titles中的所有书的价格加倍,你可以使用如下的UPDATE 语句:

你也可以同时更新多个字段。例如,下面的UPDATE语句同时更新first_column,second_column,third_column这三个字段:

 

UPDATE mytable  SET  first_column=Updated!

                     Second_column=Updated!

                     Third_column=Updated!

                 WHERE first_column=Update Me1

 

技巧:

SQL忽略语句中多余的空格。你可以把SQL语句写成任何你最容易读的格式。

 

 

SELECT 创建记录和表

你也许已经注意到,INSERT 语句与DELETE语句和UPDATE语句有一点不同,它一次只操作一个记录。然而,有一个方法可以使INSERT 语句一次添加多个记录。要作到这一点,你需要把INSERT 语句与SELECT 语句结合起来,象这样:

 

INSERT mytable (first_column,second_column)

SELECT another_first,another_second

FROM anothertable

WHERE another_first=Copy Me!

 

这个语句从anothertable拷贝记录到mytable.只有表anothertable中字段another_first的值为Copy Me的记录才被拷贝。

当为一个表中的记录建立备份时,这种形式的INSERT 语句是非常有用的。在删除一个表中的记录之前,你可以先用这种方法把它们拷贝到另一个表中。

如果你需要拷贝整个表,你可以使用SELECT  INTO 语句。例如,下面的语句创建了一个名为newtable的新表,该表包含表mytable的所有数据:

 

SELECT * INTO newtable FROM mytable

 

你也可以指定只有特定的字段被用来创建这个新表。要做到这一点,只需在字段列表中指定你想要拷贝的字段。另外,你可以使用WHERE 子句来限制拷贝到新表中的记录。下面的例子只拷贝字段second_columnd的值等于Copy Me!的记录的first_column字段。

 

SELECT first_column INTO newtable

FROM mytable

WHERE second_column=Copy Me!

 

使用SQL修改已经建立的表是很困难的。例如,如果你向一个表中添加了一个字段,没有容易的办法来去除它。另外,如果你不小心把一个字段的数据类型给错了,你将没有办法改变它。但是,使用本节中讲述的SQL语句,你可以绕过这两个问题。

例如,假设你想从一个表中删除一个字段。使用SELECT INTO 语句,你可以创建该表的一个拷贝,但不包含要删除的字段。这使你既删除了该字段,又保留了不想删除的数据。

如果你想改变一个字段的数据类型,你可以创建一个包含正确数据类型字段的新表。创建好该表后,你就可以结合使用UPDATE语句和SELECT 语句,把原来表中的所有数据拷贝到新表中。通过这种方法,你既可以修改表的结构,又能保存原有的数据。

 

集合函数

到现在为止,你只学习了如何根据特定的条件从表中取出一条或多条记录。但是,假如你想对一个表中的记录进行数据统计。例如,如果你想统计存储在表中的一次民意测验的投票结果。或者你想知道一个访问者在你的站点上平均花费了多少时间。要对表中的任何类型的数据进行统计,都需要使用集合函数。

Microsoft SQL 支持五种类型的集合函数。你可以统计记录数目,平均值,最小值,最大值,或者求和。当你使用一个集合函数时,它只返回一个数,该数值代表这几个统计值之一。

 

注意:

要在你的ASP网页中使用集合函数的返回值,你需要给该值起一个名字。要作到这一点,你可以在SELECT语句中,在集合函数后面紧跟一个字段名,如下例所示:

 

SELECT AVG(vote) the_average FROM opinion

 

在这个例子中,vote的平均值被命名为 the_average。现在你可以在你的ASP网页的数据库方法中使用这个名字。

 

统计字段值的数目

函数COUNT()也许是最有用的集合函数。你可以用这个函数来统计一个表中有多少条记录。这里有一个例子:

 

SELECT COUNT(au_lname) FROM authors

 

这个例子计算表authors中名字(last name)的数目。如果相同的名字出现了不止一次,该名字将会被计算多次。如果你想知道名字为某个特定值的作者有多少个,你可以使用WHERE子句,如下例所示:

 

SELECT COUNT(au_lname) FROM authors WHERE au_lname=Ringer

 

这个例子返回名字为Ringer的作者的数目。如果这个名字在表authors中出现了两次,则次函数的返回值是2

假如你想知道有不同名字的作者的数目。你可以通过使用关键字DISTINCT来得到该数目。如下例所示:

 

SELECT COUNT(DISTINCT au_lname) FROM authors

 

如果名字Ringer出现了不止一次,它将只被计算一次。关键字DISTINCT 决定了只有互不相同的值才被计算。

通常,当你使用COUNT()时,字段中的空值将被忽略。一般来说,这正是你所希望的。但是,如果你仅仅想知道表中记录的数目,那么你需要计算表中所有的记录─不管它是否包含空值。下面是一个如何做到这一点的例子:

 

SELECT COUNT(*) FROM authors

 

注意函数COUNT()没有指定任何字段。这个语句计算表中所有记录所数目,包括有空值的记录。因此,你不需要指定要被计算的特定字段。

函数COUNT()在很多不同情况下是有用的。例如,假设有一个表保存了对你站点的质量进行民意调查的结果。这个表有一个名为vote的字段,该字段的值要么是0,要么是10表示反对票,1表示赞成票。要确定赞成票的数量,你可以所有下面的SELECT 语句:

 

SELECT COUNT(vote) FROM opinion_table WHERE vote=1

 

计算字段的平均值

使用函数COUNT(),你可以统计一个字段中有多少个值。但有时你需要计算这些值的平均值。使用函数AVG(),你可以返回一个字段中所有值的平均值。

假如你对你的站点进行一次较为复杂的民意调查。访问者可以在110之间投票,表示他们喜欢你站点的程度。你把投票结果保存在名为voteINT型字段中。要计算你的用户投票的平均值,你需要使用函数AVG():

 

SELECT AVG(vote) FROM opinion

 

这个SELECT语句的返回值代表用户对你站点的平均喜欢程度。函数AVG()只能对数值型字段使用。这个函数在计算平均值时也忽略空值。

 

计算字段值的和

假设你的站点被用来出售卡片,已经运行了两个月,是该计算赚了多少钱的时候了。假设有一个名为orders的表用来记录所有访问者的定购信息。要计算所有定购量的总和,你可以使用函数SUM():

 

SELECT SUM(purchase_amount) FROM orders

 

函数SUM()的返回值代表字段purchase_amount中所有值的平均值。字段purchase_amount的数据类型也许是MONEY型,但你也可以对其它数值型字段使用函数SUM()。

 

返回最大值或最小值

再一次假设你有一个表用来保存对你的站点进行民意调查的结果。访问者可以选择从110 的值来表示他们对你站点的评价。如果你想知道访问者对你站点的最高评价,你可以使用如下的语句:

 

SELECT MAX(vote) FROM opinion

 

你也许希望有人对你的站点给予了很高的评价。通过函数MAX(),你可以知道一个数值型字段的所有值中的最大值。如果有人对你的站点投了数字10,函数MAX()将返回该值。

另一方面,假如你想知道访问者对你站点的的最低评价,你可以使用函数MIN(),如下例所示:

 

SELECT MIN(vote) FROM opinion

 

函数MIN()返回一个字段的所有值中的最小值。如果字段是空的,函数MIN()返回空值。

 

其它常用的SQL表达式,函数,和过程

这一节将介绍一些其它的SQL技术。你将学习如何从表中取出数据,其某个字段的值处在一定的范围,你还将学习如何把字段值从一种类型转换成另一种类型,如何操作字符串和日期时间数据。最后,你将学会一个发送邮件的简单方法。

 

通过匹配一定范围的值来取出数据

假设你有一个表用来保存对你的站点进行民意调查的结果。现在你想向所有对你的站点的评价在710之间的访问者发送书面的感谢信。要得到这些人的名字,你可以使用如下的SELECT 语句:

 

SELECT username FROM opinion WHERE vote>6  and  vote<11

 

这个SELECT 语句会实现你的要求。你使用下面的SELECT 语句也可以得到同样的结果:

 

SELECT username FROM opinion WHERE vote BETWEEN 7 AND 10

 

这个SELECT 语句与上一个语句是等价的。使用哪一种语句是编程风格的问题,但你会发现使用表达式BETWEEN 的语句更易读。

现在假设你只想取出对你的站点投了1或者10的访问者的名字。要从表opinion中取出这些名字,你可以使用如下的SELECT 语句:

 

SELECT username FROM opinion WHERE vote=1 or vote

 

   这个SELECT语句会返回正确的结果,没有理由不使用它。但是,存在一种等价的方式。使用如下的SELECT可以得到相同的结果:

 

SELECT username FROM opinion WHERE vote IN (1,10)

 

注意表达式IN 的使用。这个SELECT 语句只取出vote的值等于括号中的值之一的记录。

你也可以使用IN来匹配字符数据。例如,假设你只想取出Bill GatesPresident Clinton的投票值。你可以使用如下的SELECT 语句:

 

SELECT vote FROM opinion  WHERE  username IN (Bill Gates,President Clinton)

 

最后,你可以在使用BETWEENIN的同时使用表达式NOT。例如,要取出那些投票值不在710之间的人的名字,你可以使用如下的SELECT 语句:

 

SELECT username FROM opinion WHERE vote NOT BETWEEN 7 and 10

 

要选取那些某个字段的值不在一列值之中的记录,你可以同时使用NOT IN,如下例所示:

 

SELECT vote FROM opinion

            WHERE username NOT IN (Bill Gates,President Clinton)

 

你不是必须在SQL语句中使用BETWEENIN,但是,要使你的查询更接近自然语言,这两个表达式是有帮助的。

 

转换数据

SQL Sever足够强大,可以在需要的时候把大部分数值从一种类型转换为另一种类型。例如,要比较SMALLINT型和INT型数据的大小,你不需要进行显式的类型转换。SQL Sever会为你完成这项工作。但是,当你想在字符型数据和其它类型的数据之间进行转换时,你的确需要自己进行转换操作。例如,假设你想从一个MONEY型字段中取出所有的值,并在结果后面加上字符串“US Dollars。你需要使用函数CONVERT(),如下例所示:

 

SELECT CONVERT(CHAR(8),price)+US Dollars FROM orders

 

函数CONVERT()带有两个变量。第一个变量指定了数据类型和长度。第二个变量指定了要进行转换的字段。在这个例子中,字段price被转换成长度为8个字符的CHAR型字段。字段price要被转换成字符型,才可以在它后面连接上字符串US Dollars

当向BIT型,DATETIME型,INT型,或者NUMERIC型字段添加字符串时,你需要进行同样的转换操作。例如,下面的语句在一个SELECT语句的查询结果中加入字符串The vote is,该SELECT语句返回一个BIT型字段的值:

 

SELECT The vote is+CONVERT(CHAR(1),vote) FROM opinion

 

下面是这个语句的结果示例:

 

The vote is 1

The vote is 1

The vote is 0

(3 row(s) affected)

 

如果你不进行显式的转换,你会收到如下的错误信息:

Implicit conversion from datatype varchar to bit is not allowec.

Use the CONVERT function to run this query.

 

操作字符串数据

SQL Sever有许多函数和表达式,使你能对字符串进行有趣的操作,包括各种各样的模式匹配和字符转换。在这一节中,你将学习如何使用最重要的字符函数和表达式。

 

匹配通配符

假设你想建立一个与Yahoo功能相似的Internet目录。你可以建立一个表用来保存一系列的站点名称,统一资源定位器(URL),描述,和类别,并允许访问者通过在HTML form中输入关键字来检索这些内容。

假如有一个访问者想从这个目录中得到其描述中包含关键字trading card的站点的列表。要取出正确的站点列表,你也许试图使用这样的查询:

 

SELECT site_name FROM site_directory  WHERE site_desc=trading card

 

这个查询可以工作。但是,它只能返回那些其描述中只有trading card这个字符串的站点。例如,一个描述为We have the greatest collection of trading cards in the world!的站点不会被返回。

要把一个字符串与另一个字符串的一部分相匹配,你需要使用通配符。你使用通配符和关键字LIKE来实现模式匹配。下面的语句使用通配符和关键字LIKE重写了上面的查询,以返回所有正确站点的名字:

 

SELECT SITE_name FROM site_directory

                 WHERE site_desc LIKE %trading cark%

 

    在这个例子中,所有其描述中包含表达式trading card的站点都被返回。描述为We have the greatest collection of trading cards in the world!的站点也被返回。当然,如果一个站点的描述中包含I am trading cardboard boxes online ,该站点的名字也被返回。

注意本例中百分号的使用。百分号是通配符的例子之一。它代表0个或多个字符。通过把trading card括在百分号中,所有其中嵌有字符串trading card的字符串都被匹配。

现在,假设你的站点目录变得太大而不能在一页中完全显示。你决定把目录分成两部分。在第一页,你想显示所有首字母在AM之间的站点。在第二页,你想显示所有首字母在NZ之间的站点。要得到第一页的站点列表,你可以使用如下的SQL语句:

 

SELECT site_name FROM site_directory WHERE site_name LIKE [A-M]%

 

在这个例子中使用了表达式[A-M],只取出那些首字母在AM之间的站点。中括号([])用来匹配处在指定范围内的单个字符。要得到第二页中显示的站点,应使用这个语句:

 

SELECT site_name FROM  site_directory

                 WHERE site_name LIKE [N-Z]%

 

在这个例子中,括号中的表达式代表任何处在NZ之间的单个字符。

假设你的站点目录变得更大了,你现在需要把目录分成更多页。如果你想显示那些以ABC开头的站点,你可以用下面的查询来实现:

 

SELECT site_name FROM site_directory WHERE site_name LIKE  [ABC]%

 

在这个例子中,括号中的表达式不再指定一个范围,而是给出了一些字符。任何一个其名字以这些字符中的任一个开头的站点都将被返回。

通过在括号内的表达式中同时包含一个范围和一些指定的字符,你可以把这两种方法结合起来。例如,用下面的这个查询,你可以取出那些首字母在CF之间,或者以字母Y开头的站点:

 

SELECT site_name FROM site_directory WHERE site_name LIKE [C-FY]%

 

在这个例子中,名字为CollegescapeYahoo的站点会被选取,而名字为Magicw3的站点则不会被选取。

你也可以使用脱字符(^)来排除特定的字符。例如,要得到那些名字不以Y开头的站点,你可以使用如下的查询:

 

SELECT site_name FROM site_directory WHERE site_name LIKE [^Y]%

 

对给定的字符或字符范围均可以使用脱字符。

最后,通过使用下划线字符(_),你可以匹配任何单个字符。例如,下面这个查询返回每一个其名字的第二个字符为任何字母的站点:

 

SELECT site_name FROM site_directory WHERE site_name LIKE M_crosoft

 

这个例子既返回名为Microsoft的站点,也返回名为Macrosoft的站点。但是,名字为Moocrosoft的站点则不被返回。与通配符不同,下划线只代表单个字符。

 

注意:

如果你想匹配百分号或下划线字符本身,你需要把它们括在方括号中。如果你想匹配连字符(-),应把它指定为方括号中的第一个字符。如果你想匹配方括号,应把它们也括在方括号中。例如,下面的语句返回所有其描述中包含百分号的站点:

 

    SELECT site_name FROM site_directory WHERE site_desc LIKE %[%]%

匹配发音

Microsoft SQL 有两个允许你按照发音来匹配字符串的函数。函数SOUNDEX()给一个字符串分配一个音标码,函数DIFFERENCE()按照发音比较两个字符串。当你不知道一个名字的确切拼写,但多少知道一点它的发音时,使用这两个函数将有助于你取出该记录。

例如,如果你建立一个Internet目录,你也许想增加一个选项,允许访问者按照站点名的发音来搜索站点,而不是按名字的拼写。考虑如下的语句:

 

SELECT site_name FROM site_directory

                 WHERE DIFFERENCE(site_name , Microsoft>3

 

这个语句使用函数DEFFERENCE()来取得其名字的发音与Microsoft非常相似的站点。函数DIFFERENCE()返回一个04之间的数字。如果该函数返回4,表示发音非常相近;如果该函数返回0,说明这两个字符串的发音相差很大。

例如,上面的语句将返回站点名MicrosoftMacrosoft。这两个名字的发音与Microsoft都很相似。如果你把上一语句中的大于3改为大于2,那么名为ZicrosoftMegasoft的站点也将被返回。最后,如果你只需要差别等级大于1即可,则名为PicosoftMinisoft的站点也将被匹配。

要深入了解函数DIFFERENCE()是如何工作的,你可以用函数SOUNDEX()来返回函数DIFFERENCE()所使用的音标码。这里有一个例子:

 

SELECT site_name site name,SOUNDEX(site_name) sounds like

 

这个语句选取字段site_name的所有数据及其音标码。下面是这个查询的结果:

 

site name                     sounds like

……………………………………………………………….

Yahoo                         Y000

Mahoo                         M000

Microsoft                     M262

Macrosoft                     M262

Minisoft                      M521

Microshoft                    M262

Zicrosoft                     Z262

Zaposoft                      Z121

Millisoft                     M421

Nanosoft                      N521

Megasoft                      M221

Picosoft                      P221

(12 row(s) affected)

 

如果你仔细看一下音标码,你会注意到音标码的第一个字母与字段值的第一个字母相同。例如,YahooMahoo的音标码只有第一个字母不同。你还可以发现MicrosoftMacrosoft的音标码完全相同。

函数DIFFERENDE()比较两个字符串的第一个字母和所有的辅音字母。该函数忽略任何元音字母(包括y),除非一个元音字母是一个字符串的第一个字母。

不幸的是,使用SOUNDEX()和DIFFERENCE()有一个欠缺。WHERE子句中包含这两个函数的查询执行起来效果不好。因此,你应该小心使用这两个函数。

 

删除空格

有两个函数,TTRIM()和LTRIM(),可以用来从字符串中剪掉空格。函数LTRIM()去除应该字符串前面的所有空格;函数RTRIM()去除一个字符串尾部的所有空格。这里有一个任何使用函数RTRIM()的例子:

 

SELECT RTRIM(site_name) FROM site_directory

 

在这个例子中,如果任何一个站点的名字尾部有多余的空格,多余的空格将从查询结果中删去。

你可以嵌套使用这两个函数,把一个字符串前后的空格同时删去:

 

SELECT LTRIM(RTRIM(site_name) FROM site_directory

 

你会发现,在从CHAR型字段中剪掉多余的空格时,这两个函数非常有用。记住,如果你把一个字符串保存在CHAR型字段中,该字符串会被追加多余的空格,以匹配该字段的长度。用这两个函数,你可以去掉无用的空格,从而解决这个问题。

 

操作日期和时间

日期和时间函数对建立一个站点是非常有用的。站点的主人往往对一个表中的数据何时被更新感兴趣。通过日期和时间函数,你可以在毫秒级跟踪一个表的改变。

 

返回当前日期和时间

通过函数GETDATE(),你可以获得当前的日期和时间。例如,语句SELECT GETDATE()返回如下的结果:

……………………………..

    NOV 30 1997

(1 row(s) affected)

 

显然,如果你将来使用这个函数,你得到的日期将比这个时间晚,或者梗早。

函数GETDATE()可以用来作为DATEDIME()型字段的缺省值。这对插入记录时保存当时的时间是有用的。例如,假设有一个表用来保存你站点上的活动日志。每当有一个访问者访问到你的站点时,就在表中添加一条新记录,记下访问者的名字,活动,和进行访问的时间。要建立一个表,其中的记录包含有当前的日期和时间,可以添加一个DATETIME型字段,指定其缺省值为函数GETDATE()的返回值,就象这样:

 

CREATE TABLE site_log (

       username VARCHAR(40),

       useractivity VARCHAR(100),

       entrydate DATETIME DEFAULT GETDATE())

 

转换日期和时间

你也许已经注意到,在上一节的例子中,函数GETDATE()的返回值在显示时只显示到秒。实际上,SQL Sever内部时间可以精确到毫秒级(确切地说,可以精确到3.33毫秒)。

要得到不同格式的日期和时间,你需要使用函数CONVERT()。例如,当下面的这个语句执行时,显示的时间将包括毫秒:

 

SELECT CONVERT(VARCHAR(30),GETDATE(),9)

 

注意例子中数字9的使用。这个数字指明了在显示日期和时间时使用哪种日期和时间格式。当这个语句执行时,将显示如下的日期和时间:

…………………………………..

Nov 30 1997 3:29:55:170AM

(1 row(s) affected)

 

在函数CONVERT()中你可以使用许多种不同风格的日期和时间格式。表11.1显示了所有的格式。

 

11.1  日期和时间的类型

类型值            标准             输出

   0                 Default           mon dd yyyy hh:miAM

   1                 USA               mm/dd/yy

   2                 ANSI              yy.mm.dd

   3                 British/French    dd/mm/yy

   4                 German            dd.mm.yy

   5                 Italian           dd-mm-yy

   6                 -                 dd mon yy

   7                 -                 mon dd,yy

   8                 -                 hh:mi:ss

9                                                                         Default + milliseconds–mon dd yyyy

hh:mi:ss:mmmAM(or )

   10                USA              mm-dd-yy

   11                JAPAN            yy/mm/dd

   12                ISO              yymmdd

   13                Europe           Default + milliseconds–dd mon yyyy

                                       hh:mi:ss:mmm(24h)

   14                 -                hh:mi:ss:mmm(24h)

 

   类型09,和13总是返回四位的年。对其它类型,要显示世纪,把style值加上100。类型1314返回24小时时钟的时间。类型07,和13返回的月份用三位字符表示(用Nov代表November.

 

对表11.1中所列的每一种格式,你可以把类型值加上100来显示有世纪的年(例如,00年将显示为2000年)。例如,要按日本标准显示日期,包括世纪,你应使用如下的语句:

 

SELECT CONVERTVARCHAR30),GETDATE(),111

 

    在这个例子中,函数CONVERT()把日期格式进行转换,显示为1997/11/30

 

抽取日期和时间

在许多情况下,你也许只想得到日期和时间的一部分,而不是完整的日期和时间。例如,假设你想列出你的站点目录中每个站点被查询的月份。这时你不希望完整的日期和时间把网页弄乱。为了抽取日期的特定部分,你可以使用函数DATEPART(),象这样:

 

SELECT site_name Site Name,

DATEPART(mm,site_entrydate) Month Posted FROM site_directory

 

函数DATEPART()的参数是两个变量。第一个变量指定要抽取日期的哪一部分;第二个变量是实际的数据。在这个例子中,函数DATEPART()抽取月份,因为mm代表月份。下面是这个SELECT 语句的输出结果:

 

Site Name                         Month Posted

………………………………………………………………

Yahoo                              2

Microsoft                          5

Magicw3                            5

(3 row(s) affected)

 

   Month Posted列显示了每个站点被查询的月份。函数DATEPART()的返回值是一个整数。你可以用这个函数抽取日期的各个不同部分,如表11.2所示。

 

11.2  日期的各部分及其简写

日期部分           简写              

year                yy                1753–9999

quarter             qq                1–4

month               mm                1–12

day of year         dy                1–366

day                 dd                1–31

week                wk                1–53

weekday             dw                1–7(Sunday–Saturday)

hour                hh                0–23

minute              mi                0–59

second              ss                0–59

milisecond          ms                0–999

 

当你需要进行日期和时间的比较时,使用函数DATEPART()返回整数是有用的。但是,上例中的查询结果(25)不是十分易读。要以更易读的格式得到部分的日期和时间,你可以使用函数DATENAME(),如下例所示:

 

SELECT site_name Site Name

DATENAME(mm,site_entrydate) Month Posted

FROM site_directory

 

函数DATENAME()和函数DATEPART()接收同样的参数。但是,它的返回值是一个字符串,而不是一个整数。下面是上例该用DATENAME()得到的结果:

 

Site Name                           Month Postec

………………………………………………………………….

Yahoo                               February

Microsoft                           June

Magicw3                             June

(3 row(s) affected)

 

你也可以用函数DATENAE()来抽取一个星期中的某一天。下面的这个例子同时抽取一周中的某一天和日期中的月份:

 

SELECT site_name Site Name,

DATENAME(dw,site_entrydate)+ - + DATENAMEmm,site_entrydate

         Day and Month Posted FORM  site_directory

 

这个例子执行时,将返回如下的结果:

 

Site Name                       Day and Month Posted

………………………………………………………………………

Yahoo                           Friday – February

Microsoft                       Tuesday – June

Magicw3                         Monday – June

(3 row(s) affected)

 

返回日期和时间范围

当你分析表中的数据时,你也许希望取出某个特定时间的数据。你也许对特定的某一天中――比如说20001225日――访问者在你站点上的活动感兴趣。要取出这种类型的数据,你也许会试图使用这样的SELECT语句:

 

SELECT * FROM weblog WHERE entrydate=12/25/20000

 

不要这样做。这个SELECT语句不会返回正确的记录――它将只返回日期和时间是12/25/2000 12:00:00:000AM的记录。换句话说,只有刚好在午夜零点输入的记录才被返回。

 

注意:

在本节的讨论中,假设字段entrydateDATETIME型,而不是SMALLDATETIME型。本节的讨论对SMALLDATETIME型字段也是适用的,不过SMALLDATETIME型字段只能精确到秒。

 

问题是SQL Sever将用完整的日期和时间代替部分日期和时间。例如,当你输入一个日期,但不输入时间时,SQL Sever将加上缺省的时间“120000000AM”。当你输入一个时间,但不输入日期时,SQL Sever将加上缺省的日期“Jan 1 1900”。

要返回正确的记录,你需要适用日期和时间范围。有不止一种途径可以做到这一点。例如,下面的这个SELECT 语句将能返回正确的记录:

 

SELECT * FROM weblog

WHERE  entrydate>=12/25/2000 AND entrydate<12/26/2000

 

这个语句可以完成任务,因为它选取的是表中的日期和时间大于等于12/25/2000 12:00:00:000AM并小于12/26/2000 12:00:00:000AM的记录。换句话说,它将正确地返回2000年圣诞节这一天输入的每一条记录。

另一种方法是,你可以使用LIKE来返回正确的记录。通过在日期表达式中包含通配符“%”,你可以匹配一个特定日期的所有时间。这里有一个例子:

 

SELECT * FROM weblog WHERE entrydate LIKE Dec 25 2000%

 

这个语句可以匹配正确的记录。因为通配符“%”代表了任何时间。

使用这两种匹配日期和时间范围的函数,你可以选择某个月,某一天,某一年,某个小时,某一分钟,某一秒,甚至某一毫秒内输入的记录。但是,如果你使用LIKE 来匹配秒或毫秒,你首先需要使用函数CONVERT()把日期和时间转换为更精确的格式(参见前面“转换日期和时间”一节)。

 

比较日期和时间

最后,还有两个日期和时间函数对根据日期和时间取出记录是有用的。使用函数DATEADD()和DATEDIFF(),你可以比较日期的早晚。例如,下面的SELECT语句将显示表中的每一条记录已经输入了多少个小时:

 

SELECT entrydate Time Entered

DATEDIFF(hh,entrydate,GETDATE()) Hours Ago FROM weblog

 

如果当前时间是20001130号下午615分,则会返回如下的结果:

 

Time Entered                Hours Ago

…………………………………………………..

Dec 30 2000  4:09PM          2

Dec 30 2000  4:13PM          2

Dec 1 2000  4:09PM           698

(3 row(s) affected)

 

函数DADEDIFF()的参数是三个变量。第个变量指定日期的某一部分。在这个例子中,是按小时对日期进行比较,(要了解日期各部分的详细内容,请参考表11.2)在日期2000111日和20001130日的指定时间之间有689个小时。另外两个参数是要进行比较的时间。为了返回一个正数,较早的时间应该先给。

函数DATEADD()把两个日期相加。当你需要计算截止日期这一类的数据时,这个函数是有用处的。例如,假设访问者必须先注册才能使用你的站点。注册以后,他们可以免费使用你的站点一个月。要确定什么时候他们的免费时间会用完,你可以使用如下的SELECT语句:

 

SELECT username User Name,

DATEADD(mm,1,firstvisit_date) Registration Expires

FROM registration_table

 

函数DATEADD()的参数有三个变量。第一个变量代表日期的某一部分(参见表11.2),这个例子用到了代表月份的mm。第二个变量指定了时间的间隔――在本例中是一个月。最后一个变量是一个日期,在这个例子中,日期是取自DATETIME型字段firstvisit_date.假设当前日期是June 30,2000,这个语句将返回如下的内容:

 

User Name                         Registration Expires

……………………………………………………………………………

Bill Gates                        Jul 30 2000  4:09PM

President Clinton                 Jul 30 2000  4:13PM

William Shakespeare               Jul 1 2000  4:09PM

(3 row(s) affected)

 

注意:

与你预料的相反,使用函数DATEADD()把一个日期加上一个月,它并不加上30天。这个函数只简单地把月份值加1。这意味着在11月注册的人将比在2月注册的人多得到2天或3天的时间。要避免这个问题,你可以用函数DATEADD()直接增加天数,而不是月份。

 

发送邮件

你可以用SQL Sever发送简单的e_mail信息。要做到这一点,你需要在你的系统中安装邮件服务器,如Microsoft Exchange Sever(参见第四章“Exchange Active Sever,Index Sever,NetShow)。你还需要配置SQL Sever 以识别邮件服务器。

要让SQL Sever 能识别邮件服务器,启动事务管理器并从菜单中选择Sever|SQL Mail|Configue,这时会出现一个如图11.3所示的对话框。输入你在邮件服务器中注册的用户名和口令,然后单击OK

 

注意:

如果你使用Microsoft Exchange Sever,配置SQL Sever的过程将会大大不同。你需要在同一个(域)用户帐号下运行Microsoft SQL SeverExchange Sever。你还需要在安装了SQL Sever的机器上安装Exchange Cliect并给这个帐号创建一个一个配置文件。完成这些之后,你就可以在SQL Mail Configuration对话框中输入该配置文件的名字。

 

113

 

在发送邮件之前,你要先启动SQL Mail。从菜单中选择Sever|SQL Mail|Start。如果你的邮件服务器配置正确,并且你输入了正确的用户名和口令,则SQL Mail会成功启动。

 

注意:

你可以把SQL Sever配置为自动启动邮件服务。要做到这一点,在Set Sever Optons对话框(从菜单中选择Sever|SQL Sever|Configure)中选择Auto Start Mail Client即可。

 

要发送一个邮件,你可以使用名为xp_sendmail的扩展存储过程。这里有一个如何使用这个过程的例子:

 

master..xp_sendmail president@whitehouse.gov,Hello Mr. President

 

这个过程调用向e_mail地址president@whitehouse.gov发送一个简单的email信息:“Hello Mr. President。你可以用任何其它的email地址和信息取代上例中相应的内容,但是,你所发送的信息不能超过255个字符长度。

    当你想随时了解你的站点数据库的状态时,存储过程xp_sendmail是有用处的。例如,你可以向一个页面管理程序发送信息。如果你的站点出了什么问题,你马上就可以知道。下一章将讲述更多有关存储过程的内容。

 

总结

这一章加深了你的SQL知识。你学会了如何建立索引,使你的查询速度更快。你还学会了如何插入,删除和更新一个表中的数据,如何使用集合函数得到一个表中数据的统计信息。最后,你学会了许多有价值的表达式,函数和过程,用来操作字符串,日期和时间及邮件。

下一章将进一步加深你对Microsoft SQL Sever的掌握。你将学习如何用SQL来进行程序设计,如何建立存储过程,触发器和执行计划。更另人兴奋的是,你将学会让SQL Sever自动创建网页的一个简单方法。