在Windows Mobile软件开发中.Net正扮演着日益重要的角色，我们已经可以看到很多用.Net CF开发的软件，这些软件涉及到了日常应用的方方面面。 在智能设备的软件开发中，无线互联是一个相当重要的一块，我们可以看到，红外几乎是所有智能设备的标配，而蓝牙也日益在越来越多的智能设备上出现，有了硬件，显然要有相应的软件相关的应用。
我们也知道，用.NET CF开发红外通信应用时相当轻松的，因为.NET CF中有一个命名空间System.Net.IrDA就是用于红外通信的通信模块。但是，.NET CF中还没有关于蓝牙通信的模块，所以目前来讲做这方面的开发还有一定的困难。下面，就谈谈如何用C#开发.NET CF蓝牙通信模块。
一. 基本要点
首先明确一点，因为涉及到驱动硬件的问题，所以仅靠了解C#开发的相关知识显然是无法完成开发的，我们必须对C++开发有所了解。但是为了简单起见，我们不希望用C++写半行代码，所有的编码工作全部使用C#，也就是说，使用的开发环境只需要使用Visual Studio.net，不需要用其他的编辑器。
作为开发这类驱动硬件的程序的知识准备，您需要了解C++的基本知识，知道头文件是怎么一回事，知道托管代码如何与非托管代码交互。因为本文的核心是说明如何开发.net CF蓝牙通信模块，所以前述这些准备知识并不作讲述。
二. 关于蓝牙
做蓝牙通信模块开发，自然先要知道蓝牙通信是怎么一回事。在我看来，蓝牙通信应该和红外通信模块类似，当然我是从开发者的角度来讲，抽象化以后应该就是这样，当然蓝牙和红外通信也有很多不一样的地方，这在面向对象设计里面怎么讲，我想一定有很多人理解的比我透彻。好了，这就是我们的基本思路了。我曾经在网上查过关于蓝牙开发的文章，很多人在.net CF开发中把蓝牙通信当作一个串行通信来处理，这也是不错的，但是我不是很喜欢，因为这样做的话，并不是针对蓝牙来开发的，换言之，在使用过程中，需要先手动开启蓝牙，配对，连接，建立串行通道，然后开启应用程序使用，你还要在应用程序中设置串行端口，对最终用户来讲，这是非常麻烦的。我觉得，这样的解决方案冠上蓝牙通信的名头简直就是……不多说了，书归正传。
在红外通信中，我们知道，设备的DeviceID是一个Byte数组，那么蓝牙设备的DeviceID什么样子呢?我想这个大家都很清楚，是一串以“：”分隔的16进制数字。
红外通信中，一般而言红外并没有开启、关闭之类的状态，但是蓝牙有开启、关闭、可发现三种状态。
红外没有安全设置，而蓝牙有安全设置，所以我们需要对蓝牙设备进行配对，而红外通信这部需要。
我们查看.net的Socket地址族里有IrDA，但是没有蓝牙相关的地址族，这是我们需要解决的问题。
三. 获取设备ID
1.获取本地设备的ID
我们查看Window CE 4.2的SDK文档，得知获取本地设备ID的函数是BthReadLocalAddr，在btdrt.dll中。SDK文档中的英文原文是这样的：“This function retrieves the Bluetooth address of the current device.”好了，知道了这个就好说了：
首先封装本地托管函数：
[DllImport("Btdrt.dll", SetLastError=true)]
public static extern int BthReadLocalAddr(byte[] pba);
这个函数得到的本地DeviceID也是一组byte数组，为了向人们显示出来，我们要把它变为String：
string text1 = "";
text1 = text1 + pba[5].ToString("X2") + ":";
text1 = text1 + pba [4].ToString("X2") + ":";
text1 = text1 + pba [3].ToString("X2") + ":";
text1 = text1 + pba [2].ToString("X2") + ":";
text1 = text1 + pba [1].ToString("X2") + ":";
return (text1 + pba [0].ToString("X2"));
2.获取远程设备的ID
其实谈到获取远程设备的ID就涉及到如何去发现远程设备了，所以这里就一并把发现设备的方法也说明了吧。 发现设备需要用到三个Winsock API，分别是WSALookupServiceBegin、WSALookupServiceNext和WSALookupServiceEnd，这三个API到底起什么作用可以去查看Windows CE 4.2的SDK，这里就不详细解释了，只谈一下几个需要注意的地方。
WSALookupServiceBegin的函数原形是这样的：
INT WSALookupServiceBegin(
LPWSAQUERYSET lpqsRestrictions,
DWORD dwControlFlags,
LPHANDLE lphLookup
);
我们用托管代码进行包装：
[DllImport("ws2.dll", EntryPoint="WSALookupServiceBegin", SetLastError=true)]
public static extern int CeLookupServiceBegin(byte[] pQuerySet, LookupFlags dwFlags, ref int lphLookup);
可以看到，本来lpqsRestrictions是一个struct，经过包装后在托管代码中成为了byte[]，我们计算好该struct大概要占用多少个byte，struct中每一个成员在byte数组中的位置是怎样的，装配出来就好了。
由于是针对蓝牙作的开发，所以我们要查看一下这些参数应该是哪些值。Windows CE 4.2的SDK中说，蓝牙开发时，struct LPWSAQUERYSET中的如下成员应当为这些值：
The dwSize member must be sizeof(WSAQUERYSET).
The lpBlob member (itself a pointer to a BLOB structure) is optional, but if used, the device inquire parameters valid for LUP_FLUSHCACHE are the following:
The cbSize member of the BLOB structure must be sizeof(BTH_QUERY_DEVICE).
The pBlobData member is a pointer to a BTH_QUERY_DEVICE structure, for which the LAP member is the Bluetooth inquiry access code, and the length member is the length of the inquiry, in seconds.
The dwNameSpace member must be NS_BTH.
All other WSAQUERYSET members are ignored.
具体什么意思各位可以自己去理解，我想比我翻译出来要好些，毕竟我英语很差的。根据以上要求，我们这样装配pQuerySet:
byte[] buffer1 = new byte[0x400];
BitConverter.GetBytes(60).CopyTo(buffer1, 0);
GCHandle handle1 = GCHandle.Alloc(blob1.ToByteArray(), GCHandleType.Pinned);
IntPtr ptr1 = handle1.AddrOfPinnedObject();
BitConverter.GetBytes((int) (ptr1.ToInt32() + 4)).CopyTo(buffer1, 0x38);
另外的两个API也照类似方法调用即可。
在调用了WSALookupServiceNext之后，bytes数组pQuerySet中便包含了远程设备的地址信息，下面我们需要把它找出来。通过阅读SDK中WSAQUERYSET结构的说明和计算每个成员的位置之后，我们写出如下代码：
int num5 = BitConverter.ToInt32(buffer1, 0x30);
int num6 = Marshal.ReadInt32((IntPtr) num5, 8);
int num7 = Marshal.ReadInt32((IntPtr) num5, 12);
SocketAddress address1 = new SocketAddress(AddressFamily.Unspecified, num7);
因为.net框架的地址族里面没有蓝牙，所以我们这里用的是AddressFamily.Unspecified。
然后的工作就是从中获取远程设备的ID了：
前面我们已经计算出，这个Address里面的前六个字节是byte数组形式的设备ID，第七到第二十二个字节是蓝牙的Service Guid，在后面四个字节是端口号，所以我们只需要分别提取出来即可。
四. 监听服务
监听服务调用的是非托管API WSASetService,其原型是
INT WSASetService(
LPWSAQUERYSET lpqsRegInfo,
WSAESETSERVICEOP essoperation,
DWORD dwControlFlags
);
可以看到关键也是第一个参数，lpqsRegInfo，这也是一个struct，我们的包装方法与前面的发现设备采用的方法类似，做蓝牙通信时要注意其成员要如下设置：
lpqsRegInfodwSizesizeof(WSAQUERYSET)
lpszServiceInstanceNameNot supported on Windows CE. Set to 0.
lpServiceClassIdNot supported on Windows CE. Set to 0.
dwNameSpaceNS_BTH.
dwNumberOfCsAddrsNot supported on Windows CE. Set to 0.
IpcsaBufferNot supported on Windows CE. Set to 0.
lpBlobPoints to a BTHNS_SETBLOB structure, containing information about the service to be added.
*
All other WSAQUERYSET fields are ignored.
五. 连接
我们知道，IrDA中连接远程服务是使用方法System.Net.Sockets.IrDAClient类中的Connect方法。而这个方法又是调用的Socket类中的Connect方法。而Socket类是一个比较抽象的类，它并不绑定某个具体的地址族、SocketType和protocolType，所以在实例化的时候，需要指定这三个参数。我们也知道，在IrDA中，这三个参数分别是AddressFamily.Irda, SocketType.Stream,和ProtocolType.IP，那么在蓝牙中这三个参数分别是什么呢?我们好像找不到。
且慢，真是这样吗?
我们知道在.net中，这三个参数都是枚举值，而枚举在默认情况下，你可以认为就是int值的替代表现。
我们该如何知道这三个参数到底是什么呢?
还是先看Socket类的Connect方法。
我们查查有关资料，可以知道这个方法实际上是调用的一个非托管函数：
[DllImport("mscoree", EntryPoint="@339")]
public static extern int connect(int s, byte[] name, int namelen);
也就是非托管的Socket API。
我们看Windows CE 4.2的SDK，可以看到，在使用蓝牙进行连接的时候，需要使用WinSock扩展。我们还可以看到，在使用蓝牙进行连接的时候，三个参数分别应当是AF_BTH、SOCK_STREAM和BTHPROTO_RFCOMM，至于这三个参数分别代表什么，我们就要查看相关的头文件了。
我们找到ws2bth.h头文件，可以看到AF_BTH代表十进制数32，而BTHPROTO_RFCOMM代表十六进制数0x0003，恰好和ProtocolType.Ggp代表的数值是一致的。所以，我们在实例化Socket时是这么写的：
new Socket((AddressFamily) 0x20, SocketType.Stream, ProtocolType.Ggp);
Socket实例化出来了，其他的当然就都好说了，这里不再赘述。
六. 蓝牙的安全设置
蓝牙比红外多了安全方面的设置，所以就需要多一些代码来处理这些。具体也就不多说了，其实也就是一些非托管代码的包装调用，这些API在Btdrt.dll中：
获取配对码请求：
[DllImport("Btdrt.dll", SetLastError=true)]
public static extern int BthGetPINRequest(byte[] pba);
设置配对码：
[DllImport("btdrt.dll", SetLastError=true)]
public static extern int BthSetPIN(byte[] pba, int cPinLength, byte[] ppin);
比较麻烦点的是配对，总共有三步操作：
首先是创建ACL连接：
[DllImport("Btdrt.dll", SetLastError=true)]
public static extern int BthCreateACLConnection(byte[] pbt, ref ushort phandle);
然后是配对码验证：
[DllImport("Btdrt.dll", SetLastError=true)]
public static extern int BthAuthenticate(byte[] pbt);
然后一定要关闭连接：
[DllImport("Btdrt.dll", SetLastError=true)]
public static extern int BthCloseConnection(ushort handle);
七. 设置蓝牙无线电状态
我们知道，蓝牙无线电有打开、关闭、可发现三种状态，那么我们如何实现编程控制呢?
我想这个一定大家都知道了，因为网上有很多关于这个的文章：
先写一个枚举：
public enum RadioMode
{
Connectable = 1,
Discoverable = 2,
PowerOff = 0
}
然后写一个函数调用非托管代码即可：
[DllImport("BthUtil.dll", SetLastError=true)]
public static extern int BthSetMode(RadioMode dwMode);
获取无线电状态的话就用下面的函数：
[DllImport("BthUtil.dll", SetLastError=true)]
public static extern int BthGetMode(ref RadioMode dwMode);
八. 已知的问题
可能是因为蓝牙控制软件还没有实现标准化或者还是其他的问题，我们发现根据Windows CE 4.2 SDK 使用Winsock 扩展做的蓝牙开发有一个问题，而且不论是本文中所述的托管代码还是其他的非托管代码，只要是用的这种思路用Winsock 2做的开发都会存在这样一个问题，那就是不是在所有的Windows Mobile设备上都能正常运行。经过我的测试，我发现在很多使用另行开发的蓝牙控制软件的设备上，如联想ET560、华硕MyPAL A730上都无法运行，而在没有另行开发蓝牙控制软件的设备上是可以正常运行的，我不知道这是什么原因，初步推测可能是厂商另行开发的蓝牙控制软件屏蔽了微软的API的缘故，到底是不是这样，还得请高人指点。
2008年9月23日星期二
Asp.net 备份和还原SQL Server及压缩Access数据库
出处：不详
/**********************************************************************************
*
* 功能说明:备份和恢复SQL Server数据库
* 作者: 刘功勋;
* 版本:V0.1(C#2.0);时间:2007-1-1
* 当使用SQL Server时,请引用 COM组件中的,SQLDMO.dll组件
* 当使用Access中,请浏览添加引用以下两个dll
* 引用C:\Program Files\Common Files\System\ado\msadox.dll,该DLL包含ADOX命名空间
* 引用C:\Program Files\Common Files\System\ado\msjro.dll,该DLL包含JRO命名空间
* *******************************************************************************/
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.IO;
using ADOX;//该命名空间包含创建ACCESS的类(方法)--解决方案 ==> 引用 ==> 添加引用 ==> 游览找到.dll
using JRO;//该命名空间包含压缩ACCESS的类(方法)
namespace EC
{
///
/// 数据库恢复和备份
///
public class SqlBackObject
{
public SqlBackObject()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region SQL数据库备份
///
/// SQL数据库备份
///
/// SQL服务器IP或(Localhost)
/// 数据库登录名
/// 数据库登录密码
/// 数据库名
/// 备份到的路径
public static void SQLBACK(string ServerIP,string LoginName,string LoginPass,string DBName,string BackPath)
{
SQLDMO.Backup oBackup = new SQLDMO.BackupClass();
SQLDMO.SQLServer oSQLServer = new SQLDMO.SQLServerClass();
try
{
oSQLServer.LoginSecure = false;
oSQLServer.Connect(ServerIP, LoginName, LoginPass);
oBackup.Database = DBName;
oBackup.Files = BackPath;
oBackup.BackupSetName = DBName;
oBackup.BackupSetDescription = "数据库备份";
oBackup.Initialize = true;
oBackup.SQLBackup(oSQLServer);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
oSQLServer.DisConnect();
}
}
#endregion
#region SQL恢复数据库
///
/// SQL恢复数据库
///
/// SQL服务器IP或(Localhost)
/// 数据库登录名
/// 数据库登录密码
/// 要还原的数据库名
/// 数据库备份的路径
public static void SQLDbRestore(string ServerIP,string LoginName,string LoginPass,string DBName,string BackPath)
{
SQLDMO.Restore orestore = new SQLDMO.RestoreClass();
SQLDMO.SQLServer oSQLServer = new SQLDMO.SQLServerClass();
try
{
oSQLServer.LoginSecure = false;
oSQLServer.Connect(ServerIP, LoginName, LoginPass);
orestore.Action = SQLDMO.SQLDMO_RESTORE_TYPE.SQLDMORestore_Database;
orestore.Database = DBName;
orestore.Files = BackPath;
orestore.FileNumber = 1;
orestore.ReplaceDatabase = true;
orestore.SQLRestore(oSQLServer);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
oSQLServer.DisConnect();
}
}
#endregion
#region 根据指定的文件名称创建Access数据库
///
/// 根据指定的文件名称创建数据
///
/// 绝对路径+文件名称
public static void CreateAccess(string DBPath)
{
if (File.Exists(DBPath))//检查数据库是否已存在
{
throw new Exception("目标数据库已存在,无法创建");
}
DBPath = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+DBPath;
//创建一个CatalogClass对象实例
ADOX.CatalogClass cat = new ADOX.CatalogClass();
//使用CatalogClass对象的Create方法创建ACCESS数据库
cat.Create(DBPath);
}
#endregion
#region 压缩Access数据库
///
/// 压缩Access数据库
///
/// 数据库绝对路径
public static void CompactAccess(string DBPath)
{
if (!File.Exists(DBPath))
{
throw new Exception("目标数据库不存在,无法压缩");
}
//声明临时数据库名称
string temp = DateTime.Now.Year.ToString();
temp += DateTime.Now.Month.ToString();
temp += DateTime.Now.Day.ToString();
temp += DateTime.Now.Hour.ToString();
temp += DateTime.Now.Minute.ToString();
temp += DateTime.Now.Second.ToString() + ".bak";
temp = DBPath.Substring(0, DBPath.LastIndexOf("\\") + 1) + temp;
//定义临时数据库的连接字符串
string temp2 = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+temp;
//定义目标数据库的连接字符串
string DBPath2 = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+DBPath;
//创建一个JetEngineClass对象的实例
JRO.JetEngineClass jt = new JRO.JetEngineClass();
//使用JetEngineClass对象的CompactDatabase方法压缩修复数据库
jt.CompactDatabase(DBPath2, temp2);
//拷贝临时数据库到目标数据库(覆盖)
File.Copy(temp, DBPath, true);
//最后删除临时数据库
File.Delete(temp);
}
#endregion
#region 备份Access数据库
///
/// 备份Access数据库
///
/// 要备份的数据库绝对路径
/// 备份到的数据库绝对路径
///
public static void Backup(string srcPath,string aimPath)
{
if (!File.Exists(srcPath))
{
throw new Exception("源数据库不存在,无法备份");
}
try
{
File.Copy(srcPath,aimPath,true);
}
catch(IOException ixp)
{
throw new Exception(ixp.ToString());
}
}
#endregion
#region 还原Access数据库
///
/// 还原Access数据库
///
/// 备份的数据库绝对路径
/// 要还原的数据库绝对路径
public static void RecoverAccess(string bakPath,string dbPath)
{
if (!File.Exists(bakPath))
{
throw new Exception("备份数据库不存在,无法还原");
}
try
{
File.Copy(bakPath, dbPath, true);
}
catch (IOException ixp)
{
throw new Exception(ixp.ToString());
}
}
#endregion
}
}
/**********************************************************************************
*
* 功能说明:备份和恢复SQL Server数据库
* 作者: 刘功勋;
* 版本:V0.1(C#2.0);时间:2007-1-1
* 当使用SQL Server时,请引用 COM组件中的,SQLDMO.dll组件
* 当使用Access中,请浏览添加引用以下两个dll
* 引用C:\Program Files\Common Files\System\ado\msadox.dll,该DLL包含ADOX命名空间
* 引用C:\Program Files\Common Files\System\ado\msjro.dll,该DLL包含JRO命名空间
* *******************************************************************************/
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.IO;
using ADOX;//该命名空间包含创建ACCESS的类(方法)--解决方案 ==> 引用 ==> 添加引用 ==> 游览找到.dll
using JRO;//该命名空间包含压缩ACCESS的类(方法)
namespace EC
{
///
/// 数据库恢复和备份
///
public class SqlBackObject
{
public SqlBackObject()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region SQL数据库备份
///
/// SQL数据库备份
///
/// SQL服务器IP或(Localhost)
/// 数据库登录名
/// 数据库登录密码
/// 数据库名
/// 备份到的路径
public static void SQLBACK(string ServerIP,string LoginName,string LoginPass,string DBName,string BackPath)
{
SQLDMO.Backup oBackup = new SQLDMO.BackupClass();
SQLDMO.SQLServer oSQLServer = new SQLDMO.SQLServerClass();
try
{
oSQLServer.LoginSecure = false;
oSQLServer.Connect(ServerIP, LoginName, LoginPass);
oBackup.Database = DBName;
oBackup.Files = BackPath;
oBackup.BackupSetName = DBName;
oBackup.BackupSetDescription = "数据库备份";
oBackup.Initialize = true;
oBackup.SQLBackup(oSQLServer);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
oSQLServer.DisConnect();
}
}
#endregion
#region SQL恢复数据库
///
/// SQL恢复数据库
///
/// SQL服务器IP或(Localhost)
/// 数据库登录名
/// 数据库登录密码
/// 要还原的数据库名
/// 数据库备份的路径
public static void SQLDbRestore(string ServerIP,string LoginName,string LoginPass,string DBName,string BackPath)
{
SQLDMO.Restore orestore = new SQLDMO.RestoreClass();
SQLDMO.SQLServer oSQLServer = new SQLDMO.SQLServerClass();
try
{
oSQLServer.LoginSecure = false;
oSQLServer.Connect(ServerIP, LoginName, LoginPass);
orestore.Action = SQLDMO.SQLDMO_RESTORE_TYPE.SQLDMORestore_Database;
orestore.Database = DBName;
orestore.Files = BackPath;
orestore.FileNumber = 1;
orestore.ReplaceDatabase = true;
orestore.SQLRestore(oSQLServer);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
oSQLServer.DisConnect();
}
}
#endregion
#region 根据指定的文件名称创建Access数据库
///
/// 根据指定的文件名称创建数据
///
/// 绝对路径+文件名称
public static void CreateAccess(string DBPath)
{
if (File.Exists(DBPath))//检查数据库是否已存在
{
throw new Exception("目标数据库已存在,无法创建");
}
DBPath = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+DBPath;
//创建一个CatalogClass对象实例
ADOX.CatalogClass cat = new ADOX.CatalogClass();
//使用CatalogClass对象的Create方法创建ACCESS数据库
cat.Create(DBPath);
}
#endregion
#region 压缩Access数据库
///
/// 压缩Access数据库
///
/// 数据库绝对路径
public static void CompactAccess(string DBPath)
{
if (!File.Exists(DBPath))
{
throw new Exception("目标数据库不存在,无法压缩");
}
//声明临时数据库名称
string temp = DateTime.Now.Year.ToString();
temp += DateTime.Now.Month.ToString();
temp += DateTime.Now.Day.ToString();
temp += DateTime.Now.Hour.ToString();
temp += DateTime.Now.Minute.ToString();
temp += DateTime.Now.Second.ToString() + ".bak";
temp = DBPath.Substring(0, DBPath.LastIndexOf("\\") + 1) + temp;
//定义临时数据库的连接字符串
string temp2 = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+temp;
//定义目标数据库的连接字符串
string DBPath2 = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+DBPath;
//创建一个JetEngineClass对象的实例
JRO.JetEngineClass jt = new JRO.JetEngineClass();
//使用JetEngineClass对象的CompactDatabase方法压缩修复数据库
jt.CompactDatabase(DBPath2, temp2);
//拷贝临时数据库到目标数据库(覆盖)
File.Copy(temp, DBPath, true);
//最后删除临时数据库
File.Delete(temp);
}
#endregion
#region 备份Access数据库
///
/// 备份Access数据库
///
/// 要备份的数据库绝对路径
/// 备份到的数据库绝对路径
///
public static void Backup(string srcPath,string aimPath)
{
if (!File.Exists(srcPath))
{
throw new Exception("源数据库不存在,无法备份");
}
try
{
File.Copy(srcPath,aimPath,true);
}
catch(IOException ixp)
{
throw new Exception(ixp.ToString());
}
}
#endregion
#region 还原Access数据库
///
/// 还原Access数据库
///
/// 备份的数据库绝对路径
/// 要还原的数据库绝对路径
public static void RecoverAccess(string bakPath,string dbPath)
{
if (!File.Exists(bakPath))
{
throw new Exception("备份数据库不存在,无法还原");
}
try
{
File.Copy(bakPath, dbPath, true);
}
catch (IOException ixp)
{
throw new Exception(ixp.ToString());
}
}
#endregion
}
}
2008年9月17日星期三
C#设计模式之四：Factory Method
本系列文章将向大家介绍一下C#的设计模式，此为第四篇文章，相信对大家会有所帮助的。废话不多说，继续来看。
意图
定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
场景
上次，我们使用抽象工厂解决了生产一组产品的问题，但是我们把各个场景作为了具体工厂来生产场景模式和场景纹理两个产品。在调用代码中也并没有出现具体工厂的影子。其实，场景类要做的不仅仅是创建具体的产品系列，可能它还需要做一个初始化工作。那么，我们就需要在调用代码中能得到这个场景类。
在前一节中，由于场景类(比如HalfPaper)本身是具体级别的(具体工厂)。那么，我们也不应该在调用代码中直接依赖场景类。因此，我们可以使用工厂方法来生产这个具体产品。
示例代码
using System;
using System.Reflection;
namespace FactoryMethodExample
{
class Program
{
static void Main(string[] args)
{
Patrix patrix = new Patrix();
patrix.LoadScene("HalfPaper");
patrix.LoadScene("Matrix");
}
}
class Patrix
{
private PatrixSceneFactory GetGameScene(string gameSceneName)
{
return (PatrixSceneFactory)Assembly.Load("FactoryMethodExample").CreateInstance("FactoryMethodExample." + gameSceneName + "Factory");
}
public void LoadScene(string gameSceneName)
{
PatrixSceneFactory psf = GetGameScene(gameSceneName);
PatrixScene ps = psf.CreateScene();
ps.InitScene();
}
}
abstract class PatrixSceneFactory
{
public abstract PatrixScene CreateScene();
}
abstract class PatrixScene
{
public void InitScene()
{
Texture texture = CreateTexture();
Model model = CreateModel();
model.FillTexture(texture);
}
public abstract Model CreateModel();
public abstract Texture CreateTexture();
}
abstract class Model
{
public abstract void FillTexture(Texture texture);
}
abstract class Texture
{
}
class HalfPaperFactory : PatrixSceneFactory
{
public override PatrixScene CreateScene()
{
return new HalfPaper();
}
}
class HalfPaper : PatrixScene
{
public HalfPaper()
{
Console.WriteLine("HalfPaper Creating");
}
public override Model CreateModel()
{
return new HalfPaperModel();
}
public override Texture CreateTexture()
{
return new HalfPaperTexture();
}
}
class HalfPaperModel : Model
{
public HalfPaperModel()
{
Console.WriteLine("HalfPaper Model Creating");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("HalfPaper Model is filled Texture");
}
}
class HalfPaperTexture : Texture
{
public HalfPaperTexture()
{
Console.WriteLine("HalfPaper Texture Created");
}
}
class MatrixFactory : PatrixSceneFactory
{
public override PatrixScene CreateScene()
{
return new Matrix();
}
}
class Matrix : PatrixScene
{
public Matrix()
{
Console.WriteLine("Matrix Created");
}
public override Model CreateModel()
{
return new MatrixModel();
}
public override Texture CreateTexture()
{
return new MatrixTexture();
}
}
class MatrixModel : Model
{
public MatrixModel()
{
Console.WriteLine("Matrix Model Created");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("Matrix Model is filled Texture");
}
}
class MatrixTexture : Texture
{
public MatrixTexture()
{
Console.WriteLine("Matrix Texture Created");
}
}
}
代码执行结果如下图：
代码说明
这个代码基于前一节抽象工厂的代码修改而来，因此代码比较厂。其中能体现的设计模式有抽象工厂、工厂方法以及模版方法。
这次的PatrixSceneFactory和前一节的不同，它是一个产品的抽象工厂，也就是工厂方法模式中的抽象工厂角色，它是具体产品工厂的抽象形式。
HalfPaperFactory和MatrixFactory是工厂方法模式中的具体工厂角色，它负责创建具体的产品。
PatrixScene是工厂方法模式中的抽象产品角色，同时也是抽象工厂模式中的抽象工厂角色。它既是场景的抽象形式，又负责创建每个场景中的产品系列，也就是模型和纹理。还有，它的InistScene()方法还体现了模版方法的思想，封装了产品初始化过程中的共同步骤。
HalfPaper和Matrix当然就是工厂方法模式中的具体产品角色了，同时，它们也是抽象工厂模式中的具体工厂角色。
从这个例子可以看出，抽象工厂针对一组产品的创建进行抽象，抽象程度比较高。抽象工厂生产重点在于规范一组产品的创建，能让产品线保持产品的一致。比如，N卡不管是7系列还是8系列，总会分低端的7300，8300和中端的7600，8600以及高端的7900，8900。
而工厂方法针对某种产品的创建，每种产品在创建的过程中可能会有一些相似的步骤，那么就可以在抽象产品中进行一些提取，自然而然运用到了模版方法。工厂方法还能针对具体产品创建时的易变性，在这里我们可能很清楚HalfPaperFactory一定会创建HalfPaper这个产品，但是万一以后改为创建HalfPaperSpecial了呢?有了工厂方法，我们可以只需修改HalfPaperFactory就可以了。
不管怎么样，目的还是让调用方尽量和接口依赖(或者说和稳定的东西去依赖，让变化在接口下面变)，既是要以来具体类型，也希望能只依赖一个。试想一下，如果没有抽象工厂和工厂方法，也少了这些抽象类型，那么调用方可能就要依赖具体场景类型和具体的纹理以及模型类型。并且在调用的时候，通过条件来判断并且创建各种具体类型，一旦有新的场景需要实现，调用方代码可能就需要做很大的调整。暂且不说调整的工作量有多少，调整所带来的风险谁能承担呢?
何时采用
从代码角度来说， 如果我们需要创建一个易变的对象，或是希望对象由子类决定创建哪个对象的时候可以考虑工厂方法。
从应用角度来说， 如果我们觉得具体产品的创建不稳定，或者客户端根本无需知道创建哪个具体产品的时候可以使用工厂方法。后者对于框架和工具包软件来说更常见，比如有一个打印类负责打印图纸，我们需要得到一个打印对象，对于调用方来说并不知道要使用超宽打印对象还是普通打印对象，我们可以通过工厂方法使客户端和抽象打印工厂直接沟通，由它来决定具体创建哪个打印对象。
实现要点
通过继承创建具体产品。很多时候，每一种具体产品对应一个具体的工厂来创建。
使用具体工厂类来决定怎么样创建具体产品。调用方并不关心工厂创建的是哪个游戏场景，它只用知道工厂给我的是一个游戏场景即可。
注意事项
工厂方法通常需要为每个具体产品对应一个具体工厂，如果滥用的话会使得类的数目急剧增多。
意图
定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
场景
上次，我们使用抽象工厂解决了生产一组产品的问题，但是我们把各个场景作为了具体工厂来生产场景模式和场景纹理两个产品。在调用代码中也并没有出现具体工厂的影子。其实，场景类要做的不仅仅是创建具体的产品系列，可能它还需要做一个初始化工作。那么，我们就需要在调用代码中能得到这个场景类。
在前一节中，由于场景类(比如HalfPaper)本身是具体级别的(具体工厂)。那么，我们也不应该在调用代码中直接依赖场景类。因此，我们可以使用工厂方法来生产这个具体产品。
示例代码
using System;
using System.Reflection;
namespace FactoryMethodExample
{
class Program
{
static void Main(string[] args)
{
Patrix patrix = new Patrix();
patrix.LoadScene("HalfPaper");
patrix.LoadScene("Matrix");
}
}
class Patrix
{
private PatrixSceneFactory GetGameScene(string gameSceneName)
{
return (PatrixSceneFactory)Assembly.Load("FactoryMethodExample").CreateInstance("FactoryMethodExample." + gameSceneName + "Factory");
}
public void LoadScene(string gameSceneName)
{
PatrixSceneFactory psf = GetGameScene(gameSceneName);
PatrixScene ps = psf.CreateScene();
ps.InitScene();
}
}
abstract class PatrixSceneFactory
{
public abstract PatrixScene CreateScene();
}
abstract class PatrixScene
{
public void InitScene()
{
Texture texture = CreateTexture();
Model model = CreateModel();
model.FillTexture(texture);
}
public abstract Model CreateModel();
public abstract Texture CreateTexture();
}
abstract class Model
{
public abstract void FillTexture(Texture texture);
}
abstract class Texture
{
}
class HalfPaperFactory : PatrixSceneFactory
{
public override PatrixScene CreateScene()
{
return new HalfPaper();
}
}
class HalfPaper : PatrixScene
{
public HalfPaper()
{
Console.WriteLine("HalfPaper Creating");
}
public override Model CreateModel()
{
return new HalfPaperModel();
}
public override Texture CreateTexture()
{
return new HalfPaperTexture();
}
}
class HalfPaperModel : Model
{
public HalfPaperModel()
{
Console.WriteLine("HalfPaper Model Creating");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("HalfPaper Model is filled Texture");
}
}
class HalfPaperTexture : Texture
{
public HalfPaperTexture()
{
Console.WriteLine("HalfPaper Texture Created");
}
}
class MatrixFactory : PatrixSceneFactory
{
public override PatrixScene CreateScene()
{
return new Matrix();
}
}
class Matrix : PatrixScene
{
public Matrix()
{
Console.WriteLine("Matrix Created");
}
public override Model CreateModel()
{
return new MatrixModel();
}
public override Texture CreateTexture()
{
return new MatrixTexture();
}
}
class MatrixModel : Model
{
public MatrixModel()
{
Console.WriteLine("Matrix Model Created");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("Matrix Model is filled Texture");
}
}
class MatrixTexture : Texture
{
public MatrixTexture()
{
Console.WriteLine("Matrix Texture Created");
}
}
}
代码执行结果如下图：
代码说明
这个代码基于前一节抽象工厂的代码修改而来，因此代码比较厂。其中能体现的设计模式有抽象工厂、工厂方法以及模版方法。
这次的PatrixSceneFactory和前一节的不同，它是一个产品的抽象工厂，也就是工厂方法模式中的抽象工厂角色，它是具体产品工厂的抽象形式。
HalfPaperFactory和MatrixFactory是工厂方法模式中的具体工厂角色，它负责创建具体的产品。
PatrixScene是工厂方法模式中的抽象产品角色，同时也是抽象工厂模式中的抽象工厂角色。它既是场景的抽象形式，又负责创建每个场景中的产品系列，也就是模型和纹理。还有，它的InistScene()方法还体现了模版方法的思想，封装了产品初始化过程中的共同步骤。
HalfPaper和Matrix当然就是工厂方法模式中的具体产品角色了，同时，它们也是抽象工厂模式中的具体工厂角色。
从这个例子可以看出，抽象工厂针对一组产品的创建进行抽象，抽象程度比较高。抽象工厂生产重点在于规范一组产品的创建，能让产品线保持产品的一致。比如，N卡不管是7系列还是8系列，总会分低端的7300，8300和中端的7600，8600以及高端的7900，8900。
而工厂方法针对某种产品的创建，每种产品在创建的过程中可能会有一些相似的步骤，那么就可以在抽象产品中进行一些提取，自然而然运用到了模版方法。工厂方法还能针对具体产品创建时的易变性，在这里我们可能很清楚HalfPaperFactory一定会创建HalfPaper这个产品，但是万一以后改为创建HalfPaperSpecial了呢?有了工厂方法，我们可以只需修改HalfPaperFactory就可以了。
不管怎么样，目的还是让调用方尽量和接口依赖(或者说和稳定的东西去依赖，让变化在接口下面变)，既是要以来具体类型，也希望能只依赖一个。试想一下，如果没有抽象工厂和工厂方法，也少了这些抽象类型，那么调用方可能就要依赖具体场景类型和具体的纹理以及模型类型。并且在调用的时候，通过条件来判断并且创建各种具体类型，一旦有新的场景需要实现，调用方代码可能就需要做很大的调整。暂且不说调整的工作量有多少，调整所带来的风险谁能承担呢?
何时采用
从代码角度来说， 如果我们需要创建一个易变的对象，或是希望对象由子类决定创建哪个对象的时候可以考虑工厂方法。
从应用角度来说， 如果我们觉得具体产品的创建不稳定，或者客户端根本无需知道创建哪个具体产品的时候可以使用工厂方法。后者对于框架和工具包软件来说更常见，比如有一个打印类负责打印图纸，我们需要得到一个打印对象，对于调用方来说并不知道要使用超宽打印对象还是普通打印对象，我们可以通过工厂方法使客户端和抽象打印工厂直接沟通，由它来决定具体创建哪个打印对象。
实现要点
通过继承创建具体产品。很多时候，每一种具体产品对应一个具体的工厂来创建。
使用具体工厂类来决定怎么样创建具体产品。调用方并不关心工厂创建的是哪个游戏场景，它只用知道工厂给我的是一个游戏场景即可。
注意事项
工厂方法通常需要为每个具体产品对应一个具体工厂，如果滥用的话会使得类的数目急剧增多。
C#设计模式之三：Abstract Factory
本系列文章将向大家介绍一下C#的设计模式，此为第三篇文章，相信对大家会有所帮助的。废话不多说，继续来看。
意图
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
场景
还是上次说的那个网络游戏，定下来是一个休闲的FPS游戏。和CS差不多，8到16个玩家在游戏里面分成2组对战射击。现在要实现初始化场景的工作。要呈现一个三维物体一般两个元素是少不了的，一是这个物体的骨架，也就是模型，二就是这个骨架上填充的纹理。
我们知道，这样的一个游戏不可能只有一张地图，而且地图的数量肯定是会一直增加的。如果游戏在初始化场景的时候需要根据不同的地图分别加载模型和纹理对象，那么势必就会使得场景的扩充变得很不方便。由此，我们引入Abstract Factory，抽象工厂生产的都是实际类型的接口(或者抽象类型)，如果加了新的场景可以确保不需要修改加载场景的那部分代码。
示例代码
using System;
using System.Reflection;
namespace AbstractFactoryExample
{
class Program
{
static void Main(string[] args)
{
Patrix patrix = new Patrix();
patrix.LoadScene("HalfPaper");
patrix.LoadScene("Matrix");
}
}
class Patrix
{
private PatrixSceneFactory GetGameScene(string gameSceneName)
{
return (PatrixSceneFactory)Assembly.Load("AbstractFactoryExample").CreateInstance("AbstractFactoryExample." + gameSceneName);
}
public void LoadScene(string gameSceneName)
{
PatrixSceneFactory psf = GetGameScene(gameSceneName);
Texture texture = psf.CreateTexture();
Model model = psf.CreateModel();
model.FillTexture(texture);
}
}
abstract class PatrixSceneFactory
{
public abstract Model CreateModel();
public abstract Texture CreateTexture();
}
abstract class Model
{
public abstract void FillTexture(Texture texture);
}
abstract class Texture
{
}
class HalfPaper : PatrixSceneFactory
{
public override Model CreateModel()
{
return new HalfPaperModel();
}
public override Texture CreateTexture()
{
return new HalfPaperTexture();
}
}
class HalfPaperModel : Model
{
public HalfPaperModel()
{
Console.WriteLine("HalfPaper Model Created");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("HalfPaper Model is filled Texture");
}
}
class HalfPaperTexture : Texture
{
public HalfPaperTexture()
{
Console.WriteLine("HalfPaper Texture Created");
}
}
class Matrix : PatrixSceneFactory
{
public override Model CreateModel()
{
return new MatrixModel();
}
public override Texture CreateTexture()
{
return new MatrixTexture();
}
}
class MatrixModel : Model
{
public MatrixModel()
{
Console.WriteLine("Matrix Model Created");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("Matrix Model is filled Texture");
}
}
class MatrixTexture : Texture
{
public MatrixTexture()
{
Console.WriteLine("Matrix Texture Created");
}
}
}
代码说明
PatrixSceneFactory就是一个抽象工厂，它声明了创建抽象的场景以及抽象的纹理的接口。(广告时间：Patrix是我公司的一款休闲FPS游戏，详细请见http://www.qwd1.com)
Model和Texture是抽象产品。在Model类中有一个抽象方法，用于为模型填充纹理。
HalfPaper和Matrix是具体工厂，它用于创建某个场景的模型和纹理。(你可能对两个类的名字不太理解，其实HalfPaper和Matrix是两个地图的名字)
xxxModel和xxxTexture就是具体的产品了。它们就是针对某个场景的模型和纹理，具体工厂负责创建它们。
Patrix这个类负责加载场景，为了避免加载不同场景使用case语句，在这里我们使用反射来加载具体工厂类。
可以看到，一旦有了新的场景(或者说地图)，我们只需要设计新的xxxModel和xxxTexture以及具体工厂类就可以了，加载场景的那部分代码(也就是Patrix类)不需要做改动。
我们现在这个游戏可是不支持和电脑对战的，万一以后需要支持电脑了，那么场景中的元素除了纹理和模型之外就还需要加电脑了。也就是说抽象工厂还需要多生产一种类型的产品，这个时候抽象工厂就无能为力了。抽象工厂只能解决系列产品扩张的变化点(在我们的例子中就是地图的新增)，因此千万把抽象工厂所能生产的产品考虑周全了。
何时采用
从代码角度来说，你希望在统一的地方创建一系列相互关联的对象，并且基于抽象对象的时候。
从应用角度来说，如果你的产品是成组成套的，并且肯定会不断扩展新系列的，那么就适用抽象工厂。比如说，外面买的塑料模型，里面总是有图纸、模型元件板和外壳包装三部分。那么生产模型的厂就是抽象工厂，打印图纸、打印包装盒以及生产元件板的三个流水线就是具体工厂了。需要生产新的模型，只需要制作新的图纸输入到三个流水线的电脑中就可以了。
实现要点
抽象工厂本身不负责创建产品，产品最终还是由具体工厂来创建的。比如，MatrixModel是Matrix创建的，而不是PatrixSceneFactory创建的。在.NET中可以使用反射来创建具体工厂，从而使得代码变动降到最低。
在抽象工厂中需要体现出生产一系列产品。这一系列产品是相互关联，相互依赖一起使用的。
抽象工厂对应抽象产品，具体工厂对应具体产品，外部依赖抽象类型，这样对于新系列产品的创建，外部唯一依赖的就是具体工厂的创建过程(可以通过反射解决)。
注意事项
一般来说需要创建一系列对象的时候才考虑抽象工厂。比如，创建一个场景，需要创建模型和纹理，并且模型和纹理之间是有一定联系的，不太可能把PatrixTexture套用在MatrixModel上。
如果系统的变化点不在新系列的扩充上，那么就没有必要使用抽象工厂。比如，如果我们不会增加新地图的话，那么也就没有必要引入抽象工厂。
.NET中的抽象工厂
我们说过，抽象工厂针对系列产品的应变。在使用ADO.NET进行数据访问的时候，如果目标数据库是Access，我们会使用OleDbConnection、OleDbCommand以及OleDbDataAdapter等一系列ADO.NET对象。那么如果数据库是SQL Server，我们又会改用SqlConnection、SqlCommand以及SqlDataAdapter等一系列ADO.NET对象。如果只使用一套对象，没有什么大问题，如果我们的数据访问有系列变化的需求，比如可以针对Access和SQL Server，而且希望改换数据库尽量对客户端代码透明，那么就需要引入抽象工厂模式。
好在，ADO.NET 2.0中已经有了整套抽象工厂的类型。看下面的代码，你应该能辨别这些类型在抽象工厂中的角色：
public abstract class DbProviderFactory
{
// Methods
protected DbProviderFactory()
{
}
public virtual DbCommand CreateCommand()
{
return null;
}
public virtual DbCommandBuilder CreateCommandBuilder()
{
return null;
}
public virtual DbConnection CreateConnection()
{
return null;
}
public virtual DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return null;
}
public virtual DbDataAdapter CreateDataAdapter()
{
return null;
}
public virtual DbDataSourceEnumerator CreateDataSourceEnumerator()
{
return null;
}
public virtual DbParameter CreateParameter()
{
return null;
}
public virtual CodeAccessPermission CreatePermission(PermissionState state)
{
return null;
}
// Properties
public virtual bool CanCreateDataSourceEnumerator
{
get
{
return false;
}
}
}
public sealed class OleDbFactory : DbProviderFactory
{
// Fields
public static readonly OleDbFactory Instance = new OleDbFactory();
// Methods
private OleDbFactory()
{
}
public override DbCommand CreateCommand()
{
return new OleDbCommand();
}
public override DbCommandBuilder CreateCommandBuilder()
{
return new OleDbCommandBuilder();
}
public override DbConnection CreateConnection()
{
return new OleDbConnection();
}
public override DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return new OleDbConnectionStringBuilder();
}
public override DbDataAdapter CreateDataAdapter()
{
return new OleDbDataAdapter();
}
public override DbParameter CreateParameter()
{
return new OleDbParameter();
}
public override CodeAccessPermission CreatePermission(PermissionState state)
{
return new OleDbPermission(state);
}
}
public sealed class SqlClientFactory : DbProviderFactory, IServiceProvider
{
// Fields
public static readonly SqlClientFactory Instance = new SqlClientFactory();
// Methods
private SqlClientFactory()
{
}
public override DbCommand CreateCommand()
{
return new SqlCommand();
}
public override DbCommandBuilder CreateCommandBuilder()
{
return new SqlCommandBuilder();
}
public override DbConnection CreateConnection()
{
return new SqlConnection();
}
public override DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return new SqlConnectionStringBuilder();
}
public override DbDataAdapter CreateDataAdapter()
{
return new SqlDataAdapter();
}
public override DbDataSourceEnumerator CreateDataSourceEnumerator()
{
return SqlDataSourceEnumerator.Instance;
}
public override DbParameter CreateParameter()
{
return new SqlParameter();
}
public override CodeAccessPermission CreatePermission(PermissionState state)
{
return new SqlClientPermission(state);
}
object IServiceProvider.GetService(Type serviceType)
{
object obj2 = null;
if (serviceType == GreenMethods.SystemDataCommonDbProviderServices_Type)
{
obj2 = GreenMethods.SystemDataSqlClientSqlProviderServices_Instance();
}
return obj2;
}
// Properties
public override bool CanCreateDataSourceEnumerator
{
get
{
return true;
}
}
}
意图
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
场景
还是上次说的那个网络游戏，定下来是一个休闲的FPS游戏。和CS差不多，8到16个玩家在游戏里面分成2组对战射击。现在要实现初始化场景的工作。要呈现一个三维物体一般两个元素是少不了的，一是这个物体的骨架，也就是模型，二就是这个骨架上填充的纹理。
我们知道，这样的一个游戏不可能只有一张地图，而且地图的数量肯定是会一直增加的。如果游戏在初始化场景的时候需要根据不同的地图分别加载模型和纹理对象，那么势必就会使得场景的扩充变得很不方便。由此，我们引入Abstract Factory，抽象工厂生产的都是实际类型的接口(或者抽象类型)，如果加了新的场景可以确保不需要修改加载场景的那部分代码。
示例代码
using System;
using System.Reflection;
namespace AbstractFactoryExample
{
class Program
{
static void Main(string[] args)
{
Patrix patrix = new Patrix();
patrix.LoadScene("HalfPaper");
patrix.LoadScene("Matrix");
}
}
class Patrix
{
private PatrixSceneFactory GetGameScene(string gameSceneName)
{
return (PatrixSceneFactory)Assembly.Load("AbstractFactoryExample").CreateInstance("AbstractFactoryExample." + gameSceneName);
}
public void LoadScene(string gameSceneName)
{
PatrixSceneFactory psf = GetGameScene(gameSceneName);
Texture texture = psf.CreateTexture();
Model model = psf.CreateModel();
model.FillTexture(texture);
}
}
abstract class PatrixSceneFactory
{
public abstract Model CreateModel();
public abstract Texture CreateTexture();
}
abstract class Model
{
public abstract void FillTexture(Texture texture);
}
abstract class Texture
{
}
class HalfPaper : PatrixSceneFactory
{
public override Model CreateModel()
{
return new HalfPaperModel();
}
public override Texture CreateTexture()
{
return new HalfPaperTexture();
}
}
class HalfPaperModel : Model
{
public HalfPaperModel()
{
Console.WriteLine("HalfPaper Model Created");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("HalfPaper Model is filled Texture");
}
}
class HalfPaperTexture : Texture
{
public HalfPaperTexture()
{
Console.WriteLine("HalfPaper Texture Created");
}
}
class Matrix : PatrixSceneFactory
{
public override Model CreateModel()
{
return new MatrixModel();
}
public override Texture CreateTexture()
{
return new MatrixTexture();
}
}
class MatrixModel : Model
{
public MatrixModel()
{
Console.WriteLine("Matrix Model Created");
}
public override void FillTexture(Texture texture)
{
Console.WriteLine("Matrix Model is filled Texture");
}
}
class MatrixTexture : Texture
{
public MatrixTexture()
{
Console.WriteLine("Matrix Texture Created");
}
}
}
代码说明
PatrixSceneFactory就是一个抽象工厂，它声明了创建抽象的场景以及抽象的纹理的接口。(广告时间：Patrix是我公司的一款休闲FPS游戏，详细请见http://www.qwd1.com)
Model和Texture是抽象产品。在Model类中有一个抽象方法，用于为模型填充纹理。
HalfPaper和Matrix是具体工厂，它用于创建某个场景的模型和纹理。(你可能对两个类的名字不太理解，其实HalfPaper和Matrix是两个地图的名字)
xxxModel和xxxTexture就是具体的产品了。它们就是针对某个场景的模型和纹理，具体工厂负责创建它们。
Patrix这个类负责加载场景，为了避免加载不同场景使用case语句，在这里我们使用反射来加载具体工厂类。
可以看到，一旦有了新的场景(或者说地图)，我们只需要设计新的xxxModel和xxxTexture以及具体工厂类就可以了，加载场景的那部分代码(也就是Patrix类)不需要做改动。
我们现在这个游戏可是不支持和电脑对战的，万一以后需要支持电脑了，那么场景中的元素除了纹理和模型之外就还需要加电脑了。也就是说抽象工厂还需要多生产一种类型的产品，这个时候抽象工厂就无能为力了。抽象工厂只能解决系列产品扩张的变化点(在我们的例子中就是地图的新增)，因此千万把抽象工厂所能生产的产品考虑周全了。
何时采用
从代码角度来说，你希望在统一的地方创建一系列相互关联的对象，并且基于抽象对象的时候。
从应用角度来说，如果你的产品是成组成套的，并且肯定会不断扩展新系列的，那么就适用抽象工厂。比如说，外面买的塑料模型，里面总是有图纸、模型元件板和外壳包装三部分。那么生产模型的厂就是抽象工厂，打印图纸、打印包装盒以及生产元件板的三个流水线就是具体工厂了。需要生产新的模型，只需要制作新的图纸输入到三个流水线的电脑中就可以了。
实现要点
抽象工厂本身不负责创建产品，产品最终还是由具体工厂来创建的。比如，MatrixModel是Matrix创建的，而不是PatrixSceneFactory创建的。在.NET中可以使用反射来创建具体工厂，从而使得代码变动降到最低。
在抽象工厂中需要体现出生产一系列产品。这一系列产品是相互关联，相互依赖一起使用的。
抽象工厂对应抽象产品，具体工厂对应具体产品，外部依赖抽象类型，这样对于新系列产品的创建，外部唯一依赖的就是具体工厂的创建过程(可以通过反射解决)。
注意事项
一般来说需要创建一系列对象的时候才考虑抽象工厂。比如，创建一个场景，需要创建模型和纹理，并且模型和纹理之间是有一定联系的，不太可能把PatrixTexture套用在MatrixModel上。
如果系统的变化点不在新系列的扩充上，那么就没有必要使用抽象工厂。比如，如果我们不会增加新地图的话，那么也就没有必要引入抽象工厂。
.NET中的抽象工厂
我们说过，抽象工厂针对系列产品的应变。在使用ADO.NET进行数据访问的时候，如果目标数据库是Access，我们会使用OleDbConnection、OleDbCommand以及OleDbDataAdapter等一系列ADO.NET对象。那么如果数据库是SQL Server，我们又会改用SqlConnection、SqlCommand以及SqlDataAdapter等一系列ADO.NET对象。如果只使用一套对象，没有什么大问题，如果我们的数据访问有系列变化的需求，比如可以针对Access和SQL Server，而且希望改换数据库尽量对客户端代码透明，那么就需要引入抽象工厂模式。
好在，ADO.NET 2.0中已经有了整套抽象工厂的类型。看下面的代码，你应该能辨别这些类型在抽象工厂中的角色：
public abstract class DbProviderFactory
{
// Methods
protected DbProviderFactory()
{
}
public virtual DbCommand CreateCommand()
{
return null;
}
public virtual DbCommandBuilder CreateCommandBuilder()
{
return null;
}
public virtual DbConnection CreateConnection()
{
return null;
}
public virtual DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return null;
}
public virtual DbDataAdapter CreateDataAdapter()
{
return null;
}
public virtual DbDataSourceEnumerator CreateDataSourceEnumerator()
{
return null;
}
public virtual DbParameter CreateParameter()
{
return null;
}
public virtual CodeAccessPermission CreatePermission(PermissionState state)
{
return null;
}
// Properties
public virtual bool CanCreateDataSourceEnumerator
{
get
{
return false;
}
}
}
public sealed class OleDbFactory : DbProviderFactory
{
// Fields
public static readonly OleDbFactory Instance = new OleDbFactory();
// Methods
private OleDbFactory()
{
}
public override DbCommand CreateCommand()
{
return new OleDbCommand();
}
public override DbCommandBuilder CreateCommandBuilder()
{
return new OleDbCommandBuilder();
}
public override DbConnection CreateConnection()
{
return new OleDbConnection();
}
public override DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return new OleDbConnectionStringBuilder();
}
public override DbDataAdapter CreateDataAdapter()
{
return new OleDbDataAdapter();
}
public override DbParameter CreateParameter()
{
return new OleDbParameter();
}
public override CodeAccessPermission CreatePermission(PermissionState state)
{
return new OleDbPermission(state);
}
}
public sealed class SqlClientFactory : DbProviderFactory, IServiceProvider
{
// Fields
public static readonly SqlClientFactory Instance = new SqlClientFactory();
// Methods
private SqlClientFactory()
{
}
public override DbCommand CreateCommand()
{
return new SqlCommand();
}
public override DbCommandBuilder CreateCommandBuilder()
{
return new SqlCommandBuilder();
}
public override DbConnection CreateConnection()
{
return new SqlConnection();
}
public override DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return new SqlConnectionStringBuilder();
}
public override DbDataAdapter CreateDataAdapter()
{
return new SqlDataAdapter();
}
public override DbDataSourceEnumerator CreateDataSourceEnumerator()
{
return SqlDataSourceEnumerator.Instance;
}
public override DbParameter CreateParameter()
{
return new SqlParameter();
}
public override CodeAccessPermission CreatePermission(PermissionState state)
{
return new SqlClientPermission(state);
}
object IServiceProvider.GetService(Type serviceType)
{
object obj2 = null;
if (serviceType == GreenMethods.SystemDataCommonDbProviderServices_Type)
{
obj2 = GreenMethods.SystemDataSqlClientSqlProviderServices_Instance();
}
return obj2;
}
// Properties
public override bool CanCreateDataSourceEnumerator
{
get
{
return true;
}
}
}
C#设计模式之二：Singleton
本系列文章将向大家介绍一下C#的设计模式，此为第二篇文章，相信对大家会有所帮助的。废话不多说，继续来看。
意图
保证一个类只有一个实例，并提供访问它的全局访问点。
场景
我们现在要做一个网络游戏的服务端程序，需要考虑怎么样才能承载大量的用户。在做WEB程序的时候有各种负载均衡的方案，不管是通过硬件实现还是软件实现，基本的思想就是有一个统一的入口，然后由它来分配用户到各个服务器上去。
需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入了Singleton模式来实现这个唯一的入口。
示例代码
using System;
using System.Collections.Generic;
using System.Threading;
namespace SingletonExample
{
class Program
{
static void Main(string[] args)
{
ParameterizedThreadStart ts = new ParameterizedThreadStart(EnterPlayer);
for (int i = 0; i < 20; i++)
{
Thread t = new Thread(ts);
t.Start("player" + i);
}
LoadBalanceServer.GetLoadBalanceServer().ShowServerInfo();
}
static void EnterPlayer(object playerName)
{
LoadBalanceServer lbs = LoadBalanceServer.GetLoadBalanceServer();
lbs.GetLobbyServer().EnterPlayer(playerName.ToString());
}
}
class LoadBalanceServer
{
private const int SERVER_COUNT = 3;
private List serverList = new List();
private static volatile LoadBalanceServer lbs;
private static object syncLock = new object();
public LoadBalanceServer()
{
for (int i = 0; i < SERVER_COUNT; i++)
{
serverList.Add(new LobbyServer("LobbyServer" + i));
}
}
public static LoadBalanceServer GetLoadBalanceServer()
{
if (lbs == null)
{
lock (syncLock)
{
if (lbs == null)
{
Thread.Sleep(100);
lbs = new LoadBalanceServer();
}
}
}
return lbs;
}
public LobbyServer GetLobbyServer()
{
LobbyServer ls = serverList[0];
for (int i = 1; i < SERVER_COUNT; i++)
{
if (serverList[i].PlayerList.Count < ls.PlayerList.Count)
ls = serverList[i];
}
return ls;
}
public void ShowServerInfo()
{
foreach (LobbyServer ls in serverList)
{
Console.WriteLine("=================" + ls.ServerName + "=================");
foreach (string player in ls.PlayerList)
{
Console.WriteLine(player);
}
}
}
}
class LobbyServer
{
private List playerList = new List();
public List PlayerList
{
get { return playerList; }
}
private string serverName;
public string ServerName
{
get { return serverName; }
}
public LobbyServer(string serverName)
{
this.serverName = serverName;
}
public void EnterPlayer(string playerName)
{
playerList.Add(playerName);
}
}
}
代码执行结果如下图：
代码说明
LoadBalanceServer类实现了Singleton模式，也就是说无论在什么情况下，只会有一个LoadBalanceServer类的实例出现。
LobbyServer类表示大厅服务，用户进入大厅后和大厅服务进行服务，在这里我们仅仅在大厅服务里面保存了用户列表。
Singleton模式有很多实现方式，在这里使用的是双重锁定方式。对于C#来说，可能使用静态初始化方式是最简洁的，这里就不演示了。
LoadBalanceServer类的GetLobbyServer()方法负责返回一个压力最小的LobbyServer对象。
实例化LoadBalanceServer的时候Sleep了线程，目的是模拟高并发的情况，在正式代码中没有必要这样做。
何时采用
从代码角度来说，当你希望类只有一个实例的时候。
从应用角度来说，你希望有一个总管来负责某一件事情。并且这件事情的分配只能有一个人进行，如果有多个人进行肯定会弄乱。比如创建处理流水号如果有两个地方在创建的话是不是就会重复了呢?
实现要点
一个Singleton类，它能确保自身的实例是唯一的。
注意事项
不要滥用Singleton模式，只有非一个实例不可的情况下才考虑引入Singleton。否则，程序的可扩展性可能会受到限制。
意图
保证一个类只有一个实例，并提供访问它的全局访问点。
场景
我们现在要做一个网络游戏的服务端程序，需要考虑怎么样才能承载大量的用户。在做WEB程序的时候有各种负载均衡的方案，不管是通过硬件实现还是软件实现，基本的思想就是有一个统一的入口，然后由它来分配用户到各个服务器上去。
需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入了Singleton模式来实现这个唯一的入口。
示例代码
using System;
using System.Collections.Generic;
using System.Threading;
namespace SingletonExample
{
class Program
{
static void Main(string[] args)
{
ParameterizedThreadStart ts = new ParameterizedThreadStart(EnterPlayer);
for (int i = 0; i < 20; i++)
{
Thread t = new Thread(ts);
t.Start("player" + i);
}
LoadBalanceServer.GetLoadBalanceServer().ShowServerInfo();
}
static void EnterPlayer(object playerName)
{
LoadBalanceServer lbs = LoadBalanceServer.GetLoadBalanceServer();
lbs.GetLobbyServer().EnterPlayer(playerName.ToString());
}
}
class LoadBalanceServer
{
private const int SERVER_COUNT = 3;
private List serverList = new List();
private static volatile LoadBalanceServer lbs;
private static object syncLock = new object();
public LoadBalanceServer()
{
for (int i = 0; i < SERVER_COUNT; i++)
{
serverList.Add(new LobbyServer("LobbyServer" + i));
}
}
public static LoadBalanceServer GetLoadBalanceServer()
{
if (lbs == null)
{
lock (syncLock)
{
if (lbs == null)
{
Thread.Sleep(100);
lbs = new LoadBalanceServer();
}
}
}
return lbs;
}
public LobbyServer GetLobbyServer()
{
LobbyServer ls = serverList[0];
for (int i = 1; i < SERVER_COUNT; i++)
{
if (serverList[i].PlayerList.Count < ls.PlayerList.Count)
ls = serverList[i];
}
return ls;
}
public void ShowServerInfo()
{
foreach (LobbyServer ls in serverList)
{
Console.WriteLine("=================" + ls.ServerName + "=================");
foreach (string player in ls.PlayerList)
{
Console.WriteLine(player);
}
}
}
}
class LobbyServer
{
private List playerList = new List();
public List PlayerList
{
get { return playerList; }
}
private string serverName;
public string ServerName
{
get { return serverName; }
}
public LobbyServer(string serverName)
{
this.serverName = serverName;
}
public void EnterPlayer(string playerName)
{
playerList.Add(playerName);
}
}
}
代码执行结果如下图：
代码说明
LoadBalanceServer类实现了Singleton模式，也就是说无论在什么情况下，只会有一个LoadBalanceServer类的实例出现。
LobbyServer类表示大厅服务，用户进入大厅后和大厅服务进行服务，在这里我们仅仅在大厅服务里面保存了用户列表。
Singleton模式有很多实现方式，在这里使用的是双重锁定方式。对于C#来说，可能使用静态初始化方式是最简洁的，这里就不演示了。
LoadBalanceServer类的GetLobbyServer()方法负责返回一个压力最小的LobbyServer对象。
实例化LoadBalanceServer的时候Sleep了线程，目的是模拟高并发的情况，在正式代码中没有必要这样做。
何时采用
从代码角度来说，当你希望类只有一个实例的时候。
从应用角度来说，你希望有一个总管来负责某一件事情。并且这件事情的分配只能有一个人进行，如果有多个人进行肯定会弄乱。比如创建处理流水号如果有两个地方在创建的话是不是就会重复了呢?
实现要点
一个Singleton类，它能确保自身的实例是唯一的。
注意事项
不要滥用Singleton模式，只有非一个实例不可的情况下才考虑引入Singleton。否则，程序的可扩展性可能会受到限制。
C#设计模式之一：开篇
本系列文章将向大家介绍一下C#的设计模式，此为第一篇文章，相信对大家会有所帮助的。废话不多说，接下来就开始吧。
什么是设计模式?
什么是少林拳呢?少林拳是少林僧人经过长期的总结，得出的一套武功套路。有一本叫做少林拳法的武功秘籍，上面记载这这套拳法的适用人群，打法套路和学成后的效果。设计模式虽然记录在了设计模式一书上，但是要真正掌握设计模式光靠看每一个模式的结构并且进行模仿是不够的。试想一下，在真枪实战的情况下，谁会和你按照少林拳法，一二三四的套路打呢?打套路也只能用来看看，只有当你能根据不同的场景灵活出招的时候才能说是学会了这套拳法。相似的例子还有三十六计，这也是一种模式，每种计谋都是针对不同场景的，如果不管遇到什么时候都来个“走为上”，那这仗还怎么打呢?
总之，设计模式要用活才能发挥作用。
设计模式有什么用?
设计模式可以让你在遇到需求变化的时候不至于手忙脚乱。设计模式可以让你程序的可维护性、可扩展性更好。设计模式可以让程序的性能更高。当然，这些的前提是正确使用了设计模式，如果滥用的话那么设计模式可以让程序没人看得懂，让程序速度慢到死，让程序不能维护，添加新的功能等于重做。
设计模式的原则?
单一职责：你不希望因为电脑内存损坏而更换CPU吧，同样也不应该让一个类有多种修改的理由。
对扩展开放，对修改封闭：你一定不希望电脑只有一个内存槽，加内存就要换主板吧，程序也应该能在不修改原先程序的情况下就能扩展功能。
里氏替换：如果你买的DX9显卡不支持DX9特性，那么这个显卡一定没法用。如果父类的方法在子类中没有实现那就晕了。在程序的世界中千万别认为鸟都会飞，先考虑清楚将会有哪些鸟吧。
依赖倒置：针对接口编程，这样即使实现有变也不需要修改外部代码。其实，现在电脑的硬件、网络通讯等都是符合这个原则的，比如USB接口、PCI-E接口、TCP/IP协议。
接口隔离：花3000买一个带拍照、听MP3功能的手机还是花1000买一个手机、1000买一个MP3、1000买一个数码相机呢?买了前者的话手机动不动就要修，而且还不一定是因为不能打电话而修，买了后面三样的话即使修也不影响其它使用，你说买哪个?
记得看过一个例子很恰当，说是修电脑比修收音机简单多了。电脑坏了，更换一个零件即可，原因是电脑中的各部分都是基于相对稳定的接口，而且部件各司其职，不会相互影响，电脑本身就是一个非常符合设计原则的产品。收音机的修理没有这么简单了，没有什么部件是插件式的，会修收音机的人肯定明白其中每一个部件的原理。
小程序就好像收音机，确实可以这么做，一共才一个人做的，即使重新做也用不了多少时间。几十个人的大项目如果要改一个需求需要牵涉所有人来修改，那么这个项目用不了多少时间就会因为维护成本太大，维护后BUG太多而报废。
怎样学习设计模式?
学习新概念英文要什么基础?首先，要知道26个字母吧。如果你对面向对象完全没有概念的话，建议先可以看一下面向对象的一些知识。毕竟，设计模式是面向对象编程模式的一种总结。学了26个字母你就可以学习新概念了，但是，为了能更好地学习最好是先学一下国际音标。对于设计模式的学习来说，你可以学习一下UML的一些知识。当然，完全不知道UML也可以学习设计模式，在学习的过程中慢慢也就会UML了。
设计模式不是什么很高深的东西，有了这些知识大胆地学习吧。很多人说，看了很多设计模式的文章，为什么就是看不懂呢?我觉得原因可能有两个，第一就是你没有花时间认真看，第二就是看的文章不适合作为切入点。不管学习什么，切入点非常重要，如果切入点不是那么平易近人的话很可能会把你拒之门外，对于初学者来说从实例切入最合适。最好是能碰到自己做过的项目的实例作为切入点，这样你一比较就知道为什么设计模式好了。
如果要把设计模式的学习境界分一下级的话，我这么分：
第一重：能看懂设计模式的文章
第二重：能自己写一个设计模式的骨架
第三重：能自己编一个新的运用设计模式的例子
第四重：能在写代码的时候想到似乎有设计模式适合，在翻阅资料后找到了这种设计模式
第五重：在理解项目的需求后就能意识到哪里可以使用哪种设计模式进行优化
第六重：完全掌握了设计模式的精髓，灵活使用各种设计模式以及其变种
不管怎么样，多看多做多替换才是学习的办法，别人举例十个都不及自己做一个例子，被动十个原则都不及自己体会出一个原则。每一种设计模式虽然都有一个骨架，但是也不必过于强调这个形式，很多时候根据自己的需求简化一点，改变一点，或者混杂一些其它的设计模式，只要能实现目的了，也是一个不错的选择。
很多人会觉得这么多种设计模式没有几种能用得上。我觉得这不是什么问题，用不上那就用不上，这些设计模式是大师经历无数大型项目后的精华，如果能在自己做的一个小项目中用上两三个就很不错了，用上二三十个的项目绝对是怪胎。用不上千万别强求，否则既不利于项目的可维护性又增加了工作量。
还有很多人会觉得这些设计模式很多都是相似的。而且每个人的感觉还不一样，有人觉得A和B很相似，有人却觉得A和B很好区分，但是B和C却很相似啊。感觉很好区分，说明你看准设计模式的着重点的，感觉一样说明你看到的还是它的形。双胞胎虽然形一样，但是神肯定不一样的，只要认准设计模式解决的问题，就不会看错。
关于本系列文章
本来这些内容都是用来进行公司内部每周知识分享活动的，既然有一些内容了，想想不妨就整理一下贴出来吧。也正由于这个原因，文章中的一些例子都基于团队内部成员所能理解的一些项目，可能这些项目对大家来说比较陌生，不过好处是例子相对比较贴近实际一点。本系列一共有20篇左右，除了介绍23种GOF设计模式中常用的一部分之外(一些设计模式的思想在C#语言中有了更简单的实现，一些设计模式不是很常用)还可能会介绍一些其它有用的设计模式。在这些文章中，我不会过多去说一些理论上的东西，也不会有结构图(这些内容网上到处都是)，所有的内容都是围绕相对实际例子展开。我想，只有这样才能更快的吸收设计模式的神而不是其形。在看文章的时候建议你结合《设计模式》一书以及博客园的其它设计模式相关文章一起看，这样才能对设计模式理解的全面和充分一点。
每一篇文章都会有以下部分：
意图：抄设计模式一书的，因为意图实在是太重要，所以不得不首先列出。
场景：以一个实际的场景来说明为什么要引入设计模式。
示例代码：对引入设计模式后场景的说明。
代码说明：说明设计模式中的几个角色以及代码中需要注意的地方。
何时采用：从代码和应用两个角度说明何时采用这个模式。
实现要点：实现这种模式必要的几个地方，或者说模式主要的特点在哪里。
注意事项：模式的优点缺点以及什么时候不应该使用设计模式。
什么是设计模式?
什么是少林拳呢?少林拳是少林僧人经过长期的总结，得出的一套武功套路。有一本叫做少林拳法的武功秘籍，上面记载这这套拳法的适用人群，打法套路和学成后的效果。设计模式虽然记录在了设计模式一书上，但是要真正掌握设计模式光靠看每一个模式的结构并且进行模仿是不够的。试想一下，在真枪实战的情况下，谁会和你按照少林拳法，一二三四的套路打呢?打套路也只能用来看看，只有当你能根据不同的场景灵活出招的时候才能说是学会了这套拳法。相似的例子还有三十六计，这也是一种模式，每种计谋都是针对不同场景的，如果不管遇到什么时候都来个“走为上”，那这仗还怎么打呢?
总之，设计模式要用活才能发挥作用。
设计模式有什么用?
设计模式可以让你在遇到需求变化的时候不至于手忙脚乱。设计模式可以让你程序的可维护性、可扩展性更好。设计模式可以让程序的性能更高。当然，这些的前提是正确使用了设计模式，如果滥用的话那么设计模式可以让程序没人看得懂，让程序速度慢到死，让程序不能维护，添加新的功能等于重做。
设计模式的原则?
单一职责：你不希望因为电脑内存损坏而更换CPU吧，同样也不应该让一个类有多种修改的理由。
对扩展开放，对修改封闭：你一定不希望电脑只有一个内存槽，加内存就要换主板吧，程序也应该能在不修改原先程序的情况下就能扩展功能。
里氏替换：如果你买的DX9显卡不支持DX9特性，那么这个显卡一定没法用。如果父类的方法在子类中没有实现那就晕了。在程序的世界中千万别认为鸟都会飞，先考虑清楚将会有哪些鸟吧。
依赖倒置：针对接口编程，这样即使实现有变也不需要修改外部代码。其实，现在电脑的硬件、网络通讯等都是符合这个原则的，比如USB接口、PCI-E接口、TCP/IP协议。
接口隔离：花3000买一个带拍照、听MP3功能的手机还是花1000买一个手机、1000买一个MP3、1000买一个数码相机呢?买了前者的话手机动不动就要修，而且还不一定是因为不能打电话而修，买了后面三样的话即使修也不影响其它使用，你说买哪个?
记得看过一个例子很恰当，说是修电脑比修收音机简单多了。电脑坏了，更换一个零件即可，原因是电脑中的各部分都是基于相对稳定的接口，而且部件各司其职，不会相互影响，电脑本身就是一个非常符合设计原则的产品。收音机的修理没有这么简单了，没有什么部件是插件式的，会修收音机的人肯定明白其中每一个部件的原理。
小程序就好像收音机，确实可以这么做，一共才一个人做的，即使重新做也用不了多少时间。几十个人的大项目如果要改一个需求需要牵涉所有人来修改，那么这个项目用不了多少时间就会因为维护成本太大，维护后BUG太多而报废。
怎样学习设计模式?
学习新概念英文要什么基础?首先，要知道26个字母吧。如果你对面向对象完全没有概念的话，建议先可以看一下面向对象的一些知识。毕竟，设计模式是面向对象编程模式的一种总结。学了26个字母你就可以学习新概念了，但是，为了能更好地学习最好是先学一下国际音标。对于设计模式的学习来说，你可以学习一下UML的一些知识。当然，完全不知道UML也可以学习设计模式，在学习的过程中慢慢也就会UML了。
设计模式不是什么很高深的东西，有了这些知识大胆地学习吧。很多人说，看了很多设计模式的文章，为什么就是看不懂呢?我觉得原因可能有两个，第一就是你没有花时间认真看，第二就是看的文章不适合作为切入点。不管学习什么，切入点非常重要，如果切入点不是那么平易近人的话很可能会把你拒之门外，对于初学者来说从实例切入最合适。最好是能碰到自己做过的项目的实例作为切入点，这样你一比较就知道为什么设计模式好了。
如果要把设计模式的学习境界分一下级的话，我这么分：
第一重：能看懂设计模式的文章
第二重：能自己写一个设计模式的骨架
第三重：能自己编一个新的运用设计模式的例子
第四重：能在写代码的时候想到似乎有设计模式适合，在翻阅资料后找到了这种设计模式
第五重：在理解项目的需求后就能意识到哪里可以使用哪种设计模式进行优化
第六重：完全掌握了设计模式的精髓，灵活使用各种设计模式以及其变种
不管怎么样，多看多做多替换才是学习的办法，别人举例十个都不及自己做一个例子，被动十个原则都不及自己体会出一个原则。每一种设计模式虽然都有一个骨架，但是也不必过于强调这个形式，很多时候根据自己的需求简化一点，改变一点，或者混杂一些其它的设计模式，只要能实现目的了，也是一个不错的选择。
很多人会觉得这么多种设计模式没有几种能用得上。我觉得这不是什么问题，用不上那就用不上，这些设计模式是大师经历无数大型项目后的精华，如果能在自己做的一个小项目中用上两三个就很不错了，用上二三十个的项目绝对是怪胎。用不上千万别强求，否则既不利于项目的可维护性又增加了工作量。
还有很多人会觉得这些设计模式很多都是相似的。而且每个人的感觉还不一样，有人觉得A和B很相似，有人却觉得A和B很好区分，但是B和C却很相似啊。感觉很好区分，说明你看准设计模式的着重点的，感觉一样说明你看到的还是它的形。双胞胎虽然形一样，但是神肯定不一样的，只要认准设计模式解决的问题，就不会看错。
关于本系列文章
本来这些内容都是用来进行公司内部每周知识分享活动的，既然有一些内容了，想想不妨就整理一下贴出来吧。也正由于这个原因，文章中的一些例子都基于团队内部成员所能理解的一些项目，可能这些项目对大家来说比较陌生，不过好处是例子相对比较贴近实际一点。本系列一共有20篇左右，除了介绍23种GOF设计模式中常用的一部分之外(一些设计模式的思想在C#语言中有了更简单的实现，一些设计模式不是很常用)还可能会介绍一些其它有用的设计模式。在这些文章中，我不会过多去说一些理论上的东西，也不会有结构图(这些内容网上到处都是)，所有的内容都是围绕相对实际例子展开。我想，只有这样才能更快的吸收设计模式的神而不是其形。在看文章的时候建议你结合《设计模式》一书以及博客园的其它设计模式相关文章一起看，这样才能对设计模式理解的全面和充分一点。
每一篇文章都会有以下部分：
意图：抄设计模式一书的，因为意图实在是太重要，所以不得不首先列出。
场景：以一个实际的场景来说明为什么要引入设计模式。
示例代码：对引入设计模式后场景的说明。
代码说明：说明设计模式中的几个角色以及代码中需要注意的地方。
何时采用：从代码和应用两个角度说明何时采用这个模式。
实现要点：实现这种模式必要的几个地方，或者说模式主要的特点在哪里。
注意事项：模式的优点缺点以及什么时候不应该使用设计模式。
2008年9月12日星期五
你必须学习的10项.NET技术.
当然对于这个问题，每个人都有自己的想法。以下只是作为我个人认为比较重要的10项需要学习的技术：1.WCF （Windows Communication Foundation）：虽然WCF显然没有WPF或SilverLight那么吸引人，但是它却是在。NET框架下解决业务问题的基础。所以你今年至少要学习一门。NET的新技术，那你就选择WCF吧。
2.ADO.NET （and LINQ）：这是让你与数据层打交道的技术。并且LINQ提供了将各种数据组合起来的方法。如果以上两个技术你都不熟悉的话，那就等着被人来抢你饭碗吧。
3.WPF （Windows Presentation Foundation）：学习WPF的重要性简直不言而喻。你在程序中所需要的窗体、交互界面、页面都是架构在WPF上的。并且在Vista中已经集成了WPF. 4.SQL Server 2005：我明白这其实并不是。NET的内容，但它又确实是。NET的内容。SQL Server 2005为开发者提供了一种在其他平台无法得到的强大力量。你得仔细挖掘这个版本所带来的创新技术，这将帮助你成为一个更好的开发者和问题解决者。
5.ASP.NET 2.0：即使是非在线程序开发者也应该了解一下这个技术。这代表着最新的概念——动态语言。LINQ，AJAX等崭新的技术都集成在其中（当然，最吸引人的当然是SilverLight！）。
6.安全：关于这点，我只提一句话：安全顾问专家的薪资已经提高到每小时300美元了。
7.TDD （Test Driven Development）：为了检验你的程序是否正确，你总得测试一下。而如何测试则是一门学问。好好学习测试的学问吧。
8.Networking：网络部分的基础知识当然都得复习一下，TCP，UDP，HTTP，FTP，等等协议。学习这些将能让你更容易的将各个程序与数据结合起来。并且让你的程序效率更高。
9.Threading：对于线程的理解将直接决定你的。NET开发水平。你得多学习一下线程相关知识，知道他们是干什么用、并且怎么用在你的程序里的。
10.Learning：对，我将学习定义为一项技术。人们得学会如何学习，并且选择学习什么。这样你才能前进得更快
2.ADO.NET （and LINQ）：这是让你与数据层打交道的技术。并且LINQ提供了将各种数据组合起来的方法。如果以上两个技术你都不熟悉的话，那就等着被人来抢你饭碗吧。
3.WPF （Windows Presentation Foundation）：学习WPF的重要性简直不言而喻。你在程序中所需要的窗体、交互界面、页面都是架构在WPF上的。并且在Vista中已经集成了WPF. 4.SQL Server 2005：我明白这其实并不是。NET的内容，但它又确实是。NET的内容。SQL Server 2005为开发者提供了一种在其他平台无法得到的强大力量。你得仔细挖掘这个版本所带来的创新技术，这将帮助你成为一个更好的开发者和问题解决者。
5.ASP.NET 2.0：即使是非在线程序开发者也应该了解一下这个技术。这代表着最新的概念——动态语言。LINQ，AJAX等崭新的技术都集成在其中（当然，最吸引人的当然是SilverLight！）。
6.安全：关于这点，我只提一句话：安全顾问专家的薪资已经提高到每小时300美元了。
7.TDD （Test Driven Development）：为了检验你的程序是否正确，你总得测试一下。而如何测试则是一门学问。好好学习测试的学问吧。
8.Networking：网络部分的基础知识当然都得复习一下，TCP，UDP，HTTP，FTP，等等协议。学习这些将能让你更容易的将各个程序与数据结合起来。并且让你的程序效率更高。
9.Threading：对于线程的理解将直接决定你的。NET开发水平。你得多学习一下线程相关知识，知道他们是干什么用、并且怎么用在你的程序里的。
10.Learning：对，我将学习定义为一项技术。人们得学会如何学习，并且选择学习什么。这样你才能前进得更快
2008年9月11日星期四
利用Visual C#实现任务栏通知窗口
想必大部分网友都使用过QQ、MSN等聊天程序，它们的界面都相当华丽，尤其是当网友上线以及消息提示时会有一个浮动的窗体从屏幕的右下方缓慢升起，既美观又人性化，作为程序员在享受的同时我们也不禁要问：这到底是怎么实现的呢？本文就利用Visual Studio .Net C# 2005以及.Net框架绘图技术来实现这种任务栏通知窗口。
简介
QQ和MSN的任务栏通知窗口很人性化，它可以在不丢失主窗体焦点的前提下显示一个具备皮肤Skin的通知窗体，当它显示一段时间后会自动消失，所以用户根本不用干预它。这样的通知窗体和一般的具备标题栏、系统图标和按钮的窗体没有太大的区别，窗体表面其实就是画上去的一张位图而已，而窗体的浮动则会复杂一点，我们会用到.Net框架的双重缓冲区绘图技术（参见作者编译文章"Windows 窗体的.Net框架绘图技术"）来保证移动窗体时所显示的内容平滑且不闪烁，以及使用P/Invoke平台调用进行对Win32API函数的调用来完成不获得焦点的窗体显示和非标题栏窗体拖动。两种位图的皮肤运行时的界面如下：
背景知识
通知窗口就是将一般的窗体附加上一层皮肤，这里所谓的皮肤就是一张位图图片，该位图图片通过窗体的OnPaintbackground事件被绘制到窗体表面，在附加位图之前需要调整窗体的可视属性，由于绘制操作是针对于窗体客户区域的，所谓客户区域就是指窗体标题栏下方以及窗体边框以内的所有区域，所以需要将窗体的边框和外观属性 FormBorderStyle调整为：None，这样所绘制的图像就会填充整个窗体。
首先，我们会用到Region对象，Region对象可以精确的描绘出任意形状的轮廓范围，通过一个位图图像创建Region对象后再将其传递给窗体的Region属性就可以使窗体按照Region所定义的轮廓显示出来。作为皮肤使用的位图文件可以通过任何图像编辑软件诸如：Photeshop来创建和编辑，只是注意一点，需要将图片的背景色调成特定颜色以便程序绘制时将其清除，我们在这里使用的背景色为粉红色。为了能够让Region对象按照图像中感兴趣的内容边框来创建窗体，我们还需要使用GraphicsPath类将图像轮廓按照一定路径标注下来，稍后便按照该路径创建Region对象。
然后通过窗体的绘图事件将位图的内容显示在窗体表面，我们没有直接使用OnPaintbackground事件而是重载了该方法，这样做的好处就是一些低层的绘制操作还继续交由.Net框架运行时来处理，我们只考虑实际需要的绘制操作即可。在OnPaintbackground方法中我们启用了双重缓冲区绘图技术，所谓该技术就是指先在内存中的一块画布上把将要显示的图像显示出来或进行处理，等到操作完成再将该画布上所显示的图像放置到窗体表面，这样的机制可以非常有效的降低闪烁的出现，使图像显示更加平滑。通知窗体从屏幕的右下方进行升起停留一段时间后再慢慢回落，这里需要用到返回屏幕区域的大小范围的.Net框架方法 Screen.GetWorkingArea(WorkAreaRectangle)，通过一定算法计算出通知窗体显示前的初始位置。最后，我们将要显示的文本按照一定格式和Rectangle对象所指定的区域范围绘制到窗体表面。通知窗体的关闭操作是通过设定一个区域，当用户用鼠标单击时检测单击坐标是否在该区域内，若在区域内就可以执行隐藏通知窗体的代码。
我们注意了，当QQ和MSN的通知窗口显示时其主窗体的焦点没有丢失，也就是说程序没有将自身的焦点转移到显示的通知窗体上。经过测试，我们无论怎么样调用.Net框架提供的窗体显示例程譬如：Form.Show都无法保证主窗体的焦点不丢失，在VC环境下我们可以使用Win32API的ShowWindows函数来完成复杂的窗体显示操作，但是.Net框架根本没有提供类似的方法，那么我们能否通过.Net框架调用该API函数来显示窗体呢？幸好.Net框架提供了P/Invoke平台调用，利用平台调用这种服务，托管代码就可以调用在动态链接库中实现的非托管函数，并可以封送其参数，我们可以轻松的显示但不获得焦点的窗体。程序中用到的Windows API以及常量的定义都保存在WinUser.h头文件中，其对应的动态链接库文件就是user32.dll，使用.Net框架提供的DllImportAttribute类对导入的函数进行定义，然后就可以非常方便的在程序中调用该函数了。
由于我们将通知窗体的标题栏隐藏了，所以对窗体拖动操作还需要我们自己动手进行处理。本文介绍了如何更加高效的进行拖动窗体操作，有些网友在对于非标题栏拖动窗体编程时偏向组合使用鼠标事件来进行，这样做的本质没有任何不妥，但是频繁的事件响应和处理反而使程序性能有所降低。我们将继续使用Win32API的底层处理方法来解决该问题，就是向窗体发送标题栏被单击的消息，模拟实际的拖动操作。
我们会通过2个计时器来完成窗体的显示、停留和隐藏，通过设置速度变量可以改变窗口显示和隐藏的速度。
启动Visual Studio .Net 2005，创建C# Windows 窗体应用程序，将解决方案命名为TaskbarForm，包含的项目名也为TaskbarForm，首先创建程序的主窗体Form1，在上面添加两个Button控件，一个用于显示通知窗体，另一个则终止程序。然后在解决方案管理器中右击项目，单击"添加 - Windows 窗体"，我们把新创建的窗体命名为TaskbarForm。
在类TaskbarForm定义的下方，我们创建用于显示的字符串和其颜色的变量，再定义几个Rectangle对象的变量用于放置标题、提示内容以及可以拖动窗体的区域和关闭按钮的区域。然后，我们需要保存窗体在浮动时的高度以便计算移动后的新高度，intervalValue变量用来确定窗体显示和隐藏的速度。进行平台调用时我们需要提前定义好常量的值用来传递给函数，WM_NCLBUTTONDOWN和HT_CAPTION常量用于拖动窗体，他们的值都保存在WinUser.h头文件中，所对应的动态链接库名为：user32.dll。我们用到的Win32API为：SendMessage、ReleaseCapture和ShowWindow，通过使用DllImportAttribute可以导入相应的函数并在程序中重新进行定义，如下：
[DllImportAttribute("user32.dll")]
public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);
//发送消息//winuser.h 中有函数原型定义
[DllImportAttribute("user32.dll")]
public static extern bool ReleaseCapture(); //释放鼠标捕捉winuser.h
[DllImportAttribute("user32.dll")] //winuser.h
private static extern Boolean ShowWindow(IntPtr hWnd, Int32 nCmdShow);
SendMessage向消息循环发送标题栏被按下的消息来模拟窗体的拖动，ShowWindow用来将特定句柄的窗体显示出来，注意第二个参数nCmdShow，它表示窗体应该怎样显示出来，而我们需要窗体不获得焦点显示出来，SW_SHOWNOACTIVATE可以满足我们要求，继续在WinUser.h文件中搜索找到该常量对应的值为4，于是我们就可以这样调用来显示窗体了：
ShowWindow(this.Handle, 4);
我们创建了一个自定义函数ShowForm用来封装上面的ShowWindow用来是显示窗体，同时传递了所用到的几个Rectangle矩形区域对象，最后调用ShowWindows函数将窗体显示出来，代码片段如下：
public void ShowForm(string ftitletext, string fcontenttext, Rectangle fRegionofFormTitle, Rectangle fRegionofFormTitlebar, Rectangle fRegionofFormContent, Rectangle fRegionofCloseBtn)
{
titleText = ftitletext;
contentText = fcontenttext;
WorkAreaRectangle = Screen.GetWorkingArea(WorkAreaRectangle);
this.Top = WorkAreaRectangle.Height + this.Height;
FormBorderStyle = FormBorderStyle.None;
WindowState = FormWindowState.Normal;
this.SetBounds(WorkAreaRectangle.Width - this.Width, WorkAreaRectangle.Height - currentTop, this.Width, this.Height);
CurrentState = 1;
timer1.Enabled = true;
TitleRectangle = fRegionofFormTitle;
TitlebarRectangle = fRegionofFormTitlebar;
ContentRectangle = fRegionofFormContent;
CloseBtnRectangle = fRegionofCloseBtn;
ShowWindow(this.Handle, 4); //#define SW_SHOWNOACTIVATE 4
}
CurrentState变量表示窗体的状态是显示中、停留中还是隐藏中，两个计时器根据窗体不同状态对窗体的位置进行更改，我们会使用SetBounds来执行该操作：
this.SetBounds(WorkAreaRectangle.Width - this.Width, WorkAreaRectangle.Height - currentTop, this.Width, this.Height);
当窗体需要升起时将窗体的Top属性值不断减少，而窗体回落时将Top属性值增加并超过屏幕的高度窗体就消失了，虽然原理很简单但仍需精确控制。
SetBackgroundBitmap函数首先将窗体背景图像保存到BackgroundBitmap变量中，然后根据该位图图像轮廓和透明色创建Region，BitmapToRegion就用于完成Bitmap到Region的转换，程序再将这个Region付值给窗体的Region属性以完成不规则窗体的创建。
public void SetBackgroundBitmap(Image image, Color transparencyColor)
{
BackgroundBitmap = new Bitmap(image);
Width = BackgroundBitmap.Width;
Height = BackgroundBitmap.Height;
Region = BitmapToRegion(BackgroundBitmap, transparencyColor);
}
public Region BitmapToRegion(Bitmap bitmap, Color transparencyColor)
{
if (bitmap == null)
throw new ArgumentNullException("Bitmap", "Bitmap cannot be null!");
int height = bitmap.Height;
int width = bitmap.Width;
GraphicsPath path = new GraphicsPath();
for (int j = 0; j < height; j++)
for (int i = 0; i < width; i++)
{
if (bitmap.GetPixel(i, j) == transparencyColor)
continue;
int x0 = i;
while ((i < width) && (bitmap.GetPixel(i, j) != transparencyColor))
i++;
path.AddRectangle(new Rectangle(x0, j, i - x0, 1));
}
Region region = new Region(path);
path.Dispose();
return region;
}
通知窗体背景以及文字的绘制在重载的OnPaintBackground方法中完成，而且利用了双重缓冲区技术来进行绘制操作，代码如下：
protected override void OnPaintBackground(PaintEventArgs e)
{
Graphics grfx = e.Graphics;
grfx.PageUnit = GraphicsUnit.Pixel;
Graphics offScreenGraphics;
Bitmap offscreenBitmap;
offscreenBitmap = new Bitmap(BackgroundBitmap.Width, BackgroundBitmap.Height);
offScreenGraphics = Graphics.FromImage(offscreenBitmap);
if (BackgroundBitmap != null)
{
offScreenGraphics.DrawImage(BackgroundBitmap, 0, 0, BackgroundBitmap.Width, BackgroundBitmap.Height);
}
DrawText(offScreenGraphics);
grfx.DrawImage(offscreenBitmap, 0, 0);
}
上述代码首先返回窗体绘制表面的Graphics并保存在变量grfx中，然后创建一个内存Graphics对象offScreenGraphics和内存位图对象offscreenBitmap，将内存位图对象的引用付值给offScreenGraphics，这样所有对offScreenGraphics的绘制操作也都同时作用于offscreenBitmap，这时就将需要绘制到通知窗体表面的背景图像BackgroundBitmap绘制到内存的Graphics对象上，DrawText函数根据需要显示文字的大小和范围调用Graphics.DrawString将文字显示在窗体的特定区域。最后，调用Graphics.DrawImage将内存中已经绘制完成的图像显示到通知窗体表面。
我们还需要捕获窗体的鼠标操作，有三个操作在这里进行，1、处理拖动窗体操作，2、处理通知窗体的关闭操作，3、内容区域的单击操作。三个操作都需要检测鼠标的当前位置与每个Rectangle区域的包含关系，只要单击落在特定区域我们就进行相应的处理，代码如下：
private void TaskbarForm_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (TitlebarRectangle.Contains(e.Location)) //单击标题栏时拖动
{
ReleaseCapture(); //释放鼠标捕捉
SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0); //发送左键点击的消息至该窗体(标题栏)
}
if (CloseBtnRectangle.Contains(e.Location)) //单击Close按钮关闭
{
this.Hide();
currentTop = 1;
}
if (ContentRectangle.Contains(e.Location )) //单击内容区域
{
System.Diagnostics.Process.Start("http://www.Rithia.com");
}
}
}
结论
该程序可以很好的进行通知窗体的显示、停留和隐藏操作，并且具备简单的换肤机制，在利用了双重缓冲区绘图技术后，可以保证窗体的绘制平滑且没有闪烁。
简介
QQ和MSN的任务栏通知窗口很人性化，它可以在不丢失主窗体焦点的前提下显示一个具备皮肤Skin的通知窗体，当它显示一段时间后会自动消失，所以用户根本不用干预它。这样的通知窗体和一般的具备标题栏、系统图标和按钮的窗体没有太大的区别，窗体表面其实就是画上去的一张位图而已，而窗体的浮动则会复杂一点，我们会用到.Net框架的双重缓冲区绘图技术（参见作者编译文章"Windows 窗体的.Net框架绘图技术"）来保证移动窗体时所显示的内容平滑且不闪烁，以及使用P/Invoke平台调用进行对Win32API函数的调用来完成不获得焦点的窗体显示和非标题栏窗体拖动。两种位图的皮肤运行时的界面如下：
背景知识
通知窗口就是将一般的窗体附加上一层皮肤，这里所谓的皮肤就是一张位图图片，该位图图片通过窗体的OnPaintbackground事件被绘制到窗体表面，在附加位图之前需要调整窗体的可视属性，由于绘制操作是针对于窗体客户区域的，所谓客户区域就是指窗体标题栏下方以及窗体边框以内的所有区域，所以需要将窗体的边框和外观属性 FormBorderStyle调整为：None，这样所绘制的图像就会填充整个窗体。
首先，我们会用到Region对象，Region对象可以精确的描绘出任意形状的轮廓范围，通过一个位图图像创建Region对象后再将其传递给窗体的Region属性就可以使窗体按照Region所定义的轮廓显示出来。作为皮肤使用的位图文件可以通过任何图像编辑软件诸如：Photeshop来创建和编辑，只是注意一点，需要将图片的背景色调成特定颜色以便程序绘制时将其清除，我们在这里使用的背景色为粉红色。为了能够让Region对象按照图像中感兴趣的内容边框来创建窗体，我们还需要使用GraphicsPath类将图像轮廓按照一定路径标注下来，稍后便按照该路径创建Region对象。
然后通过窗体的绘图事件将位图的内容显示在窗体表面，我们没有直接使用OnPaintbackground事件而是重载了该方法，这样做的好处就是一些低层的绘制操作还继续交由.Net框架运行时来处理，我们只考虑实际需要的绘制操作即可。在OnPaintbackground方法中我们启用了双重缓冲区绘图技术，所谓该技术就是指先在内存中的一块画布上把将要显示的图像显示出来或进行处理，等到操作完成再将该画布上所显示的图像放置到窗体表面，这样的机制可以非常有效的降低闪烁的出现，使图像显示更加平滑。通知窗体从屏幕的右下方进行升起停留一段时间后再慢慢回落，这里需要用到返回屏幕区域的大小范围的.Net框架方法 Screen.GetWorkingArea(WorkAreaRectangle)，通过一定算法计算出通知窗体显示前的初始位置。最后，我们将要显示的文本按照一定格式和Rectangle对象所指定的区域范围绘制到窗体表面。通知窗体的关闭操作是通过设定一个区域，当用户用鼠标单击时检测单击坐标是否在该区域内，若在区域内就可以执行隐藏通知窗体的代码。
我们注意了，当QQ和MSN的通知窗口显示时其主窗体的焦点没有丢失，也就是说程序没有将自身的焦点转移到显示的通知窗体上。经过测试，我们无论怎么样调用.Net框架提供的窗体显示例程譬如：Form.Show都无法保证主窗体的焦点不丢失，在VC环境下我们可以使用Win32API的ShowWindows函数来完成复杂的窗体显示操作，但是.Net框架根本没有提供类似的方法，那么我们能否通过.Net框架调用该API函数来显示窗体呢？幸好.Net框架提供了P/Invoke平台调用，利用平台调用这种服务，托管代码就可以调用在动态链接库中实现的非托管函数，并可以封送其参数，我们可以轻松的显示但不获得焦点的窗体。程序中用到的Windows API以及常量的定义都保存在WinUser.h头文件中，其对应的动态链接库文件就是user32.dll，使用.Net框架提供的DllImportAttribute类对导入的函数进行定义，然后就可以非常方便的在程序中调用该函数了。
由于我们将通知窗体的标题栏隐藏了，所以对窗体拖动操作还需要我们自己动手进行处理。本文介绍了如何更加高效的进行拖动窗体操作，有些网友在对于非标题栏拖动窗体编程时偏向组合使用鼠标事件来进行，这样做的本质没有任何不妥，但是频繁的事件响应和处理反而使程序性能有所降低。我们将继续使用Win32API的底层处理方法来解决该问题，就是向窗体发送标题栏被单击的消息，模拟实际的拖动操作。
我们会通过2个计时器来完成窗体的显示、停留和隐藏，通过设置速度变量可以改变窗口显示和隐藏的速度。
启动Visual Studio .Net 2005，创建C# Windows 窗体应用程序，将解决方案命名为TaskbarForm，包含的项目名也为TaskbarForm，首先创建程序的主窗体Form1，在上面添加两个Button控件，一个用于显示通知窗体，另一个则终止程序。然后在解决方案管理器中右击项目，单击"添加 - Windows 窗体"，我们把新创建的窗体命名为TaskbarForm。
在类TaskbarForm定义的下方，我们创建用于显示的字符串和其颜色的变量，再定义几个Rectangle对象的变量用于放置标题、提示内容以及可以拖动窗体的区域和关闭按钮的区域。然后，我们需要保存窗体在浮动时的高度以便计算移动后的新高度，intervalValue变量用来确定窗体显示和隐藏的速度。进行平台调用时我们需要提前定义好常量的值用来传递给函数，WM_NCLBUTTONDOWN和HT_CAPTION常量用于拖动窗体，他们的值都保存在WinUser.h头文件中，所对应的动态链接库名为：user32.dll。我们用到的Win32API为：SendMessage、ReleaseCapture和ShowWindow，通过使用DllImportAttribute可以导入相应的函数并在程序中重新进行定义，如下：
[DllImportAttribute("user32.dll")]
public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);
//发送消息//winuser.h 中有函数原型定义
[DllImportAttribute("user32.dll")]
public static extern bool ReleaseCapture(); //释放鼠标捕捉winuser.h
[DllImportAttribute("user32.dll")] //winuser.h
private static extern Boolean ShowWindow(IntPtr hWnd, Int32 nCmdShow);
SendMessage向消息循环发送标题栏被按下的消息来模拟窗体的拖动，ShowWindow用来将特定句柄的窗体显示出来，注意第二个参数nCmdShow，它表示窗体应该怎样显示出来，而我们需要窗体不获得焦点显示出来，SW_SHOWNOACTIVATE可以满足我们要求，继续在WinUser.h文件中搜索找到该常量对应的值为4，于是我们就可以这样调用来显示窗体了：
ShowWindow(this.Handle, 4);
我们创建了一个自定义函数ShowForm用来封装上面的ShowWindow用来是显示窗体，同时传递了所用到的几个Rectangle矩形区域对象，最后调用ShowWindows函数将窗体显示出来，代码片段如下：
public void ShowForm(string ftitletext, string fcontenttext, Rectangle fRegionofFormTitle, Rectangle fRegionofFormTitlebar, Rectangle fRegionofFormContent, Rectangle fRegionofCloseBtn)
{
titleText = ftitletext;
contentText = fcontenttext;
WorkAreaRectangle = Screen.GetWorkingArea(WorkAreaRectangle);
this.Top = WorkAreaRectangle.Height + this.Height;
FormBorderStyle = FormBorderStyle.None;
WindowState = FormWindowState.Normal;
this.SetBounds(WorkAreaRectangle.Width - this.Width, WorkAreaRectangle.Height - currentTop, this.Width, this.Height);
CurrentState = 1;
timer1.Enabled = true;
TitleRectangle = fRegionofFormTitle;
TitlebarRectangle = fRegionofFormTitlebar;
ContentRectangle = fRegionofFormContent;
CloseBtnRectangle = fRegionofCloseBtn;
ShowWindow(this.Handle, 4); //#define SW_SHOWNOACTIVATE 4
}
CurrentState变量表示窗体的状态是显示中、停留中还是隐藏中，两个计时器根据窗体不同状态对窗体的位置进行更改，我们会使用SetBounds来执行该操作：
this.SetBounds(WorkAreaRectangle.Width - this.Width, WorkAreaRectangle.Height - currentTop, this.Width, this.Height);
当窗体需要升起时将窗体的Top属性值不断减少，而窗体回落时将Top属性值增加并超过屏幕的高度窗体就消失了，虽然原理很简单但仍需精确控制。
SetBackgroundBitmap函数首先将窗体背景图像保存到BackgroundBitmap变量中，然后根据该位图图像轮廓和透明色创建Region，BitmapToRegion就用于完成Bitmap到Region的转换，程序再将这个Region付值给窗体的Region属性以完成不规则窗体的创建。
public void SetBackgroundBitmap(Image image, Color transparencyColor)
{
BackgroundBitmap = new Bitmap(image);
Width = BackgroundBitmap.Width;
Height = BackgroundBitmap.Height;
Region = BitmapToRegion(BackgroundBitmap, transparencyColor);
}
public Region BitmapToRegion(Bitmap bitmap, Color transparencyColor)
{
if (bitmap == null)
throw new ArgumentNullException("Bitmap", "Bitmap cannot be null!");
int height = bitmap.Height;
int width = bitmap.Width;
GraphicsPath path = new GraphicsPath();
for (int j = 0; j < height; j++)
for (int i = 0; i < width; i++)
{
if (bitmap.GetPixel(i, j) == transparencyColor)
continue;
int x0 = i;
while ((i < width) && (bitmap.GetPixel(i, j) != transparencyColor))
i++;
path.AddRectangle(new Rectangle(x0, j, i - x0, 1));
}
Region region = new Region(path);
path.Dispose();
return region;
}
通知窗体背景以及文字的绘制在重载的OnPaintBackground方法中完成，而且利用了双重缓冲区技术来进行绘制操作，代码如下：
protected override void OnPaintBackground(PaintEventArgs e)
{
Graphics grfx = e.Graphics;
grfx.PageUnit = GraphicsUnit.Pixel;
Graphics offScreenGraphics;
Bitmap offscreenBitmap;
offscreenBitmap = new Bitmap(BackgroundBitmap.Width, BackgroundBitmap.Height);
offScreenGraphics = Graphics.FromImage(offscreenBitmap);
if (BackgroundBitmap != null)
{
offScreenGraphics.DrawImage(BackgroundBitmap, 0, 0, BackgroundBitmap.Width, BackgroundBitmap.Height);
}
DrawText(offScreenGraphics);
grfx.DrawImage(offscreenBitmap, 0, 0);
}
上述代码首先返回窗体绘制表面的Graphics并保存在变量grfx中，然后创建一个内存Graphics对象offScreenGraphics和内存位图对象offscreenBitmap，将内存位图对象的引用付值给offScreenGraphics，这样所有对offScreenGraphics的绘制操作也都同时作用于offscreenBitmap，这时就将需要绘制到通知窗体表面的背景图像BackgroundBitmap绘制到内存的Graphics对象上，DrawText函数根据需要显示文字的大小和范围调用Graphics.DrawString将文字显示在窗体的特定区域。最后，调用Graphics.DrawImage将内存中已经绘制完成的图像显示到通知窗体表面。
我们还需要捕获窗体的鼠标操作，有三个操作在这里进行，1、处理拖动窗体操作，2、处理通知窗体的关闭操作，3、内容区域的单击操作。三个操作都需要检测鼠标的当前位置与每个Rectangle区域的包含关系，只要单击落在特定区域我们就进行相应的处理，代码如下：
private void TaskbarForm_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (TitlebarRectangle.Contains(e.Location)) //单击标题栏时拖动
{
ReleaseCapture(); //释放鼠标捕捉
SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0); //发送左键点击的消息至该窗体(标题栏)
}
if (CloseBtnRectangle.Contains(e.Location)) //单击Close按钮关闭
{
this.Hide();
currentTop = 1;
}
if (ContentRectangle.Contains(e.Location )) //单击内容区域
{
System.Diagnostics.Process.Start("http://www.Rithia.com");
}
}
}
结论
该程序可以很好的进行通知窗体的显示、停留和隐藏操作，并且具备简单的换肤机制，在利用了双重缓冲区绘图技术后，可以保证窗体的绘制平滑且没有闪烁。
aspx 页面与ascx用户控件传值的问题
//****ascx用户控件中,定义一个要接收参数的属性
例子:
private string mBookTitle;
public string BookTite
{
get{return mBokTitle;}
set{mbookTitle=value;}
}
//****在aspx页面中调用此属性即可
protected UserControl.BookSeach mBookSeach;
//****设置传值
mBookSeach.BookTitle=txtbooktitle.value;
用户控件XXX.ascx ：
<%@ Control Language="c#" %>
//html...
在aspx中调用此变量，可以 ：
<%@ Register TagPrefix="UserControl" TagName="Webbott" Src="../../XXX.ascx" %>
例子:
private string mBookTitle;
public string BookTite
{
get{return mBokTitle;}
set{mbookTitle=value;}
}
//****在aspx页面中调用此属性即可
protected UserControl.BookSeach mBookSeach;
//****设置传值
mBookSeach.BookTitle=txtbooktitle.value;
用户控件XXX.ascx ：
<%@ Control Language="c#" %>
//html...
在aspx中调用此变量，可以 ：
<%@ Register TagPrefix="UserControl" TagName="Webbott" Src="../../XXX.ascx" %>
用C#实现语音技术
“电脑朗读”（英文）一个很好的触发点，通过它可以实现电子小说阅读、英文听力测试、英文单词学习...
下面的Speech已对MSTTS作了简单封装。
1.安装好MSTTS（如果你有装金山词霸，系统就已经安装了）,可以在winnt\speech中打到vtxtauto.tlb文件；
2.用.Net SDK自带的tlbimp工具把vtxtauto.tlb转换成.dll格式:
tlbimp vtxtauto.tlb /silent /namespace:mstts /out:mstts.dll
这时的mstts.dll已成为.net framework运行库的一个类。
3.编写一个封装vtxtauto的简单类:Speech .
//========================Speech.cs======================
using System；
using mstts； //MSTTS名称空间
namespace Bedlang{ //定义名称空间
public class Speech{
private VTxtAuto VTxtAutoEx；
public Speech（）{
VTxtAutoEx = new VTxtAuto（）；
VTxtAutoEx.Register（" "," "）； //注册COM组件
}
public void Speak（String text）{
VTxtAutoEx.Speak（text, 0）； //发音
}
}
}
//========================Speech.cs======================
4.编译Bedlang.Speech
csc /target:library /out:Bedlang.dll speech.cs /r:mstts.dll
如果用vs.net开发，可直接生成项目就可以了。
5.发音实现
//========================demo.cs======================
分别加入Label,TextBox,Button控件各一个到windows Form中，修改它们的属性，源代码如下：
using System；
using System.Drawing；
using System.Collections；
using System.ComponentModel；
using System.Windows.Forms；
using System.Data；
namespace Bedlang
{
///
/// Form1 的摘要说明。
///
public class demo : System.Windows.Forms.Form
{
private System.Windows.Forms.Label label1；
private System.Windows.Forms.TextBox textBox1；
private System.Windows.Forms.Button button1；
///
/// 必需的设计器变量。
///
private System.ComponentModel.Container components = null；
public demo（）
{
//
// Windows 窗体设计器支持所必需的
//
InitializeComponent（）；
//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}
///
/// 清理所有正在使用的资源。
///
protected override void Dispose（ bool disposing ）
{
if（ disposing ）
{
if （components != null）
{
components.Dispose（）；
}
}
base.Dispose（ disposing ）；
}
#region Windows Form Designer generated code
///
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
///
private void InitializeComponent（）
{
this.label1 = new System.Windows.Forms.Label（）；
this.textBox1 = new System.Windows.Forms.TextBox（）；
this.button1 = new System.Windows.Forms.Button（）；
this.SuspendLayout（）；
//
// label1
//
this.label1.Location = new System.Drawing.Point（24, 16）；
this.label1.Name = "label1"；
this.label1.Size = new System.Drawing.Size（120, 23）；
this.label1.TabIndex = 0；
this.label1.Text = "输入要朗读的文字："；
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point（24, 48）；
this.textBox1.Name = "textBox1"；
this.textBox1.Size = new System.Drawing.Size（248, 21）；
this.textBox1.TabIndex = 1；
this.textBox1.Text = ""；
//
// button1
//
this.button1.Location = new System.Drawing.Point（112, 112）；
this.button1.Name = "button1"；
this.button1.TabIndex = 2；
this.button1.Text = "朗读"；
this.button1.Click += new System.EventHandler（this.button1_Click）；
//
// demo
//
this.AutoScaleBaseSize = new System.Drawing.Size（6, 14）；
this.ClientSize = new System.Drawing.Size（292, 197）；
this.Controls.AddRange（new System.Windows.Forms.Control[] {
this.button1,
this.textBox1,
this.label1}）；
this.Name = "demo"；
this.Text = "demo"；
this.ResumeLayout（false）；
}
#endregion
///
/// 应用程序的主入口点。
///
[STAThread]
static void Main（）
{
Application.Run（new demo（））；
}
private void button1_Click（object sender, System.EventArgs e）
{
Speech s=new Speech（）； //创建一个Speech对象
if（textBox1.Text.Length==0）
s.Speak（"Please input letter."）； //发音
else
s.Speak（textBox1.Text）；
}
}
}
//========================demo.cs======================
6.编译demo.cs
csc demo.cs /r:bedlang.dll
Vs.net环境下可直接编译成exe文件。
7.运行demo.exe
输入要要朗读的文字，程序就可朗读了啦
下面的Speech已对MSTTS作了简单封装。
1.安装好MSTTS（如果你有装金山词霸，系统就已经安装了）,可以在winnt\speech中打到vtxtauto.tlb文件；
2.用.Net SDK自带的tlbimp工具把vtxtauto.tlb转换成.dll格式:
tlbimp vtxtauto.tlb /silent /namespace:mstts /out:mstts.dll
这时的mstts.dll已成为.net framework运行库的一个类。
3.编写一个封装vtxtauto的简单类:Speech .
//========================Speech.cs======================
using System；
using mstts； //MSTTS名称空间
namespace Bedlang{ //定义名称空间
public class Speech{
private VTxtAuto VTxtAutoEx；
public Speech（）{
VTxtAutoEx = new VTxtAuto（）；
VTxtAutoEx.Register（" "," "）； //注册COM组件
}
public void Speak（String text）{
VTxtAutoEx.Speak（text, 0）； //发音
}
}
}
//========================Speech.cs======================
4.编译Bedlang.Speech
csc /target:library /out:Bedlang.dll speech.cs /r:mstts.dll
如果用vs.net开发，可直接生成项目就可以了。
5.发音实现
//========================demo.cs======================
分别加入Label,TextBox,Button控件各一个到windows Form中，修改它们的属性，源代码如下：
using System；
using System.Drawing；
using System.Collections；
using System.ComponentModel；
using System.Windows.Forms；
using System.Data；
namespace Bedlang
{
///
/// Form1 的摘要说明。
///
public class demo : System.Windows.Forms.Form
{
private System.Windows.Forms.Label label1；
private System.Windows.Forms.TextBox textBox1；
private System.Windows.Forms.Button button1；
///
/// 必需的设计器变量。
///
private System.ComponentModel.Container components = null；
public demo（）
{
//
// Windows 窗体设计器支持所必需的
//
InitializeComponent（）；
//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}
///
/// 清理所有正在使用的资源。
///
protected override void Dispose（ bool disposing ）
{
if（ disposing ）
{
if （components != null）
{
components.Dispose（）；
}
}
base.Dispose（ disposing ）；
}
#region Windows Form Designer generated code
///
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
///
private void InitializeComponent（）
{
this.label1 = new System.Windows.Forms.Label（）；
this.textBox1 = new System.Windows.Forms.TextBox（）；
this.button1 = new System.Windows.Forms.Button（）；
this.SuspendLayout（）；
//
// label1
//
this.label1.Location = new System.Drawing.Point（24, 16）；
this.label1.Name = "label1"；
this.label1.Size = new System.Drawing.Size（120, 23）；
this.label1.TabIndex = 0；
this.label1.Text = "输入要朗读的文字："；
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point（24, 48）；
this.textBox1.Name = "textBox1"；
this.textBox1.Size = new System.Drawing.Size（248, 21）；
this.textBox1.TabIndex = 1；
this.textBox1.Text = ""；
//
// button1
//
this.button1.Location = new System.Drawing.Point（112, 112）；
this.button1.Name = "button1"；
this.button1.TabIndex = 2；
this.button1.Text = "朗读"；
this.button1.Click += new System.EventHandler（this.button1_Click）；
//
// demo
//
this.AutoScaleBaseSize = new System.Drawing.Size（6, 14）；
this.ClientSize = new System.Drawing.Size（292, 197）；
this.Controls.AddRange（new System.Windows.Forms.Control[] {
this.button1,
this.textBox1,
this.label1}）；
this.Name = "demo"；
this.Text = "demo"；
this.ResumeLayout（false）；
}
#endregion
///
/// 应用程序的主入口点。
///
[STAThread]
static void Main（）
{
Application.Run（new demo（））；
}
private void button1_Click（object sender, System.EventArgs e）
{
Speech s=new Speech（）； //创建一个Speech对象
if（textBox1.Text.Length==0）
s.Speak（"Please input letter."）； //发音
else
s.Speak（textBox1.Text）；
}
}
}
//========================demo.cs======================
6.编译demo.cs
csc demo.cs /r:bedlang.dll
Vs.net环境下可直接编译成exe文件。
7.运行demo.exe
输入要要朗读的文字，程序就可朗读了啦
在ASP.NET 2.0中使用样式、主题和皮肤二
全局的和应用程序的主题
主题可以应用于应用程序层或机器层（用于所有的应用程序）。应用程序层的主题放置在应用程序根目录下的App_Themes目录中。全局主题放置在ASP.NET安装目录下的ASP.NETClientFiles文件夹下的"Themes"目录中，例如%WINDIR%\Microsoft.NET\Framework\＜version＞\ASP.NETClientFiles\Themes。IIS Web站点的全局主题的位置是Inetpub\wwwroot\aspnet_client\system_web\＜version＞\Themes。
给页面指定主题
通过把＜%@ Page Theme="..." %＞指令设置为全局或应用程序层的主题（Themes或App_Themes目录下的文件夹名称），我们可以为单个页面指定主题。一个页面只能应用一个主题，但是该主题中的多个皮肤文件可以用于设置页面上的控件的样式信息。
在配置文件中指定主题
你也可以在Web.config文件的＜pages theme="..."/＞部分中指定应用在程序的所有页面上的主题。如果需要取消某个特定的页面的主题，需要把该页面指令的主题属性设置为空字符串（""）。请注意，母版页不能应用主题；你应该在内容页上或配置文件中设置主题。
＜configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0"＞
＜system.web＞
＜pages theme="ExampleTheme"/＞
＜/system.web＞
＜/configuration＞
禁止某个控件应用主题
你可以通过把控件的EnableTheming属性设置为false，把特定的控件排除出主题的应用范围。
＜%@ Page Language="VB" Theme="OrangeTheme" %＞
……
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" EnableTheming="False" /＞＜br /＞
主题中的命名皮肤（Named Skins）
在默认情况下，皮肤文件中的控件定义会应用到页面上的所有相同类型的控件上。但是，你可能希望应用程序不同部分的同类控件显示为不同的样式。例如，在某个地方你可能希望文本和标签控件用粗体显示，在另一个地方可能希望它用斜体显示。你可以使用主题中的命名皮肤来实现这种功能。
默认皮肤和命名皮肤
你可以通过为控件建立不同的定义，在一个皮肤文件中为同类控件定义多种不同的样式。你可以把这些控件定义的SkinID属性设置为任何名称，接着在需要应用特定皮肤的控件上设置这个SkinID值。如果缺少SkinID属性，就应用默认的皮肤（没有设置SkinID属性的皮肤）。下面的例子演示了应用不同皮肤的标签和日历控件。请注意，页面中带有命名SkinID的控件从默认的皮肤中获取了不同的样式集合。
＜%@ Page Language="VB" Theme="OrangeTheme2" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" SkinID="Blue" /＞
＜asp:Label ID="Label3" runat="server" Text="Hello 3" /＞
＜asp:Calendar ID="Calendar1" runat="server"/＞
＜asp:Calendar ID="Calendar2" SkinID="Simple" runat="server"/＞
命名皮肤可以在主题的皮肤文件中用多种方式来组织。由于主题可以包含多个皮肤文件，你可能会把命名皮肤分割到单个文件中，使每个皮肤文件包含相同SkinID的多个控件定义。例如，在一个主题中，你可能拥有三个皮肤文件，它们分别与特定的SkinID值对应：
/WebSite1
/App_Themes
/MyTheme
Default.skin
Red.skin
Blue.skin
你也可以根据控件类型对皮肤文件进行分组，使每个皮肤文件包含特定控件的一组皮肤定义：
/WebSite1
/App_Themes
/MyTheme
GridView.skin
Calendar.skin
Label.skin
你甚至于可以根据站点的不同区域来分割皮肤文件，例如：
/WebSite1
/App_Themes
/MyTheme
HomePage.skin
DataReports.skin
Forums.skin
在一个主题目录下存放多个皮肤文件的能力使你能够灵活地组织它们。它还使你能够轻易地与他人共享皮肤定义，或者把皮肤定义从一个主题复制到另一个主题，而不需要编辑主题中的皮肤文件。
使用主题的服务器端样式
主题是在应用程序建立之后，甚至于在站点寄宿在生产服务器之后才应用到程序上的。给程序应用主题的人可能是该应用程序的开发人员。例如，让应用程序的开发人员和网站设计人员一起处理站点的外观是很常见的。在主题应用到程序上之后，主题定义中的样式属性会重载应用程序页面中的目标控件的属性值。
另一方面，开发者独立地构建样式信息也很常见。例如，在独立的文件中，使用级联样式表（CSS）来定义控件和标记样式。在这种情况下，你也可以使用主题，把主题当作是一种服务器端的样式表。通过这种方式应用样式表的时候，主题定义中的样式属性会设置应用程序中的控件的默认值，但是可以通过其它操作来重新设置页面中的控件的这些值，从而重载了主题定义。
宣告式的服务器端样式
当我们通过在@Page指令或配置文件的＜pages/＞段中设置Theme属性来应用主题的时候，主题中的皮肤的属性将会重载页面中目标控件的相同属性。下面的例子演示了页面中的一个标签控件，它的ForeColor被设置为蓝色。在应用的主题中，标签皮肤把ForeColor属性设置为橙色。当你运行页面的时候，请注意主题定义重载了本地控件属性，所有的标签都显示为橙色。
＜%@ Page Language="VB" Theme="OrangeTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" ForeColor="blue" /＞
请注意，这个标签是橙色的（继承自主题）而不是蓝色的（控件设置）
当我们通过在@Page指令或配置文件的＜pages/＞段中设置StyleSheetTheme属性，把主题作为服务器端样式应用的时候，主题的属性是可以被页面中的控件重载的。下面的例子演示了应用StyleSheetTheme的情况（内容与上面一个例子相同）。请注意，页面中定义的ForeColor属性取得了胜利，所有的标签都显示为蓝色。
＜%@ Page Language="VB" StyleSheetTheme="OrangeTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" ForeColor="blue" /＞
请注意，这个标签是蓝色的（控件设置）而不是橙色的（来自StyleSheetTheme）
主题和StyleSheetTheme（样式表主题）的优先问题
StyleSheetTheme是在应用程序开发的时候使用的，是一种在页面中构建样式信息的方法，目的是为了保证应用程序的行为与外观的改变无关。你可能需要在已经使用了StyleSheetTheme的应用程序中进一步应用主题。如果应用程序同时使用了主题和StyleSheetTheme，那么控件的属性将按下面的次序来应用：
· 首先应用StyleSheetTheme属性
· 应用页面中控件的属性（重载StyleSheetTheme）
· 最后应用主题的属性（同时重载控件属性和StyleSheetTheme）
下面的例子演示了上述内容。
＜%@ Page Language="VB" Theme="OrangeTheme" StyleSheetTheme="GreenTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" ForeColor="blue" Font-Italic="false" /＞
请注意，页面重载了StyleSheetTheme 的斜体属性，但是主题的前景色重载了其它内容
Visual Web Developer的支持
VWD包含了对StyleSheetTheme的设计时（design-time）支持。当你把StyleSheetTheme应用到一个页面上的时候，Visual Studio中的"设计视图"在控件的显示预览中就反应了应用程序的状况。通过选择控件的智能事务面板（只有部分控件支持它）中的"自动格式化…"选项，你可以从可用的SkinID值列表中选择一个。"自动格式化"对话框显示了StyleSheetTheme中包含的可用SkinID值列表，同时还显示了应用选定的皮肤之后的控件样式预览。当你选中某个值之后，设计器会为该控件保存SkinID属性。
主题和皮肤的内容
前面的部分已经讲过，皮肤文件包含了控件属性值的定义，它可以应用在程序的同种类型的控件上。这一部分讨论添加到皮肤文件或主题的哪些内容是有效的。
Themable（可应用主题的）属性
皮肤文件中的控件定义只能包含属性的值，它们都被标记为Themeable（可应用主题）。每个控件都可以通过在属性上使用ThemeableAttribute来定义一组属性。把不可应用主题的属性添加到皮肤文件中会导致错误出现。某个控件本身可能被主题排除了，例如数据源控件就不可应用主题。在默认情况下，任何控件的ID属性是不能应用主题的。除非控件有特定的要求，否则在默认情况下，它的所有属性都是可以应用主题的。你可以参照.NET框架组件参考文档来确认控件的属性是否可以应用主题。
在主题中使用CSS
通过把级联样式表（CSS）放置在命名主题的子目录中，你可以给该主题添加CSS。如果页面包含了＜head runat="server"/＞控件定义，那么该CSS样式表将应用于所有使用了该主题的页面。你可以根据需要重命名CSS文件，只要它的扩展名是.css。一个主题可以包含多个CSS文件。当页面中包含了CSS文件的引用（在＜head/＞元素中使用＜link rel="stylesheet" href="..."/＞标记）的时候，主题中的CSS文件都在页面的样式表后面应用。
在主题中使用图像
主题中也可以包含图像，它们是皮肤文件中的控件定义引用的。皮肤文件中的图像引用必须使用主题目录下的图像文件夹的相对路径，这样皮肤文件和图像才能轻易地随应用程序迁移。在运行时，图像的路径会被重新定位，因此，对目标页面中的控件来说，这个引用是相对的。下面的例子演示了一个包含图像子目录的主题。
＜%@ Page Language="VB" Theme="MyTheme" %＞
＜asp:Image ID="Image1" SkinID="Warning" runat="server" /＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Image ID="Image2" SkinID="Warning" runat="server" /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" /＞＜br /＞
＜asp:Image ID="Image3" SkinID="Warning" runat="server" /＞
＜asp:Label ID="Label3" runat="server" Text="Hello 3" /＞＜br /＞
定制控件集合主题
你在皮肤文件中设置的大多数属性都是一些简单的值属性，例如Font-Name、Width和 BackColor。但是，你也可以设置皮肤集合属性。皮肤集合属性并非应用在目标控件的集合项的属性上，而是在使用主题或使用StyleSheetTheme合并集合的时候，完全地替代集合。
这对于某些包含样式集合的集合属性是有用处的，例如TreeView控件的LevelStyles（层次样式）属性或Menu控件的LevelMenuItemStyles（菜单项样式）、LevelSubMenuItemStyles（子菜单项样式）或LevelSelectedStyles（选中的样式）属性。
TreeView.skin的内容
＜asp:TreeView runat="server"
Font-Names="Verdana"
ForeColor="Black"
HoverNodeStyle-Font-Underline="true"
ShowExpandCollapse="false"
NodeIndent="0"
＞
＜LevelStyles＞
＜asp:TreeNodeStyle ChildNodesPadding="10" Font-Bold Font-Size="12pt" ForeColor="DarkGreen"/＞
＜asp:TreeNodeStyle ChildNodesPadding="5" Font-Bold Font-Size="10pt" /＞
＜asp:TreeNodeStyle ChildNodesPadding="5" Font-UnderLine Font-Size="10pt" /＞
＜asp:TreeNodeStyle Font-Size="8pt" /＞
＜/LevelStyles＞
＜/asp:TreeView＞
定制控件模板主题
你还可以在皮肤文件中应用模板属性。与集合类似，在皮肤文件中定义模板属性也不会应用在目标控件的模板的单独项上，而是代替整个模板的内容。这对于使用主题或StyleSheetTheme戏剧化地改变模板控件的布局时有用处的。
Template.skin内容
＜asp:Login runat="server"＞
＜LayoutTemplate＞
＜i＞Please log in to this site:＜/i＞＜br /＞＜br /＞
＜asp:Label Font-Bold="true" AssociatedControlID="UserName" ID="UserNameLabel" runat="server"＞User Name:＜/asp:Label＞
＜asp:TextBox ID="UserName" runat="server"＞＜/asp:TextBox＞
＜asp:RequiredFieldValidator ControlToValidate="UserName" ErrorMessage="User Name is required." ID="UserNameRequired" runat="server" ToolTip="User Name is required." ValidationGroup="Login1"＞*＜/asp:RequiredFieldValidator＞
＜asp:Label Font-Bold="true" AssociatedControlID="Password" ID="PasswordLabel" runat="server"＞Password:＜/asp:Label＞
＜asp:TextBox ID="Password" runat="server" TextMode="Password"＞＜/asp:TextBox＞
＜asp:RequiredFieldValidator ControlToValidate="Password" ErrorMessage="Password is required." ID="PasswordRequired" runat="server" ToolTip="Password is required." ValidationGroup="Login1"＞*＜/asp:RequiredFieldValidator＞
＜asp:Button CommandName="Login" ID="LoginButton" runat="server" Text="Log In" ValidationGroup="Login1" /＞
＜asp:Literal EnableViewState="False" ID="FailureText" runat="server"＞＜/asp:Literal＞
＜/LayoutTemplate＞
＜/asp:Login＞
在主题中使用数据绑定和表达式
请注意，在主题模板中使用＜%# Eval %＞或＜%# Bind %＞的数据绑定也是有效的，但是不允许使用其它的代码数据绑定或表达式。
Databinding.skin内容
＜asp:DataList RepeatColumns="2" CellPadding="20" runat="server"＞
＜ItemTemplate＞
＜h3＞＜asp:Label ID="titleLabel" runat="server" Text='＜%# Eval("title") %＞'/＞＜/h3＞
＜asp:Image ImageUrl='＜%# Eval("title_id", "Images/{0}.gif") %＞' runat="server" /＞
＜b＞ID:＜/b＞
＜asp:Label ID="title_idLabel" runat="server" Text='＜%# Eval("title_id") %＞'/＞＜br /＞
＜b＞Type:＜/b＞
＜asp:Label ID="typeLabel" runat="server" Text='＜%# Eval("type") %＞'/＞＜br /＞
＜b＞Price:＜/b＞ $
＜asp:Label ID="priceLabel" runat="server" Text='＜%# Eval("price") %＞'/＞＜br /＞
＜asp:TextBox TextMode="MultiLine" Rows="5" Columns="40" ID="notesLabel" Text='＜%# Eval("notes") %＞' runat="server"/＞＜br /＞
＜/ItemTemplate＞
＜/asp:DataList＞
主题和配置
你可能希望终端用户动态地为应用程序选择和应用主题。通过把活动主题存储在用户配置中，你可以根据用户的喜好动态的应用主题。为了实现这种功能，你需要编写代码来应用主题，而不能使用@Page指令或Web.config中宣告式的方法。
在代码中指定主题
为了在代码中应用主题，你必须在运行时设置Page（页面）对象的Theme属性。在请求的生命周期的早期（在PreInit事件中），你就必须给页面应用主题。在下面的例子中，用户从下拉列表控件中选择主题名称的时候，在PreInit事件中会动态地应用主题。
＜script runat="server"＞
Protected Sub Page_PreInit()
Page.Theme = Server.HtmlEncode(Request.QueryString("Theme"))
End Sub
＜/script＞
使用ASP.NET 2.0中的配置（Profile）特性，你可以把用户选择的主题存储起来，并在用户登陆站点的时候读取它。下面的例子演示了这种技术。用户可以选择自己喜欢的颜色并存储配置文件，接下来页面通过检索Profile对象中的主题名称，应用这种颜色主题。请注意，如果你登出站点，主题就存储为默认值（无主题），但是如果你返回该站点，用户的选择就会保留。
ProfileTheme_vb.aspx的内容
＜%@ Page Language="VB" Theme="Default" %＞
＜script runat="server"＞
Protected Sub Page_PreInit()
If Not Profile.FavoriteColor = "" Then
Page.Theme = Profile.FavoriteColor
End If
End Sub
＜/script＞
＜asp:Label ID="Label1" runat="server" Text="Welcome to my page. Please login with User=Test, Password=Test@1234"＞＜/asp:Label＞＜br /＞
＜asp:Login ID="Login1" runat="server" /＞＜br /＞
＜asp:LoginView ID="LoginView1" runat="server"＞
＜LoggedInTemplate＞
＜asp:HyperLink ID="HyperLink1" NavigateUrl="Profile_cs.aspx" Text="Edit Profile..." runat="server" /＞＜br /＞
＜asp:LoginStatus ID="LoginStatus1" runat="server"/＞
＜/LoggedInTemplate＞
＜/asp:LoginView＞
Profile_vb.aspx的内容
＜script runat="server"＞
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs)
If Not Page.IsPostBack AndAlso Not Profile.FavoriteColor = "" Then
DropDownList1.DataBind()
End If
End Sub
Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs)
Profile.FavoriteColor = DropDownList1.SelectedValue
Response.Redirect("ProfileTheme_cs.aspx")
End Sub
＜/script＞
＜b＞Favorite Color:＜/b＞
＜asp:DropDownList ID="DropDownList1" SelectedValue='＜%# Profile.FavoriteColor %＞' runat="server"＞
＜asp:ListItem Value="OrangeTheme"＞Orange＜/asp:ListItem＞
＜asp:ListItem Value="GreenTheme"＞Green＜/asp:ListItem＞
＜/asp:DropDownList＞
＜asp:Button ID="Button1" runat="server" Text="Submit" OnClick="Button1_Click" /＞
主题可以应用于应用程序层或机器层（用于所有的应用程序）。应用程序层的主题放置在应用程序根目录下的App_Themes目录中。全局主题放置在ASP.NET安装目录下的ASP.NETClientFiles文件夹下的"Themes"目录中，例如%WINDIR%\Microsoft.NET\Framework\＜version＞\ASP.NETClientFiles\Themes。IIS Web站点的全局主题的位置是Inetpub\wwwroot\aspnet_client\system_web\＜version＞\Themes。
给页面指定主题
通过把＜%@ Page Theme="..." %＞指令设置为全局或应用程序层的主题（Themes或App_Themes目录下的文件夹名称），我们可以为单个页面指定主题。一个页面只能应用一个主题，但是该主题中的多个皮肤文件可以用于设置页面上的控件的样式信息。
在配置文件中指定主题
你也可以在Web.config文件的＜pages theme="..."/＞部分中指定应用在程序的所有页面上的主题。如果需要取消某个特定的页面的主题，需要把该页面指令的主题属性设置为空字符串（""）。请注意，母版页不能应用主题；你应该在内容页上或配置文件中设置主题。
＜configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0"＞
＜system.web＞
＜pages theme="ExampleTheme"/＞
＜/system.web＞
＜/configuration＞
禁止某个控件应用主题
你可以通过把控件的EnableTheming属性设置为false，把特定的控件排除出主题的应用范围。
＜%@ Page Language="VB" Theme="OrangeTheme" %＞
……
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" EnableTheming="False" /＞＜br /＞
主题中的命名皮肤（Named Skins）
在默认情况下，皮肤文件中的控件定义会应用到页面上的所有相同类型的控件上。但是，你可能希望应用程序不同部分的同类控件显示为不同的样式。例如，在某个地方你可能希望文本和标签控件用粗体显示，在另一个地方可能希望它用斜体显示。你可以使用主题中的命名皮肤来实现这种功能。
默认皮肤和命名皮肤
你可以通过为控件建立不同的定义，在一个皮肤文件中为同类控件定义多种不同的样式。你可以把这些控件定义的SkinID属性设置为任何名称，接着在需要应用特定皮肤的控件上设置这个SkinID值。如果缺少SkinID属性，就应用默认的皮肤（没有设置SkinID属性的皮肤）。下面的例子演示了应用不同皮肤的标签和日历控件。请注意，页面中带有命名SkinID的控件从默认的皮肤中获取了不同的样式集合。
＜%@ Page Language="VB" Theme="OrangeTheme2" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" SkinID="Blue" /＞
＜asp:Label ID="Label3" runat="server" Text="Hello 3" /＞
＜asp:Calendar ID="Calendar1" runat="server"/＞
＜asp:Calendar ID="Calendar2" SkinID="Simple" runat="server"/＞
命名皮肤可以在主题的皮肤文件中用多种方式来组织。由于主题可以包含多个皮肤文件，你可能会把命名皮肤分割到单个文件中，使每个皮肤文件包含相同SkinID的多个控件定义。例如，在一个主题中，你可能拥有三个皮肤文件，它们分别与特定的SkinID值对应：
/WebSite1
/App_Themes
/MyTheme
Default.skin
Red.skin
Blue.skin
你也可以根据控件类型对皮肤文件进行分组，使每个皮肤文件包含特定控件的一组皮肤定义：
/WebSite1
/App_Themes
/MyTheme
GridView.skin
Calendar.skin
Label.skin
你甚至于可以根据站点的不同区域来分割皮肤文件，例如：
/WebSite1
/App_Themes
/MyTheme
HomePage.skin
DataReports.skin
Forums.skin
在一个主题目录下存放多个皮肤文件的能力使你能够灵活地组织它们。它还使你能够轻易地与他人共享皮肤定义，或者把皮肤定义从一个主题复制到另一个主题，而不需要编辑主题中的皮肤文件。
使用主题的服务器端样式
主题是在应用程序建立之后，甚至于在站点寄宿在生产服务器之后才应用到程序上的。给程序应用主题的人可能是该应用程序的开发人员。例如，让应用程序的开发人员和网站设计人员一起处理站点的外观是很常见的。在主题应用到程序上之后，主题定义中的样式属性会重载应用程序页面中的目标控件的属性值。
另一方面，开发者独立地构建样式信息也很常见。例如，在独立的文件中，使用级联样式表（CSS）来定义控件和标记样式。在这种情况下，你也可以使用主题，把主题当作是一种服务器端的样式表。通过这种方式应用样式表的时候，主题定义中的样式属性会设置应用程序中的控件的默认值，但是可以通过其它操作来重新设置页面中的控件的这些值，从而重载了主题定义。
宣告式的服务器端样式
当我们通过在@Page指令或配置文件的＜pages/＞段中设置Theme属性来应用主题的时候，主题中的皮肤的属性将会重载页面中目标控件的相同属性。下面的例子演示了页面中的一个标签控件，它的ForeColor被设置为蓝色。在应用的主题中，标签皮肤把ForeColor属性设置为橙色。当你运行页面的时候，请注意主题定义重载了本地控件属性，所有的标签都显示为橙色。
＜%@ Page Language="VB" Theme="OrangeTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" ForeColor="blue" /＞
请注意，这个标签是橙色的（继承自主题）而不是蓝色的（控件设置）
当我们通过在@Page指令或配置文件的＜pages/＞段中设置StyleSheetTheme属性，把主题作为服务器端样式应用的时候，主题的属性是可以被页面中的控件重载的。下面的例子演示了应用StyleSheetTheme的情况（内容与上面一个例子相同）。请注意，页面中定义的ForeColor属性取得了胜利，所有的标签都显示为蓝色。
＜%@ Page Language="VB" StyleSheetTheme="OrangeTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" ForeColor="blue" /＞
请注意，这个标签是蓝色的（控件设置）而不是橙色的（来自StyleSheetTheme）
主题和StyleSheetTheme（样式表主题）的优先问题
StyleSheetTheme是在应用程序开发的时候使用的，是一种在页面中构建样式信息的方法，目的是为了保证应用程序的行为与外观的改变无关。你可能需要在已经使用了StyleSheetTheme的应用程序中进一步应用主题。如果应用程序同时使用了主题和StyleSheetTheme，那么控件的属性将按下面的次序来应用：
· 首先应用StyleSheetTheme属性
· 应用页面中控件的属性（重载StyleSheetTheme）
· 最后应用主题的属性（同时重载控件属性和StyleSheetTheme）
下面的例子演示了上述内容。
＜%@ Page Language="VB" Theme="OrangeTheme" StyleSheetTheme="GreenTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" ForeColor="blue" Font-Italic="false" /＞
请注意，页面重载了StyleSheetTheme 的斜体属性，但是主题的前景色重载了其它内容
Visual Web Developer的支持
VWD包含了对StyleSheetTheme的设计时（design-time）支持。当你把StyleSheetTheme应用到一个页面上的时候，Visual Studio中的"设计视图"在控件的显示预览中就反应了应用程序的状况。通过选择控件的智能事务面板（只有部分控件支持它）中的"自动格式化…"选项，你可以从可用的SkinID值列表中选择一个。"自动格式化"对话框显示了StyleSheetTheme中包含的可用SkinID值列表，同时还显示了应用选定的皮肤之后的控件样式预览。当你选中某个值之后，设计器会为该控件保存SkinID属性。
主题和皮肤的内容
前面的部分已经讲过，皮肤文件包含了控件属性值的定义，它可以应用在程序的同种类型的控件上。这一部分讨论添加到皮肤文件或主题的哪些内容是有效的。
Themable（可应用主题的）属性
皮肤文件中的控件定义只能包含属性的值，它们都被标记为Themeable（可应用主题）。每个控件都可以通过在属性上使用ThemeableAttribute来定义一组属性。把不可应用主题的属性添加到皮肤文件中会导致错误出现。某个控件本身可能被主题排除了，例如数据源控件就不可应用主题。在默认情况下，任何控件的ID属性是不能应用主题的。除非控件有特定的要求，否则在默认情况下，它的所有属性都是可以应用主题的。你可以参照.NET框架组件参考文档来确认控件的属性是否可以应用主题。
在主题中使用CSS
通过把级联样式表（CSS）放置在命名主题的子目录中，你可以给该主题添加CSS。如果页面包含了＜head runat="server"/＞控件定义，那么该CSS样式表将应用于所有使用了该主题的页面。你可以根据需要重命名CSS文件，只要它的扩展名是.css。一个主题可以包含多个CSS文件。当页面中包含了CSS文件的引用（在＜head/＞元素中使用＜link rel="stylesheet" href="..."/＞标记）的时候，主题中的CSS文件都在页面的样式表后面应用。
在主题中使用图像
主题中也可以包含图像，它们是皮肤文件中的控件定义引用的。皮肤文件中的图像引用必须使用主题目录下的图像文件夹的相对路径，这样皮肤文件和图像才能轻易地随应用程序迁移。在运行时，图像的路径会被重新定位，因此，对目标页面中的控件来说，这个引用是相对的。下面的例子演示了一个包含图像子目录的主题。
＜%@ Page Language="VB" Theme="MyTheme" %＞
＜asp:Image ID="Image1" SkinID="Warning" runat="server" /＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Image ID="Image2" SkinID="Warning" runat="server" /＞
＜asp:Label ID="Label2" runat="server" Text="Hello 2" /＞＜br /＞
＜asp:Image ID="Image3" SkinID="Warning" runat="server" /＞
＜asp:Label ID="Label3" runat="server" Text="Hello 3" /＞＜br /＞
定制控件集合主题
你在皮肤文件中设置的大多数属性都是一些简单的值属性，例如Font-Name、Width和 BackColor。但是，你也可以设置皮肤集合属性。皮肤集合属性并非应用在目标控件的集合项的属性上，而是在使用主题或使用StyleSheetTheme合并集合的时候，完全地替代集合。
这对于某些包含样式集合的集合属性是有用处的，例如TreeView控件的LevelStyles（层次样式）属性或Menu控件的LevelMenuItemStyles（菜单项样式）、LevelSubMenuItemStyles（子菜单项样式）或LevelSelectedStyles（选中的样式）属性。
TreeView.skin的内容
＜asp:TreeView runat="server"
Font-Names="Verdana"
ForeColor="Black"
HoverNodeStyle-Font-Underline="true"
ShowExpandCollapse="false"
NodeIndent="0"
＞
＜LevelStyles＞
＜asp:TreeNodeStyle ChildNodesPadding="10" Font-Bold Font-Size="12pt" ForeColor="DarkGreen"/＞
＜asp:TreeNodeStyle ChildNodesPadding="5" Font-Bold Font-Size="10pt" /＞
＜asp:TreeNodeStyle ChildNodesPadding="5" Font-UnderLine Font-Size="10pt" /＞
＜asp:TreeNodeStyle Font-Size="8pt" /＞
＜/LevelStyles＞
＜/asp:TreeView＞
定制控件模板主题
你还可以在皮肤文件中应用模板属性。与集合类似，在皮肤文件中定义模板属性也不会应用在目标控件的模板的单独项上，而是代替整个模板的内容。这对于使用主题或StyleSheetTheme戏剧化地改变模板控件的布局时有用处的。
Template.skin内容
＜asp:Login runat="server"＞
＜LayoutTemplate＞
＜i＞Please log in to this site:＜/i＞＜br /＞＜br /＞
＜asp:Label Font-Bold="true" AssociatedControlID="UserName" ID="UserNameLabel" runat="server"＞User Name:＜/asp:Label＞
＜asp:TextBox ID="UserName" runat="server"＞＜/asp:TextBox＞
＜asp:RequiredFieldValidator ControlToValidate="UserName" ErrorMessage="User Name is required." ID="UserNameRequired" runat="server" ToolTip="User Name is required." ValidationGroup="Login1"＞*＜/asp:RequiredFieldValidator＞
＜asp:Label Font-Bold="true" AssociatedControlID="Password" ID="PasswordLabel" runat="server"＞Password:＜/asp:Label＞
＜asp:TextBox ID="Password" runat="server" TextMode="Password"＞＜/asp:TextBox＞
＜asp:RequiredFieldValidator ControlToValidate="Password" ErrorMessage="Password is required." ID="PasswordRequired" runat="server" ToolTip="Password is required." ValidationGroup="Login1"＞*＜/asp:RequiredFieldValidator＞
＜asp:Button CommandName="Login" ID="LoginButton" runat="server" Text="Log In" ValidationGroup="Login1" /＞
＜asp:Literal EnableViewState="False" ID="FailureText" runat="server"＞＜/asp:Literal＞
＜/LayoutTemplate＞
＜/asp:Login＞
在主题中使用数据绑定和表达式
请注意，在主题模板中使用＜%# Eval %＞或＜%# Bind %＞的数据绑定也是有效的，但是不允许使用其它的代码数据绑定或表达式。
Databinding.skin内容
＜asp:DataList RepeatColumns="2" CellPadding="20" runat="server"＞
＜ItemTemplate＞
＜h3＞＜asp:Label ID="titleLabel" runat="server" Text='＜%# Eval("title") %＞'/＞＜/h3＞
＜asp:Image ImageUrl='＜%# Eval("title_id", "Images/{0}.gif") %＞' runat="server" /＞
＜b＞ID:＜/b＞
＜asp:Label ID="title_idLabel" runat="server" Text='＜%# Eval("title_id") %＞'/＞＜br /＞
＜b＞Type:＜/b＞
＜asp:Label ID="typeLabel" runat="server" Text='＜%# Eval("type") %＞'/＞＜br /＞
＜b＞Price:＜/b＞ $
＜asp:Label ID="priceLabel" runat="server" Text='＜%# Eval("price") %＞'/＞＜br /＞
＜asp:TextBox TextMode="MultiLine" Rows="5" Columns="40" ID="notesLabel" Text='＜%# Eval("notes") %＞' runat="server"/＞＜br /＞
＜/ItemTemplate＞
＜/asp:DataList＞
主题和配置
你可能希望终端用户动态地为应用程序选择和应用主题。通过把活动主题存储在用户配置中，你可以根据用户的喜好动态的应用主题。为了实现这种功能，你需要编写代码来应用主题，而不能使用@Page指令或Web.config中宣告式的方法。
在代码中指定主题
为了在代码中应用主题，你必须在运行时设置Page（页面）对象的Theme属性。在请求的生命周期的早期（在PreInit事件中），你就必须给页面应用主题。在下面的例子中，用户从下拉列表控件中选择主题名称的时候，在PreInit事件中会动态地应用主题。
＜script runat="server"＞
Protected Sub Page_PreInit()
Page.Theme = Server.HtmlEncode(Request.QueryString("Theme"))
End Sub
＜/script＞
使用ASP.NET 2.0中的配置（Profile）特性，你可以把用户选择的主题存储起来，并在用户登陆站点的时候读取它。下面的例子演示了这种技术。用户可以选择自己喜欢的颜色并存储配置文件，接下来页面通过检索Profile对象中的主题名称，应用这种颜色主题。请注意，如果你登出站点，主题就存储为默认值（无主题），但是如果你返回该站点，用户的选择就会保留。
ProfileTheme_vb.aspx的内容
＜%@ Page Language="VB" Theme="Default" %＞
＜script runat="server"＞
Protected Sub Page_PreInit()
If Not Profile.FavoriteColor = "" Then
Page.Theme = Profile.FavoriteColor
End If
End Sub
＜/script＞
＜asp:Label ID="Label1" runat="server" Text="Welcome to my page. Please login with User=Test, Password=Test@1234"＞＜/asp:Label＞＜br /＞
＜asp:Login ID="Login1" runat="server" /＞＜br /＞
＜asp:LoginView ID="LoginView1" runat="server"＞
＜LoggedInTemplate＞
＜asp:HyperLink ID="HyperLink1" NavigateUrl="Profile_cs.aspx" Text="Edit Profile..." runat="server" /＞＜br /＞
＜asp:LoginStatus ID="LoginStatus1" runat="server"/＞
＜/LoggedInTemplate＞
＜/asp:LoginView＞
Profile_vb.aspx的内容
＜script runat="server"＞
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs)
If Not Page.IsPostBack AndAlso Not Profile.FavoriteColor = "" Then
DropDownList1.DataBind()
End If
End Sub
Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs)
Profile.FavoriteColor = DropDownList1.SelectedValue
Response.Redirect("ProfileTheme_cs.aspx")
End Sub
＜/script＞
＜b＞Favorite Color:＜/b＞
＜asp:DropDownList ID="DropDownList1" SelectedValue='＜%# Profile.FavoriteColor %＞' runat="server"＞
＜asp:ListItem Value="OrangeTheme"＞Orange＜/asp:ListItem＞
＜asp:ListItem Value="GreenTheme"＞Green＜/asp:ListItem＞
＜/asp:DropDownList＞
＜asp:Button ID="Button1" runat="server" Text="Submit" OnClick="Button1_Click" /＞
在ASP.NET 2.0中使用样式、主题和皮肤一
ASP.NET 2.0的主题和皮肤特性使你能够把样式和布局信息存放到一组独立的文件中，总称为主题（Theme）。接下来我们可以把这个主题应用到任何站点，用于改变该站点内的页面和控件的外观和感觉。通过改变主题的内容，而不用改变站点的单个页面，就可以轻易地改变站点的样式。主题也可以在开发者之间共享。
ASP.NET包含了大量的用于定制应用程序的页面和控件的外观和感觉的特性。控件支持使用Style（样式）对象模型来设置格式属性（例如字体、边框、背景和前景颜色、宽度、高度等等）。控件也支持使用样式表（CSS）来单独设置控件的样式。你可以用控件属性或CSS来定义控件的样式信息，或者把这些定义信息存放到单独的一组文件中（称为主题），然后把它应用到程序的所有或部分页面上。单独的控件样式是用主题的皮肤（Skin）属性来指定的。
本文用大量的示例演示了在ASP.NET 2.0中如何使用样式、主题和皮肤特性。
给控件应用样式
Web用户界面是非常灵活的，不同的Web站点的外观和感觉是截然不同的。目前广泛采用的样式表（CSS）在很大程度上就是负责处理Web上遇到的丰富的设计需求的。ASP.NET的HTML服务器控件和Web服务器控件都被设计成优先支持CSS样式表。这一部分讨论如何在服务器控件上使用样式，并演示了它们所提供的Web窗体的外观和感觉的非常细微的控制。
给HTML控件应用样式
标准的HTML标记通过style属性来支持CSS，我们可以用分号隔离的属性/值对（pair）来设置它。所有的ASP.NET HTML服务器控件都可以采用标准HTML标记的方式来接受样式。下面的例子演示了大量的应用到HTML服务器控件的样式。在源代码中你可以看到，这些样式都是在控件显示的时候传递给浏览器的。
＜span style="font: 12pt verdana; color:orange;font-weight:700" runat="server"＞
This is some literal text inside a styled span control＜/span＞
＜p＞＜font face="verdana"＞＜h4＞Styled Button＜/h4＞＜/font＞＜p＞
＜button style="font: 8pt verdana;background-color:lightgreen;border-color:black;width:100" runat="server"＞Click me!＜/button＞
CSS还定义了class属性，你可以把它设置为文档中＜style＞...＜/style＞内包含的CSS样式定义。Class属性使你能够一次定义样式，在多个服务器标记上使用，避免了样式的重复定义。HTML服务器控件的style属性可以用这种方式来设置，如下所示：
＜style＞
.spanstyle
{
font: 12pt verdana;
font-weight:700;
color:orange;
}
.buttonstyle
{
font: 8pt verdana;
background-color:lightgreen;
border-color:black;
width:100
}
……
＜/style＞
＜span class="spanstyle" runat="server"＞
This is some literal text inside a styled span control
＜/span＞
＜p＞＜font face="verdana"＞＜h4＞Styled Button＜/h4＞＜/font＞＜p＞
＜button class="buttonstyle" runat="server"＞Click me!＜/button＞
在分析ASP.NET页面的时候，在System.Web.UI.HtmlControls.HtmlControl类中，样式信息被填充到CssStyleCollection类型的Style属性。这个属性本质上是一个字典，它把控件的样式暴露为每个样式属性键的按字符串索引的值集合。例如，你可以使用下面的代码设置和检索HtmlInputText服务器控件的width样式属性：
＜script language="VB" runat="server" ＞
Sub Page_Load(Sender As Object, E As EventArgs)
MyText.Style("width") = "90px"
Response.Write(MyText.Style("width"))
End Sub
＜/script＞
＜input type="text" id="MyText" runat="server"/＞
下面的例子显示了如何编程使用Style集合属性来控制HTML服务器控件的样式：
＜script language="VB" runat="server"＞
Sub Page_Load(Src As Object, E As EventArgs)
Message.InnerHtml &= "＜h5＞Accessing Styles...＜/h5＞"
Message.InnerHtml &= "The color of the span is: " & MySpan.Style("color") & "＜br＞"
Message.InnerHtml &= "The width of the textbox is: " & MyText.Style("width") & "＜p＞"
Message.InnerHtml &= "MySelect's style collection is: ＜br＞＜br＞"
Dim Keys As IEnumerator
Keys = MySelect.Style.Keys.GetEnumerator()
Do While (Keys.MoveNext())
Dim Key As String
Key = CStr(Keys.Current)
Message.InnerHtml &= "＜li＞ "
Message.InnerHtml &= Key & "=" & MySelect.Style(Key) & "＜br＞"
Loop
End Sub
Sub Submit_Click(Src As Object, E As EventArgs)
Message.InnerHtml &= "＜h5＞Modifying Styles...＜/h5＞"
MySpan.Style("color") = ColorSelect.Value
MyText.Style("width") = "600"
Message.InnerHtml &= "The color of the span is: " & MySpan.Style("color") & "＜br＞"
Message.InnerHtml &= "The width of the textbox is: " & MyText.Style("width")
End Sub
＜/script＞
给Web服务器控件应用样式
Web 服务器控件添加了几个用于设置样式的强类型属性（例如背景色、前景色、字体名称和大小、宽度、高度等等），从而为样式提供了更多层次的支持。这些样式属性表现了HTML中可用的样式行为的子集，并表现为System.Web.UI.WebControls.WebControl基类直接暴露的"平面"属性。使用这些属性的优势在于，在开发工具（例如微软Visual Studio .NET）中，它们提供了编译时的类型检测和语句编译。
下面的例子显示了一个应用了几种样式的WebCalendar控件。请注意，当设置的属性是类类型（class type）的时候（例如字体），你必须使用子属性语法PropertyName-SubPropertyName（属性－子属性）：
＜ASP:Calendar runat="server"
BackColor="Beige"
ForeColor="Brown"
BorderWidth="3"
……
/＞
System.Web.UI.WebControls名字空间包含了Style基类，它封装了公用的样式属性（其它的样式类，例如TableStyle和TableItemStyle都继承自这个基类）。为了指定控件的各个显示元素，大多数Web服务器控件都暴露了这个类型属性。例如，WebCalendar暴露和很多样式属性：DayStyle、WeekendDayStyle、TodayDayStyle、SelectedDayStyle、OtherMonthDayStyle和NextPrevStyle。你可以使用子属性语法PropertyName-SubPropertyName来设置这些样式的属性，如下面的例子所示：
＜ASP:Calendar runat="server"
……
DayStyle-Width="50px"
DayStyle-Height="50px"
TodayDayStyle-BorderWidth="3"
WeekEndDayStyle-BackColor="palegoldenrod"
WeekEndDayStyle-Width="50px"
WeekEndDayStyle-Height="50px"
SelectedDayStyle-BorderColor="firebrick"
SelectedDayStyle-BorderWidth="3"
OtherMonthDayStyle-Width="50px"
OtherMonthDayStyle-Height="50px"
/＞
下面的语法有稍微的不同，它允许你把Style属性声明为Web服务器控件标记内嵌套的子元素：
＜ASP:Calendar ... runat="server"＞
＜TitleStyle BorderColor="darkolivegreen" BorderWidth="3" BackColor="olivedrab" Height="50px" /＞
＜/ASP:Calendar＞
下面的例子显示了一种替代语法，但是它的功能与前面的语法是一样的。
＜ASP:Calendar id="MyCalendar" runat="server"
……
＞
＜TitleStyle BorderColor="darkolivegreen" BorderWidth="3" BackColor="olivedrab" Height="50px" /＞
＜DayHeaderStyle BorderColor="darkolivegreen" BorderWidth="3" BackColor="olivedrab" ForeColor="black" Height="20px" /＞
＜WeekEndDayStyle BackColor="palegoldenrod" Width="50px" Height="50px" /＞
＜DayStyle Width="50px" Height="50px" /＞
＜TodayDayStyle BorderWidth="3" /＞
＜SelectedDayStyle BorderColor="firebrick" BorderWidth="3" /＞
＜OtherMonthDayStyle Width="50px" Height="50px" /＞
＜/ASP:Calendar＞
使用HTML服务器控件的时候，你可以使用CSS类定义给Web服务器控件应用样式。WebControl基类暴露了一个叫做CssClass的字符串属性，用于设置样式类：
＜style＞
.calstyle { font-size:12pt; font-family:Tahoma,Arial; }
＜/style＞
＜ASP:Calendar CssClass="calstyle" runat="server"
……
/＞
如果某个服务器控件上设置的属性没有与该控件的强类型属性相对应，那个该属性和值就被填充到控件的Attributes集合中。在默认情况下，服务器控件会把这些属性不作更改地呈现在HTML中，并返回给作出请求的浏览器客户端。这意味着，我们可以直接设置Web服务器控件的样式和类属性，而不必使用强类型的属性。尽管它要求我们理解控件的实际显示过程，但是它也是应用样式的一个灵活的途径。对于标准的输入控件，这样的操作用处很大，如下面的例子所示：
＜ASP:TextBox runat="server" class="beige" style="font-weight:700;"/＞
＜ASP:TextBox TextMode="Password" runat="server" class="beige"/＞
＜ASP:DropDownList class="beige" runat="server"＞
＜ASP:ListItem＞Default Desktop＜/ASP:ListItem＞
＜ASP:ListItem＞My Stock Portfolio＜/ASP:ListItem＞
＜ASP:ListItem＞My Contact List＜/ASP:ListItem＞
＜/ASP:DropDownList＞
＜ASP:Button Text="Submit" runat="server" class="beige"/＞
我们也可以使用WebControl基类的ApplyStyle方法来编程设置Web服务器控件的样式，如下面的代码所示：
＜script language="VB" runat="server"＞
Sub Page_Load(Src As Object, E As EventArgs)
Dim MyStyle As New Style
MyStyle.BorderColor = Color.Black
MyStyle.BorderStyle = BorderStyle.Dashed
MyStyle.BorderWidth = New Unit(1)
MyLogin.ApplyStyle (MyStyle)
MyPassword.ApplyStyle (MyStyle)
MySubmit.ApplyStyle (MyStyle)
End Sub
＜/script＞
Login: ＜ASP:TextBox id="MyLogin" runat="server" /＞/＜p/＞
Password: ＜ASP:TextBox id="MyPassword" TextMode="Password" runat="server" /＞
View: ＜ASP:DropDownList id="MySelect" runat="server"＞ ... ＜/ASP:DropDownList＞
利用主题来定制站点
前面的部分演示了几种通过设置控件自身的样式属性来指定控件样式的方法。例如，我们看看如下的页面（代码），在这个页面上的各个控件上都应用了很多样式设置。
＜asp:Label ID="Label1" runat="server" Text="Hello 1" Font-Bold="true" ForeColor="orange" /＞＜br /＞
＜asp:Calendar BackColor="White" BorderColor="Black" BorderStyle="Solid" CellSpacing="1" Font-Names="Verdana" Font-Size="9pt" ForeColor="Black" Height="250px" ID="Calendar1" NextPrevFormat="ShortMonth" runat="server" Width="330px"＞
＜SelectedDayStyle BackColor="#333399" ForeColor="White" /＞
＜OtherMonthDayStyle ForeColor="#999999" /＞
＜TodayDayStyle BackColor="#999999" ForeColor="White" /＞
＜DayStyle BackColor="#CCCCCC" /＞
＜NextPrevStyle Font-Bold="True" Font-Size="8pt" ForeColor="White" /＞
＜DayHeaderStyle Font-Bold="True" Font-Size="8pt" ForeColor="#333333" Height="8pt" /＞
＜TitleStyle BackColor="#333399" BorderStyle="Solid" Font-Bold="True" Font-Size="12pt"
ForeColor="White" Height="12pt" /＞
＜/asp:Calendar＞
作为在各个控件上指定样式的补充，ASP.NET 2.0引入了"主题"的概念，它提供了一种定义站点的控件和页面的样式设置的简单途径，而且它与应用程序的页面是分离的。主题的优势在于，你在设计站点的时候不用考虑它的样式，在将来应用样式的时候，不必更新页面或应用程序代码。你还可以从外部获取定制的主题，然后应用到自己的应用程序上。主题的优势是，样式设置都存储在一个单独的位置，它的维护与应用程序是分离的。
下面的例子演示了一个带有主题的页面。请注意，这个页面本身没有包含任何样式信息。主题在运行时自动地把样式属性应用到页面的控件上。
＜%@ Page Language="VB" Theme="ExampleTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Calendar ID="Calendar1" runat="server"/＞
＜asp:GridView ID="GridView1" AutoGenerateColumns="False" DataSourceID="SqlDataSource1" DataKeyNames="au_id" runat="server"＞
……
＜/asp:GridView＞
＜asp:SqlDataSource ConnectionString="＜%$ ConnectionStrings:Pubs %＞" ID="SqlDataSource1" runat="server" SelectCommand="SELECT [au_id], [au_lname], [au_fname], [state] FROM [authors]"＞
＜/asp:SqlDataSource＞
App_Themes文件夹
主题位于应用程序根目录的App_Themes文件夹中。主题由一个为主题命名的子目录和这个子目录下的一个或多个皮肤文件（带有.skin扩展名）组成。主题还可以包含CSS文件和/或存放静态文件（例如图像）的子目录。下图显示了定义了两个主题的App_Themes目录，分别叫做"Default"和"White"，每个主题包含一个皮肤文件和一个CSS文件。
查看前面的例子，你会发现皮肤文件的内容就是控件如何显示的简单定义。一个皮肤文件可以包含多个控件定义，例如为每种控件类型提供一个定义。在应用主题的时候，主题中定义的控件属性自动地重载相同类型的控件的本地属性值。例如，皮肤文件中的＜asp:Calendar Font-Name="Verdana" runat="server"/＞控件定义将会引发应用了该主题的页面中的所有Calendar控件都使用Verdana字体。该控件的这个属性的本地值都会被主题重载。请注意，在皮肤文件中给控件定义指定ID属性是错误的。
ASP.NET包含了大量的用于定制应用程序的页面和控件的外观和感觉的特性。控件支持使用Style（样式）对象模型来设置格式属性（例如字体、边框、背景和前景颜色、宽度、高度等等）。控件也支持使用样式表（CSS）来单独设置控件的样式。你可以用控件属性或CSS来定义控件的样式信息，或者把这些定义信息存放到单独的一组文件中（称为主题），然后把它应用到程序的所有或部分页面上。单独的控件样式是用主题的皮肤（Skin）属性来指定的。
本文用大量的示例演示了在ASP.NET 2.0中如何使用样式、主题和皮肤特性。
给控件应用样式
Web用户界面是非常灵活的，不同的Web站点的外观和感觉是截然不同的。目前广泛采用的样式表（CSS）在很大程度上就是负责处理Web上遇到的丰富的设计需求的。ASP.NET的HTML服务器控件和Web服务器控件都被设计成优先支持CSS样式表。这一部分讨论如何在服务器控件上使用样式，并演示了它们所提供的Web窗体的外观和感觉的非常细微的控制。
给HTML控件应用样式
标准的HTML标记通过style属性来支持CSS，我们可以用分号隔离的属性/值对（pair）来设置它。所有的ASP.NET HTML服务器控件都可以采用标准HTML标记的方式来接受样式。下面的例子演示了大量的应用到HTML服务器控件的样式。在源代码中你可以看到，这些样式都是在控件显示的时候传递给浏览器的。
＜span style="font: 12pt verdana; color:orange;font-weight:700" runat="server"＞
This is some literal text inside a styled span control＜/span＞
＜p＞＜font face="verdana"＞＜h4＞Styled Button＜/h4＞＜/font＞＜p＞
＜button style="font: 8pt verdana;background-color:lightgreen;border-color:black;width:100" runat="server"＞Click me!＜/button＞
CSS还定义了class属性，你可以把它设置为文档中＜style＞...＜/style＞内包含的CSS样式定义。Class属性使你能够一次定义样式，在多个服务器标记上使用，避免了样式的重复定义。HTML服务器控件的style属性可以用这种方式来设置，如下所示：
＜style＞
.spanstyle
{
font: 12pt verdana;
font-weight:700;
color:orange;
}
.buttonstyle
{
font: 8pt verdana;
background-color:lightgreen;
border-color:black;
width:100
}
……
＜/style＞
＜span class="spanstyle" runat="server"＞
This is some literal text inside a styled span control
＜/span＞
＜p＞＜font face="verdana"＞＜h4＞Styled Button＜/h4＞＜/font＞＜p＞
＜button class="buttonstyle" runat="server"＞Click me!＜/button＞
在分析ASP.NET页面的时候，在System.Web.UI.HtmlControls.HtmlControl类中，样式信息被填充到CssStyleCollection类型的Style属性。这个属性本质上是一个字典，它把控件的样式暴露为每个样式属性键的按字符串索引的值集合。例如，你可以使用下面的代码设置和检索HtmlInputText服务器控件的width样式属性：
＜script language="VB" runat="server" ＞
Sub Page_Load(Sender As Object, E As EventArgs)
MyText.Style("width") = "90px"
Response.Write(MyText.Style("width"))
End Sub
＜/script＞
＜input type="text" id="MyText" runat="server"/＞
下面的例子显示了如何编程使用Style集合属性来控制HTML服务器控件的样式：
＜script language="VB" runat="server"＞
Sub Page_Load(Src As Object, E As EventArgs)
Message.InnerHtml &= "＜h5＞Accessing Styles...＜/h5＞"
Message.InnerHtml &= "The color of the span is: " & MySpan.Style("color") & "＜br＞"
Message.InnerHtml &= "The width of the textbox is: " & MyText.Style("width") & "＜p＞"
Message.InnerHtml &= "MySelect's style collection is: ＜br＞＜br＞"
Dim Keys As IEnumerator
Keys = MySelect.Style.Keys.GetEnumerator()
Do While (Keys.MoveNext())
Dim Key As String
Key = CStr(Keys.Current)
Message.InnerHtml &= "＜li＞ "
Message.InnerHtml &= Key & "=" & MySelect.Style(Key) & "＜br＞"
Loop
End Sub
Sub Submit_Click(Src As Object, E As EventArgs)
Message.InnerHtml &= "＜h5＞Modifying Styles...＜/h5＞"
MySpan.Style("color") = ColorSelect.Value
MyText.Style("width") = "600"
Message.InnerHtml &= "The color of the span is: " & MySpan.Style("color") & "＜br＞"
Message.InnerHtml &= "The width of the textbox is: " & MyText.Style("width")
End Sub
＜/script＞
给Web服务器控件应用样式
Web 服务器控件添加了几个用于设置样式的强类型属性（例如背景色、前景色、字体名称和大小、宽度、高度等等），从而为样式提供了更多层次的支持。这些样式属性表现了HTML中可用的样式行为的子集，并表现为System.Web.UI.WebControls.WebControl基类直接暴露的"平面"属性。使用这些属性的优势在于，在开发工具（例如微软Visual Studio .NET）中，它们提供了编译时的类型检测和语句编译。
下面的例子显示了一个应用了几种样式的WebCalendar控件。请注意，当设置的属性是类类型（class type）的时候（例如字体），你必须使用子属性语法PropertyName-SubPropertyName（属性－子属性）：
＜ASP:Calendar runat="server"
BackColor="Beige"
ForeColor="Brown"
BorderWidth="3"
……
/＞
System.Web.UI.WebControls名字空间包含了Style基类，它封装了公用的样式属性（其它的样式类，例如TableStyle和TableItemStyle都继承自这个基类）。为了指定控件的各个显示元素，大多数Web服务器控件都暴露了这个类型属性。例如，WebCalendar暴露和很多样式属性：DayStyle、WeekendDayStyle、TodayDayStyle、SelectedDayStyle、OtherMonthDayStyle和NextPrevStyle。你可以使用子属性语法PropertyName-SubPropertyName来设置这些样式的属性，如下面的例子所示：
＜ASP:Calendar runat="server"
……
DayStyle-Width="50px"
DayStyle-Height="50px"
TodayDayStyle-BorderWidth="3"
WeekEndDayStyle-BackColor="palegoldenrod"
WeekEndDayStyle-Width="50px"
WeekEndDayStyle-Height="50px"
SelectedDayStyle-BorderColor="firebrick"
SelectedDayStyle-BorderWidth="3"
OtherMonthDayStyle-Width="50px"
OtherMonthDayStyle-Height="50px"
/＞
下面的语法有稍微的不同，它允许你把Style属性声明为Web服务器控件标记内嵌套的子元素：
＜ASP:Calendar ... runat="server"＞
＜TitleStyle BorderColor="darkolivegreen" BorderWidth="3" BackColor="olivedrab" Height="50px" /＞
＜/ASP:Calendar＞
下面的例子显示了一种替代语法，但是它的功能与前面的语法是一样的。
＜ASP:Calendar id="MyCalendar" runat="server"
……
＞
＜TitleStyle BorderColor="darkolivegreen" BorderWidth="3" BackColor="olivedrab" Height="50px" /＞
＜DayHeaderStyle BorderColor="darkolivegreen" BorderWidth="3" BackColor="olivedrab" ForeColor="black" Height="20px" /＞
＜WeekEndDayStyle BackColor="palegoldenrod" Width="50px" Height="50px" /＞
＜DayStyle Width="50px" Height="50px" /＞
＜TodayDayStyle BorderWidth="3" /＞
＜SelectedDayStyle BorderColor="firebrick" BorderWidth="3" /＞
＜OtherMonthDayStyle Width="50px" Height="50px" /＞
＜/ASP:Calendar＞
使用HTML服务器控件的时候，你可以使用CSS类定义给Web服务器控件应用样式。WebControl基类暴露了一个叫做CssClass的字符串属性，用于设置样式类：
＜style＞
.calstyle { font-size:12pt; font-family:Tahoma,Arial; }
＜/style＞
＜ASP:Calendar CssClass="calstyle" runat="server"
……
/＞
如果某个服务器控件上设置的属性没有与该控件的强类型属性相对应，那个该属性和值就被填充到控件的Attributes集合中。在默认情况下，服务器控件会把这些属性不作更改地呈现在HTML中，并返回给作出请求的浏览器客户端。这意味着，我们可以直接设置Web服务器控件的样式和类属性，而不必使用强类型的属性。尽管它要求我们理解控件的实际显示过程，但是它也是应用样式的一个灵活的途径。对于标准的输入控件，这样的操作用处很大，如下面的例子所示：
＜ASP:TextBox runat="server" class="beige" style="font-weight:700;"/＞
＜ASP:TextBox TextMode="Password" runat="server" class="beige"/＞
＜ASP:DropDownList class="beige" runat="server"＞
＜ASP:ListItem＞Default Desktop＜/ASP:ListItem＞
＜ASP:ListItem＞My Stock Portfolio＜/ASP:ListItem＞
＜ASP:ListItem＞My Contact List＜/ASP:ListItem＞
＜/ASP:DropDownList＞
＜ASP:Button Text="Submit" runat="server" class="beige"/＞
我们也可以使用WebControl基类的ApplyStyle方法来编程设置Web服务器控件的样式，如下面的代码所示：
＜script language="VB" runat="server"＞
Sub Page_Load(Src As Object, E As EventArgs)
Dim MyStyle As New Style
MyStyle.BorderColor = Color.Black
MyStyle.BorderStyle = BorderStyle.Dashed
MyStyle.BorderWidth = New Unit(1)
MyLogin.ApplyStyle (MyStyle)
MyPassword.ApplyStyle (MyStyle)
MySubmit.ApplyStyle (MyStyle)
End Sub
＜/script＞
Login: ＜ASP:TextBox id="MyLogin" runat="server" /＞/＜p/＞
Password: ＜ASP:TextBox id="MyPassword" TextMode="Password" runat="server" /＞
View: ＜ASP:DropDownList id="MySelect" runat="server"＞ ... ＜/ASP:DropDownList＞
利用主题来定制站点
前面的部分演示了几种通过设置控件自身的样式属性来指定控件样式的方法。例如，我们看看如下的页面（代码），在这个页面上的各个控件上都应用了很多样式设置。
＜asp:Label ID="Label1" runat="server" Text="Hello 1" Font-Bold="true" ForeColor="orange" /＞＜br /＞
＜asp:Calendar BackColor="White" BorderColor="Black" BorderStyle="Solid" CellSpacing="1" Font-Names="Verdana" Font-Size="9pt" ForeColor="Black" Height="250px" ID="Calendar1" NextPrevFormat="ShortMonth" runat="server" Width="330px"＞
＜SelectedDayStyle BackColor="#333399" ForeColor="White" /＞
＜OtherMonthDayStyle ForeColor="#999999" /＞
＜TodayDayStyle BackColor="#999999" ForeColor="White" /＞
＜DayStyle BackColor="#CCCCCC" /＞
＜NextPrevStyle Font-Bold="True" Font-Size="8pt" ForeColor="White" /＞
＜DayHeaderStyle Font-Bold="True" Font-Size="8pt" ForeColor="#333333" Height="8pt" /＞
＜TitleStyle BackColor="#333399" BorderStyle="Solid" Font-Bold="True" Font-Size="12pt"
ForeColor="White" Height="12pt" /＞
＜/asp:Calendar＞
作为在各个控件上指定样式的补充，ASP.NET 2.0引入了"主题"的概念，它提供了一种定义站点的控件和页面的样式设置的简单途径，而且它与应用程序的页面是分离的。主题的优势在于，你在设计站点的时候不用考虑它的样式，在将来应用样式的时候，不必更新页面或应用程序代码。你还可以从外部获取定制的主题，然后应用到自己的应用程序上。主题的优势是，样式设置都存储在一个单独的位置，它的维护与应用程序是分离的。
下面的例子演示了一个带有主题的页面。请注意，这个页面本身没有包含任何样式信息。主题在运行时自动地把样式属性应用到页面的控件上。
＜%@ Page Language="VB" Theme="ExampleTheme" %＞
＜asp:Label ID="Label1" runat="server" Text="Hello 1" /＞＜br /＞
＜asp:Calendar ID="Calendar1" runat="server"/＞
＜asp:GridView ID="GridView1" AutoGenerateColumns="False" DataSourceID="SqlDataSource1" DataKeyNames="au_id" runat="server"＞
……
＜/asp:GridView＞
＜asp:SqlDataSource ConnectionString="＜%$ ConnectionStrings:Pubs %＞" ID="SqlDataSource1" runat="server" SelectCommand="SELECT [au_id], [au_lname], [au_fname], [state] FROM [authors]"＞
＜/asp:SqlDataSource＞
App_Themes文件夹
主题位于应用程序根目录的App_Themes文件夹中。主题由一个为主题命名的子目录和这个子目录下的一个或多个皮肤文件（带有.skin扩展名）组成。主题还可以包含CSS文件和/或存放静态文件（例如图像）的子目录。下图显示了定义了两个主题的App_Themes目录，分别叫做"Default"和"White"，每个主题包含一个皮肤文件和一个CSS文件。
查看前面的例子，你会发现皮肤文件的内容就是控件如何显示的简单定义。一个皮肤文件可以包含多个控件定义，例如为每种控件类型提供一个定义。在应用主题的时候，主题中定义的控件属性自动地重载相同类型的控件的本地属性值。例如，皮肤文件中的＜asp:Calendar Font-Name="Verdana" runat="server"/＞控件定义将会引发应用了该主题的页面中的所有Calendar控件都使用Verdana字体。该控件的这个属性的本地值都会被主题重载。请注意，在皮肤文件中给控件定义指定ID属性是错误的。
如何构造一个C#语言的爬虫蜘蛛程序
C#特别适合于构造蜘蛛程序，这是因为它已经内置了HTTP访问和多线程的能力，而这两种能力对于蜘蛛程序来说都是非常关键的。下面是构造一个蜘蛛程序要解决的关键问题：
⑴ HTML分析：需要某种HTML解析器来分析蜘蛛程序遇到的每一个页面。
⑵ 页面处理：需要处理每一个下载得到的页面。下载得到的内容可能要保存到磁盘，或者进一步分析处理。
⑶ 多线程：只有拥有多线程能力，蜘蛛程序才能真正做到高效。
⑷ 确定何时完成：不要小看这个问题，确定任务是否已经完成并不简单，尤其是在多线程环境下。
一、HTML解析
本文提供的HTML解析器由ParseHTML类实现，使用非常方便：首先创建该类的一个实例，然后将它的Source属性设置为要解析的HTML文档：
ParseHTML parse = new ParseHTML();
parse.Source = "
Hello World
";
接下来就可以利用循环来检查HTML文档包含的所有文本和标记。通常，检查过程可以从一个测试Eof方法的while循环开始：
while(!parse.Eof())
{
char ch = parse.Parse();
Parse方法将返回HTML文档包含的字符--它返回的内容只包含那些非HTML标记的字符，如果遇到了HTML标记，Parse方法将返回0值，表示现在遇到了一个HTML标记。遇到一个标记之后，我们可以用GetTag()方法来处理它。
if(ch==0)
{
HTMLTag tag = parse.GetTag();
}
一般地，蜘蛛程序最重要的任务之一就是找出各个HREF属性，这可以借助C#的索引功能完成。例如，下面的代码将提取出HREF属性的值（如果存在的话）。
Attribute href = tag["HREF"];
string link = href.Value;
获得Attribute对象之后，通过Attribute.Value可以得到该属性的值。
二、处理HTML页面
下面来看看如何处理HTML页面。首先要做的当然是下载HTML页面，这可以通过C#提供的HttpWebRequest类实现：
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(m_uri);
response = request.GetResponse();
stream = response.GetResponseStream();
接下来我们就从request创建一个stream流。在执行其他处理之前，我们要先确定该文件是二进制文件还是文本文件，不同的文件类型处理方式也不同。下面的代码确定该文件是否为二进制文件。
if( !response.ContentType.ToLower().StartsWith("text/") )
{
SaveBinaryFile(response);
return null;
}
string buffer = "",line;
如果该文件不是文本文件，我们将它作为二进制文件读入。如果是文本文件，首先从stream创建一个StreamReader，然后将文本文件的内容一行一行加入缓冲区。
reader = new StreamReader(stream);
while( (line = reader.ReadLine())!=null )
{
buffer+=line+"rn";
}
装入整个文件之后，接着就要把它保存为文本文件。
SaveTextFile(buffer);
下面来看看这两类不同文件的存储方式。
二进制文件的内容类型声明不以"text/"开头，蜘蛛程序直接把二进制文件保存到磁盘，不必进行额外的处理，这是因为二进制文件不包含HTML，因此也不会再有需要蜘蛛程序处理的HTML链接。下面是写入二进制文件的步骤。
首先准备一个缓冲区临时地保存二进制文件的内容。 byte []buffer = new byte[1024];
接下来要确定文件保存到本地的路径和名称。如果要把一个myhost.com网站的内容下载到本地的c:test文件夹，二进制文件的网上路径和名称是http://myhost.com/images/logo.gif，则本地路径和名称应当是c:testimageslogo.gif。与此同时，我们还要确保c:test目录下已经创建了images子目录。这部分任务由convertFilename方法完成。
string filename = convertFilename( response.ResponseUri );
convertFilename方法分离HTTP地址，创建相应的目录结构。确定了输出文件的名字和路径之后就可以打开读取Web页面的输入流、写入本地文件的输出流。
Stream outStream = File.Create( filename );
Stream inStream = response.GetResponseStream();
接下来就可以读取Web文件的内容并写入到本地文件，这可以通过一个循环方便地完成。
int l;
do
{
l = inStream.Read(buffer,0,
buffer.Length);
if(l>0)
outStream.Write(buffer,0,l);
} while(l>0);
三、多线程
我们用DocumentWorker类封装所有下载一个URL的操作。每当一个DocumentWorker的实例被创建，它就进入循环，等待下一个要处理的URL。下面是DocumentWorker的主循环：
while(!m_spider.Quit )
{
m_uri = m_spider.ObtainWork();
m_spider.SpiderDone.WorkerBegin();
string page = GetPage();
if(page!=null)
ProcessPage(page);
m_spider.SpiderDone.WorkerEnd();
}
这个循环将一直运行，直至Quit标记被设置成了true（当用户点击"Cancel"按钮时，Quit标记就被设置成true）。在循环之内，我们调用ObtainWork获取一个URL。ObtainWork将一直等待，直到有一个URL可用--这要由其他线程解析文档并寻找链接才能获得。Done类利用WorkerBegin和WorkerEnd方法来确定何时整个下载操作已经完成。
从图一可以看出，蜘蛛程序允许用户自己确定要使用的线程数量。在实践中，线程的最佳数量受许多因素影响。如果你的机器性能较高，或者有两个处理器，可以设置较多的线程数量；反之，如果网络带宽、机器性能有限，设置太多的线程数量其实不一定能够提高性能。
四、任务完成了吗？
利用多个线程同时下载文件有效地提高了性能，但也带来了线程管理方面的问题。其中最复杂的一个问题是：蜘蛛程序何时才算完成了工作？在这里我们要借助一个专用的类Done来判断。
首先有必要说明一下"完成工作"的具体含义。只有当系统中不存在等待下载的URL，而且所有工作线程都已经结束其处理工作时，蜘蛛程序的工作才算完成。也就是说，完成工作意味着已经没有等待下载和正在下载的URL。
Done类提供了一个WaitDone方法，它的功能是一直等待，直到Done对象检测到蜘蛛程序已完成工作。下面是WaitDone方法的代码。
public void WaitDone()
{
Monitor.Enter(this);
while ( m_activeThreads>0 )
{
Monitor.Wait(this);
}
Monitor.Exit(this);
}
WaitDone方法将一直等待，直到不再有活动的线程。但必须注意的是，下载开始的最初阶段也没有任何活动的线程，所以很容易造成蜘蛛程序一开始就立即停止的现象。为解决这个问题，我们还需要另一个方法WaitBegin来等待蜘蛛程序进入"正式的"工作阶段。一般的调用次序是：先调用WaitBegin，再接着调用WaitDone，WaitDone将等待蜘蛛程序完成工作。下面是WaitBegin的代码：
public void WaitBegin()
{
Monitor.Enter(this);
while ( !m_started )
{
Monitor.Wait(this);
}
Monitor.Exit(this);
}
WaitBegin方法将一直等待，直到m_started标记被设置。m_started标记是由WorkerBegin方法设置的。工作线程在开始处理各个URL之时，会调用WorkerBegin；处理结束时调用WorkerEnd。WorkerBegin和WorkerEnd这两个方法帮助Done对象确定当前的工作状态。下面是WorkerBegin方法的代码：
public void WorkerBegin()
{
Monitor.Enter(this);
m_activeThreads++;
m_started = true;
Monitor.Pulse(this);
Monitor.Exit(this);
}
WorkerBegin方法首先增加当前活动线程的数量，接着设置m_started标记，最后调用Pulse方法以通知（可能存在的）等待工作线程启动的线程。如前所述，可能等待Done对象的方法是WaitBegin方法。每处理完一个URL，WorkerEnd方法会被调用：
public void WorkerEnd()
{
Monitor.Enter(this);
m_activeThreads--;
Monitor.Pulse(this);
Monitor.Exit(this);
}
⑴ HTML分析：需要某种HTML解析器来分析蜘蛛程序遇到的每一个页面。
⑵ 页面处理：需要处理每一个下载得到的页面。下载得到的内容可能要保存到磁盘，或者进一步分析处理。
⑶ 多线程：只有拥有多线程能力，蜘蛛程序才能真正做到高效。
⑷ 确定何时完成：不要小看这个问题，确定任务是否已经完成并不简单，尤其是在多线程环境下。
一、HTML解析
本文提供的HTML解析器由ParseHTML类实现，使用非常方便：首先创建该类的一个实例，然后将它的Source属性设置为要解析的HTML文档：
ParseHTML parse = new ParseHTML();
parse.Source = "
Hello World
";
接下来就可以利用循环来检查HTML文档包含的所有文本和标记。通常，检查过程可以从一个测试Eof方法的while循环开始：
while(!parse.Eof())
{
char ch = parse.Parse();
Parse方法将返回HTML文档包含的字符--它返回的内容只包含那些非HTML标记的字符，如果遇到了HTML标记，Parse方法将返回0值，表示现在遇到了一个HTML标记。遇到一个标记之后，我们可以用GetTag()方法来处理它。
if(ch==0)
{
HTMLTag tag = parse.GetTag();
}
一般地，蜘蛛程序最重要的任务之一就是找出各个HREF属性，这可以借助C#的索引功能完成。例如，下面的代码将提取出HREF属性的值（如果存在的话）。
Attribute href = tag["HREF"];
string link = href.Value;
获得Attribute对象之后，通过Attribute.Value可以得到该属性的值。
二、处理HTML页面
下面来看看如何处理HTML页面。首先要做的当然是下载HTML页面，这可以通过C#提供的HttpWebRequest类实现：
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(m_uri);
response = request.GetResponse();
stream = response.GetResponseStream();
接下来我们就从request创建一个stream流。在执行其他处理之前，我们要先确定该文件是二进制文件还是文本文件，不同的文件类型处理方式也不同。下面的代码确定该文件是否为二进制文件。
if( !response.ContentType.ToLower().StartsWith("text/") )
{
SaveBinaryFile(response);
return null;
}
string buffer = "",line;
如果该文件不是文本文件，我们将它作为二进制文件读入。如果是文本文件，首先从stream创建一个StreamReader，然后将文本文件的内容一行一行加入缓冲区。
reader = new StreamReader(stream);
while( (line = reader.ReadLine())!=null )
{
buffer+=line+"rn";
}
装入整个文件之后，接着就要把它保存为文本文件。
SaveTextFile(buffer);
下面来看看这两类不同文件的存储方式。
二进制文件的内容类型声明不以"text/"开头，蜘蛛程序直接把二进制文件保存到磁盘，不必进行额外的处理，这是因为二进制文件不包含HTML，因此也不会再有需要蜘蛛程序处理的HTML链接。下面是写入二进制文件的步骤。
首先准备一个缓冲区临时地保存二进制文件的内容。 byte []buffer = new byte[1024];
接下来要确定文件保存到本地的路径和名称。如果要把一个myhost.com网站的内容下载到本地的c:test文件夹，二进制文件的网上路径和名称是http://myhost.com/images/logo.gif，则本地路径和名称应当是c:testimageslogo.gif。与此同时，我们还要确保c:test目录下已经创建了images子目录。这部分任务由convertFilename方法完成。
string filename = convertFilename( response.ResponseUri );
convertFilename方法分离HTTP地址，创建相应的目录结构。确定了输出文件的名字和路径之后就可以打开读取Web页面的输入流、写入本地文件的输出流。
Stream outStream = File.Create( filename );
Stream inStream = response.GetResponseStream();
接下来就可以读取Web文件的内容并写入到本地文件，这可以通过一个循环方便地完成。
int l;
do
{
l = inStream.Read(buffer,0,
buffer.Length);
if(l>0)
outStream.Write(buffer,0,l);
} while(l>0);
三、多线程
我们用DocumentWorker类封装所有下载一个URL的操作。每当一个DocumentWorker的实例被创建，它就进入循环，等待下一个要处理的URL。下面是DocumentWorker的主循环：
while(!m_spider.Quit )
{
m_uri = m_spider.ObtainWork();
m_spider.SpiderDone.WorkerBegin();
string page = GetPage();
if(page!=null)
ProcessPage(page);
m_spider.SpiderDone.WorkerEnd();
}
这个循环将一直运行，直至Quit标记被设置成了true（当用户点击"Cancel"按钮时，Quit标记就被设置成true）。在循环之内，我们调用ObtainWork获取一个URL。ObtainWork将一直等待，直到有一个URL可用--这要由其他线程解析文档并寻找链接才能获得。Done类利用WorkerBegin和WorkerEnd方法来确定何时整个下载操作已经完成。
从图一可以看出，蜘蛛程序允许用户自己确定要使用的线程数量。在实践中，线程的最佳数量受许多因素影响。如果你的机器性能较高，或者有两个处理器，可以设置较多的线程数量；反之，如果网络带宽、机器性能有限，设置太多的线程数量其实不一定能够提高性能。
四、任务完成了吗？
利用多个线程同时下载文件有效地提高了性能，但也带来了线程管理方面的问题。其中最复杂的一个问题是：蜘蛛程序何时才算完成了工作？在这里我们要借助一个专用的类Done来判断。
首先有必要说明一下"完成工作"的具体含义。只有当系统中不存在等待下载的URL，而且所有工作线程都已经结束其处理工作时，蜘蛛程序的工作才算完成。也就是说，完成工作意味着已经没有等待下载和正在下载的URL。
Done类提供了一个WaitDone方法，它的功能是一直等待，直到Done对象检测到蜘蛛程序已完成工作。下面是WaitDone方法的代码。
public void WaitDone()
{
Monitor.Enter(this);
while ( m_activeThreads>0 )
{
Monitor.Wait(this);
}
Monitor.Exit(this);
}
WaitDone方法将一直等待，直到不再有活动的线程。但必须注意的是，下载开始的最初阶段也没有任何活动的线程，所以很容易造成蜘蛛程序一开始就立即停止的现象。为解决这个问题，我们还需要另一个方法WaitBegin来等待蜘蛛程序进入"正式的"工作阶段。一般的调用次序是：先调用WaitBegin，再接着调用WaitDone，WaitDone将等待蜘蛛程序完成工作。下面是WaitBegin的代码：
public void WaitBegin()
{
Monitor.Enter(this);
while ( !m_started )
{
Monitor.Wait(this);
}
Monitor.Exit(this);
}
WaitBegin方法将一直等待，直到m_started标记被设置。m_started标记是由WorkerBegin方法设置的。工作线程在开始处理各个URL之时，会调用WorkerBegin；处理结束时调用WorkerEnd。WorkerBegin和WorkerEnd这两个方法帮助Done对象确定当前的工作状态。下面是WorkerBegin方法的代码：
public void WorkerBegin()
{
Monitor.Enter(this);
m_activeThreads++;
m_started = true;
Monitor.Pulse(this);
Monitor.Exit(this);
}
WorkerBegin方法首先增加当前活动线程的数量，接着设置m_started标记，最后调用Pulse方法以通知（可能存在的）等待工作线程启动的线程。如前所述，可能等待Done对象的方法是WaitBegin方法。每处理完一个URL，WorkerEnd方法会被调用：
public void WorkerEnd()
{
Monitor.Enter(this);
m_activeThreads--;
Monitor.Pulse(this);
Monitor.Exit(this);
}
2008年9月9日星期二
VS.NET 2003开发移动Web应用 六
移动.net图像
移动.NET在不同设备类型上显示不同图像的类型。
Image控件
不同的移动设备显示的兼容性不同。
Image控件允许开发者为不同的设备类型指定图像的不同类型。
Image类型
有些移动设备显示GIF图像，有些显示BMP或者WBM图像，Image控件允许你为每个适合的图像类型指定不同的图像。
这个移动页面显示一个图像：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜Mobile:Form runat="server"＞
＜Mobile:Image runat="server"＞
＜DeviceSpecific＞
＜Choice ImageURL="image.gif" /＞
＜Choice ImageURL="image.bmp" /＞
＜Choice ImageURL="image.wbmp" /＞
＜/DeviceSpecific＞
＜/Mobile:Image＞
＜/Mobile:Form＞
当这个页面显示在Pocket PC上的时候，将显示成GIF图像。在手机上将根据收集的特性显示成WBMP或者BMP图像。
移动.NET Utility
Utility控件通过很少的代码支持复杂的用户界面。
Adrotator 控件
这个移动页面显示不同的广告：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜Mobile:Form runat="server"＞
＜Mobile:AdRotator runat="server"
AdvertisementFile="advertisements.XML"＞
＜/Mobile:AdRotator＞
＜/Mobile:Form＞
这个是广告(ad)文件叫做“advertisements.xml”：
＜?xml version="1.0" ?＞
＜Advertisements＞
＜Ad＞
＜ImageUrl＞image1.gif＜/ImageUrl＞
＜BmpImageUrl＞image1.bmp＜/BmpImageUrl＞
＜WBmpImageUrl＞image1.wbmp＜/WBmpImageUrl＞
＜NavigateUrl＞http://www.1.com＜/NavigateUrl＞
＜AlternateText＞Visit 1＜/AlternateText＞
＜/Ad＞
＜Ad＞
＜ImageUrl＞image2.gif＜/ImageUrl＞
＜BmpImageUrl＞image2.bmp＜/BmpImageUrl＞
＜WBmpImageUrl＞image2.wbmp＜/WBmpImageUrl＞
＜NavigateUrl＞http://www.2.com＜/NavigateUrl＞
＜AlternateText＞Visit 2＜/AlternateText＞
＜/Ad＞
＜Ad＞
＜ImageUrl＞image3.gif＜/ImageUrl＞
＜BmpImageUrl＞image3.bmp＜/BmpImageUrl＞
＜WBmpImageUrl＞image3.wbmp＜/WBmpImageUrl＞
＜NavigateUrl＞http://www.3.com＜/NavigateUrl＞
＜AlternateText＞Visit 3＜/AlternateText＞
＜/Ad＞
＜/Advertisements＞
日历控件
这个也动页面显示一个日历：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub CalChanged(sender as Object,e as EventArgs)
lab1.Text="You selected " & c1.SelectedDate
ActiveForm=f2
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:Calendar id="c1"
OnSelectionChanged="CalChanged" runat="server" /＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label id="lab1" runat="server" /＞
＜/Mobile:Form＞
这个例子里日历显示在第一个表单里，当用户从日历里面选择数据时，选择的日期显示在新的页面里。
PhoneCall控件
当用户选择文本这个移动页面显示文本“Tove’s number”和电话号码(555)555-5555。
The PhoneCall Control
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜Mobile:Form runat="server"＞
＜Mobile:PhoneCall runat="server"
PhoneNumber="(555) 555-5555"
Text="Tove''s number"
AlternateFormat="{0}" /＞
＜/Mobile:Form＞
这里的属性”AllternateFormat”是{0}。设置成这种显示将会显示为文本状。
如果你是用值{1}它将显示成”PhoneNumber”。
你也可以实用如下的构作AlternateFormat =”{0}is{1}”.这时候将会显示“Tove''s number is (555) 555-5555”。
Utility 控件
Name Function
AdRotator Displays advertisements
Calendar Displays a calendar
PhoneCall Calls a telephone number
移动.NET在不同设备类型上显示不同图像的类型。
Image控件
不同的移动设备显示的兼容性不同。
Image控件允许开发者为不同的设备类型指定图像的不同类型。
Image类型
有些移动设备显示GIF图像，有些显示BMP或者WBM图像，Image控件允许你为每个适合的图像类型指定不同的图像。
这个移动页面显示一个图像：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜Mobile:Form runat="server"＞
＜Mobile:Image runat="server"＞
＜DeviceSpecific＞
＜Choice ImageURL="image.gif" /＞
＜Choice ImageURL="image.bmp" /＞
＜Choice ImageURL="image.wbmp" /＞
＜/DeviceSpecific＞
＜/Mobile:Image＞
＜/Mobile:Form＞
当这个页面显示在Pocket PC上的时候，将显示成GIF图像。在手机上将根据收集的特性显示成WBMP或者BMP图像。
移动.NET Utility
Utility控件通过很少的代码支持复杂的用户界面。
Adrotator 控件
这个移动页面显示不同的广告：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜Mobile:Form runat="server"＞
＜Mobile:AdRotator runat="server"
AdvertisementFile="advertisements.XML"＞
＜/Mobile:AdRotator＞
＜/Mobile:Form＞
这个是广告(ad)文件叫做“advertisements.xml”：
＜?xml version="1.0" ?＞
＜Advertisements＞
＜Ad＞
＜ImageUrl＞image1.gif＜/ImageUrl＞
＜BmpImageUrl＞image1.bmp＜/BmpImageUrl＞
＜WBmpImageUrl＞image1.wbmp＜/WBmpImageUrl＞
＜NavigateUrl＞http://www.1.com＜/NavigateUrl＞
＜AlternateText＞Visit 1＜/AlternateText＞
＜/Ad＞
＜Ad＞
＜ImageUrl＞image2.gif＜/ImageUrl＞
＜BmpImageUrl＞image2.bmp＜/BmpImageUrl＞
＜WBmpImageUrl＞image2.wbmp＜/WBmpImageUrl＞
＜NavigateUrl＞http://www.2.com＜/NavigateUrl＞
＜AlternateText＞Visit 2＜/AlternateText＞
＜/Ad＞
＜Ad＞
＜ImageUrl＞image3.gif＜/ImageUrl＞
＜BmpImageUrl＞image3.bmp＜/BmpImageUrl＞
＜WBmpImageUrl＞image3.wbmp＜/WBmpImageUrl＞
＜NavigateUrl＞http://www.3.com＜/NavigateUrl＞
＜AlternateText＞Visit 3＜/AlternateText＞
＜/Ad＞
＜/Advertisements＞
日历控件
这个也动页面显示一个日历：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub CalChanged(sender as Object,e as EventArgs)
lab1.Text="You selected " & c1.SelectedDate
ActiveForm=f2
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:Calendar id="c1"
OnSelectionChanged="CalChanged" runat="server" /＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label id="lab1" runat="server" /＞
＜/Mobile:Form＞
这个例子里日历显示在第一个表单里，当用户从日历里面选择数据时，选择的日期显示在新的页面里。
PhoneCall控件
当用户选择文本这个移动页面显示文本“Tove’s number”和电话号码(555)555-5555。
The PhoneCall Control
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜Mobile:Form runat="server"＞
＜Mobile:PhoneCall runat="server"
PhoneNumber="(555) 555-5555"
Text="Tove''s number"
AlternateFormat="{0}" /＞
＜/Mobile:Form＞
这里的属性”AllternateFormat”是{0}。设置成这种显示将会显示为文本状。
如果你是用值{1}它将显示成”PhoneNumber”。
你也可以实用如下的构作AlternateFormat =”{0}is{1}”.这时候将会显示“Tove''s number is (555) 555-5555”。
Utility 控件
Name Function
AdRotator Displays advertisements
Calendar Displays a calendar
PhoneCall Calls a telephone number
VS.NET 2003开发移动Web应用 五
移动.net列表
移动列表控件支持不同的输入和显示特性。
从List中选择
这个页面有两个表单：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub Show_Price(sender As Object,e As ListCommandEventArgs)
text1.Text=e.ListItem.Text & "=" & e.ListItem.Value
ActiveForm=f2
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:List runat="server"
OnItemCommand="Show_Price"＞
＜Item text="Volvo" value="$30,000" /＞
＜Item text="BMW" value="$32,000" /＞
＜Item text="Audi" value="$34,000" /＞
＜/Mobile:List＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label runat="server" id="text1" /＞
＜/Mobile:Form＞
第一个表单有一个车的列表。
第二个页面显示价钱。当在第一个页上选择一个车这个页面就被激活。
当这个应用程序运行在移动的设备上这两个页面看起来就像下面的：
移动.NET选择列表
SelectionList控件支持下拉框，复选框以及单选按钮。
SelectionList
这个移动页面使用SelectionList让用户选择车：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub Car_Click(sender as Object, e as EventArgs)
ActiveForm=f2
t1.text=cars.Selection.Value
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:SelectionList runat="server" id="cars" ＞
＜Item Text="Volvo" Value="$30,000" /＞
＜Item Text="BMW" Value="$32,000" /＞
＜Item Text="Audi" Value="$34,000" /＞
＜/Mobile:SelectionList＞
＜Mobile:Command runat="server"
OnClick="Car_Click" Text="Submit" /＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label id="t1" runat="server" /＞
＜/Mobile:Form＞
移动列表控件支持不同的输入和显示特性。
从List中选择
这个页面有两个表单：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub Show_Price(sender As Object,e As ListCommandEventArgs)
text1.Text=e.ListItem.Text & "=" & e.ListItem.Value
ActiveForm=f2
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:List runat="server"
OnItemCommand="Show_Price"＞
＜Item text="Volvo" value="$30,000" /＞
＜Item text="BMW" value="$32,000" /＞
＜Item text="Audi" value="$34,000" /＞
＜/Mobile:List＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label runat="server" id="text1" /＞
＜/Mobile:Form＞
第一个表单有一个车的列表。
第二个页面显示价钱。当在第一个页上选择一个车这个页面就被激活。
当这个应用程序运行在移动的设备上这两个页面看起来就像下面的：
移动.NET选择列表
SelectionList控件支持下拉框，复选框以及单选按钮。
SelectionList
这个移动页面使用SelectionList让用户选择车：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ Register
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub Car_Click(sender as Object, e as EventArgs)
ActiveForm=f2
t1.text=cars.Selection.Value
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:SelectionList runat="server" id="cars" ＞
＜Item Text="Volvo" Value="$30,000" /＞
＜Item Text="BMW" Value="$32,000" /＞
＜Item Text="Audi" Value="$34,000" /＞
＜/Mobile:SelectionList＞
＜Mobile:Command runat="server"
OnClick="Car_Click" Text="Submit" /＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label id="t1" runat="server" /＞
＜/Mobile:Form＞
VS.NET 2003开发移动Web应用 四
移动.net输入验证
验证控件用来验证用户输入的数据。
验证控件
验证控件用来验证用户输入的数据。
验证控件允许你去验证输入控件（比如：TextBox）并且当验证失败的时候显示消息。
每个验证控件完成特定类型的验证（比如：不是指定的值或者不是指定的范围）。
默认情况下，当命令控件被点击得失后页面验证才处理。设置控件的CausesValidation属性为false后当控件被点击时你可以阻止页面的验证（和ASP.NET的模式一样设置命令控件（可能激发服务器事件的）的CausesValidation可以不用激发验证逻辑）。
验证输入
这个页面包含两个表单：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub Page2(Sender as Object,E as EventArgs)
If Page.IsValid Then
ActiveForm=f2
text2.Text="You are " & age.text & " years old"
end if
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:CompareValidator runat="server"
ControlToValidate="age"
Type="Integer"
ValueToCompare="18"
Operator="GreaterThanEqual"＞
You must be at least 18
＜/Mobile:CompareValidator＞
＜Mobile:Label runat="server"＞Age?＜/Mobile:Label＞
＜Mobile:TextBox id="age" runat="server" /＞
＜Mobile:Command OnClick="Page2" runat="server"＞
Submit＜/Mobile:Command＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label id="text2" runat="server" /＞
＜/Mobile:Form＞
第一个表单有一个Text属性是Age的Label控件，一个输入年龄的输入框以及一个提交按钮。
通过点击第一个页面的提交按钮后第二个页面被激活，显示相应。
如果验证输入错误，错误消息被显示出来。
当应用程序运行在移动设备上，这两个页面看起来象下面的样子：
ValidationSummary 控件
前面的例子使用CompareValidator控件验证输入的信息。输入信息的验证通过验证控件的属性ContolToValidate定义。
你也可以实用ValidationSummary控件的属性FormToValidate，去验证表单里的所有的输入信息。（功能和ASP.NET一样）
这种方式你可以用错误的摘要信息替换原来的单个错误显示。
验证控件参考
Name Function
CompareValidator Compares two values
CustomValidator Provides custom validation
RangeValidator Validates a range
RegularExpressionValidator Validates an expression
RequiredFieldValidator Validates required data
ValidationSummary Displays a validation summary
要得到包括属性方法、事件以及更多实例的控件完整参考，请参考”Mobile Reference”页面。（译者注：参考原始页面或者MSDN。）
验证控件用来验证用户输入的数据。
验证控件
验证控件用来验证用户输入的数据。
验证控件允许你去验证输入控件（比如：TextBox）并且当验证失败的时候显示消息。
每个验证控件完成特定类型的验证（比如：不是指定的值或者不是指定的范围）。
默认情况下，当命令控件被点击得失后页面验证才处理。设置控件的CausesValidation属性为false后当控件被点击时你可以阻止页面的验证（和ASP.NET的模式一样设置命令控件（可能激发服务器事件的）的CausesValidation可以不用激发验证逻辑）。
验证输入
这个页面包含两个表单：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Sub Page2(Sender as Object,E as EventArgs)
If Page.IsValid Then
ActiveForm=f2
text2.Text="You are " & age.text & " years old"
end if
End Sub
＜/script＞
＜Mobile:Form id="f1" runat="server"＞
＜Mobile:CompareValidator runat="server"
ControlToValidate="age"
Type="Integer"
ValueToCompare="18"
Operator="GreaterThanEqual"＞
You must be at least 18
＜/Mobile:CompareValidator＞
＜Mobile:Label runat="server"＞Age?＜/Mobile:Label＞
＜Mobile:TextBox id="age" runat="server" /＞
＜Mobile:Command OnClick="Page2" runat="server"＞
Submit＜/Mobile:Command＞
＜/Mobile:Form＞
＜Mobile:Form id="f2" runat="server"＞
＜Mobile:Label id="text2" runat="server" /＞
＜/Mobile:Form＞
第一个表单有一个Text属性是Age的Label控件，一个输入年龄的输入框以及一个提交按钮。
通过点击第一个页面的提交按钮后第二个页面被激活，显示相应。
如果验证输入错误，错误消息被显示出来。
当应用程序运行在移动设备上，这两个页面看起来象下面的样子：
ValidationSummary 控件
前面的例子使用CompareValidator控件验证输入的信息。输入信息的验证通过验证控件的属性ContolToValidate定义。
你也可以实用ValidationSummary控件的属性FormToValidate，去验证表单里的所有的输入信息。（功能和ASP.NET一样）
这种方式你可以用错误的摘要信息替换原来的单个错误显示。
验证控件参考
Name Function
CompareValidator Compares two values
CustomValidator Provides custom validation
RangeValidator Validates a range
RegularExpressionValidator Validates an expression
RequiredFieldValidator Validates required data
ValidationSummary Displays a validation summary
要得到包括属性方法、事件以及更多实例的控件完整参考，请参考”Mobile Reference”页面。（译者注：参考原始页面或者MSDN。）
VS.NET 2003开发移动Web应用 三
移动.net输入
输入控件
有很多的移动控件支持用户输入。
在前面的demo中，最长用的输入控件可能就是TextBox控件了。TextBox是完成一些简单的输入，比如像姓名，数量，以及标识符和关键字。
如果输入大量的文本那么TextView控件可能是更好的选择。TextView控件允许长的多行的输入就像你用MSN给其他人发消息一样。
数字输入
我们可以通过设置TextBox的属性Numeric让TextBox只接收来接收数字的输入信息。
注意：这个特性通常工作在通过改变从文字到数字的输入模式的手机上。然而在HTML的浏览器上，通常不支持这种行为。
密码输入
我们可以将TextBox控件的Password属性设置成true或者false来指定TextBox处理密码字段。
密码字段将会通过*（星号）替换原始的文本来隐藏输入信息。
列表控件
TextBox和TextView控件是非常适合输入信息的，但是有时你想让用户从已有的列表中选择事先定义好的值。
SelectionList控件支持下拉列表，复选选框和单选按钮。这部分的内容将在其他的章节介绍。
List控件支持菜单和列表的选项，List控件将会在其他的章节介绍。
用户界面控件
用户控件是显示用户界面的控件集。
Name Function
Command Performs an action
Form Defines a container for mobile controls
Image Defines an image
Label Defines a text
Link Defines a hyPerlink
List Defines a list
MobilePage Defines a container for mobile controls
ObjectList Defines a list of data objects
Panel Defines a container for other controls
SelectionList Defines a list to select from
StyleSheet Defines styles to be applied to other controls
TextBox Defines a single line input box
TextView Defines a multi-line input box
输入控件
有很多的移动控件支持用户输入。
在前面的demo中，最长用的输入控件可能就是TextBox控件了。TextBox是完成一些简单的输入，比如像姓名，数量，以及标识符和关键字。
如果输入大量的文本那么TextView控件可能是更好的选择。TextView控件允许长的多行的输入就像你用MSN给其他人发消息一样。
数字输入
我们可以通过设置TextBox的属性Numeric让TextBox只接收来接收数字的输入信息。
注意：这个特性通常工作在通过改变从文字到数字的输入模式的手机上。然而在HTML的浏览器上，通常不支持这种行为。
密码输入
我们可以将TextBox控件的Password属性设置成true或者false来指定TextBox处理密码字段。
密码字段将会通过*（星号）替换原始的文本来隐藏输入信息。
列表控件
TextBox和TextView控件是非常适合输入信息的，但是有时你想让用户从已有的列表中选择事先定义好的值。
SelectionList控件支持下拉列表，复选选框和单选按钮。这部分的内容将在其他的章节介绍。
List控件支持菜单和列表的选项，List控件将会在其他的章节介绍。
用户界面控件
用户控件是显示用户界面的控件集。
Name Function
Command Performs an action
Form Defines a container for mobile controls
Image Defines an image
Label Defines a text
Link Defines a hyPerlink
List Defines a list
MobilePage Defines a container for mobile controls
ObjectList Defines a list of data objects
Panel Defines a container for other controls
SelectionList Defines a list to select from
StyleSheet Defines styles to be applied to other controls
TextBox Defines a single line input box
TextView Defines a multi-line input box
VS.NET 2003开发移动Web应用 二
移动.net事件
移动控件有一个可对属性，方法和事件编程的对象模型。
要得到完整的信息请参考MSDN。
提交文本
这个页面有两个表单：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Dim age
Sub AgeClick(sender As Object, e As EventArgs)
age=text1.Text
ActiveForm=Form2
End Sub
Sub Form2_Activate(sender As Object,e As EventArgs)
message.Text="You are " & age & " years old"
End Sub
＜/script＞
＜Mobile:Form id="form1" runat="server"＞
＜Mobile:Label runat="server"＞Age?＜/Mobile:Label＞
＜Mobile:TextBox runat="server" id="text1" /＞
＜Mobile:Command runat="server" OnClick="AgeClick" Text="Submit" /＞
＜/Mobile:Form＞
＜Mobile:Form id="form2" runat="server" OnActivate="Form2_Activate"＞
＜Mobile:Label runat="server" id="message" /＞
＜/Mobile:Form＞
当一个页面有两个表单的时候，第一个表单总是作为打开的默认表单。
第一个表单有一内容是Age的label控件，一个输入控件用来输入年龄(Age)以及一个提交（Submit）按钮。
第二个页面通过第一个页面的提交按钮激活（译者注：偶觉的是第二个Form通过第一个Form的提交按钮激活，而不是原文种的Page。），同时显示相应信息。
当应用程序运行在移动设备上的时候，这两个页面看起来就像下面
移动控件有一个可对属性，方法和事件编程的对象模型。
要得到完整的信息请参考MSDN。
提交文本
这个页面有两个表单：
＜%@ Page
Inherits=
"System.Web.UI.MobileControls.MobilePage"%＞
＜%@ ReGISter
TagPrefix="Mobile"
Namespace="System.Web.UI.MobileControls"
Assembly="System.Web.Mobile" %＞
＜script runat="server"＞
Dim age
Sub AgeClick(sender As Object, e As EventArgs)
age=text1.Text
ActiveForm=Form2
End Sub
Sub Form2_Activate(sender As Object,e As EventArgs)
message.Text="You are " & age & " years old"
End Sub
＜/script＞
＜Mobile:Form id="form1" runat="server"＞
＜Mobile:Label runat="server"＞Age?＜/Mobile:Label＞
＜Mobile:TextBox runat="server" id="text1" /＞
＜Mobile:Command runat="server" OnClick="AgeClick" Text="Submit" /＞
＜/Mobile:Form＞
＜Mobile:Form id="form2" runat="server" OnActivate="Form2_Activate"＞
＜Mobile:Label runat="server" id="message" /＞
＜/Mobile:Form＞
当一个页面有两个表单的时候，第一个表单总是作为打开的默认表单。
第一个表单有一内容是Age的label控件，一个输入控件用来输入年龄(Age)以及一个提交（Submit）按钮。
第二个页面通过第一个页面的提交按钮激活（译者注：偶觉的是第二个Form通过第一个Form的提交按钮激活，而不是原文种的Page。），同时显示相应信息。
当应用程序运行在移动设备上的时候，这两个页面看起来就像下面
VS.NET 2003开发移动Web应用 一
背景
手机(移动电话)已经成为我们生活的一部分,一些新的设备添加到其中比如:PalmPilot,Pocket PC以及马上产生的AutoPC。
幸运的是这些新的移动设备都可以连接网络或者执行应用程序.
现在的移动应用程序被开发成可以传递数据的任何类型给世界上任何地方的任何人.
不同的移动设备支持不同的编程语言.有些支持WAP和WML,有些则支持HTML或者受限制的HTML,还有些同时支持以上两种或者其他不同的语言.
为了支持所有类型的移动设备,开发人员不得不为每一种语言创建不同的应用程序.
移动的.net,微软已经为移动应用程序的开发生产了新的平台.
该向导是一个关于如何运用扩展的.NET框架开发移动应用程序,叫做MMIT(Microsoft Mobile Internet Toolkit)或者简单的叫做移动.NET(.NET Mobile).
移动.NET(.NET Mobile)
移动.NET是微软ASP.NET和微软.NET框架的扩展.
移动.NET是一组用来来创建应用程序的服务器端的Web Forms控件,比如:Web电话和PDA.
那些控件通过产生WML1.1,HTNL3.2或者简单的(compact)HTML给不同的设备呈现不同的输出.(译者注:就是对应不同设备的不同呈现.)
如何工作
下面的表格显示了移动.NET是如何工作的:
移动设备
Internet网络
IIS服务
.NET框架
ASP.NET
移动.NET
1. web客户端请求web页面.
2. internet上传送该请求.
3. 通过IIS接收该请求.
4. 通过.NET框架处理该请求.
5. 通过ASP.NET编译请求的页面.
6. 移动.NET处理任何移动设备的要求.( .NET Mobile handles any mobile device requirements)(译者注:这里处理详细的设备信息,以及该如何呈现页面)
7. 页面被返回给客户端.
软件要求
要使用移动.NET开发移动的应用程序,你必须拥有下面的环境或者组件:
1. 带IIS5的Windows 2000 Professional 或者Server
2. 所有的Windows 2000的补丁.
3. ASP.NET框架(译者注:.NET 框架).
4. 微软移动网络工具包(Microsoft Mobile Internet Toolkit MMIT).
5. IE 6.0或者5.5
6. 你喜欢的模拟器.
你许要使用Windows 2000开发.NET应用程序.同时你还必须安装Windows 2000的所有补丁程序.
IIS 5(Internet Information Service)是Windows 2000的一部分.
如果你想要了解更多的关于如何安装.NET的资料请去我们的ASP.NET tutorial.
你还要安装MMIT(.NET Mobile)和最新版本的IE浏览器.
IE和MMIT可以去这里Microsoft MSDN下载.
如何开始
用ASP.NET开发移动Web应用程序非常简单:
1. 创建ASP.NET页面.
2. 加入命名控件System.Mobile.UI.(译者注:在VS2003不用这么麻烦,建立移动项目这些都已经做好了).
3. 添加移动控件到页面上.
手机(移动电话)已经成为我们生活的一部分,一些新的设备添加到其中比如:PalmPilot,Pocket PC以及马上产生的AutoPC。
幸运的是这些新的移动设备都可以连接网络或者执行应用程序.
现在的移动应用程序被开发成可以传递数据的任何类型给世界上任何地方的任何人.
不同的移动设备支持不同的编程语言.有些支持WAP和WML,有些则支持HTML或者受限制的HTML,还有些同时支持以上两种或者其他不同的语言.
为了支持所有类型的移动设备,开发人员不得不为每一种语言创建不同的应用程序.
移动的.net,微软已经为移动应用程序的开发生产了新的平台.
该向导是一个关于如何运用扩展的.NET框架开发移动应用程序,叫做MMIT(Microsoft Mobile Internet Toolkit)或者简单的叫做移动.NET(.NET Mobile).
移动.NET(.NET Mobile)
移动.NET是微软ASP.NET和微软.NET框架的扩展.
移动.NET是一组用来来创建应用程序的服务器端的Web Forms控件,比如:Web电话和PDA.
那些控件通过产生WML1.1,HTNL3.2或者简单的(compact)HTML给不同的设备呈现不同的输出.(译者注:就是对应不同设备的不同呈现.)
如何工作
下面的表格显示了移动.NET是如何工作的:
移动设备
Internet网络
IIS服务
.NET框架
ASP.NET
移动.NET
1. web客户端请求web页面.
2. internet上传送该请求.
3. 通过IIS接收该请求.
4. 通过.NET框架处理该请求.
5. 通过ASP.NET编译请求的页面.
6. 移动.NET处理任何移动设备的要求.( .NET Mobile handles any mobile device requirements)(译者注:这里处理详细的设备信息,以及该如何呈现页面)
7. 页面被返回给客户端.
软件要求
要使用移动.NET开发移动的应用程序,你必须拥有下面的环境或者组件:
1. 带IIS5的Windows 2000 Professional 或者Server
2. 所有的Windows 2000的补丁.
3. ASP.NET框架(译者注:.NET 框架).
4. 微软移动网络工具包(Microsoft Mobile Internet Toolkit MMIT).
5. IE 6.0或者5.5
6. 你喜欢的模拟器.
你许要使用Windows 2000开发.NET应用程序.同时你还必须安装Windows 2000的所有补丁程序.
IIS 5(Internet Information Service)是Windows 2000的一部分.
如果你想要了解更多的关于如何安装.NET的资料请去我们的ASP.NET tutorial.
你还要安装MMIT(.NET Mobile)和最新版本的IE浏览器.
IE和MMIT可以去这里Microsoft MSDN下载.
如何开始
用ASP.NET开发移动Web应用程序非常简单:
1. 创建ASP.NET页面.
2. 加入命名控件System.Mobile.UI.(译者注:在VS2003不用这么麻烦,建立移动项目这些都已经做好了).
3. 添加移动控件到页面上.
用VS2005实现ASP.NET2.0移动开发
即将到来的3G技术，将使得移动设备突破现在的带宽限制，这样我们就可以构建出许多新颖且功能强大的移动应用。现在已经有许多商业应用都开始向移动设备上进行迁移，所以对开发者来说，现在就开始移动开发的学习将是一种非常适合的时机。
在本文中我将介绍如何使用Visual Studio 2005创建一个ASP.net 2.0移动程序，然后介绍一些常用的移动开发控件并以适合的方式在程序中加于应用，最后将谈谈如何开发针对特定移动设备的Web程序和管理程序中的ViewState(视图状态)和Session。
创建一个新的ASP.NET 移动WEB程序
Visual Studio 2005提供了一组功能强大且友好的开发工具来创建移动WEB程序，如果你已经有创建传统的ASP.NET应用程序的经验，那么你就会发现创建移动WEB程序和创建传统的ASP.NET应用程序是非常类似的。你只需要创建一个ASP.NET网站项目并添加一些移动WEB窗体即可。当你添加移动WEB窗体后，你就会发现在工具箱中添加了如下图所示的ASP.NET移动控件。
现在你可以按照如下的步骤在Visual Studio 2005创建一个新的ASP.NET 移动WEB程序：
1． 选择"文件"－"新建"－"网站"
2． 在"Visual Studio已安装的模板"列表中选择"ASP.NET 网站"
3． 设置好程序的"位置"、"语言"和"路径"等选项后，单击"确定"按钮。
当你完成上述步骤后，就已经创建好了一个ASP.NET 网站。现在我们就可以在该网站中添加一些针对移动设备的WEB窗体，其具体的实现过程如下：
1. 在Visual Studio 2005的"解决方案资源管理器"窗口中选择刚才创建好的网站项目，右键点击并在弹出的菜单中选择"添加新项"命令。
2. 在弹出的"添加新项"窗体中选择"移动WEB窗体"项。
3. 设置窗体的"名称"和"语言"等项，并且确保"将代码放在单独的文件中"选择框处于选中状态。
4. 单击"添加"按钮。
当单击"添加"按钮后，你会发现Visual Studio 2005自动添加了两个文件，在这里窗体名称被设置为"MobileDefault"，因此这两个文件分别为MobileDefault.aspx 和MobileDefault.aspx.cs (如果你选择的语言为VB的话，则这两个文件为MobileDefault.aspx和MobileDefault.aspx.vb)。MobileDefault.aspx文件包含在窗体使用的各个ASP.NET 移动控件的声明方式，而MobileDefault.aspx.cs则包含了一些程序实现代码和事件处理代码，这和传统的ASP.NET应用程序采用的"代码后置"的方式是一致的。
窗体添加完毕后，我们就可以使用工具箱中的"移动WEB窗体"标签下的各个控件。如同其它的ASP.NET控件一样，我们也可以根据需求设置这些控件的属性和事件行为。你可以在"原代码"窗口下直接输入"＜mobile: /＞"的语法方式来添加移动控件：
＜mobile:TextBox ID="MyTextBox" runat="server"＞＜/mobile:TextBox＞
＜mobile:Label ID="MyLabel" runat="server"＞标签控件＜/mobile:Label＞
下图显示了一个放置了Label、TextBox和Command控件的移动WEB窗体。该窗体所实现的功能是根据TextBox控件中输入的CustomerID来查找相应的用户信息，我们并没有编写对应的逻辑代码，只是显示了该窗体的界面：
Visual Studio 2005中对应的HTML代码如下所示，我们可以看到上述的3个控件均以 ＜mobile: 为前缀在页面代码中进行了声明。同样的，Form也采用了类似的方式加以声明，见代码7所示。在传统的ASP.NET应用程序中处理窗体和处理控件的方式是不一样的，这和移动WEB页面有很大的差别。其最大的不同就是开发人员可以在同一个移动WEB页面中创建多个窗体，并且可以在这些窗体间自由地导航而无需回发到服务器。利用该项特性可以减少因移动设备带宽小而带来的约束，大大减少了和服务器通讯的数据量。换句话说，移动设备中是以窗体为单位进行显示，而不是像传统的ASP.NET程序那样以页面为单位进行显示。我们使用移动设备浏览不同屏的信息时，可能并没有跳转到不同的页面，而是在同一个页面的不同窗体间进行跳转。
01 ＜%@ Page Language="C#" AutoEventWireup="true" CodeFile="MobileDefault.aspx.cs"
02 Inherits="MobileDefault" %＞
03 ＜%@ ReGISter TagPrefix="mobile" Namespace="System.Web.UI.MobileControls"
04 Assembly="System.Web.Mobile" %＞
05 ＜html XMLns="http://www.w3.org/1999/xhtml" ＞
06 ＜body＞
07 ＜mobile:Form id="Form1" runat="server"＞
08 ＜mobile:Label id="lblID" Runat="server"＞Customer ID＜/mobile:Label＞
09 ＜mobile:TextBox id="txtCustID" Runat="server"＞＜/mobile:TextBox＞
10 ＜mobile:Command id="cmdGetCustomer" Runat="server"＞Find Customer
11 ＜/mobile:Command＞
12 ＜/mobile:Form＞
13 ＜/body＞
14 ＜/html＞
ASP.NET 移动WEB窗体的开发视图 Visual Studio 2005的开发环境中提供了三种视图进行ASP.NET 移动WEB窗体的设计和开发。这三种视图分别为设计视图、HTML视图和代码视图，我们可以针对不同的开发需求在这些视图间进行切换。现在我们就这三种视图进行一个简短的概要。
在本文中我将介绍如何使用Visual Studio 2005创建一个ASP.net 2.0移动程序，然后介绍一些常用的移动开发控件并以适合的方式在程序中加于应用，最后将谈谈如何开发针对特定移动设备的Web程序和管理程序中的ViewState(视图状态)和Session。
创建一个新的ASP.NET 移动WEB程序
Visual Studio 2005提供了一组功能强大且友好的开发工具来创建移动WEB程序，如果你已经有创建传统的ASP.NET应用程序的经验，那么你就会发现创建移动WEB程序和创建传统的ASP.NET应用程序是非常类似的。你只需要创建一个ASP.NET网站项目并添加一些移动WEB窗体即可。当你添加移动WEB窗体后，你就会发现在工具箱中添加了如下图所示的ASP.NET移动控件。
现在你可以按照如下的步骤在Visual Studio 2005创建一个新的ASP.NET 移动WEB程序：
1． 选择"文件"－"新建"－"网站"
2． 在"Visual Studio已安装的模板"列表中选择"ASP.NET 网站"
3． 设置好程序的"位置"、"语言"和"路径"等选项后，单击"确定"按钮。
当你完成上述步骤后，就已经创建好了一个ASP.NET 网站。现在我们就可以在该网站中添加一些针对移动设备的WEB窗体，其具体的实现过程如下：
1. 在Visual Studio 2005的"解决方案资源管理器"窗口中选择刚才创建好的网站项目，右键点击并在弹出的菜单中选择"添加新项"命令。
2. 在弹出的"添加新项"窗体中选择"移动WEB窗体"项。
3. 设置窗体的"名称"和"语言"等项，并且确保"将代码放在单独的文件中"选择框处于选中状态。
4. 单击"添加"按钮。
当单击"添加"按钮后，你会发现Visual Studio 2005自动添加了两个文件，在这里窗体名称被设置为"MobileDefault"，因此这两个文件分别为MobileDefault.aspx 和MobileDefault.aspx.cs (如果你选择的语言为VB的话，则这两个文件为MobileDefault.aspx和MobileDefault.aspx.vb)。MobileDefault.aspx文件包含在窗体使用的各个ASP.NET 移动控件的声明方式，而MobileDefault.aspx.cs则包含了一些程序实现代码和事件处理代码，这和传统的ASP.NET应用程序采用的"代码后置"的方式是一致的。
窗体添加完毕后，我们就可以使用工具箱中的"移动WEB窗体"标签下的各个控件。如同其它的ASP.NET控件一样，我们也可以根据需求设置这些控件的属性和事件行为。你可以在"原代码"窗口下直接输入"＜mobile: /＞"的语法方式来添加移动控件：
＜mobile:TextBox ID="MyTextBox" runat="server"＞＜/mobile:TextBox＞
＜mobile:Label ID="MyLabel" runat="server"＞标签控件＜/mobile:Label＞
下图显示了一个放置了Label、TextBox和Command控件的移动WEB窗体。该窗体所实现的功能是根据TextBox控件中输入的CustomerID来查找相应的用户信息，我们并没有编写对应的逻辑代码，只是显示了该窗体的界面：
Visual Studio 2005中对应的HTML代码如下所示，我们可以看到上述的3个控件均以 ＜mobile: 为前缀在页面代码中进行了声明。同样的，Form也采用了类似的方式加以声明，见代码7所示。在传统的ASP.NET应用程序中处理窗体和处理控件的方式是不一样的，这和移动WEB页面有很大的差别。其最大的不同就是开发人员可以在同一个移动WEB页面中创建多个窗体，并且可以在这些窗体间自由地导航而无需回发到服务器。利用该项特性可以减少因移动设备带宽小而带来的约束，大大减少了和服务器通讯的数据量。换句话说，移动设备中是以窗体为单位进行显示，而不是像传统的ASP.NET程序那样以页面为单位进行显示。我们使用移动设备浏览不同屏的信息时，可能并没有跳转到不同的页面，而是在同一个页面的不同窗体间进行跳转。
01 ＜%@ Page Language="C#" AutoEventWireup="true" CodeFile="MobileDefault.aspx.cs"
02 Inherits="MobileDefault" %＞
03 ＜%@ ReGISter TagPrefix="mobile" Namespace="System.Web.UI.MobileControls"
04 Assembly="System.Web.Mobile" %＞
05 ＜html XMLns="http://www.w3.org/1999/xhtml" ＞
06 ＜body＞
07 ＜mobile:Form id="Form1" runat="server"＞
08 ＜mobile:Label id="lblID" Runat="server"＞Customer ID＜/mobile:Label＞
09 ＜mobile:TextBox id="txtCustID" Runat="server"＞＜/mobile:TextBox＞
10 ＜mobile:Command id="cmdGetCustomer" Runat="server"＞Find Customer
11 ＜/mobile:Command＞
12 ＜/mobile:Form＞
13 ＜/body＞
14 ＜/html＞
ASP.NET 移动WEB窗体的开发视图 Visual Studio 2005的开发环境中提供了三种视图进行ASP.NET 移动WEB窗体的设计和开发。这三种视图分别为设计视图、HTML视图和代码视图，我们可以针对不同的开发需求在这些视图间进行切换。现在我们就这三种视图进行一个简短的概要。
在C#中如何读写INI文件
//写ini文件
[ dllimport ( "kernel32" ) ] 【相关文章:走进C# （我的C#学习之旅）之二】
【扩展阅读:Northwind中一个特别之处】
private static extern bool writeprivateprofilestring ( string section ,string key , string val , string filepath ) ; 【扩展信息:用.net操作word】
//读ini文件（字符
[ dllimport ( "kernel32" ) ]
private static extern int getprivateprofilestring ( string section ,string key , string def , stringbuilder retval ,int size , string filepath ) ;
//读ini文件（数字
[ dllimport ( "kernel32" ) ]
private static extern int getprivateprofileint ( string section ,string key , int def , string filepath ) ;
//////////////////////////////////////////////////////////////
using system;
using system.io;
using system.runtime.interopservices;
using system.text;
namespace echoncomponentlibrary
{
///
/// inifile 的摘要说明。
///
public class inifile
{
private string ffilename;
[ dllimport ( "kernel32" ) ] 【相关文章:走进C# （我的C#学习之旅）之二】
【扩展阅读:Northwind中一个特别之处】
private static extern bool writeprivateprofilestring ( string section ,string key , string val , string filepath ) ; 【扩展信息:用.net操作word】
//读ini文件（字符
[ dllimport ( "kernel32" ) ]
private static extern int getprivateprofilestring ( string section ,string key , string def , stringbuilder retval ,int size , string filepath ) ;
//读ini文件（数字
[ dllimport ( "kernel32" ) ]
private static extern int getprivateprofileint ( string section ,string key , int def , string filepath ) ;
//////////////////////////////////////////////////////////////
using system;
using system.io;
using system.runtime.interopservices;
using system.text;
namespace echoncomponentlibrary
{
///
/// inifile 的摘要说明。
///
public class inifile
{
private string ffilename;
2008年9月7日星期日
MSSQL数据库同步的方法--使用企业管理器
第一先来配置出版服务器
(1)选中指定[服务器]节点
(2)从[工具]下拉菜单的[复制]子菜单中选择[发布、订阅服务器和分发]命令
(3)系统弹出一个对话框点[下一步]然后看着提示一直操作到完成。
(4)当完成了出版服务器的设置以后系统会为该服务器的树形结构中添加一个复制监视器。同时也生成一个分发数据库(distribution)
第二创建出版物
(1)选中指定的服务器
(2)从[工具]菜单的[复制]子菜单中选择[创建和管理发布]命令。此时系统会弹出一个对话框
(3)选择要创建出版物的数据库，然后单击[创建发布]
(4)在[创建发布向导]的提示对话框中单击[下一步]系统就会弹出一个对话框。对话框上的内容是复制的三个类型。我们现在选第一个也就是默认的快照发布(其他两个大家可以去看看帮助)
(5)单击[下一步]系统要求指定可以订阅该发布的数据库服务器类型，SQLSERVER允许在不同的数据库如 ORACLE或ACCESS之间进行数据复制。但是在这里我们选择运行"SQL SERVER 2000"的数据库服务器
(6)单击[下一步]系统就弹出一个定义文章的对话框也就是选择要出版的表
(7)然后[下一步]直到操作完成。当完成出版物的创建后创建出版物的数据库也就变成了一个共享数据库。
第三设计订阅
(1)选中指定的订阅服务器
(2)从[工具]下拉菜单中选择[复制]子菜单的[请求订阅]
(3)按照单击[下一步]操作直到系统会提示检查SQL SERVER代理服务的运行状态，执行复制操作的前提条件是SQL SERVER代理服务必须已经启动。
(4)单击[完成]。完成订阅操作。
完成上面的步骤其实复制也就是成功了。但是如何来知道复制是否成功了呢？这里可以通过这种方法来快速看是否成功。展开出版服务器下面的复制——发布内容——右键发布内容——属性——击活——状态然后点立即运行代理程序接着点代理程序属性击活调度把调度设置为每一天发生，每一分钟，在0：00：00和23：59：59之间。
(1)选中指定[服务器]节点
(2)从[工具]下拉菜单的[复制]子菜单中选择[发布、订阅服务器和分发]命令
(3)系统弹出一个对话框点[下一步]然后看着提示一直操作到完成。
(4)当完成了出版服务器的设置以后系统会为该服务器的树形结构中添加一个复制监视器。同时也生成一个分发数据库(distribution)
第二创建出版物
(1)选中指定的服务器
(2)从[工具]菜单的[复制]子菜单中选择[创建和管理发布]命令。此时系统会弹出一个对话框
(3)选择要创建出版物的数据库，然后单击[创建发布]
(4)在[创建发布向导]的提示对话框中单击[下一步]系统就会弹出一个对话框。对话框上的内容是复制的三个类型。我们现在选第一个也就是默认的快照发布(其他两个大家可以去看看帮助)
(5)单击[下一步]系统要求指定可以订阅该发布的数据库服务器类型，SQLSERVER允许在不同的数据库如 ORACLE或ACCESS之间进行数据复制。但是在这里我们选择运行"SQL SERVER 2000"的数据库服务器
(6)单击[下一步]系统就弹出一个定义文章的对话框也就是选择要出版的表
(7)然后[下一步]直到操作完成。当完成出版物的创建后创建出版物的数据库也就变成了一个共享数据库。
第三设计订阅
(1)选中指定的订阅服务器
(2)从[工具]下拉菜单中选择[复制]子菜单的[请求订阅]
(3)按照单击[下一步]操作直到系统会提示检查SQL SERVER代理服务的运行状态，执行复制操作的前提条件是SQL SERVER代理服务必须已经启动。
(4)单击[完成]。完成订阅操作。
完成上面的步骤其实复制也就是成功了。但是如何来知道复制是否成功了呢？这里可以通过这种方法来快速看是否成功。展开出版服务器下面的复制——发布内容——右键发布内容——属性——击活——状态然后点立即运行代理程序接着点代理程序属性击活调度把调度设置为每一天发生，每一分钟，在0：00：00和23：59：59之间。
关于MSSQL数据库同步问题
就是从本地数据库表更新到远程数据库表是同步进行的
打开企业管理器→工具→复制→创建和管理发布→创建发布→下步选要发布的数据库→选否，定义选项和属性→（根据情况选发布类型）事务发布→下步选择你要发布的数据表→编辑名称（随便）→否，根据指定方式创建发布→完成
*创建完成了发布在开始订阅远程的数据库
企业管理器→工具→复制→创建和管理发布→展开你所创建发布的数据库选择
发布的表→强制新订阅→下一步→选择远程服务器（如果没有就先到企业管理器上连接）→*编要订阅的数据库名（这里是很多新手会搞错的地方：是需订阅的远程数据库名）→是，初始化（这项是没做过复制的数据库可选，如果以前做过的选择此项就会导至以前订阅的数据丢失。*做过复制的数据库可选"否"）→完成
远程也同上。
打开企业管理器→工具→复制→创建和管理发布→创建发布→下步选要发布的数据库→选否，定义选项和属性→（根据情况选发布类型）事务发布→下步选择你要发布的数据表→编辑名称（随便）→否，根据指定方式创建发布→完成
*创建完成了发布在开始订阅远程的数据库
企业管理器→工具→复制→创建和管理发布→展开你所创建发布的数据库选择
发布的表→强制新订阅→下一步→选择远程服务器（如果没有就先到企业管理器上连接）→*编要订阅的数据库名（这里是很多新手会搞错的地方：是需订阅的远程数据库名）→是，初始化（这项是没做过复制的数据库可选，如果以前做过的选择此项就会导至以前订阅的数据丢失。*做过复制的数据库可选"否"）→完成
远程也同上。
2008年9月4日星期四
windows mobile上调用摄像头接口
使用SHCameraCapture接口可以调出照相机进行拍照、摄像，并得到图片或视频文件的路径。
以下代码进行拍照：
SHCAMERACAPTURE shcc;
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = NULL;
shcc.pszInitialDir = NULL;
shcc.pszDefaultFileName = NULL;
shcc.pszTitle = NULL;
shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_DEFAULT;
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_ALL;
shcc.nResolutionWidth = 0;
shcc.nResolutionHeight = 0;
shcc.nVideoTimeLimit = 0;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
HRESULT hReturn = SHCameraCapture(&shcc);
如果hReturn为S_OK，则表示拍照成功，shcc.szFile即为文件名称(包含路径)。shcc.pszInitialDir和shcc.pszDefaultFileName可以设置保存路径和默认文件名。shcc.hwndOwner如果使用了不同的窗体，可能会有问题。
如果要进行摄像，有些参数需进行调整，如下
shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_NORMAL;
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_STANDARD;
shcc.nResolutionWidth = 640;
shcc.nResolutionHeight = 480;
shcc.Mode = CAMERACAPTURE_MODE_VIDEOWITHAUDIO;
这些参数涉及到几个枚举变量，我们来看看：
typedef enum {
CAMERACAPTURE_MODE_STILL = 0,
CAMERACAPTURE_MODE_VIDEOONLY,
CAMERACAPTURE_MODE_VIDEOWITHAUDIO,
} CAMERACAPTURE_MODE;
CAMERACAPTURE_MODE_STILL对应照片，CAMERACAPTURE_MODE_VIDEOONLY对应无声视频，CAMERACAPTURE_MODE_VIDEOWITHAUDIO对应有声视频。
typedef enum {
CAMERACAPTURE_STILLQUALITY_DEFAULT = 0,
CAMERACAPTURE_STILLQUALITY_LOW,
CAMERACAPTURE_STILLQUALITY_NORMAL,
CAMERACAPTURE_STILLQUALITY_HIGH,
} CAMERACAPTURE_STILLQUALITY;
对应图片和视频清晰度。
typedef enum {
CAMERACAPTURE_VIDEOTYPE_ALL = 0xFFFF,
CAMERACAPTURE_VIDEOTYPE_STANDARD = 1,
CAMERACAPTURE_VIDEOTYPE_MESSAGING = 2,
} CAMERACAPTURE_VIDEOTYPES;
CAMERACAPTURE_VIDEOTYPE_ALL对应照片，CAMERACAPTURE_VIDEOTYPE_STANDARD对应WMV视频，CAMERACAPTURE_VIDEOTYPE_MESSAGING对应MMS视频。当使用后两个值时，shcc的nResolutionWidth和nResolutionHeight成员均不能为零。一般是640x480。
很遗憾，这个接口只能在WM5.0以上使用。WM2003上没有统一摄像头标准，硬件厂商各做各的，只能跟硬件厂商询问调用方法。
以下代码进行拍照：
SHCAMERACAPTURE shcc;
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = NULL;
shcc.pszInitialDir = NULL;
shcc.pszDefaultFileName = NULL;
shcc.pszTitle = NULL;
shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_DEFAULT;
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_ALL;
shcc.nResolutionWidth = 0;
shcc.nResolutionHeight = 0;
shcc.nVideoTimeLimit = 0;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
HRESULT hReturn = SHCameraCapture(&shcc);
如果hReturn为S_OK，则表示拍照成功，shcc.szFile即为文件名称(包含路径)。shcc.pszInitialDir和shcc.pszDefaultFileName可以设置保存路径和默认文件名。shcc.hwndOwner如果使用了不同的窗体，可能会有问题。
如果要进行摄像，有些参数需进行调整，如下
shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_NORMAL;
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_STANDARD;
shcc.nResolutionWidth = 640;
shcc.nResolutionHeight = 480;
shcc.Mode = CAMERACAPTURE_MODE_VIDEOWITHAUDIO;
这些参数涉及到几个枚举变量，我们来看看：
typedef enum {
CAMERACAPTURE_MODE_STILL = 0,
CAMERACAPTURE_MODE_VIDEOONLY,
CAMERACAPTURE_MODE_VIDEOWITHAUDIO,
} CAMERACAPTURE_MODE;
CAMERACAPTURE_MODE_STILL对应照片，CAMERACAPTURE_MODE_VIDEOONLY对应无声视频，CAMERACAPTURE_MODE_VIDEOWITHAUDIO对应有声视频。
typedef enum {
CAMERACAPTURE_STILLQUALITY_DEFAULT = 0,
CAMERACAPTURE_STILLQUALITY_LOW,
CAMERACAPTURE_STILLQUALITY_NORMAL,
CAMERACAPTURE_STILLQUALITY_HIGH,
} CAMERACAPTURE_STILLQUALITY;
对应图片和视频清晰度。
typedef enum {
CAMERACAPTURE_VIDEOTYPE_ALL = 0xFFFF,
CAMERACAPTURE_VIDEOTYPE_STANDARD = 1,
CAMERACAPTURE_VIDEOTYPE_MESSAGING = 2,
} CAMERACAPTURE_VIDEOTYPES;
CAMERACAPTURE_VIDEOTYPE_ALL对应照片，CAMERACAPTURE_VIDEOTYPE_STANDARD对应WMV视频，CAMERACAPTURE_VIDEOTYPE_MESSAGING对应MMS视频。当使用后两个值时，shcc的nResolutionWidth和nResolutionHeight成员均不能为零。一般是640x480。
很遗憾，这个接口只能在WM5.0以上使用。WM2003上没有统一摄像头标准，硬件厂商各做各的，只能跟硬件厂商询问调用方法。
订阅：
博文 (Atom)