Son of VB.NET

Comics Service

2008-12-18T14:49:00.003+08:00

Comics Servics 是模仿 WCF 官方事例 Picture Serivce 制作

主要功能是

发布漫画的RSS/ATom

同时生成简单的HTML页面显示。

实现环境 VS2008 SP1 + .NET 3.5 SP1

欢迎大家测试～～

目前是 Beta1

网址： http://www.codeplex.com/ComicServices

下载位置 http://www.codeplex.com/ComicServices/Release/ProjectReleases.aspx?ReleaseId=20665

漫画样例下载 http://cid-fdf36fbb7ef0e5e7.skydrive.live.com/self.aspx/Comics%20Servic/sample.Comics.rar

2008-08-31T20:01:00.000+08:00

最近，在群里讨论的时候看到一个很有趣的需求，所以研究了一下。下面是研究出来来的结果。

有没有想过，想用.NET做一个演示程序或者做个光盘的MENU。但却苦于，机器上没有.NET 而无法运行。

或许你认为这个很简单，做个安装程序不就可以了，但实际上，这样自动运行的程序，不适合制作安装程序，或者说，他应该不需要安装。

也许你认为这个也容易，用Dot NET 虚拟机不久好了。没错，用这个，确实可以，不过会有几个问题。

第一，会有一个兼容性的问题。毕竟精简了.NET 类库，只有几个少数文件。
第二，版权问题。

实际上，大家可能都没有注意这个问题，但如果自己找，还是有人说的，飞信用的那个虚拟机，是购买而来的。因此，你用了用了，就算是盗版了。这个问题，在国内，或许没人深究，但在国外就不同了，这也是我写本文的原因之一。

还有，另一种，解决方式，就是用VC++ 写一个引导，不过这对于我们这些不熟悉VC的人，是一个麻烦。

不知道，大家最近有没有关注 SQL2008呢？尝试过的人，一定会发现一个很细节的不同，那就是，安装的引导界面不同了。

实际上，在这个之前，还会有一个东西出来，那就是，提示你安装 .NET Framework 3.5 SP1 。为什么会这样呢？因为，新的引导程序，就是.NET 做的了。

本文，将会指导你，如何让VS帮助我们生成这样的Loader，在没有安装.NET 的机器上，自动安装.NET Framework，在已安装的机器上，直接运行程序。

注意：由于需要手动修改项目文件，因此操作错误，可能会使项目出现问题。请在对已有的工程修改前，做好备份。

先说一下原理，做Client程序，应该都会知道ClickOnce，通过它，可以快速制作一个安装程序，来部署项目。在部署的时候，选择依赖，这样在安装的时候，如果客户端，没有相应的组件，就会自动安装。这个就是Bootstrapper，用于检查程序依赖项，并自动安装的启动程序。我们的任务，就是定这个Bootstrapper，将它指向的安装程序，对准我们实际要运行的程序，这样就达到了上面的目的。

那么我们开始吧，这里，为了演示，我将新建一个Win Form程序，当然，你也可以用一个已有的项目，不过，记得要备份哦！

1、新建一个项目，名字为 AutorunDotNet。这里要说明的是，我选择的是.NET 3.5，实际上，你也可以选择.NET 2.0 的程序。另外，要说的一点是，我用的是VB.NET ，但实际上，我们是修改的项目文件，和语言无关。

2、简单修改一下项目。（实际上，可以不用做这个。）

3、设置项目依赖。

a.双击解决方案中的“My Project” ，打开项目属性页。

b.选择 “发布” 选项卡，单击 “系统必备”。

c.在“系统必备”里，确保选择 “ 创建用于安装系统必备组件的安装程序”，然后下发，选择需要安装的系统必备组件。最后，在“指定系统必备组件的安装位置” 里，选择 “从与我的应用程序相同的位置下载系统必备组件”，单击确定。（注：你可以不必设置这个，这样，安装程序，会在网络上下载，安装程序。）

恩，准备工作差不多了。下面开始修改项目文件吧。

4、编辑项目

a.卸载项目
右键单击项目，选择 “卸载项目”

注：如果，VS没有显示，需要打开 “工具” ——“选项”，找到“项目和解决方案”，选择 “总是显示解决方案”。

b.编辑项目

右键单击“AutotrunDotNet”，选择“编辑 AutorunDotNet.vbProj”。

5、在开的项目文件里，找到以下内容。（默认在项目结尾）
　　　　

a.将这段内容改成如下样子。

Code 
<!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
           Other similar extension points exist, see Microsoft.Common.targets.  -->
      <Target Name="BeforeBuild">
      </Target>
      <Target Name="AfterBuild">
        <GenerateBootstrapper
          ApplicationFile="$(TargetFileName)" 
          ApplicationName="$(AssemblyName)" 
          ApplicationUrl="$(_DeploymentFormattedApplicationUrl)" 
          BootstrapperItems="@(BootstrapperPackage)" 
          OutputPath="$(TargetDir)" 
          ComponentsLocation="$(BootstrapperComponentsLocation)" 
          Path="$(GenerateBootstrapperSdkPath)" />
      </Target>

b.修改好后，保存。在右键单击“AutorunDotNet”项目，选择“重新加载项目”。

6、OK，修改完成。编译一下看看。

如果没有错误，你将会在输出的文件夹下，看到一下内容。

这个Setup.exe，就是我们要的Loader。 2个文件夹里的是.NET 安装程序和 Windows Installer 3.1 。

补充一点，这个方法，目前还不能自动生成 Autorun.inf 。

因此只能我们自己手动写一个了，不是很难。（虽然我很想人让它自动，生成，但没有找到相关资料。）

Autorun.inf

[autorun]
open=setup.exe
icon=setup.exe,0

其他说明

这个，我在VS2008 SP1上测试的，根据MSDN的说法，这个最低适用于 VS2005

如果怕影响当前项目，可以新建一个项目，专门用来做这个～

还有这里，简单说明一下 <GenerateBootstrapper > 就是用来生成实Bootstrapper 。

ApplicationFile="$(TargetFileName)" 这个指定要运行的程序名字，这里这个参数，是默认项目输出的名字。

ApplicationName="$(AssemblyName)" 程序的名字，即在执行的时候，提示的。这里是程序集的名字。

OutputPath="$(TargetDir)" 输出位置，这里默认是项目输出的文件夹

其他的属性，请参考http://msdn.microsoft.com/zh-cn/library/ms164294.aspx

事例代码在这里下载 http://code.msdn.microsoft.com/AutorunDotNET

在这里简述一下，当初在群提出这个问题的情况。（由于实际信息，可能不方便说书，所以，决定，不说！！）

这个公司，给客户做了一个网站的演示程序，用WinForm作的。之后，要把这个程序刻录到光盘，送给客户。

但因为是.NET 做的，在没有.NET 的机器上，程序就无法运行。反之，有因为商业程序，客户不见得会懂得很多开发信息。也不好让客户自己安装.NET 。

所以，需要一个确保的机制。在没有.NET的机器上自动安装，之后并自动运行程序。

实际上，当时在讨论的时候，说了2点，一是用飞信的虚机，二是写一个VC++的程序。

但这2点都不符合，一是，客户是国外的，对用了带版权的东西，有多说头。二是，他们公司里面的没有人懂VC++。

=================

Q&A

=================

Q：错误 1 系统必备的安装位置未设置为“组件供应商的网站”，无法在磁盘上找到项“.NET Framework 3.5 SP1”中的文件“DotNetFX35SP1dotNetFX20aspnet.msp”。有关详细信息，请参见“帮助”。

A：VS 2008 SP1 升级后，并没安装.NET 3.5 SP1 完整版的 Bootstrapper，而只是复制了几个文件。因此，默认是按配置中的信息，从网络上下载的在线安装版本。你可以按照下面的方法，制作离线的完整版。或者在这里下载完整版的复制到 Bootstrapper下。

首先，去官方，下载 .NET 3.5 Sp1 完整版和 2个中文语言包（x86 和x64)

http://download.microsoft.com/download/2/0/e/20e90413-712f-438c-988e-fdaa79a8ac3d/dotnetfx35.exe

http://download.microsoft.com/download/7/7/b/77b96978-c805-4674-a9b0-43351e86b41f/dotnetfx35langpack_x64zh-CHS.exe

http://download.microsoft.com/download/7/7/b/77b96978-c805-4674-a9b0-43351e86b41f/dotnetfx35langpack_x86zh-CHS.exe

然后，找到Bootstrapper的本地位置。

这个位置，默认是Windows SDK安装的位置。

我这里的位置是 C:Program FilesMicrosoft SDKsWindowsv6.0ABootstrapper

C 盘是我的系统盘， V6.0A 是SDK的版本号，如果你安装了其他版本，有可能会使Bootstrapper 更改位置

在这个文件夹下，可以看到 DotNetFX35SP1 文件夹，把.NET 安装程序解压到这里，如果怕操作失误，可以先备份一下。

1、用Winrar等工具，将dotnetfx35.exe 解压缩。

2、打开解压缩的文件夹，进入到 wcudotNetFramework （用WinRAR查看的时候，有很多… 原因不明）

3、将dotNetFramework 下的所有内容，复制到（之前那个Bootstrapper里的） DotNetFX35SP1 下。

4、进入DotNetFX35SP1，下的zh-CHS 文件夹。

5、新建一个名为 DotNetFX35 文件夹，并进入。

6、新建2个文件夹，名字分别是 “x64”和 “x86”

7、将下载的x64语言包 dotnetfx35langpack_x64zh-CHS.exe 复制到 “x64”文件夹下

8、将下载的x86语言包 dotnetfx35langpack_x86zh-CHS.exe 复制到 “x86”文件夹下

这样就完成了，你的VS应该可以正常的从本地复制 .NET 3.5 的完整安装。

完整版的下载链接在这里，虽然，很想弄成3个文件，但没有成功。

http://www.mediafire.com/file/oe3kgyz1eis/DotnetFX35SP1.part1.rar
http://www.mediafire.com/file/fxfqb5lxtnd/DotnetFX35SP1.part2.rar
http://www.mediafire.com/file/pu405auktni/DotnetFX35SP1.part3.rar
http://www.mediafire.com/file/2hyammjnr5o/DotnetFX35SP1.part4.rar

将以上文件解压至 Bootstrapper 文件夹下即可。

如果链接出现问题，请回复。

PS.本打算，直接分享一个来的，结果，看了一下容量，我晕倒了。 316MB

如果能找到一个好的空间的话，稍后会上传上来。

在这里说一个题外话，很多人都说.NET 太大了。实际上，一点点细节没有注意。

.NET 3.5 之后，提供的程序包，里面，实际上包含了 X64 和X86 2个平台的安装程序。另外，由于，Vista 以上的系统内置.NET ，因此，对这个平台的安装，又使用了MSU。所以，最终，的结果是，包含了2类系统的安装程序，每种又有X86和X64平台的安装文件。

PS.刚才瞄了一下，MSU里，居然还有一个安腾的X64。那上面的就。。。

Q:怎样更改引导程序的图标和名称呢?
A:很抱歉，这个生成，图标资源，无法更改。因此，图标只能。。。以后可能会研究看看，但希望恐怕不大，因为 VS 所有生成的安装程序（ClickOnce和MSI）都是这个图标。但听说ClickOnce ，在.NET 3.5 SP1 有够个重大变革，可以自定义安装界面。不过这个还没有深入研究。如果，放入到光盘上的话，可以通过修改Autorun.inf 更改光盘的显示图标。
[autorun]
open=setup.exe
icon=AutorunDotNet.exe,0
将Icon指定光盘的图标，可以是个ICO文件。

至于，文件名称，这个可以自由更改，没有限制。

2008-08-29T17:28:00.000+08:00

简介使用Sync Services for ADO.NET建立偶尔链接的程序

Introduction to Occasionally Connected Applications using Sync Services for ADO.NET

原文链接：http://msdn.microsoft.com/en-us/sync/bb887608.aspx

引言

Introduction

移动和远程工作能力在团队中的重要性与日俱增。最重要的是能让当团队中的成员在办公的时候，访问到相同的信息。在多数情况下，这些成员将有某种笔记本电脑，办公桌，智能手机或者PDA。通过这些设备，用户们可以快速访问他们的数据，通过VPN链接或其它方式连接到公司网络，像下面的样子。

The ability to support mobile and remote workers is becoming more and more important for organizations every day. It is critical that organizations ensure users have access to the same information they have when they are in the office. In most cases, these workers will have some sort of laptop, office desktop, Smartphone or PDA. From these devices, users may be able to access their data directly through VPN connections, Web servers or some other connectivity method into the corporate networks as seen below.

这种解决方案很容易实现。不幸的是，无法令外部员工满意。这类解决方案的主要缺点是：

This type of solution is fairly simple to implement. Unfortunately, for most remote workers it is less than satisfactory. Some major disadvantages of this type of solution include:

网络需求:为了能让用户访问他们的信息，远程设备在访问他们的数据时需要不间断的网络连接到过公司网络。对于一些像是在家里工作的员工，这可能不是问题。对于另一些员工，像是经常移动的销售代表，可能很困难。例如，如果一个销售代表访问一个客户，却因为缺乏网络而不能访问清单数据，这将让他很难有效率的完成他的工作。
数据访问速度： 在典型的C/S企业环境中，用户有着高速网络，是他们快速的获取信息。但是，外部员工普遍使用的是低速的，不可靠的有线或无线的网络。在这个解决方案中，每次用户请求的部分数据都需要被（重新）下载下来，因为没有方法在设备上保存数据。例如，如果一个销售代表在他每次打开程序的时候都需要下载他的产品类表，他将很快因为程序的长时间的等待而变得沮丧。
单点故障： 在这个解决方案中，所有的用户都将依赖于同一个服务器。如果由于计划的停机维护或者启动失败，而使数据库变得不可用，这将使所有外部员工将不能连接到他们的数据。
服务器的可扩展性：随着远程工作的员工变多，服务器的性能也受到影响，这将会产生添加额外硬件的需求。

Network Requirements: In order to allow users to access their information, the remote device needs to have a constant connection to the corporate network while accessing their data. For some workers, such as those who are working from home, this may not be a problem. For others, such as sales reps who are constantly on the move, this may be more difficult. For example, if that sales rep were visiting a customer and was unable to access inventory data because of a lack of network connectivity, it would be very difficult for this user to effectively do their job.
Data Access Speeds: In a typical client / server corporate environment, users have high speed networks that allow them quick access to information. Remote workers, however, are typically connected over slow, unreliable wired or wireless networks. With this solution, every piece of data this user needed would need to be downloaded every time it is requested because there is no way to persist the data on the device. For example, if a sales rep is required to download his product list every time he opens his application, he will quickly become frustrated with the time lag required to populate his application with information.
Single Point of Failure: With this type of solution, all users are reliant on a single server. If that database becomes unavailable due to planned server downtime or from server failures, all of the remote workers will be disconnected from their data.
Server Scalability: As more workers work remotely, the performance of the corporate servers will be affected, leading to a need to add additional hardware.

一种可以替代的解决方案是实现偶尔链接程序（Occasionally Connected Application (OCA)）。OCA允许外部员工持续的访问他们的数据，但不像先前那样，用户直接访问企业数据库（情形），而是用户请求的信息储存在本地用户设备上。为了填充这个本地数据库，OCA程序通常都会包括一些数据同步能力。数据同步是由周期提取储存在客户端数据库（像SQL Server Compact）的信息并同步更改到服务端的数据库（像是SQL Server）。基于同步的解决方案的优势是用户不在需要长时间的持续连接来访问他们的数据。由于数据是保存在本地，它能提供持续的连接来访问他们的数据，将不需要中心数据库的处理。此外，也减小了网络限制和提高访问速度到达设备的速度。

One alternative to this solution is to implement an Occasionally Connected Application (OCA). An OCA allows a remote worker to continue to access their data, but unlike the previous scenario where the user accessed the corporate database directly, the information the worker requires is stored locally on the user’s device. In order to populate this user’s local database, an OCA will typically include some data synchronization capabilities. Data synchronization consists of the ability to periodically take information that is stored in the client database (such as SQL Server Compact) and synchronize changes with a server database (such as SQL Server). The advantage of a synchronization-based solution is that users are no longer required to have a constant network connection to access their information. Since their data is stored locally they are given constant access to their data while offloading processing requirements from the central database. Furthermore, the user is no longer limited by the network speed and can now access the data at the speed of the device.

在下面2个图表中我们见到OCA 的例子，数据（用绿色数据库表示）位于外部员工的本地设备上。第一个例子是直接储存到用户设备上的独立的数据库系统中。第二个例子是外部办公室将储存信息到工作组的数据库中，外部办公室的员工可以访问这个数据。

In the following two diagrams we can see examples of OCAs where data (represented by a green database) is persisted locally on the remote worker’s device. The first example is of a standalone database system where information is stored directly on the user’s device. The second example is of a remote office where information is stored in a workgroup database within this remote office so that multiple local workers can access the data.

OCA一种常见的扩展是支持多个数据库之间的数据协作。像下面的事例，一个远程的数据库自由的和其它数据库交换信息。这种解决方案当在一个小组成员在偏远位置工作并且不能访问中心数据库时很有用。这些员工经常需要向其他员工共享信息，但是他们不能连接到中央中数据库，他们需要共享信息通过一些像是P2P网络传输。

A common extension to this type of OCA is the ability to support data collaboration between databases. As seen below, a remote database is free to exchange information with any other database. This type of solution is useful when a team of people are working in remote locations and do not have access to a central database. These workers often need to share information amongst each other but since they do not have connectivity to the central database they need to share information through some sort of peer-to-peer network.

在本文剩下的部分里，我们将主要讨论OCA和Sync Services for ADO.NET，这个关键的技术可以使你构建OCA程序。

Throughout the rest of this document we will discuss OCAs with a special emphasis on Sync Services for ADO.NET, a key technology that enables developers to build OCAs.

Sync Services for ADO.NET 和 the Microsoft Sync Framework

Sync Services for ADO.NET and the Microsoft Sync Framework

Sync Services for ADO.NET 是微软同步服务 (MSF)。MSF是一个综合的同步平台，它可以使开发人员添加同步能力到应用程序，服务和设备中。MSF 解决了基本的问题，如何同步储存在任何位置中的任何数据类型使用任何协议在任何拓扑。MSF 的基本的能力是支持离线和任何类型终结点之间的数据协作（如：设备到桌面，桌面到服务器，等等）。

Sync Services for ADO.NET is a part of the Microsoft Sync Framework (MSF). MSF is a comprehensive synchronization platform that enables developers to add synchronization capabilities to applications, services and devices. MSF solves the fundamental problem of how to synchronize any type of data in any store using any protocol over any topology. Fundamental to MSF is the ability to support offline and collaboration of data between any types of endpoints (e.g. device to desktop, device to server, etc.).

Sync Services for ADO.NET 能够同步使用ADO.NET访问的数据库。由于Sync Services for ADO.NET 是MSF的一部分，任何使用uses Sync Services for ADO.NET 的数据库也能交换信息同其他的数据源，这些都是被MSF所支持的，像是Web 服务，文件系统，或者自定义数据储存。

Sync Services for ADO.NET enables synchronization between ADO.NET enabled databases. Since Sync Services for ADO.NET is part of the MSF, any database that uses Sync Services for ADO.NET can then also exchange information with other data sources that are supported by MSF, such as web services, file systems or custom data stores.

本文重点是在数据库系统中同步信息和Sync Services for ADO.NET 将如何帮助开发人员避免许多和OCA相关的常见问题。

The primary focus of this document will be on synchronizing information between database systems and how Sync Services for ADO.NET helps developers avoid many of the common issues associated with OCAs.

构建偶尔链接程序的挑战Challenges of Building an OCA

Challenges of Building an OCA

对于OCA，用户可以快速的访问他们数据并且不需要网络连接到中央数据中，以便获取他们的数据。OCA，先更新本地数据库，然后将数据更改同步到中心数据库上，而不是直接更新中心数据库。虽然虽然 OCA解决直接访问中心数据库相关的关键问题，但在建立OCA时还有大量的挑战。下面几节将讨论这些挑战，并提出如何使用Sync Services for ADO.Net 来避免这些挑战的建议。

With an OCA, users have quick access to their data and do not require a network connection to the central database in order to access their information. With an OCA, updates are made locally and then synchronized into the central database, rather than being made directly at the central database,. Although OCAs solve the key problems associated with directly accesing a central server, there are a number of challenges associated with building OCAs. The following sections will discuss these challenges and propose ways that Sync Services for ADO.Net can be used to avoid these challenges.

修改跟踪

Change Tracking

为了使数据同步有效，某种修改跟踪的方法是必需的。修改跟中能提供数据库在某一时间点到另一个时间点之间的修改列表（插入、更新、删除）。想象一下，一个远程的用户链接到中央数据库并希望获取他从上次在线到现在的数据。没有修改跟踪，这个用户需要从中心数据源获取所有的数据然后向用户的计算机或设备上的本地数据库中合并数据的修改。在移动环境中，这是极其低效率的，因为使用无线网络交换这种信息将花费大量的时间。如果有大量的数据交换更会特别的慢。不幸的是，如果连接丢失数据则必须重新下载，这将会更加的没有效率。

In order to make data synchronization efficient, some method of change tracking is required. Change tracking is the ability to provide a list of changes (insert, updates and deletes) that were made to the database from one point in time to another. Imagine a remote user who connects to the central database and wishes to bring their data up-to-date since the last time they were online. Without change tracking, this user would need to take all of the data from the central data source and then merge that data with the changes that the user made to the local database on the user’s computer or device. In a mobile environment, this is extremely inefficient because of the amount of time a wireless network would take to exchange this information. It would be especially slow if large datasets were exchanged. Furthermore, if the connection drops the data must be re-downloaded, making this even less efficient.

为了避免这个问题，通常使用一个修改跟踪系统。一个比较流行的修改跟中方法是通过使用rowversions 和触发器（triggers）。这个方法需将rowversion列添加到每个表中。为了删除，可能需要一个独立表或者一个删除标记列通常需要记录这些被删除的行并通过触发器来维护。

To avoid these issues, a change-tracking system is typically used. One popular method for change tracking is through the use of rowversions and triggers. This method requires a rowversion column to be added to each table. For deletions, a separate table or a “deleted” flag column is typically required to log these removed rows that are maintained through triggers.

这种解决方案的主要缺点有：

必须修改中心数据库的结构，添加列和表，这可能会影响到当前的程序。
触发器将在每行被更改后出发，这可能会对性能产生影响。
维护正确的rowversions和删除行的逻辑是很复杂的。
长时间运行事务将可能会有数据在同步期间丢失，这回照成结果不一致。

The major disadvantages to this solution are:

Changes are required in the central database schema to add columns and tables that may affect current applications.
Triggers are fired for each change made to a row, which has performance implications.
Logic for maintaining proper rowversions and row deletions can get extremely complicated.
Long running transactions can result in some data being missed during synchronization, resulting in data inconsistencies.

对于SQL Server 2008，跟踪修改方法将有一个新选择SQL Server 2008 修改跟踪。修改追踪的原理是管理标记几个监视更改的表。之后， SQL Server 2008 将跟踪任何的插入、更新或删除。当远程 “requestor” 请求更改，SQL Server 2008 将会提供全部的更改，从“Requestor”指定的最后一次成功下载开始。 Sync Services for ADO.NET 使用SQL Server 2008 修改跟踪可以给OCA环境提供以下优势：

不需要修改结构既可以跟踪修改
触发器对于修改跟中不是必需的，这意味修改跟中将减少对服务器的影响。在某些情况下，使用发器跟踪的DML开销可能比SQL Server 2008 修改跟踪高400%之多。SQL Server 2008 修改跟踪开销少的原因是维护第二个索引。
所有跟踪修改的逻辑都在SQL Server 引擎的内部，这样就减少了设置系统类型的复杂性。
对于长时间事务的数据一致性问题将不再是问题。
包括整合数据库管理特性，像是动态管理视图和安全。

SQL Server 2008 has introduced a new alternative method for tracking changes called SQL Server 2008 Change Tracking. The concept behind change tracking is that an administrator marks certain tables to be monitored for changes. From that point SQL Server 2008 keeps tracks of any inserts, updates or deletes that are made. When a remote “requestor” requests changes, SQL Server 2008 will provide all of the changes that have occurred since the last successful download as specified by the requestor. Sync Services for ADO.NET has been built to take advantage of SQL Server 2008 change tracking and provides the following advantages for an OCA environment:

No schema changes are required to be able to track changes
Triggers are not required for tracking changes, which means that tracking changes has far less of an impact on the server. In certain cases, the DML overhead associated with trigger based change tracking can be 400% greater than that of SQL Server 2008 change tracking. The overhead of enabling SQL Server 2008 change tracking is similar to the overhead of maintaining a second index.
All of the logic for tracking changes is internal to the SQL Server engine and as such reduces the complexity for setting up this type of system.
Data consistency issues associated with long running transactions are no longer an issue.
Includes integrated database administration feature such as Dynamic Management Views and Security

维护数据更改

Maintaining Change Data

修改跟踪表通常会快速增大，占用磁盘空间和影响查询效率。因此，合理的下一步是决定何时移除修改跟踪。根据用户最后一次同步来清理很困难，因为设备可能还没有同步或者用户只是简单的不使用它。这些因素使得管理员决定何时所有活动用户接受到更改并可以清理更改数据变的困难。

Change tracking tables will typically grow quite quickly, taking up storage space and affecting the performance of queries being executed against them. As such, the next logical step is to determine when tracked changes can be removed. Basing cleanup on when users have last synchronized is difficult because a device may have not been synchronized or the user may have simply stopped using it. These factors make it difficult for administrators to determine when all active users have received the changes which would allow them to clean up the change data.

在SQL Server 2008中，可以定制阈值，用来维护更改数据和自动清理旧的数据。而且，这是运行时在后台进程，不会对服务器产生性能影响。

In SQL Server 2008, customizable retention thresholds are used to maintain this change data and automatically clean up old data. Furthermore, this process runs as a background process to help offset any performance impact on the server.

冲突检测和解决

Conflict Detection and Resolution

冲突是OCA可能出现的另一个问题。当2个或更多的对同一数据的数据库修改后，同步引擎将尝试将这些修改应用到一个数据库上，这时就发生了冲突。例如，想想一下，有2个销售代表尝试更新同一个客户的2个不同的地址。第一个销售代表成功同步更新了中心数据库。当下一个销售代表同步更新到主数据库中时，就会发生异常，因为当前行的状态和同步引擎期望的不同。有多种方式解决这个问题。例如，以最后一次更新为准或者根据用户的资历进行选择。

Conflicts are another issue that can arise in an OCA. Conflicts will occur when two or more databases make a change to the same piece of data and then the synchronization engine tries to apply those into a single database. For example, imagine two sales reps who try to update a customer’s address to two different values. The first sales rep successfully synchronizes the update to the central database. When the next sales rep goes to synchronize the update to the main database, a conflict occurs because the current state of the row is different from what the synchronization engine was expecting. There are a variety of ways to resolve these conflicts. For example, the last change to come in may be the one that wins, or alternatively it may be based on which user has the most seniority.

Sync Services for ADO.NET提供使用外部冲突检测和解决的能力配合SQL Server 2008 改进低复杂度的检测数据冲突的体验。使用这个技术，在上个例子中的第一个销售代表将成功更新中心服务器。新值将会被应用，因为至今没有冲突。当第二个销售代表上传更改时，一个冲突将被检测到，因为在中心服务器的变更版本（Change Version）不包含当前销售代表的数据库。之后，远程的程序逻辑将决定如何处理这个冲突。

Sync Services for ADO.NET provides conflict detection and resolution capabailities out-of-the-box and SQL Server 2008 improves on this experience by decreasing the complexity associated with identifiying conflicts. By using this technique, the first sales rep in our example will successfully upload the change to the central server. It will be applied since there is no conflict yet. When the second sales rep goes to upload the change, a conflict will be detected because the change version in the central server does not exist in the current sales rep database. From this point, logic in the remote application determines how to handle the conflict.

优先数据交换

Prioritizing Data Exchange

当OCA成功部署后，通常需要一种方式来优化用户的数据交换一遍限制或者适应低速网络连接。一种优化数据同步的方式是定义数据的优先级，是高优先或者关键。使用优先级数据交换，关键更改将会立即被同步，次重要的数据将会稍后同步。例如，想想一下，当一个用户使用一个慢速网络访问，由于带宽有限，这个用户希望发送单个表的更改（高度重要），而其它表的更改将在之后连接高速网络后发送。对于Sync Services for ADO.NET，同步执行将从远端程序执行，基于表到表和只上传或只下载的同步。这意味着可以指定同步的表，其他的将在稍后同步，并且能够保证所有数据的交换。

When an OCA is deployed, users will often look for ways to optimize their data exchange given limited or slow network connections. One good way to optimize data synchronization is by prioritizing data to define data that is high priority or critical. Using priority data exchange, critical changes could be synchronized immediately while leaving less important data to be synchronized at a later time. For example, imagine a user currently has access only to a slow connection. Given the limited bandwidth, this user wishes to send change from a single (highly important) table and leave changes from other tables for later in the day when she can connect through a faster network connection. With Sync Services for ADO.NET, synchronization can be executed from the remote application on a table-by-table basis and on an upload-only or download-only basis. This means that specific tables can be synchronized, leaving others to be synchronized at a later time while still enabling guaranteed data exchange for all data.

后台同步

Background Synchronization

当用户的程序执行一个命令的时候（如，数据同步），也不会影响用户的控制。对于OCA，当执行诸如数据同步的时候，用户将不能访问本地数据库。

Nothing will frustrate a user more than when they are locked out of their application while another process (such as data synchronization) takes control. With most OCAs, users are not able to access their local database while processes like data synchronization are being executed.

对于Sync Services for ADO.NET，同步是在后台线程运行的。只要本地数据库支持在独立连接上同步（像 SQL Server Compact does），同步就可以在后台执行。这允许本地用户继续使用和修改数据库直到同步完成。

With Sync Services for ADO.NET, synchronization can run as a background thread. As long as the local database supports the ability to synchronize on a separate connection (as SQL Server Compact does), synchronization can be executed in the background. This allows a local user to continue to use and change their database while synchronization is being completed.

多同步拓扑

Multiple Synchronization Topologies

当构建OCA时，组织通常会选择一个网络扩谱。例如，想想一下，一组运送工，在一天开始从中心库存数据库中下载路线信息，然后在一天结束的时候，上传包囊和路线完成信息到同一库存数据库。在传统的同步环境中，这可能会被设计成放射状模型（hub-and-spoke），如下。

When first architecting an OCA, organizations will typically start with a single network topology. For example, imagine a group of delivery workers who download their route information at the start of the day from a central warehouse database and then upload their package and route completion information to the same warehouse database at the end of the day. In a traditional synchronization environment this would be considered a hub-and-spoke model as seen below.

然而，如果当一个员工完成了他的工作，却从仓库开到城市的另一端，这时司机可能希望同步数据到另一个仓库。或者进一步，使用数据协作将数据同步给另一个运送工。第二个用户回到仓库将他们数据都上传到服务器。你可以想象，这种同步逻辑将会很快变得很复杂。

However, what happens if a delivery worker completes his work on the other side of the city from the warehouse and the driver wishes to synchronize with a different warehouse? Or to take it one step further, why not let the delivery worker synchronize data with another delivery worker by using data collaboration. The second user could then go to a warehouse and upload both users’ data. As you can imagine the logic required to orchestrate this type of synchronization can quickly become very complicated.

对于Sync Services for ADO.NET，实际上支持使用任何类型同步拓扑。现在，公司将不再局限单个拓扑或者组合拓扑，这意味着可以建立包含离线和协作基础结构.

With Sync Services for ADO.NET, virtually any type of synchronization topology can be used. Now organizations are no longer limited to a single topology but can choose any one or a combination of topologies, meaning they could create combinations of offline and collaboration-based architectures.

自定义客户端和服务器数据库

Custom Client and Server Databases

毫无疑问，将来的某一时刻，你需要添加新的数据库到你的同步环境中。例如，一个企业可能拥有一个遗留系统或者大型主机需要整合到现有的同步环境中。或者，一个移动设备可能已经有了自定义数据库，需要将它整合到后端数据库。使问题更糟的是，如果数据库不允许你跟踪更改，使是你无法应用更改。Sync Services for ADO.NET，提供了通用数据库，像是SQL Server Compact和 SQL Server 2008 是外部功能。然而，使用Microsoft Sync Framework，开发人员可以闯进自定义提供器（provider），来整合同步存在任何位置的数据库，想Web service、 U 盘，有机上的SIM卡。

Without a doubt, there will come a time when you need to add a new database into your synchronization environment. For example, an enterprise may have legacy systems or mainframes that need to be integrated into the existing synchronization environment. Or alternatively, a mobile device may already have a custom database that needs to be integrated into the back-end database. To make matters worse, what if you are not able to make changes to that database to allow you to track changes? With Sync Services for ADO.NET, providers for common databases such as SQL Server Compact and SQL Server 2008 are included out of the box. However, using the Microsoft Sync Framework, a developer can create custom providers that integrate synchronization with virtually any place you store your data, whether that is a Web service, a USB key-chain drive, or a SIM card on a cell phone.

安全

Security

在一个OCA中，有多方面的安全需要实现。这些方面包括：

In an OCA, there are many aspects to security that may need to be implemented. Some of these areas include:

数据库加密
数据库认证
加密同步数据
内部认证

Database encryption
Database authentication
Encryption of data synchronization
Internal authentication

Sync Services for ADO.NET 能够帮助增加依赖同步的应用程序的安全性。在设备上， SQL Server Compact可以加密数据库，同时启动用户身份验证功能。从同步角度， Sync Services for ADO.NET 支持能使加密数据在2个数据库间传播。在企业端， SQL Server 2008，以及现有的IIS安全可以提供用户认证，认证用户交换数据。

Sync Services for ADO.NET helps to increase the security of applications that depend on synchronization. On the device side, SQL Server Compact offers the ability to both encrypt the database as well as the ability to enable user authentication. From a synchronization perspective, Sync Services for ADO.NET supports the ability to encrypt data as it travels between databases. On the corporate side, SQL Server 2008 as well as existing IIS security can be leveraged for user authentication as users exchange data.

总结

Summary

Sync Services for ADO.NET是一个中和数据同步解决方案，能使开发者构建支持任何数据库，任何数据库，在任何网络上的同步解决方案。对于Sync Services for ADO.NET 和Microsoft Sync Framework，信息同步的方向是可以进出组织的，允许开发者构建高效率和高伸缩性的偶尔连接程序。使用Microsoft Sync Framework开发者可以扩展Sync Services for ADO.NET 应用程序具备在设备间使用任何数据源协作的能力。

Sync Services for ADO.NET is a comprehensive data synchronization solution that enables developers to build solutions that support synchronization of any database, on any data protocol over any network topology. With Sync Services for ADO.NET and the Microsoft Sync Framework, the synchronization of information can flow virtually anywhere in or out of the organization, allowing developers to build efficient and highly scalable Occasionally Connected Applications. Using the Microsoft Sync Framework developers can extend Sync Services for ADO.NET applications to enable collaboration of data between devices using any data source.

关于Sync Services for ADO.NET 和Microsoft Sync Framework的更多信息，请访问： http://msdn2.microsoft.com/en-us/sync/default.aspx .

For more information about Sync Services for ADO.NET and the Microsoft Sync Framework, please visit: http://msdn2.microsoft.com/en-us/sync/default.aspx .

2008-08-29T17:27:00.000+08:00

让WCF使用自定义业务对象

Using Custom Business Objects with Windows Communication

原文链接：http://msdn.microsoft.com/zh-cn/vbasic/bb960413.aspx

作者：Rob Windsor Visual Basic MVP, ObjectSharp Consulting

在我之前的文章《Windows Communication Foundation 入门》中，我描述如何创建简单的WCF服务。服务事例演示了入户是使用简单类型，像数字和字符串，但在真实的应用程序中大多使用更复杂的数据类型，像是Customers 和 Invoices。在这篇文章中，我将介绍如何在WCF中使用这些自定义的业务对象（类型）。

In my previous article, Getting Started with Windows Communication Foundation, I described the basics of creating and consuming a simple WCF service. The services demonstrated used simple types like numbers and strings, but most real-world applications use more complex data like customers and invoices. In this article I’ll demonstrate how to work with these custom business objects in WCF.

事例代码在这里下载。要运行事例代码，你需安装要Visual Studio 2005，.NET Framework 3.0, 和 Visual Studio 2005 extensions for .NET Framework 3.0 (WCF and WPF)。（或者安装VS2008）

Download the sample code here. To run the sample code, you'll need Visual Studio 2005, the .NET Framework 3.0, and the Visual Studio 2005 extensions for .NET Framework 3.0 (WCF and WPF) installed.

开始

Setting Up

我的演示的解决方案里包含4个项目。

I’ll start with a solution that contains four projects.

Business 是一个类库项目，包含自定义名称为Person的业务类。Person有几个属性（Id，Name，和BirthDate）和一个ToString 方法。

Business is a class library project with a custom business class named Person. Person has a few simple properties (Id, Name

, and BirthDate) and a ToString method.

Public Class Person

Private _id As Integer

Private _name As String

Private _birthDate As DateTime

Public Sub New(ByVal id As Integer, _

ByVal name As String, ByVal birthDate As DateTime)

_id = id

_name = name

_birthDate = birthDate

End Sub

Public Property Id() As Integer

Get

Return _id

End Get

Set(ByVal value As Integer)

_id = value

End Set

End Property

Public Property Name() As String

Get

Return _name

End Get

Set(ByVal value As String)

_name = value

End Set

End Property

Public Property BirthDate() As DateTime

Get

Return _birthDate

End Get

Set(ByVal value As DateTime)

_birthDate = value

End Set

End Property

Public Overrides Function ToString() As String

Return String.Format( _

"{0} [Id:{1}; Birth Date: {2}]", _

_name, _id, _birthDate)

End Function

End Class

Services 是一个类库项目，包含一个名为PersonService的服务类。它暴露有3个操作：获取单个Person对象，获取一组Person对象，和更新一个Person对象。因为服务使用内存存储数据（像字典），所以实例模式将设置成Single。这意味着一个服务对象将处理所有的过来的请求，并且这些请求将访问和修改字典中的数据。

Services is a class library project with a service class named PersonService. It exposes three operations: one to get a single Person object, one to get a group of Person objects, and one to update a Person object. Because the service uses an in-memory data store (i.e., the Dictionary), the instancing mode has been set to Single. This means that a single service object will handle all incoming requests, and those requests will access or modify the data inside the Dictionary.

Imports System.ServiceModel

Imports Business

<ServiceContract()> _

Public Interface IPersonService

<OperationContract()> Function GetPerson(ByVal id As Integer) As Person

<OperationContract()> Function GetPeople() As Person()

<OperationContract()> Sub UpdatePerson(ByVal p As Person)

End Interface

<ServiceBehavior(InstanceContextMode:=InstanceContextMode.Single)> _

Public Class PersonService

Implements IPersonService

Private _people As New Dictionary(Of Integer, Person)

Public Sub New()

_people.Add(1, New Person(1, "Frodo Baggins", #1/1/1380#))

_people.Add(2, New Person(2, "Sam Gamgee", #2/2/1385#))

_people.Add(3, New Person(3, "Merry Brandybuck", #3/3/1390#))

_people.Add(4, New Person(4, "Pippin Took", #4/4/1395#))

End Sub

Public Function GetPerson(ByVal id As Integer) As Person Implements IPersonService.GetPerson

Dim result As Person = Nothing

If _people.ContainsKey(id) Then

result = _people(id)

End If

Return result

End Function

Public Function GetPeople() As Person() Implements IPersonService.GetPeople

Dim result(_people.Count - 1) As Person

_people.Values.CopyTo(result, 0)

Return result

End Function

Public Sub UpdatePerson(ByVal p As Person) Implements IPersonService.UpdatePerson

If _people.ContainsKey(p.Id) Then

_people(p.Id) = p

End If

End Sub

End Class

Hosts 是一个控制台程序，它是我们服务的宿主。配置了一个使用了http://localhost:8081/PersonService地址和basicHttpBinding 的端点。

Hosts is a console application that will be our service host. An endpoint has been configured to use an address of “http://localhost:8081/PersonService” and the basicHttpBinding.

Imports System.ServiceModel

Module Module1

Sub Main()

Using host As New ServiceHost(GetType(Services.PersonService))

host.Open()

Console.WriteLine("Service started")

Console.ReadLine()

End Using

End Sub

End Module

<?xml version="1.0" encoding="utf-8" ?>

<system.serviceModel>

</behavior>

</serviceBehaviors>

</behaviors>

<endpoint

address="http://localhost:8081/PersonService"

binding="basicHttpBinding"

bindingConfiguration=""

contract="Services.IPersonService" />

</service>

</services>

</system.serviceModel>

</configuration>

最后， Client 是一Windows Forms 项目，将用来浏览也编辑数据。用户界面的元素已经添加到窗体，但还没有实现事件处理。

Finally, Client is a Windows Forms project that will be used to browse and edit data. The user interface elements have been added to the form, but none of the event handlers have been implemented.

数据契约

Data Contracts

一旦你准备好和编译后，右键单击Hosts项目，并选择调试->启动新的实例。你将收到一个像错误，它看起来像这样样子：

Once you have the solution set up and have a clean build, right-click the Hosts project and choose Debug > Start new instance. You should receive an error that looks like this:

不像ASMX Web Services，WCF不允许自动序列化对象。所有你接收参数或方法的返回值得类型都必须是可序列化的。虽然你可以通过实现IXmlSerializable接口，或者应用Serializable attribute 到你的类上，来要完成这个，不过这里推荐使用新的DataContact 和 DataMember attributes 在System.Runtime.Serialization 命名空间。

Unlike ASMX Web Services, WCF does not allow automatic serialization of objects. All types you receive as parameters or return from methods must be serializable. While this can be done by having your type implement the IXmlSerializable interface, or by applying the Serializable attribute to your class, the preferred method is to use the new DataContact and DataMember attributes from the System.Runtime.Serialization namespace.

为了解决InvalidDataContractException异常，我们需要添加这些attributes到我们自定义的业务对象上。右键单击Business项目并选择引用，选择System.Runtime.Serialization，然后单击确定。

To address the InvalidDataContractException, we will add these attributes to our custom business object. Right-click the Business project and select Add reference, select System.Runtime.Serialization, and click OK.

在Person类的源代码文件的最顶端添加导入System.Runtime.Serialization命名空间的声明。然后将DataContract attribute添加到Person类的声明上和将DataMember attribute 添加到每个属性上。

Add an Imports statement for System.Runtime.Serialization to the top of the source code file for the Person class. Then add the DataContract attribute to the Person class declaration and the DataMember attribute to each of the properties.

Imports System.Runtime.Serialization

<DataContract()> _

Public Class Person

Private _id As Integer

Private _name As String

Private _birthDate As DateTime

Public Sub New(ByVal id As Integer, ByVal name As String, ByVal birthDate As DateTime)

_id = id

_name = name

_birthDate = birthDate

End Sub

<DataMember()> _

Public Property Id() As Integer

Get

Return _id

End Get

Set(ByVal value As Integer)

_id = value

End Set

End Property

<DataMember()> _

Public Property Name() As String

Get

Return _name

End Get

Set(ByVal value As String)

_name = value

End Set

End Property

<DataMember()> _

Public Property BirthDate() As DateTime

Get

Return _birthDate

End Get

Set(ByVal value As DateTime)

_birthDate = value

End Set

End Property

Public Overrides Function ToString() As String

Return String.Format("{0} [Id:{1}; Birth Date: {2}]", _name, _id, _birthDate)

End Function

End Class

经过这些修改，我们的服务应该可以使用了。右键单击Hosts项目，选择调试 ->启动新的实例。这次所有的东西应该正确的工作了：控制台窗口应该显示出来并且应该看到指示服务已经启动的消息。

With these changes, our service should be ready to go. Right-click the Hosts project and select Debug > Start new instance. This time everything should work correctly: the console window should appear and there should be an indication that the service has started.

让服务宿主继续运行，右键单击Client项目并选择添加服务引用。输入http://localhost:8081/PersonService到服务URI中并输入PersonServiceProxy 到服务引用名字中并点击确定。一旦将服务引用添加到客户端，就可以关闭服务宿主的控制台窗口了。

With the service host still running, right-click the Client project and select Add service reference. Enter “http://localhost:8081/PersonService” for the Service URI and PersonServiceProxy for the Service reference name, and then click OK. Once the service reference has been added to the client, close the service host console window.

代理类

Proxy Class

添加服务对话框做了2件事。一是添加客户端终结点到项目或网站的配置文件中。二是建立服务代理类。要查看代理类，选择Client项目并单击解决方案浏览器工具栏中的显示所有文件按钮。

The Add Service Reference dialog does two things. It adds a client endpoint to the configuration for the project or web site, and it creates a service proxy class. To see the proxy class, select the Client project and click the Show All Files button in the Solution Explorer’s toolbar.

双击PersonServiceProxy.vb 文件，在文本编辑器中打开。在这个部分，我们将说说Preson类。代理类不仅仅包含调用服务的代码，也包含客户端表示业务对象类。服务端发送Person数据将储存在这里。另外，请注意这个类仅用来表示数据，没有函数（方法）。原来类中的方法将不会包含在这里。

Double-click PersonServiceProxy.vb to open it in the text editor. The part we are interested in is the Person class. Not only does the proxy contain the code we need to call our service, it also has a client-side representation of our business class. When the data for a Person is sent from the service, it will be stored here. Also note that this class only represents the data, not the functionality. None of the methods from the original class will be included here.

<System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "3.0.0.0"), _

System.Runtime.Serialization.DataContractAttribute([Namespace]:="http://schemas.datacontract.org/2004/07/Business"), _

System.SerializableAttribute()> _

Partial Public Class Person

Inherits Object

Implements System.Runtime.Serialization.IExtensibleDataObject

<System.NonSerializedAttribute()> _

Private extensionDataField As System.Runtime.Serialization.ExtensionDataObject

<System.Runtime.Serialization.OptionalFieldAttribute()> _

Private BirthDateField As Date

<System.Runtime.Serialization.OptionalFieldAttribute()> _

Private IdField As Integer

<System.Runtime.Serialization.OptionalFieldAttribute()> _

Private NameField As String

Public Property ExtensionData() As System.Runtime.Serialization.ExtensionDataObject Implements System.Runtime.Serialization.IExtensibleDataObject.ExtensionData

Get

Return Me.extensionDataField

End Get

Set

Me.extensionDataField = value

End Set

End Property

<System.Runtime.Serialization.DataMemberAttribute()> _

Public Property BirthDate() As Date

Get

Return Me.BirthDateField

End Get

Set

Me.BirthDateField = value

End Set

End Property

<System.Runtime.Serialization.DataMemberAttribute()> _

Public Property Id() As Integer

Get

Return Me.IdField

End Get

Set

Me.IdField = value

End Set

End Property

<System.Runtime.Serialization.DataMemberAttribute()> _

Public Property Name() As String

Get

Return Me.NameField

End Get

Set

Me.NameField = value

End Set

End Property

End Class

使用服务

Using the Service

现在我们有了代理类，我们可以向客户端添加逻辑了。我们将添加ListBox填充代码，在窗体载入的时候。为窗体的Load事件和ListBox的SelectedIndexChanged事件添加事件处理。Leave these empty for now.

Now that we have the proxy, we can add the logic to our client application. We will start by adding code to populate the list box when the form loads. Add event handlers for the form’s Load event and the list box's SelectedIndexChanged event. Leave these empty for now.

就如下面的代码，添加一个私有的子过程LoadListBox.在这个方法中我们建立一个服务实例并将调用GetPeople方法的返回值绑定到ListBox上。一旦ListBox填充了数据，我们将激活SelectedIndexChanged事件处理。为了执行这个方法，还需要在在窗体的Load事件中调用LoadListBox。

Just below this code, add the declaration for a private subroutine called LoadListBox. In this method we want to create an instance of our service proxy and then data bind the results of calling GetPeople to the list box. Once the list box is populated, we want to activate the event handler for the SelectedIndexChanged event. With this method complete, have the form’s Load event call LoadListBox.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

LoadListBox()

End Sub

Private Sub LoadListBox()

Using ws As New PersonServiceProxy.PersonServiceClient

PeopleListBox.DataSource = ws.GetPeople()

PeopleListBox.DisplayMember = "Name"

PeopleListBox.ValueMember = "Id"

End Using

PeopleListBox_SelectedIndexChanged(Me, EventArgs.Empty)

AddHandler PeopleListBox.SelectedIndexChanged, AddressOf PeopleListBox_SelectedIndexChanged

End Sub

现在，当用户选择ListBox中的项目时，我们希望显示关联的Person对象数据在下面的区域中。在SelectedIndexChanged 事件处理中，建立服务代理实例并调用GetPerson方法，将ListBox的SelectedValue 作为参数传入。我们需要一个变量来储存结果，所以我们声明了一个私有字段（如类级别的）叫做_person并使用它。然后将Person对象的属性值复制到文本框中。

Now, when the user selects an item in the list box, we want to show the data for the associated Person object in the data entry area below. In the SelectedIndexChanged event hander, create an instance of the service proxy and call GetPerson, passing in the SelectedValue from the list box (cast to an integer) as a parameter. We’ll need a variable to store the result, so declare a private field (i.e., a class-level variable) called _person and use it. Then copy the values of the properties from the Person object into the text boxes.

Private Sub PeopleListBox_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs)

Using ws As New PersonServiceProxy.PersonServiceClient

_person = ws.GetPerson(CInt(PeopleListBox.SelectedValue))

IdTextBox.Text = _person.Id

NameTextBox.Text = _person.Name

BirthDateTextBox.Text = _person.BirthDate.ToShortDateString()

End Using

End Sub

最后，在Save按钮的单击（Click）事件中，我们希望反转这个过程。将文本框里的值复制到_person 字段的属性中，建立服务代理实例，并调用UpdatePerson 发送更给到服务。最后，在调用LoadListBox方法来重新加载服务上的数据（你更改的）。

Finally, in the Save button’s Click event, we want to reverse this process. Copy the values of the text boxes into the _person field’s properties, create an instance of the service proxy, and then call UpdatePerson to send the changes back to the service. The last line should be a call to LoadListBox to reload the data (with your changes) from the service.

Private Sub SaveButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SaveButton.Click

_person.Id = IdTextBox.Text

_person.Name = NameTextBox.Text

_person.BirthDate = CDate(BirthDateTextBox.Text)

Using ws As New PersonServiceProxy.PersonServiceClient

ws.UpdatePerson(_person)

End Using

LoadListBox()

End Sub

完成后，你应该就能够测试了。我们需要启动Client和service host 来运行程序，所以右键单击解决方案并选择属性。选择多启动项目并设置Hosts项目先于Client项目启动。

With this done, you should now be able to test. We are going to need both the client and the service host running to use the application, so right-click the solution and select Properties. Select Multiple startup projects and then set the Hosts project to start first followed by the Client project.

现在你应该能够浏览People列表，编辑数据并保存到服务。

You should now be able browse through the list of people (Hobbits actually), edit their data and save it back to the service.

只读属性

Read-Only Properties

你可能已经注意到了我们程序中的小问题，在测试的时候，我们可以编辑Person对象的ID属性。这可不是什么好事，由于我们的服务使用属性来识别Person对象。如果你编辑ID，并提交更改，结果可能被忽略或者更糟，你可能更改错误的Person对象的数据。

You may have noticed a small problem with our application while testing it: we can edit the Id property of the Person object. This is not a good idea, since we are using the property to identify the Person object in the service. If you edit the Id, your changes may be ignored or, worse yet, you may change the data for the wrong person.

要解决这个问题，定位到Person类并设置ID属性为只读。

To address this problem, go to the Person class and make the Id property read-only.

<DataMember()> _

Public ReadOnly Property Id() As Integer

Get

Return _id

End Get

End Property

清理解决方案，并右键单击Hosts项目，选择调试->启动新的实例。

Get a clean build on the solution, and then right-click the Hosts project and select Debug > Start new instance.

噢～～！它没有工作。就像ASMX Web Services，只有可以读写的实体才可以被序列话。有几种方式可以解决这个问题，我将描述其中的一种。

Arggghhh!! This won’t work. Just like ASMX Web Services, only entities that can be read from and written to can be serialized. There are several possible solutions for this issue. I will describe one of them.

解决方法

One Solution

自从设置只读属性后，将不能序列化，我们将更改Person类，让字段包含data contract 来替换原来的属性。开打Person类并移除DataMember attribute 从3个属性中，并切添加它到3个字段声明上（如 _id， _name，和_birthDate）

Since read-only properties cannot be serialized, we are going to change the Person class so that the fields are included in the data contract instead of the properties. Open the Person class and remove the DataMember attribute from the three properties, and then add it to the declarations of the three fields (i.e. _id, _name, and _birthDate).

Imports System.Runtime.Serialization

<DataContract()> _

Public Class Person

<DataMember()> Private _id As Integer

<DataMember()> Private _name As String

<DataMember()> Private _birthDate As DateTime

Public Sub New(ByVal id As Integer, ByVal name As String, ByVal birthDate As DateTime)

_id = id

_name = name

_birthDate = birthDate

End Sub

Public ReadOnly Property Id() As Integer

Get

Return _id

End Get

End Property

Public Property Name() As String

Get

Return _name

End Get

Set(ByVal value As String)

_name = value

End Set

End Property

Public Property BirthDate() As DateTime

Get

Return _birthDate

End Get

Set(ByVal value As DateTime)

_birthDate = value

End Set

End Property

Public Overrides Function ToString() As String

Return String.Format("{0} [Id:{1}; Birth Date: {2}]", _name, _id, _birthDate)

End Function

End Class

既然我们更改了Person对象的序列化的样子，所以客户端的服务代理需要修改。你应该能够通过右键单击PersonServiceProxy.map 并选择更新服务引用来完成这个。不过我这建立是有问题的，代替的，右键单击服务引用文件夹，并选择删除。对App.config文件也做用羊的事。

Since we’ve changed how the Person object will look when it is serialized, the service proxy on the client needs to be modified. While you should be able to right-click PersonServiceProxy.map and select Update service reference to do this, I have found doing so problematic. Instead, right-click the Service References folder and select Delete. Do the same for the app.config file.

清理Hosts项目，并右键单击选择调试>启动新的实例。当服务Host运行的时候，右键单击并选择调试->穷调试。当服务宿主运行后，右键单击Client项目，并选择添加服务引用。在服务引用中输入服务地的URL http://localhost:8081/PersonService，并将PersonServiceProxy 添加到服务引用名著中，之后单击确定，一旦将服务引用添加到Client，就可以关闭服务宿主的控制台窗口了。

Get a clean build of the Hosts project, and then right-click and select Debug > Start new instance. With the service host running, right-click the client project and select Add service reference. Enter “http://localhost:8081/PersonService” for the Service URI and PersonServiceProxy for the Service reference name, and then click OK. Once the service reference has been added to the client, close the service host console window.

现在还没有解决我们的问题。客户端版本的Person的_ID属性还是可读写的。我们需要使用真正的Person对象代替客户端代理生成的版本。右键单击Client项目并选择添加引用，然后选择项目选项卡，选择Business，单击确定。

This hasn’t really solved our problem. The _id property of the client-side version of Person is still read/write. What we need to do to address this issue is to use the real Person object on the client side instead of the version in the proxy. Right-click the Client project and select Add reference, then from the Projects tab, select Business, and click OK.

接下来将是冒险的部分，我们需要手动修改客户端代理类，即使在违背在代理类顶端注释中的警告。这个问题是因为，如果我们重新生成代理类，我们所作的所有修改将会丢失。所以，你需要记住在每次重新生成代理类的时候再次修改代码。值得欣慰的是，在VS2008添加服务引用对话框中将解决这个问题。

Here comes the dodgy part. We need to manually edit the client-side proxy—even though the comment at the top of the proxy warns you against doing so. This is a problem because, if we need to regenerate our proxy, all of the changes we are about to make will be blown away. So, you will need to remember to make the edits every time you regenerate the proxy. If it’s any comfort, the Add Service Reference dialog in Visual Studio 2008 will address this issue.

在代码编辑器中打开 PersonServiceProxy.vb 并移除Person类。然后替换所有出现的PersonServiceProxy.Person 为 Business.Person。现在，在代码编辑器中打开Form1.vb并替换PersonServiceProxy.Person 为 Business.Person。最后，在Save按钮单击事件中，移除设置ID属性的代码。由于ID不能更改，你也可以将显示文本框设置成只读。

Open PersonServiceProxy.vb in the code editor and remove the Person class from it. Then replace PersonServiceProxy.Person with Business.Person everywhere it appears. Now open Form1.vb in the code editor and replace PersonServiceProxy.Person with Business.Person everywhere it appears. Finally, in the Save button’s Click event hander, remove the line of code that sets the Id property. Since the Id cannot be changed, you may also want to make the text box that displays it read-only.

Imports System.ComponentModel

Public Class Form1

Private _person As Business.Person = Nothing

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

LoadListBox()

End Sub

Private Sub LoadListBox()

Using ws As New PersonServiceProxy.PersonServiceClient

PeopleListBox.DataSource = ws.GetPeople()

PeopleListBox.DisplayMember = "Name"

PeopleListBox.ValueMember = "Id"

End Using

PeopleListBox_SelectedIndexChanged(Me, EventArgs.Empty)

AddHandler PeopleListBox.SelectedIndexChanged, AddressOf PeopleListBox_SelectedIndexChanged

End Sub

Private Sub PeopleListBox_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs)

Using ws As New PersonServiceProxy.PersonServiceClient

_person = ws.GetPerson(CInt(PeopleListBox.SelectedValue))

IdTextBox.Text = _person.Id

NameTextBox.Text = _person.Name

BirthDateTextBox.Text = _person.BirthDate.ToShortDateString()

End Using

End Sub

Private Sub SaveButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SaveButton.Click

_person.Name = NameTextBox.Text

_person.BirthDate = CDate(BirthDateTextBox.Text)

Using ws As New PersonServiceProxy.PersonServiceClient

ws.UpdatePerson(_person)

End Using

LoadListBox()

End Sub

End Class

你现在应该能够运行和测试完成的程序了。

You should now be able to run and test the completed application.

在客户端使用原Person类型的另一个好处是你可以使用它的方法。为了演示这个，我们将添加一些代码来调用Person类重写的ToString方法。添加按钮到客户端窗体上并双击他添加事件处理。事件处理的代码将PeopleListBox的SelectItem转换成Person对象并在消息框中显示调用ToString方法的结果。

Another benefit of using the real Person type on the client is that you can now make use of its methods. To demonstrate this, we will add some code to call the ToString method, which the Person class has overridden. Add the button to the client form and then double-click it to add an event handler. In the event handler add the code to cast the SelectItem from the PeopleListBox to a Person and then show the results of calling ToString in a message box.

Private Sub ToStringButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ToStringButton.Click

Dim p As Business.Person

p = CType(PeopleListBox.SelectedItem, Business.Person)

MsgBox(p.ToString())

End Sub

当你单击按钮后，你看到的结果像如下样子：

When you click the button, you should see results that look like this:

销毁

Dispose()

有更多关于数据序列化的主题，在这个文章中只讲解了基本的和主要的问题。最常见的挑战是处理只读数据，我已经向你展示处理这种情况的技术。武装你的知识，你现在能够暴露和使用自定义业务对象的服务。

While there is more to the subject of data serialization, this article covers the fundamentals and the core issues. The most common challenge is dealing with read-only data, and I’ve shown you a technique to deal with this situation. Armed with this knowledge, you should now be able to build services that expose and consume custom business objects.

2008-08-29T11:37:00.000+08:00

Lambda表达式和表达式树（Lambda Expressions and Expression Trees）

原文地址：http://blogs.msdn.com/vbteam/archive/2007/09/11/lambda-expressions-and-expression-trees.aspx

作者： Tim

最近我的《Lambda 表达式》的文章被发布到MSDN magazine上了。所以在这个帖子我将展开讨论之前文章中的想法（Ideas），如果这里想法使你感到迷茫，请你先去读一下之前的文章。

Lambda 表达式非常Cool ，除了文章中所描述的,Lambda表达式还可以捕获另一个可读形式的Lambda表达式的内容，并把它当作数据而不是可执行代码。

例如，下面几行代码将Lambda表达式转换成可调用委托（Callable delegate）

Dim f As Func(Of Integer, Integer) = function(x) x * 2

Dim r = f(10)

在这个实例中，第一行代码将建立一个Lambda 表达式并将它神奇的配额给一个可调用委托（Callable delegate） f 。之后，第二行调用 f 并返回 20.

这个非常酷，我希望我的文章能说明我为什么觉得的原因。还有更酷的你可以分配一个Lambda 表达式到一个特殊变量类型并且编译器将帮你做更多魔法般的事：

Dim e As Expression(Of Func(Of Integer, Integer)) = function(x) x * 2

在这个代码示例中，e 不是可调用委托（Callable delegate）。实际上，它是一个表达式树。一个表达式树是Lambda表达式在数据表单中的表示形式，它可以方便你阅读和编写lambda表达式。

如果你在调试器中查看e的值，你将会看到你可以简单的推测那个表达式是一个整数变量x乘以常数2。

默认的，IEnumerable 的扩展查询操作使用Lambda表达式。IQueryable的扩展查询使用表达式树。因此，当你在queryable对象上使用查询时，编译器将产生表达式树通过Lambda表达式树。

Scott,我们小组开发人员之一。他写了一篇极好的文章来说明这些想法。他有一个很好的实例来展示使用若干Lambda表达式来表示表达式树。

你可以用表达式树做什么？

通常，你可以做2件事：

表达式树中的数据，自定义处理。你也可以转换表达式树中的数据到另一个格式（像是XML）
使用.Compile() 方法将表达式树变成一个可执行的委托
使用动态条件构建查询：查看Jonathan's (我们的 PM)发布的文章。他有一个很好的实例来说明你如何操作表达式树和Lambda表达式来构建自定义条件。

第二项是有趣的，因为它意味着你可以写一个Lambda表达式到表达式树中或者类似的等待，并返回一个可调用委托（Callable delegate）。

Dim e As Expression(Of Func(Of Integer, Integer)) = function(x) x * 2

Dim f = e.Compile

Dim r = f(10)

在这个示例中，r的值是20，就像先前例子一样我们直接分配了Lambda到一个委托（类）。

为什么有趣？

除了表达式树，不可能用描述（格式）来描述表达式。除非使用IL（中间语言），但那个太低级来来重新建立用户需要的表达式。相比之下，表达式树提供了一个高级的树的形式来表示一个表达式，所以你可以简单的理解用户表达式的目的。

这有可能使你感兴趣的使用表达式树：

表达式，可以转换他们成为委托并调用它们。
转换表达式到SQL，那将使得它们可被服务器执行（这就是LINQ to SQL 做的）
转换表达式到XML并写入它们到磁盘上。
转换表达式到自定义格式，可以通过网络协议放松到服务器，并可以重新建立表达式树，之后根据它执行与/或（And/OR）。

2008-08-29T03:07:00.000+08:00

充分发挥 Visual Studio“Orcas”中查询的强大功能

原文地址：http://msdn.microsoft.com/msdnmag/issues/07/06/VBLINQ/Default.aspx?loc=zh

作者：Ting Liang Kit George

LINQ 语法
From 子句
Select 子句
使用查询结果
使用 Where 子句筛选
使用 Order By 排序
更多子句
摘要

长期以来，开发人员一直需要能够以其代码使用数据查询技术，这与他们在 SQL 查询中可能需要的十分相似。现在，随着 Microsoft® Visual Studio® 的新版本（代号为“Orcas”）即将发布，这种工具也将面市。Visual Studio 的下一个版本包含了一组新的语言功能 (LINQ)，统称为语言集成查询 (LINQ)，它将查询功能直接添加到 Visual Basic® 和 Visual C#®。

有了 LINQ，您可以直接使用 Visual Basic 编写数据访问代码。您可以使用编译时语法检查和架构检查，以及更好的工具支持（如 IntelliSense®）来编写您的查询。您不必再使用字符串来编写查询，也不必甚至等到运行时才能知道其构成是否正确。有了 LINQ，数据访问代码便可以从底层存储工具中提取出来。这意味着，您可以使用同一个代码构造来查询关系数据库、XML 和内存中的对象，而且您可以轻松地联接跨不同源域的信息。例如，您可以创建一个存储在 XML 中的客户名称列表和存储在数据库表中的客户名称列表之间的组合。此外，LINQ 允许延迟执行，这样您就可以将查询分成几个逻辑部分，并且仍能实现只要运行一次最终结果的性能优势。最后，Visual Basic/XML 集成几乎可以彻底消除您编写的代码和您正试图表示或操作的文档之间的概念性障碍。现在，让我们开始学习如何编写一些查询。

LINQ 语法

利用 LINQ 您可以查询不同的源，例如 Microsoft .NET Framework 对象集合、关系数据库或 XML 数据源。在 Visual Basic 中，LINQ 查询的一般格式如下所示：

From ... < Where ... Order By ... Select ... >

当然，如果您是 SQL 程序员，您会想知道为什么查询是以 From 开始，而不是以 Select 开始。原因很简单：即 IntelliSense。通过首先指出数据源，IntelliSense 可以显示集合中对象的类型成员的正确列表。当您键入 Select 子句时，这一点很重要。在下面的部分，我们会看一些标准的 LINQ 子句，并且看一下它们是如何相互构建的，以致可以创建强大、灵活的查询。我们会依次看下列各个子句：From 子句、Select 子句、使用查询结果、Where 子句和 Order By 子句。在下列示例中，我们有时会引用一个 Customer 或一个 Order。对于这些示例，设想它们已在图1 中定义。每个 Customer 都通过 Orders 属性具有对其订单的集合的引用。这允许两个实体之间存在简单关系。该关联由每个 Order 中的 CustomerID 外键形成。除了这些类型定义外，还有存储在变量客户中的 Customers 集合。

From 子句

From 子句是 LINQ 的核心，因为每个查询都需要它。查询必须始终以 From 子句开头，它是必须要明确提供的唯一的子句。From 子句的基本模式如下：

From <query variable> In <datasource>

从本质上而言，From 表示遍历一组数据的行为。要实现此操作，它需要与源中的每个数据项相对应的变量，这与用于 For Each 语句的迭代变量非常相似。在 From 语句后面的子句中，可以引用该查询变量来对数据进行筛选、排序或其他操作。下面是 From 子句一个非常简单的示例：

Dim numbers() As Integer = {1, 7, 4, 2, 91, 12, 23, 37, 42}

Dim allNumbers = From number In numbers

For Each num In allNumbers

Console.Write(num & " ")

Next

在此示例中，查询会返回类型为 IEnumerable(Of Integer) 的集合。关于此查询，有几个地方值得注意。首先，Select 是隐式的，这也就是您在示例中的看不到它的原因。Select 语句是可选的；如果您一个也不提供，那么即会返回作用域中的变量集。其次，该查询不是真的很有用。您可以删除该查询，然后只要遍历使用 For Each 循环的那些数字变量。LINQ 的真正功能还尚不明显，但是我们来看一下下面的查询：

From <query variable> As Type In <datasource>

Dim checkboxes = From checkbox As Checkbox In groupJobType.Controls

From 语句的变体允许您指定遵循该查询变量的类型语句。如果您想从特定源检索类型，并且在检索它们的时候重新将它们键入到更具体（也可能不那么具体）的类型中，这就很有用。我们恰好知道，groupJobType 的 GroupBox 中的所有控件都是 Checkbox 控件，因此，我们可以在检索它们的时候安全地将它们键入 Checkbox。

还有使用 From 关键字两次的 From 子句的另一个变体：

From <query variable> In <datasource> Let <variable> = <value>

Dim evens = From Number In numbers Let IsEven = (Number Mod 2 = 0)

该查询语法实际上就是一个 From 子句，它后面的部分称为 From 的“Let”部分。实际上，我们是在定义另一个变量，并将它赋予指定的值。在这种情况下，我们是在名为“IsEven”的结果集上定义另一个值，即布尔值 — 不论我们选择的数字是否为偶数，都是这个结果。这个过程必然意味着所返回的对象发生了变化：它不再只是 Integers 的 IEnumerable，因为返回的可枚举的结果中的每个项目都包含数字和布尔值。我们会看一下如何使用下面的查询结果。请注意，在通用语法表达式中，只要有可能省略 From 关键字的第二次使用，就可以使用逗号代替；上面的两个示例都是相同的。

Let 变量和标准查询变量的区别在于，对 Let 变量始终指定 using = 值，而查询变量的后面则是 In 关键字。然而，Visual Basic 团队正在积极地研究公开 Let 变量的方法，因此，现在有一个好机会，那就是用于 Let 的支持的语法会从现在到产品以最终形式发布的这段时间内发生变化。

From <queryVar1> In <datasource1>, <queryVar2> In <datasource2>, ...

Dim customerOrders = From cust In customers, ord In cust.Orders

该语法允许您指定多个数据源。在上面的示例中，我们获得了客户和订单的集合；实际上，这是对这两个源的一个隐式 Join。很多时候，这些源不会这么容易就关联起来（您的第一个查询变量上不会有第二个查询变量的集合），因此您必须使用 Where 子句将它们关联起来。但是在这种情况下，我们的 Orders 集合实际上都位于每个 cust 实例上；因此我们仅获得了应用于给定客户的订单。

Select 子句

到目前为止，您已了解如何指定数据源。请注意，在每个示例中，我们都已省略了 Select 关键字。这仅意味着我们使用了默认的 Select 行为，就是要选择指定的每个查询或 Let 变量（逻辑上等同于 Select *）。但是我们也有能力指定 Select 子句，并且我们在执行时获得了高得多的灵活性：

Select <varA>, <varB>, ...

Dim allNumbers = From number In numbers _

Select number

Dim evens = From Number In numbers Let IsEven = (Number Mod 2 = 0) _

Select Number, IsEven

Dim customerOrders = From cust In customers, ord In cust.Orders _

Select cust, ord

这是最简单的 Select。比较一下前面的查询和此处 From 部分中的同等查询。使用显式 Select 子句的这三个示例中的每一个查询，都将具有和 Select 子句为隐式子句的先前查询一样的行为。

使用 Select 会更有趣，但是，当您对这个主题尝试变体时：

Dim customerInfos1 = From cust In customers _

Select cust.FirstName, cust.LastName

Dim customerInfos2 = From cust In customers, ord In cust.Orders _

Select cust.LastName, ord.OrderID, ord.OrderDate

首先要注意的是新的通用语法并未指定（该示例上方没有注释）。这是因为，如果您考虑了这些示例，则前一个代码就会是同一个样式：毕竟 FirstName 和 LastName 只是变量。但是与先前的示例不同，我们废弃了查询变量，并只返回了几个属性。这是一个非常强大的功能。

LINQ 另一个强大的功能就是：当您不需要重命名字段的时候，Visual Basic 会根据属性的名称来推断这些名称。但是，有时候您可能希望重命名字段，或者合并数据，如下所示：

Select <aliasA> = <varA>, <aliasB> = <varB>, ...

Dim customerInfos1 = From cust In customers, ord In cust.Orders _

Select [Date] = ord.OrderDate, _

Name = cust.FirstName & cust.LastName

在某些情况下（例如 Date = ord.OrderDate），您可能会由于个人偏好而这样做。在另一种情况下（例如 Name = cust.FirstName & cust.LastName），您实际上会想创建一个新的数据段 — 一个字段组合。还有使用别名的第三种情况。设想您从恰好具有相同名称但实际不同的源中选择了两个字段。名称推断会对产生的类型为这些变量指定相同的属性名称，由于冲突，所以无法编译。您可以对一个（或两个）冲突的字段名称使用别名，以解决该冲突。

关于 Select 子句，值得注意的最后一点就是，它可以重新确定变量的作用域，因此查询中的任何子句仅可以看到 Select 公开的内容。我们会在讨论 Where 子句的时候更详细地讨论这一点。

使用查询结果

现在，让我们看一下如何使用查询结果。要执行这个操作，您需要了解在执行查询时，这个查询是由什么组成的：

Dim allNumbers = From number In numbers _

Select number

任何查询的结果始终都会是 IEnumerable(Of T)。这是查询最可靠、最强大的一个方面，因为这意味着您可以一直遍历数据。有时候您可能知道 of T 的类型是什么，但有时候可能又不知道，例如在匿名类型的情况下。匿名类型对于 LINQ 是新类型，用来表示具有多个返回字段列的查询的任何结果。匿名类型是一种您无法以代码直接命名或参考，但是编译器可以将它视为其他命名类型的类型（编译器为该类型指定了名称，您只是不知道是什么名称，或者您不需要知道是什么名称）。匿名类型的字段名称可以直接以代码指定，也可以由查询表达式的编译器自动推断。例如，使用匿名类型会启用类似您之前看到的代码，{Num, IsEven} 和 {cust, ord} 的配对是有效的新类型，每个类型都包含两个数据段（包含作为各自可访问的字段名称的 Num、IsEven 和 Cust、Ord）：

Dim customerInfos1 = From cust In customers _

Select cust.FirstName, cust.LastName

Dim customerInfos2 = From cust In customers, ord In cust.Orders _

Select cust.LastName, ord.OrderID, ord.OrderDate

正如您能看到的一样，匿名类型允许您在 Select 子句指定不同数量的字段，而无需您预先指定表示每个特定字段组合的准确类型。虽然我们说每个查询都是一个 IEnumerable(Of T)，但是您可能已经注意到，实际上没有一个示例为代表该查询的变量指定了类型。您可能会担心该变量的类型会变成 System.Object，并且您正在失去流程中的所有强类型化支持。其实并非如此。有一个称为类型推断的新编译器功能，这意味着该编译器可以根据其初始化值，推断出声明没有类型说明符的变量的类型（如果您在代码顶部包括了 Option Infer On 语句）。例如，下列变量就是根据初始化值以静态的方式确定类型的：

Dim x = 5 ' x is typed as an Integer

Dim y = DateTime.Now ' x is typed as a DateTime

Dim z = GetCustomer() ' assuming GetCustomer returns a customer

' type, z is typed as a Customer

x = "hello" ' COMPILE-TIME ERROR: x can only store Integers

表示查询的变量也可以采用相同的方式被强类型化。这使您可以真正地对那个变量直接使用成员，而不必担心那些后期绑定的成员。另外，您会保留强类型化的其他优点，例如 IntelliSense 支持。当声明新变量没有类型说明符时，在 For Each 语句中会出现同一种类型推断：

' assuming allNumbers is a collection of Integers,

' the type of num is inferred to be an Integer

For Each num In allNumbers

通常，使用查询时您可能最难知道的事情便是正被返回的对象是哪种特定种类。这就是您必须信任查询的原因。实际上，不同种类的对象都可以用来存储查询结果。值得注意的是，它们将始终为 IEnumerable(Of T)，因此您可以使用 For Each 或将它们传递给接受 IEnumerable 对象的 API，来遍历它们。尽管如此，但还有一条经验法则，它将帮助您分辨返回的对象，这条经验非常重要（您随即就会明白原因）。当返回的结果由单个命名类型组成时，则查询会返回 IEnumerable(Of <your type>)。当返回的结果由多个类型组成，则查询会返回 IEnumerable(Of <anonymous type>)。因此在上面的示例中，正好返回一个来自 Integers 数组的整数，所以您将获得一个 IEnumerable(Of Integer)。

当查询结果为单个类型的 IEnumerable 时，使用这个结果就会非常容易。您只需要使用 For Each 子句：

For Each num In allNumbers

Console.WriteLine(num)

Next

既然我们有了单个类型的 IEnumerable，就应该不会再有什么出乎我们的意料了。但是，现在让我们看一下涉及匿名类型的情况：

Dim evens = From Number In numbers Let IsEven = (Number Mod 2 = 0) _

Select Number, IsEven

For Each numInfo In evens

Console.WriteLine("Is " & numInfo.Number & " even? " & _

numInfo.IsEven)

Next

由于查询会返回内部具有两个数据段的对象，因此变量“evens”是 IEnumerable(Of <anonymous type>)。我们得出的每个实体都具有名为 Num 和 IsEven 的字段；因此，当我们遍历偶数集合时，我们需要废弃所有数据段以检索它们（例如 numInfo.Num）。有几个地方值得注意。首先，我们将这个迭代变量命名为 numInfo。当遍历匿名类型的集合时，使用通用名称来指示它具有多个数据段是一个不错的方法。其次，我们对示例中的查询变量使用了大写，因此当我们在 For Each 循环内部废弃和使用它们时，它们看似标准属性。我们不需要对上一个示例中的“number”这么做，因为那时还尚未引入匿名类型。为了说明这个操作的简易性，让我们再看一个示例：

Dim customerInfos = From cust In customers, ord In cust.Orders _

Select Name = cust.FirstName & cust.LastName, _

[Date] = ord.OrderDate

For Each custInfo In customerInfos

Console.WriteLine("Customer Name: " & custInfo.Name & _

" Order Date: " & custInfo.Date)

Next

它真是再简单不过了。但是，有时候您可能想分别检索您的名和姓两个字段。上面的变体会保留 Customers 和 Orders 中的所有数据（以后我们想使用其他字段），但是对这个特定的迭代不会获得同样的效果。

Dim customerInfos = From cust In customers, ord In cust.Orders _

Select Customer = cust, Order = ord

For Each custInfo In customerInfos

Console.WriteLine("Customer Name: " & _

custInfo.Customer.LastName & ", " & _

custInfo.Customer.FirstName)

Console.WriteLine("Order Date: " & custInfo.Order.OrderDate)

Next

同样，一切都在意料之中。通过将每个完整的对象纳入我们的结果，我们必须废弃这些对象，以获得我们想使用的特定字段。请注意，我们会在 For Each 循环内部将名和姓连接起来。我们会教您一个更深一层的小技巧。如果您要考虑查询时可用的成员，您可以做一些相当酷的操作。例如，请考虑下面这个代码：

Dim customerInfos_2 = From cust In customers, ord In cust.Orders _

Select Customer = cust, Order = ord

Console.WriteLine("There are " & customerInfos.Count & _

" customer orders")

这个示例对查询结果直接使用了 Count，以查看有多少项结果。我们不会进入您可在集合找到的所有成员，但是请不要忘记试试您可以对结果集执行何种操作。同时也请注意，这些成员对由查询产生的所有集合都是可用的。如果您猜测到这意味着这些成员必须要在 IEnumerable(Of T) 上，您就猜对了；甚至连它们的实现也必须在 IEnumerable(Of T) 上进行。这是一个被称作扩展方法的新功能。关于如何执行查询，有一个概念您必须了解，那就是延迟执行。在延迟执行中，直到它被实际使用时才会尝试检索查询的数据。这一点很重要，因为它允许您在不同的部分编写查询，而不需要多次调用底层数据源，同时还存在巨大的性能优势，特别是在根据数据库访问信息时（在这种情况下应特别避免多次调用）。这意味着，查询的声明实际上不会检索这些数据；只执行需要数据的操作会导致检索这些数据。您将可能执行的操作最常见的就是遍历查询。但是其他可能的操作还包括通过显示数据或尝试使用一种方法（如 Count）来查找查询的条目数。图 2 显示了执行数据检索的地方。

使用 Where 子句筛选

Where 子句通过允许根据特定条件筛选使您的查询变得更加强大。Where 子句的用法与 If 语句非常相似。即在 If 语句中可能出现的情况，在 Where 子句中也可能出现：

Where <condition>

Dim evens = From num In numbers _

Where num Mod 2 = 0 _

Select num

请注意这个集合称为“evens”，与上一示例中的一样。与上一个示例不同的是，它仅包含偶数数字。当您遍历结果时，您只能得到偶数结果：

Dim mids = From num In numbers _

Where num > 10 And num < 50 _

Select num

Where 子句的优点就在于它很简单。您的 <condition> 可以是您选择的任何条件。让我们看一下它如何处理更棘手的查询：

Dim seattleCustomers = From cust In customers, ord In cust.Orders _

Where cust.City = "Seattle" _

Select Customer = cust, Order = ord

Dim seattle2003Orders = From cust In customers, ord In cust.Orders _

Where cust.City = "Seattle" _

And ord.OrderDate.Year = 2003 _

Select Customer = cust, Order = ord

有时候您可能会想要按一个字段来进行筛选，并选择一个（或多个）不同的字段。这非常简单：

Dim dallas2005Orders = From cust In customers, ord In cust.Orders _

Where cust.City = "Dallas" _

And ord.OrderDate.Year = 2005 _

Select cust.CustomerID, ord.OrderID

一旦您声明了 From 子句，则其他子句的顺序就是可选的，您可以按照您喜欢的任何顺序使用它们：

Dim seattle2003Orders = From cust In customers, ord In cust.Orders _

Select Customer = cust, Order = ord _

Where Customer.City = "Seattle" _

And Order.OrderDate.Year = 2003

请比较一下这个示例和上述相同名称的示例。请注意，我们已将 Select 子句移到了 Where 子句之前，这是完全可以接受的。但是也请注意，Where 子句必须进行细微的更改，现在提到的是 Customer 和 Order，而不是 cust 和 ord。请特别注意，Select 子句是重新确定作用域的子句，这样在 Select 子句之后的任何子句就仅可以看到 Select 公开的内容，这意味着该代码将无效：

' This won’t compile

Dim dallas2005Orders = From cust In customers, ord In cust.Orders _

Select cust.CustomerID, ord.OrderID _

Where cust.City = "Dallas" _

And ord.OrderDate.Year = 2005

我们在 Where 子句内部提到了 ord 和 cust，但是现在 Where 在 Select 的后面，因此这两个变量就不见了。Select 之后，我们所留下的是具有 CustomerID 和 OrderID 这两个属性的匿名类型。该代码可以被更改，如下所示：

Dim dallas2005Orders = From cust In customers, ord In cust.Orders _

Select cust.CustomerID, ord.OrderID, _

cust.City, ord.OrderDate _

Where City = "Dallas" _

And OrderDate.Year = 2005

请注意许多子句，包括 Where 和 Order By，都不会重新确定可用变量的作用域。

使用 Order By 排序

Order By 是任何查询的基本子句之一。Order By 将查询结果按指定的一个或多个字段进行排序：

Order By <query variable>

这是最简单的 Order By。如果没有指定任何顺序方向，则假定您是想按升序的顺序查看结果。下面是一个使用中的子句：

Dim nums = From num In numbers _

Order By num _

Select num

Order By 的下一个变体几乎与第一个变体完全相同。它假设您是想要 Order By 变量内部的一个字段，而不是变量本身：

Order By <field1>, <field2>, ...

Dim customerInfos1 = From cust In customers, ord In cust.Orders _

Order By cust.City _

Select Customer = cust, Order = ord

Dim customerInfos2 = From cust In customers, ord In cust.Orders _

Order By cust.City, ord.OrderDate _

Select Customer = cust, Order = ord

最好选择一个或多个字段。此外，因为 Order By 不会重新确定可用变量的作用域，所以下列 Select 子句可以使用前一作用域中可用的任何变量：

Order By <var1> [Ascending/Descending], _
<var2> [Ascending/Descending], ...

Dim customerInfos = From cust In customers, ord In cust.Orders _

Order By cust.City Descending, ord.OrderDate _

Select Customer = cust, Order = ord

这充分使用了 Order By。我们忽略了第二列的方向，但是它仍包含在第一列，这意味着我们先按城市以降序排序，然后再按订单日期以升序排序。当然，您可以将 Order By 和 Where 结合起来，我们以几个示例结束对该子句的介绍：

Dim orderedEvens = From num In numbers _

Where num Mod 2 = 0 _

Order By num _

Select num

Dim seattleCustomers = From cust In customers, ord In cust.Orders _

Order By cust.City Descending, ord.OrderDate _

Where cust.City = "Dallas" _

And ord.OrderDate.Year = 2005 _

Select Name = cust.LastName & ", " & _

cust.FirstName, ord.OrderDate

摘要

LINQ 提供了基本查询功能，包括指定源 (From)、识别要返回的数据 (Select)、筛选 (Where) 和排序 (Order By)。同时还提供可以对您的数据集进行分组、联接或聚合的高级查询功能。有了这些功能，又能得到其他功能（如匿名类型或类型推断）的支持，您便完全可以直接使用 Visual Basic 代码来编写类似 SQL 的查询。

附件

图1

Public customers As List(Of Customer)

Public orders As List(Of Order)

Public Class Customer

Public Property CustomerID() As Integer

Get

End Get

Set(ByVal value As Integer)

End Set

End Property

Public Property FirstName() As String

Get

End Get

Set(ByVal value As String)

End Set

End Property

Public Property LastName() As String

Get

End Get

Set(ByVal value As String)

End Set

End Property

Public Property City() As String

Get

End Get

Set(ByVal value As String)

End Set

End Property

Public Property Orders() As List(Of Order)

Get

End Get

Set(ByVal value As List(Of Order))

End Set

End Property

End Class

Public Class Order

Public Property OrderID() As Integer

Get

End Get

Set(ByVal value As Integer)

End Set

End Property

Public Property CustomerID() As Integer

Get

End Get

Set(ByVal value As Integer)

End Set

End Property

Public Property OrderDate() As DateTime

Get

End Get

Set(ByVal value As DateTime)

End Set

End Property

End Class

图2

'Figure 2 在 For Each 子句中检索到的数据

Dim seattleCustomers = From cust In customers _

Where cust.City = "Seattle"

Dim recentOrders = From ord In orders _

Where ord.OrderDate.Year = 2007

Dim custInfos = From cust In seattleCustomers, ord In recentOrders _

Where cust.CustomerID = ord.OrderID _

Select Name = cust.LastName & ", " & cust.FirstName, _

cust.CustomerID, ord.OrderDate _

Order By OrderDate Descending, Name

' None of the above queries are run until this point.

' This means that the information is only retrieved once.

For Each custInfo In custInfos

' take action on the data here

Next

2008-08-29T03:00:00.000+08:00

转换VS2005项目到VS2008-开启LINQ（Converting VS 2005 Projects to VS 2008 - Enabling LINQ）

原文地址：http://blogs.msdn.com/bethmassi/archive/2007/08/21/converting-vs-2005-projects-to-vs-2008.aspx

作者： Beth Massi

你有一个VS2005写的程序，你想转换它并使用在VS2008中的LINQ。在这里我将给主要的步骤，包括使LINQ工作时你可能要用到的提供器（Provider）。

在Visual Studio 2008 中，新的多平台（multi-targeting）特性允许你工作在VS2008下却能够写出面向.NET 2.0,3.0,3.5平台的程序。ScottGu 有个很好的帖子讨论这个和 Rick Strahl 。这个意谓着你不需要在机器上安装多个版本的VS IDE来处理之前版本的.NET目标平台。（注意：如果你目标平台是.NET 1.0或1.1 那么你仍需要 2002或者 2003）这是一个好的消息不仅仅因为它能节省磁盘空间和上下文开关（context switching），它允许你利用新的调试工具和编辑器的好处不需要冒着升级当前项目的风险）。然而，当你希望升级项目到3.5，开始使用LINQ的优势，你需要自己手动导入一些新的命名空间。

当你在VS2008中第一次打开VS2005写的项目的时候VS2008将会提示你升级项目。实际上是升级项目(.vbproj) 和解决方案(.sln) 文件兼容VS2008。项目文件实际仍向后兼容VS2005，所以你仍能打开它解决方案文件。而然他是单向的。所以如果你所在开发小组同时使用VS2005和VS2008 IDE时，你将需要2个解决方案文件，幸运的是你的项目文件（那些比项目文件更加经常变化的文件）可以共享。

所谓的升级，仅仅是处理升级你的项目和解决方案文件，但你的程序的目标平台仍然.NET 2.0。在你升级完的程序里使用新特性像LINQ你需要更改目标平台和添加一些引用。你也会希望打开新的 Option Infer 特性。这个允许编译器推断本地变量类型声明通过评估右边表达式（right-hand side of the expression）。这将在编写LINQ查询时非常有用。现在，要更改目标框架，单击“高级编译选项”按钮并更改目标平台在下拉框：

选择 .NET Framework 3.5 ，单击 OK，然后项目将关闭并重新打开。如果你再一次打开项目属性并查看引用标签，你将注意到System.Core.dll 版本3.5 将自动引用进来。然而，要使用LINQ你仍需要导入一些LINQ依赖的命名空间和添加一些引用。要使用LINQ to Objcects，在选项标签下导入命名空间选择 System.Linq。现在你将能够编写面向对象的查询了，像是：

Dim currentFiles = From File In My.Computer.FileSystem.GetFiles(CurDir) _
Select My.Computer.FileSystem.GetFileInfo(File)

要使用工作在数据集上的查询，你需要引用System.Data.DataSetExtensions 然后你需要重新运行数据集生成器。之后就可以写LINQ查询了在数据集上。像是右击数据集并单击“运行自定义工具（Run Custom Tool）”。这将产生数据集代码，所以那个数据表将从LINQ-Ready类名为TypedTableBase （在System.Data.DataSetExtension 命名空间下）继承。现在你将能够编写查询在类型化数据集上。例如，你可以写：

Dim total = Aggregate Products In Me.CategoryProductDataSet.Products _
Where Products.CategoryID = 1 AndAlso _

Products.Discontinued = False _

Into Sum(Products.UnitPrice * Products.UnitsInStock)

如果你希望开始使用LINQ to XML提供器，你需要引用 System.Xml.Linq.dll 和导入 System.Xml.Linq命名空间。之后你就可以编写XML查询了像：

Dim survey = XElement.Load(CurDir() & "questions.xml")
Dim questions = From q In survey...<question> Select q

最后，如果你希望使用LINQ to SQL 类到你升级的项目里，非常简单。仅仅右击并选择添加新项目，然后选择 LINQ to SQL 类模板，之后将打开新的 O/R 设计器并自动的添加System.Data.Linq.dll 引用。这将允许你编写如下的查询：

Dim countryList = From Customer In Db.Customers _

Where Customer.Country <> "" _

Order By Customer.Country _

Select Customer.Country Distinct

我希望我阐明如果在VS2008开始使用LINQ到你当前的程序中。

2008-08-29T02:33:00.000+08:00

使用LINQ实现动态搜索(Implementing Dynamic Searching Using LINQ)

原文链接：http://blogs.msdn.com/vbteam/archive/2007/08/29/implementing-dynamic-searching-using-linq.aspx

作者： Jonathan

在数据窗体应用程序中一个常见的需求是使用户能够按照由任意字段组合的动态查询搜索。例如，程序中的搜索功能允许用户查找所有满足在多个列上定义了不同规则的记录。

LINQ 使得编写跨越多种数据源的（强大）查询变得简单。例如，我们可以使用下面的查询来查找在用户指定的时间段内所有运往指定国家的所有订单（Orders）：

Dim query = From order In db.Orders _

Where order.ShipCountry = txtCountry.Text _

And order.ShippedDate >= dtpStartDate.Value _

And order.ShippedDate <= dtpEndDate.Value

这可以很容易的在编译时做到，但是如果我们希望检查订单日期而不是出货（Shipped）日期？这使得我们不得不编写另一个使用order.OrderDate的查询。如果你仅仅生成SQL字符串，那么运行时动态的生成不全是困难的，但LINQ如何做这个？LINQ 是否要求我在编译时指定条件为了建立查询？幸运的是，答案是肯定的。LINQ支持在运行时通过表达式树 API 和表达式编译器（Expression Tree API and the Expression Compiler）来建立动态查询。

在Visual Studio 2008中，任何有效的VB表达式都被解释成表达式树（Expression Tree ）。我们要做的是建立一个表达式树（Expression Tree ）来表示用户条件，然后在传递它到LINQ to SQL，LINQ to SQL运行时将会把它转换成SQL语句。那么我们上面说的 Where语句第一个部分看起来像这个样子：

Dim p = Expression.Parameter(GetType(Order), "")
Dim order = GetType(Order).GetProperty("ShipCountry")

Dim expr = Expression.Equal(Expression.PropertyOrField(p, order.Name), Expression.Constant("Germany"))

Dim predicate = Expression.Lambda(Of Func(Of Order, Boolean))(expr, New ParameterExpression() {p})

Yikes，这只是一小部分，我们目前只完成了1/3的Where语句！我可不想在写12行代码去来在运行时建立Where语句。我想做的是写一个CreateCondition 扩展方法，允许我用一行简单的代码建立表达式树（Expression Tree），像是这个样：

Dim condition1 = db.Orders.CreateCondition("ShipCountry", Compare.Equal, "Germany")

那么对于ShippedDate 我们可以建立2个条件：

Dim startDate? = #1/1/1997#
Dim endDate? = #1/31/1997#

Dim condition2 = db.Orders.CreateCondition("ShippedDate", Compare.GreaterThanOrEqual, startDate)

Dim condition3 = db.Orders.CreateCondition("ShippedDate", Compare.LessThanOrEqual, endDate)

注意我们第一次传递一个字符串，之后又传入2个可为空的日期（Literal），我们可以这么做是因为CreateCondition 方法是泛型的并可以根据传入的参数推断类型。我们现在仅需要组合条件到一个条件中：

Dim c = Condition.Combine(condition1, Compare.And, condition2, condition3)

或者我们也可以用操作符重载（Operator Overloading ）来完成这个（等价于上面的代码）：

Dim c = condition1 And condition2 And condition3

OK现在我们可以建立我们的 Condition 对象来过滤数据：

'过滤所有不符合条件的Orders

'注意这个查询还没有执行，他将延期执行

Dim filteredQuery = db.Orders.Where(c)

'我们还可以执行其他操作（像是排序）在 filteredQuery

Dim query = From row In filteredQuery _
Order By row.OrderDate, row.OrderID _

Select row

'执行查询并显示结构到DataGridView1

DataGridView1.DataSource = query

到现在为止,还不错。我们使用动态构造条件和强类型等在LINQ上。我们还有一个到数据库问题，由于使用了延期执行它将确保直到我们列举数据（通过数据绑定）之前都不会执行。条件API（Condition API )是用来简单的构造和编译表达式树，但是我们还需要写一点代码来构建基于用户输入的条件。在ConditionBuilder 控件里

它允许用户在运行时动态指定条件

注意那个日期字段我们将自动使用DateTimePicker 代替TextBox，还有布尔值我们将结果放入Checkbox 中

OK，我们隐藏了在运行时的用户体验，但是我们怎么实际创建Condition API？文档中以的代码在下面，我不打算在全部解释，但这里只解释一下基础部分：

1、有3个主要类的： Condition, Condition(Of T), and Condition(Of T, S)

Condition 是一个抽象类用来构造一般版本（generic versions）通过构造这个，可以为一般版本参数推断带来好处，即我们不用担心传入的一般版本参数到方法，工厂方法将帮助我们解决。
Condition(Of T) 使用合并多个conditions 到一起。T是元素类型（即上面例子中的 Order ）
Condition(Of T, S)是一种简单类型，它表示“object.propery <comparison> 值”表达式。类型参数 S将被推断为相应的值类型传入（即 String, Date, Boolean ...）

2、执行本地查询我们将 Lambda 表达式编译成一个代理，所以它可以在内存中执行（executed in-memory）。用户可以调用这个代理通过调用匹配方法。

'编译lambda 表达式成委托

del = DirectCast(LambdaExpr.Compile(), Func(Of T, Boolean))

3、扩展方法实际上是定义在 IQueryable(Of T) 对于远程执行，和IEnumerable(Of T) 对于本地执行

Converter

2007-11-04T21:50:00.001+08:00

以前自己做的字符串编码转换程序，发出来共享一下～

http://www.codeplex.com/Converter

WCF 基础之契约（Contract）

2007-10-04T18:13:00.003+08:00

在WCF 中包含 4 种契约，分别是Service Contract， Data Contract， Message Contract，以及定义错误异常的 Fault Contract。它们算是WCF的核心之一，如果你要使用WCF，就需要了解他们。

正文在这里http://docs.google.com/Doc?id=dggdkn6_132fwt6cm

(PS. 如果讨厌这个跳转的话可以说一下，我会把原文粘贴过来，不过管理起来有点费劲了）

WCF 基础之绑定（Binding）

2007-10-04T18:13:00.001+08:00

最近看WCF的实例，简单总结一下。虽然这么说，但差不多算是搜集一些常用的资料。(自己知道文笔不好写的很差，如果有有错，请指正）

正文在这里 http://docs.google.com/Doc?id=dggdkn6_138f4xwv4

(PS. 如果讨厌这个跳转的话可以说一下，我会把原文粘贴过来，不过管理起来有点费劲了）

WCF初探总结

2007-09-26T17:02:00.000+08:00

简单总结了一下，现在自己已经学过的东西。

正文在这里 http://docs.google.com/Doc?id=dggdkn6_125gdms8k
使用 Google 文档制作。

StarTrooper 简单的MDX游戏

2007-01-10T21:37:00.000+08:00

这个是我参照MSDN 的WebCast 做的，语言换成了VB.NET，使用的是2006 十月的 DX SDK

PS.最近网络有点问题，上传可能有问题，要是下载代码损坏，请通知我，我会及时更新的。

http://groups-beta.google.com/group/SonofVBNet/web/startrooper-mdx

下载地址：http://groups-beta.google.com/group/SonofVBNet/web/StarTrooper.rar?_done=%2Fgroup%2FSonofVBNet%2Fweb%2Fstartrooper-mdx%3Fmsg%3Dns

申请一个论坛

2006-12-31T20:34:00.001+08:00

为这个BLog创建一个论坛，其实，我刚才想发点代码上来的，结果发现这里不能上传附件，所以只好申请一个论坛了～～～

地址如下，旁片也有哦！！～～～
http://groups-beta.google.com/group/SonofVBNet/

--
G yc
Son of VB.NET

哈哈测试

2006-12-11T23:49:00.009+08:00

为自己注册了一个新的Blog

Son of VB.NET

Comics Service

简介使用Sync Services for ADO.NET建立偶尔链接的程序

引言

Introduction

Sync Services for ADO.NET 和 the Microsoft Sync Framework

Sync Services for ADO.NET and the Microsoft Sync Framework

构建偶尔链接程序的挑战Challenges of Building an OCA

Challenges of Building an OCA

修改跟踪

Change Tracking

维护数据更改

Maintaining Change Data

冲突检测和解决

Conflict Detection and Resolution

优先数据交换

Prioritizing Data Exchange

后台同步

Background Synchronization

多同步拓扑

Multiple Synchronization Topologies

自定义客户端和服务器数据库

Custom Client and Server Databases

安全

Security

总结

Summary

让WCF使用自定义业务对象

开始

Setting Up

数据契约

Data Contracts

代理类

Proxy Class

使用服务

Using the Service

只读属性

Read-Only Properties

解决方法

One Solution

销毁

Dispose()

Lambda表达式和表达式树（Lambda Expressions and Expression Trees）

充分发挥 Visual Studio“Orcas”中查询的强大功能

LINQ 语法

From 子句

Select 子句

使用查询结果

使用 Where 子句筛选

使用 Order By 排序

更多子句

摘要

附件

转换VS2005项目到VS2008-开启LINQ（Converting VS 2005 Projects to VS 2008 - Enabling LINQ）

使用LINQ实现动态搜索(Implementing Dynamic Searching Using LINQ)

Converter

WCF 基础之契约（Contract）

WCF 基础之绑定（Binding）

WCF初探总结

StarTrooper 简单的MDX游戏

申请一个论坛

哈哈测试