好贴子可不能找不到了

改进基于 Microsoft .NET Framework 精简版应用程序窗体的加载性能

teky — Wed, 28 Feb 2007 02:52:00 GMT

http://www.microsoft.com/china/MSDN/library/archives/library/dnnetCOMp/html/netcfimproveformloadperf.asp

改进基于 Microsoft .NET Framework 精简版应用程序窗体的加载性能

Neil Cowburn
Content Master Ltd
2003年3月

适用于：
Microsoft® .NET Framework 精简版 1.0
Microsoft Visual Studio® .NET 2003

摘要：学习如何通过一些简单的优化技术来减少 .NET Framework 精简版 Windows 窗体应用程序加载所需的时间。

简介

默认的 Forms Designer（窗体设计器）生成的代码不能始终创建适用于创建 Microsoft® Windows® 窗体的最优代码。但是，执行一些操作可以帮助优化生成的代码。通过编写自己的窗体初始化代码，可以改进窗体的加载性能。

此外，通过重新排列和/或覆盖由 Microsoft Visual Studio® .NET 中的 Forms Designer（窗体设计器）生成的代码，可以显著提高应用程序整个窗体的加载性能。

警告：请勿在修改 InitializeComponent 后使用设计器。

InitializeComponent 方法前有一个注释，警告您不要修改代码。如果修改 InitializeComponent 方法中的代码，将无法再使用 Forms Designer（窗体设计器）。如果使用 Forms Designer（窗体设计器），所做的修改将丢失。只应在开发的最后阶段，完成所有设计工作后，再执行这些优化。

本文假定您在 Microsoft .NET Framework 精简版和 Microsoft Visual C#® .NET 方面有一定的使用经验，并且已安装了 Visual Studio .NET 2003。

测量性能

要测量窗体初始化代码的性能，可以使用一个简单的测试来测量初始化窗体控件所需的时间。通过记录调用 InitializeComponent 方法前后系统计时器的刻度计数，可以记录初始化窗体控件所需的时间。为此，您可以通过 Platform Invoke (P/Invoke) 使用 coredll.dll 中的 GetTickCount() API 调用。

// GetTickCount() 的 API 原型
[DllImport("coredll.dll", EntryPoint="GetTickCount")]
public static extern uint GetTickCount();
// 窗体构造函数
public Form1()
{
    uint startTickCount, endTickCount, timeTaken;
    // 调用 GetTickCount 获取起始刻度计数
    startTickCount = GetTickCount();
    // 初始化窗体中的控件
    InitializeComponent();
    // 再次调用 GetTickCount 获取最终的刻度计数
    endTickCount = GetTickCount();
    // 计算初始化控件所用的时间（以毫秒为单位）
    timeTaken = startTickCount - endTickCount;
    // 在消息框中显示所用的时间
    MessageBox.Show("加载时间：" + timeTaken.ToString() + "毫秒");
}

减少方法调用的数目

提高窗体加载性能的方法之一是减少窗体初始化期间生成的方法调用的数目。例如，Forms Designer（窗体设计器）生成的用于设置控件的位置和大小的代码使用两个方法调用来设置这些属性，如下所示：

    this.textBox1.Location = new Point(10,20);
    this.textBox1.Size = new Size(72,23);

使用 Bounds 属性可以将这两个方法调用统一成一个方法调用：

    this.textBox1.Bounds = new Rectangle(10,20,72,23);

要显示可实现的性能增益，请考虑创建一个窗体，其中包含 1 个 MenuBar、1 个 TabControl 控件、5 个 TabPage（各包含 7 个 Label、7 个 Button 和 7 个 TextBox）。总共是 112 个控件。此应用程序是使用 Release（发行）配置文件生成的，并部署到 Pocket PC 2002 仿真器，此应用程序在仿真器中运行 5 次，下面是整理的各次运行时间的比较。

表 1：Forms Designer（窗体设计器）生成的代码计时

第次	初始化控件的时间（毫秒）
1	14275
2	13950
3	15475
4	15175
5	14325
平均时间（毫秒）：	14630

注意：在实际设备上获得的性能要远高于此。

应用上述的方法调用优化时，将记录以下计时：

表 2：方法调用优化的代码计时

第次	初始化控件的时间（毫秒）
1	13225
2	13850
3	13000
4	13625
5	13100
平均时间（毫秒）：	13360

与 Forms Designer（窗体设计器）生成的代码相比，性能提高了将近 9%。

自上而下地创建控件

提高性能的另一种方法是在控件树中自上而下地初始化控件。例如，如果有一个包含许多控件的面板控件，请先创建面板，然后在面板上添加控件。同样，设置控件的父属性而不是添加至控件集合，也可以提高性能。例如，请考虑在面板的控件集合中添加一个文本框：

// 优化前
// 创建一个新面板和文本框控件
Panel panel1 = new Panel();
TextBox textBox1 = new TextBox();
// 设置 TextBox 控件的 Text 属性
textBox1.Text = "我的文本";
// 将 TextBox 添加至面板的控件集合中
panel1.Controls.Add(this.textBox1);
// 将面板添加至窗体的控件集合中
this.Controls.Add(panel1);
... // 在此处添加后续控件

使用自上而下和父级处理技术优化此代码片断将生成以下代码片断：

// 优化后
// 创建一个新面板和文本框控件
Panel panel1 = new Panel();
TextBox textBox1 = new TextBox();
// 使当前窗体成为面板的父级
this.panel1.Parent = this;
// 使面板成为 TextBox 的父级
this.textBox1.Parent(this.panel1);
// 设置 TextBox 控件的 Text 属性
textBox1.Text = "我的文本";
... // 在此处添加后续控件

综合使用以上技术对深层嵌套的控件层次结构具有重要影响。

通过自上而下创建控件并重新分配父关系来优化 InitializeComponent 方法中的代码，将生成以下数据：

表 3：自上而下优化的代码计时

第次	初始化控件的时间（毫秒）
1	7425
2	7450
3	7225
4	7375
5	7500
平均时间（毫秒）：	7395

与默认的 Forms Designer（窗体设计器）生成的代码相比，性能提高了将近 49%。

如果将两种优化技术组合使用，将获得以下计时结果：

表 4：组合后的优化代码计时

第次	初始化控件的时间（毫秒）
1	6625
2	6600
3	6575
4	6475
5	6750
平均时间（毫秒）：	6605

与 Forms Designer（窗体设计器）生成的代码相比，将方法调用优化与自上而下的控件初始化技术组合使用可以使整体性能提高将近 55%。如果应用程序包含复杂的窗体，并且您希望提高窗体的加载性能，则在代码中应用这些优化将很有帮助。

从桌面移动到设备：多线程和用户界面

teky — Fri, 19 Jan 2007 02:48:00 GMT

从桌面移动到设备：多线程和用户界面

http://www.microsoft.com/china/msdn/library/mobility/mobileapp/multithreadui.mspx?mfr=true

发布日期： 2/5/2005 | 更新日期： 2/5/2005

Jim Wilson
JW Hedgehog, Inc.

适用于：
Microsoft® .NET Compact Framework

摘要：本文帮助开发人员克服他们在使用后台线程与用户界面进行交互时 Microsoft .NET Compact Framework 的局限性。从 Microsoft 下载中心下载 UI Safe Invoker Code Sample.msi。

本页内容

	简介
	多线程和用户界面基础知识
	构建更好的类
	小结

简介

当北美春季会议接近结束的时候我正在撰写本月的专栏。MDC Canada、MDC United States、Tech-Ed 以及 Embedded Developer Conference 等会议的出席率都非常高。我发现在这些活动中与那么多人会面交流使我大增见识。很多人开发移动应用程序已经好多年了，但更多的人对移动性还很陌生。大多数是传统企业的开发人员，他们对用 Microsoft® .NET Framework 构建桌面应用程序很有经验，并且现在开始使用 Microsoft .NET Compact Framework 构建设备应用程序。

您们中间那些使用 .NET Compact Framework 和 .NET Framework 的人都非常清楚：由于处理能力或者大小方面的原因，尽管这两者之间有很多共同点，但还是忽略了一些特性。尽管这些方面大多数都不会有问题，但一些重要方面足以产生挑战。

会议上，我在和企业开发人员的谈话中发现，当使用 .NET Framework 的开发人员转向使用 .NET Compact Framework 时，他们好像一般会在两个方面遇到问题。第一个问题是从后台线程与用户界面 (UI) 交互。另一个问题就是管理复杂的部署，尤其是那些涉及全局程序集缓存和转发版本的部署。

两个问题都非常重要并且都有点棘手，因此我将在本专栏中分两个版次进行讨论。本月专栏将焦点集中在：当从后台线程与 UI 交互时，克服 .NET Compact Framework 的局限性。下个月本专栏将专门讨论部署，即全局程序集缓存以及转发版本。

返回页首

多线程和用户界面基础知识

构建一个不稳定的应用程序

您们中的许多人可能已经熟悉从后台线程与 UI 交互的相关问题，但作为一种复习，让我们快速回顾一下。考虑下面的代码示例。

class MyForm : Form{
  ListBox lbData ;
  MyForm() {
    InitializeComponent(); // Create form controls

    Work1_(); // Call Work1_ on the current thread
  }
  void Work1_(){
    StreamReader rdr1 = new StreamReader(@"\My Documents\DataFile.dat");
    string line = rdr1.ReadLine();
    while(line != null) {
      lbData.Items.Add(line); // Populates the list box as expected
      line = rdr1.ReadLine();
    }
  } 
}

这是一个非常简单的示例，但是它表示了智能设备开发人员所面临的共同问题：需要用数据填充应用程序 UI，检索这些数据可能会非常耗时。在该示例中，应用程序创建了一个包含有列表框的窗体，然后调用函数 Work1_ 来用某个文件的内容填充列表框。

如果该文件很小，那么毫无意外，该应用程序会运行的非常好。但是，如果读取数据的过程所花时间过长，那么呈现给用户的应用程序可能会无响应甚至会冻结。如果将应用程序修改为从低带宽的无线连接中读取数据，应用程序的无响应性则更需要关注。

我们必须确保开发人员执行一项冗长的任务时 UI 要保持响应性的一种方法是，将该任务转移给一条后台线程。这不会使实际任务的运行速度更快，但是通过长时间运行的任务在后台运行期间允许应用程序的其他部分继续进行，它确实提供了一种响应性更好的用户体验。

通过使用 Thread 类和 ThreadStart 委托在后台线程中执行 Work1_，我们可以轻松地将应用程序修改为使用多线程。

class MyForm : Form{
  ListBox lbData ;
  MyForm() {
    InitializeComponent(); // Create form controls

    Thread t = new Thread(new ThreadStart(Work1_));
    t.Start() ; // Runs Work1_ on a background thread
  }
  void Work1_(){
    StreamReader rdr1 = new StreamReader(@"\My Documents\DataFile.dat");
    string line = rdr1.ReadLine();
    while(line != null) {
      lbData.Items.Add(line); // This line is unstable
      line = rdr1.ReadLine();
    }
  } 
}

好消息是，长时间运行的任务现在在后台运行，因此不会延时或者冻结 UI。坏消息是，在引入多线程之前很稳定的应用程序现在好像会随机发生崩溃。实际上，程序很不稳定，所以我们不可能成功地部署它。

问题在于 Microsoft .NET 中所有的 Microsoft Windows 窗体控件都有所谓的线程关系，意思是说，它们的属性和方法只能由运行在创建该控件的同一个线程上的代码调用。对于本例的情况，lbData 是在主应用程序线程上创建的，但却是从一个后台线程调用 lbData.Items.Add 的。从后台线程调用 lbData.Items.Add 会导致数据损坏。

注有关 Windows 窗体控件和多线程需要特殊考虑的具体原因，请参阅 Chris Sells 的文章 Safe, Simple Multithreading in WinForms。本文的目标是 .NET Framework 完全版，因此该文章提供的一些解决方案不适用于 .NET Compact Framework，但 Chris 对问题的描述极为不错。

亡羊补牢

为了使我们的应用程序重新稳定，我们需要修改代码，这样所有与列表框的交互都会在主应用程序线程上发生。通过使用列表框上的 Invoke 方法，我们可以修改代码。Invoke 方法由 System.Windows.Forms.Control 基类提供，因此由所有的 Windows 窗体控件公开。Control.Invoke 方法在最初创建控件的线程上运行某个委托，允许该委托安全地与控件交互。

注.NET Framework 实现可以运行任何委托，与此不同，Control.Invoke 的 .NET Compact Framework 实现只支持 EventHandler 委托。

class MyForm : Form{
  ListBox lbData ;
  MyForm() {
    InitializeComponent(); // Create form controls

    Thread t = new Thread(new ThreadStart(Work1_));
    t.Start() ; // Runs Work1_ on a background thread
  }

private Queue qData = new Queue(); // Visible to all member functions on all threads

  void Work1_(){
    // Wrap AddItem in delegate
    EventHandler eh = new EventHandler(AddItem);
    StreamReader rdr1 = new StreamReader(@"\My Documents\DataFile.dat");
    string line = rdr1.ReadLine();
    while(line != null) {
      lock(qData){ // Synchronize queue acess
        qData.Enqueue(line); // Store line value in queue
      }
      lbData.Invoke(eh); // Transfer control to thread that created lbData
      line = rdr1.ReadLine();
    }
  } 

  void AddItem(object o, EventArgs e)
  {
    string line = null;
    lock(qData){ // Synchronize queue acess
      line = (string)qData(); // Get data from queue
    }
    lbData.Items.Add(line); // Update list box
  }
}

应用程序又稳定了。通过将修改列表框内容的代码移动到 AddItem 函数中，并将它包装到一个 EventHandler 委托中，我们已经将后台任务从它与 UI 的交互中分离出来。循环的每次传递期间，Work1_ 将从文件读取的数据放置到 qData 队列中并调用 lbData.Invoke 来运行包装 AddItem 函数的 EventHandler 委托。每次调用 lbData.Invoke 会挂起运行后台线程，直到主应用程序线程完成运行 AddItem 方法。AddItem 运行在主应用程序线程上，它从队列中提取值并将其安全地添加到列表框中。

克服局限性

对于简单的线程方案，Control.Invoke 的 .NET Compact Framework 实现很适用，但与 .NET Framework 实现相比却具有明显的局限性。

传递参数

首先，.NET Framework 提供了 Control.Invoke 的一种重载，它接受一个对象数组。用该对象数组将参数传递给执行的委托。

通过使用 .NET Framework 中的 Control.Invoke 重载，我们不再需要使用队列或者任何其他的数据结构在线程之间共享数据。数据可以只是作为委托调用的一部分而传递，明显地简化了在后台与 UI 线程之间的数据传递。

使用 Control.Invoke 重载生成下面 Work1_ 与 AddItem 的实现。

  void Work1_(){
    // Wrap AddItem in delegate
    EventHandler eh = new EventHandler(AddItem);
    StreamReader rdr1 = new StreamReader(@"\My Documents\DataFile.dat");
    string line = rdr1.ReadLine();
    while(line != null) {
      lbData.Invoke(eh, new object[]{line, EventArgs.Empty}); // Pass to AddItem
      line = rdr1.ReadLine();
    }
  } 

  // o receives the reference to line, e receives EventArgs.Empty
  void AddItem(object o, EventArgs e)
  {
    string line = (string) o; // Upcast o
    lbData.Items.Add(line);  // Add to list box
  }

异步执行

另一个主要不同点是，台式计算机支持 Control.BeginInvoke，这样委托可以异步执行。在我们的应用程序中，每次调用 lbData.Invoke 时，后台线程就挂起执行，直到 AddItem 方法结束。结果是，循环的每次迭代中应用程序被迫导致一个线程上下文切换。

一般情况下，我们希望将线程上下文切换降低到最低限度，因为执行它的成本相当高；首选的做法是允许操作系统选择何时发出线程上下文切换。用 .NET Framework 中的 Control.BeginInvoke 替代 Control.Invoke 调用消除了这种不得已的线程上下文切换，并允许后台线程继续处理，直到操作系统决定执行一个线程上下文切换并运行委托。

为了更新 Work1_ 方法来异步运行 AddItem 委托，我们只需使用 lbData.BeginInvoke 替代对 lbData.Invoke 的调用。

lbData.BeginInvoke(eh, new object[]{line, EventArgs.Empty});

返回页首

构建更好的类

我们在构建多线程设备应用程序时，.NET Compact Framework Control 类缺乏支持传递参数以及异步执行增加了复杂性并降低了效率。我发现这种不支持是一个特别重要的问题，因为智能设备应用程序一般都使用多线程。同时，智能设备的资源往往有限，这使得简单、有效的多线程非常重要。

因为我们没有使用 .NET Compact Framework 源代码，因此我们不能合理地向 .NET Compact Framework Control 类添加对参数和异步委托执行的支持。但是，我们可以构建一个提供这些功能的新类。我将该类称为 UISafeInvoker。

注本月专栏随附的下载包括 UISafeInvoker 的完整源代码以及一个演示其用法的应用程序。

一言以蔽之，UISafeInvoker 是一个与线程有关的 .NET Compact Framework 类，它提供了行为与 .NET Framework Control 类的 Invoke 与 BeginInvoke 方法类似的 Invoke 与 BeginInvoke 方法。虽然不是 Control 类的一部分，但 UISafeInvoker.Invoke 与 UISafeInvoker.BeginInvoke 方法的使用却非常简单。

注本专栏的作者提供了 UISafeInvoker 的代码示例。Microsoft 不提供对这些代码的支持，对该类的使用也没有明确或暗示的任何担保。

与可以执行任何种类委托的台式机的 Control.Invoke 与 BeginInvoke 方法不同，UISafeInvoker 和 .NET Compact Framework Control.Invoke 与 BeginInvoke 方法一样，只支持 EventHandler 委托。因为 UISafeInvoker 仅支持一种委托类型，因此不需要使用对象数组来传递参数。相反，Invoke 与 BeginInvoke 接受直接传递给 EventHandler 委托中对应参数的对象和 EventArgs 参数。这里是每种方法的签名。

void Invoke(EventHandler eh, object obj, EventArgs eArgs);
IAsyncResult BeginInvoke(EventHandler eh, object obj, EventArgs eArgs);

使用 UISafeInvoker 就是简单地在 Form 类中声明一个引用，并在 Form 构造函数中创建一个实例。创建之后，UISafeInvoker 就内部跟踪创建它的线程，因此 Invoke 和 BeginInvoke 方法可以在同一个线程上运行期望的委托。作为 Form 构造函数的一部分而创建 UISafeInvoker，并且是在与所有窗体控件相同的线程上创建；因此，Invoke 或者 BeginInvoke 方法运行的任何委托都可以安全地更新 UI 控件。

这里是使用 UISafeInvoker 更新后的测试应用程序。

class MyForm : Form{
  ListBox lbData ;
  UISafeInvoker invoker ; // Declare UISafeInvoker
  MyForm() {
    InitializeComponent();
    invoker = new UISafeInvoker(); // Create UISafeInvoker on main UI thread

    Thread t = new Thread(new ThreadStart(Work1_));
    t.Start() ; // Runs Work1_ on a background thread
  }
  void Work1_(){
    // Wrap AddItem in delegate
    EventHandler eh = new EventHandler(AddItem);
    StreamReader rdr1 = new StreamReader(@"\My Documents\DataFile.dat");
    string line = rdr1.ReadLine();
    while(line != null) {
      invoker.BeginInvoke(eh, line, EventArgs.Empty); // Pass to AddItem
      line = rdr1.ReadLine();
    }
  } 

  // o receives the reference to line, e receives EventArgs.Empty
  void AddItem(object o, EventArgs e)
  {
    string line = (string) o; // Upcast o
    lbData.Items.Add(line);  // Add to Listbox
  }
}

对于 UISafeInvoker，我们的 .NET Compact Framework 应用程序已经克服了 .NET Compact Framework Control.Invoke 方法的局限性，现在可以提供简单、有效的线程内通信了。这种通信类似于 .NET Framework 中的通信，不需要额外的数据结构或者复杂的编码。

使用窗口消息

在内部，UISafeInvoker 非常简单，因为它仅完成两件事情：跟踪创建它的线程并提供一种在线程之间传输数据的可靠方法。

这种解决方案 — 虽然听起来有些陈旧 — 是基于窗口消息的。Windows 操作系统创建的所有窗口都有一个消息队列。应用程序可以通过使用 Microsoft Win32_ SDK 函数 SendMessage 和 PostMessage 将消息放置到该队列中。这些函数允许应用程序传递一个标识执行操作的整数标志和两个过去被称为 WParam 与 LParam 的消息定义数据值。

除了有一个主要的不同点，SendMessage 和 PostMessage 函数基本上是一样的。SendMessage 将消息放置到窗口消息队列中，并阻止消息直到窗口完成对它的处理。PostMessage 将消息放置到窗口消息队列中并立即返回。SendMessage 和 PostMessage 可以由任何线程调用，但是窗口总是在创建该窗口的线程上处理消息。这种行为隐含地解决了线程跟踪和在线程间传输数据的问题。

所有的 UI 控件都是窗口，但是应用程序也可以创建隐藏的窗口，它们能够处理消息，但在屏幕上不会呈现任何可见物。MessageWindow 类向 .NET Compact Framework 公开了实现隐藏窗口的功能。

注如果您对消息队列和消息处理如何工作的细节感兴趣，请参阅 About Messages and Message Queues。有关 MessageWindow 类的更多信息，请参阅 Compact Framework Unique Classes。

从根本上说，UISafeInvoker 只是封装了一个隐藏窗口和对 SendMessage 和 PostMessage 的调用。这里是 UISafeInvoker 实现的框架。

public class UISafeInvoker : MessageWindow
{
  const int WM_USER = 1024; // Traditional start of application-defined messages
  const int WM_INVOKEMETHOD = WM_USER + 1; // Our special message

  // Handle window message processing
  protected override void WndProc(ref Message m)
  {
    base.WndProc (ref m);
    if (m.Msg == WM_INVOKEMETHOD)
    {
      // Get data from message
      // Run delegate
    }
  }

  // Instigate delegate execution and wait for completion
  public void Invoke(EventHandler eh, ...)
  {
    Message m = Message.Create(this.Hwnd, 
                               WM_INVOKEMETHOD, ...);
    MessageWindow.SendMessage(ref m);
  }

  // Instigate delegate execution and return immediately
  public void BeginInvoke(EventHandler eh, ...)
  {
    Message m = Message.Create(this.Hwnd, 
                               WM_INVOKEMETHOD, ...);
    MessageWindow.PostMessage(ref m);
  }
}

Invoke 和 BeginInvoke 方法都向包含有关运行委托信息的隐藏窗口发送消息。由于 Invoke 方法使用 SendMessage ，因此是同步运行。BeginInvoke 提供异步执行，因为 PostMessage 将消息放置到窗口消息队列中并立即返回。

每次隐藏窗口接收到一条消息就会调用 WndProc 方法，它负责运行期望的委托。由于它是作为窗口消息处理的一部分而调用的，因此创建该窗口的线程总是执行 WndProc 方法。因为总是在同一个线程上运行代码，所以它运行的委托可以安全地与在同一个线程上创建的 UI 控件进行交互。

在线程之间传递数据

UISafeInvoker 实现的一个复杂方面就是将数据从 Invoke 与 BeginInvoke 方法传递到 WndProc 方法。为了使用 SendMessage 或者 PostMessage 将数据发送给隐藏窗口，我们首先需要定义一个类，该类包含将引用存储到 EventHandler 委托以及对象和 EventHandler 委托期望的 EventArgs 参数等必需信息。

class InvokerData{
  public EventHandler eventHandler;
  public object obj;
  public EventArgs eventArgs;
}

然后，Invoke 和 BeginInvoke 实现可以填充 InvokerData 类的一个实例，并使用 SendMessage 或者 PostMessage 将这些信息发送给 WndProc 方法。

问题是，InvokerData 是一个存储在 .NET Compact Framework 托管内存空间中的 .NET 类。SendMessage 和 PostMessage 的实现以及窗口消息队列由底层的 Windows 操作系统来处理，操作系统位于 .NET Compact Framework 托管内存空间之外。

请记住，.NET Compact Framework 主动地跟踪和管理着所有应用程序对象的内存。它可以将对象在内存中从一个位置移动到另一个位置，并且它删除没有活动 .NET 引用指向的任何对象。

我们使用 SendMessage 和 PostMessage 的复杂性在于，如果我们将 InvokerData 对象引用作为参数传递给这些函数中的一个，那么该对象的当前地址将被直接复制到隐藏窗口消息队列中。Windows 操作系统实现的窗口消息队列位于 .NET Compact Framework 托管内存空间之外；因此，.NET Compact Framework 不知道应用程序仍旧保存着 InvokerData 对象地址的事实，并计划再次使用它。

当隐藏窗口最终处理消息时，地址从窗口消息队列中复制到由 UISafeInvokerWndProc 函数接收的 .NET Compact Framework Message 结构中。在地址被复制到消息队列中并传递回 WndProc 函数期间，.NET Compact Framework 垃圾回收器可能会移动甚至可能会删除 InvokerData 对象。

为了避免这种潜在的危险情况，我们可以只要求 .NET Compact Framework 为我们提供一种表示 InvokerData 对象安全传输到 .NET 环境之外并且我们返回时仍旧有效的标记。为此，我们可以使用 GCHandle 结构。

GCHandle 结构可以方便地创建一种表示 .NET 对象被安全传递到 .NET 环境之外并且稍后可以用来找到同一个对象的标记。拥有 GCHandle 结构的 .NET 对象可以防止该对象被作为垃圾回收。GCHandle 结构还可以安全地来回转换成 IntPtr，使得使用 SendMessage 和 PostMessage 非常简单。

既然我们有了 GCHandle，因此这里是完整的 UISafeInvoker.Invoke 方法；UISafeInvoker.BeginInvoke 除了使用 PostMessage 之外，基本上是相同的。

public void Invoke(EventHandler eh, object obj, EventArgs e){
  InvokerData d = new InvokerData() ;
  d.eventHandler eh; 
  d.obj = sender;
  d.eventArgs = e;

  GCHandle dataHandle = GCHandle.Alloc(d); // Get token to InvokerData
  IntPtr iPtr = (IntPtr) dataHandle; // Cast to IntPtr
  Message m = Message.Create(this.Hwnd, WM_INVOKEMETHOD, IntPtr.Zero, iPtr);
  MessageWindow.SendMessage(ref m);
}

我们的 WndProc 实现然后就可以使用包含在接收消息内的 GCHandle 结构来检索 InvokerData 实例。

注在不再需要该结构时，WndProc 函数必须调用 GCHandle 结构上的 Free 方法。如果没有调用 Free 方法，.NET Compact Framework 内存管理器就无法知道我们不再需要 GCHandle，并且将不能清除相关的对象。

protected override void WndProc(ref Message m)
{
  base.WndProc (ref m);
  if (m.Msg == WM_INVOKEMETHOD)  {
    GCHandle h = (GCHandle) m.LParam;// Cast IntPtr back to GCHandle
    InvokerData d = (InvokerData) h.Target; // Get the InvokerData instance
    h.Free(); // Indicate that we are finished with GCHandle

    d.eventHandler(d.obj, d.eventArgs); // Call the delegate passing the parameters
  }
}

返回页首

小结

.NET Framework 与 .NET Compact Framework 之间有许多不同点。大多数差别都是细微的；有些更为复杂，另外还需要一点创造性。虽然从后台线程与 UI 进行交互是一种更为复杂的情况，我们的 UISafeInvoker 类为我们提供了在线程之间传递参数并异步运行委托的能力，正如 .NET Framework 一样。

在我结束之前，我想感谢参加我的本季会议的每个人。我希望您们喜欢参加这个会议，就像我乐意为会议做事一样，也希望在下季的会议上看到各位。同时，我希望您们每月都会继续参加进来。

我还想特别感谢所有那些询问我这么多重要问题的人们。和每位进行交流并聆听人们在实际工作中遇到的问题就是我工作中最有价值的一部分。如果您有任何问题或者主题，并且希望在 You Can Take It with You 中进行讨论，请给我发送邮件到 jimw@jwhh.com。

请下个月加入进来，那时我们将考察 .NET Framework 开发人员转移到 .NET Compact Framework 的另一个共同难题：部署，即全局程序集缓存以及转发版本。

转到原英文页面

SmartPhone手机上查看QQ天气预报

teky — Fri, 01 Dec 2006 08:42:00 GMT

智能手机应用程序开发是软件开发的一个新的热点，但如何才能跨入这道门楣呢？今天我通过为自己的多普达565手机添加一个天气预报程序来向大家讲解一下。我们都知道QQ有一个免费提供给Blog引用的天气预报服务网址http://appnews.qq.com/cgi-bin/news_qq_search?city=上海（上海是我自己所在城市，如果想看自己的城市，在浏览器中改成城市名称即可），现在我使用QQ提供的这个服务，将其包装部署为一个Web服务，并编写程序使得我的多普达565智能手机能使用这个Web服务。

　　设备要求：

　　PC开发环境：Windows XP SP2，Visual Studio 2003.NET,.NET Framework 1.1 SP1

　　操作系统：Windows Mobile(TM) 2003第二版，版本4.21.1088(Build 14235.2.0.0)

　　智能手机：多普达565

　　一、环境安装

　　首先我们必须安装.NET Mobile所需要的开发环境，必须安装的软件(如下软件都是微软提供免费下载和使用的)

　　1、Microsoft ActiveSync 3.7.1

　　下载网址：http://www.microsoft.com/windowsmobile/downloads/activesync37.mspx，里面有中文版本，或者，在手机附带的微软光盘里面有安装程序；最新版本Microsoft ActiveSync 3.8出来了，可以到摘要的页面中去找链接下载，但这个程序我还是用的老版本。

　　作用：同步手机和PC机数据的程序

　　2、Microsoft SMARTPHONE 2003 SDK.msi

　　下载网址：

　　http://download.microsoft.com/download/e/3/1/e310bb99-2f33-4d79-bb8a-41d9cb3c79b4/Microsoft SMARTPHONE 2003 SDK.msi

　　3、MobileAppDevToolkit2004.exe

　　下载地址：http://download.microsoft.com/download/b/2/5/b25742c0-daa3-4a8c-988d-a947a35e0a68/MobileAppDevToolkit2004.exe

　　二、设计并部署WebService

　　1、建立一个名为WeatherService的WebService，并将QQ的天气服务转为XML WebService服务，部署在一台具有固定IP的服务器上。

　　2、新建一个WeatherDataSet.XSD，存储我们的天气信息

＜?xml version="1.0" encoding="utf-8" ?＞
＜xs:schema id="WeatherDataSet" targetNamespace="Ezhi.Services.WeatherService" elementFormDefault="qualified"
　　attributeFormDefault="qualified" xmlns="Ezhi.Services.WeatherService" 　　　xmlns:mstns="Ezhi.Services.WeatherService"
　　xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"＞

＜xs:element name="WeatherDataSet" msdata:IsDataSet="true"＞
＜xs:complexType＞
　＜xs:choice maxOccurs="unbounded"＞
　　＜xs:element name="WeatherDS"＞
　　　＜xs:complexType＞
　　　　＜xs:sequence＞
　　　　　＜xs:element name="CityName" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="Date1" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="Weather1" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="Temp1" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="WindPower1" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="Date2" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="Weather2" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="Temp2" type="xs:string" minOccurs="0" /＞
　　　　　＜xs:element name="WindPower2" type="xs:string" minOccurs="0" /＞
　　　　＜/xs:sequence＞
　　　＜/xs:complexType＞
　　＜/xs:element＞
　＜/xs:choice＞
＜/xs:complexType＞
＜/xs:element＞
＜/xs:schema＞

　　3、WeatherService的源代码如下

#region Using directives

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Web;
using System.Web.Services;
using System.IO;
using System.Net;
using System.Text;

#endregion

namespace WeatherService
{
　/// ＜summary＞
　/// Service1 的摘要说明。
　/// ＜/summary＞

　[WebService(Description="WeatherService 天气Service",Namespace="WeatherService")]

　public class Weather : System.Web.Services.WebService
　{
　　#region Variable
　　private string tommorow;
　　#endregion

　　#region 构造函数

public Weather()
{
　InitializeComponent();

　if(DateTime.Today.AddDays(1).Month.ToString().Length == 1)
　{
　　tommorow= "0"+DateTime.Today.AddDays(1).Month.ToString()+"月" +
　　　　　　DateTime.Today.AddDays(1).Day.ToString()+"日";
　}
　else
　{
　　tommorow= DateTime.Today.AddDays(1).Month.ToString()+"月" +
　　　　　DateTime.Today.AddDays(1).Day.ToString()+"日";
　}
}

#endregion

　　#region 组件设计器生成的代码

//Web 服务设计器所必需的

private IContainer components = null;

/// ＜summary＞
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// ＜/summary＞

private void InitializeComponent()
{}

/// ＜summary＞
/// 清理所有正在使用的资源。
/// ＜/summary＞

protected override void Dispose( bool disposing )
{
　if(disposing && components != null)
　{
　　components.Dispose();
　}
　base.Dispose(disposing);
}

#endregion

#region [OK] GetWeatherDataSet 天气预报

[WebMethod(Description="天气预报")]

public DataSet GetWeatherDataSet(string cityName)
{
　string url=@"http://appnews.qq.com/cgi-bin/news_qq_search";
　string weatherData="";

　try
　{
　　weatherData = GetPage(url,cityName).Replace(" ","").Trim();
　}
　catch(Exception)
　{
　　throw new Exception("对不起，没有这个城市的天气信息！");
　}

　//System.Diagnostics.Trace.WriteLine( tommorow );
　//System.Diagnostics.Trace.WriteLine( weatherData );

　WeatherDataSet weatherDs = new WeatherDataSet();
　weatherDs.WeatherDS.AddWeatherDSRow(GetWeatherRow(ref weatherDs,weatherData,cityName) );
　return weatherDs;
}

private WeatherDataSet.WeatherDSRow GetWeatherRow(ref WeatherDataSet weatherDs,string weatherData,string cityName)
{
　WeatherDataSet.WeatherDSRow weatherRow = weatherDs.WeatherDS.NewWeatherDSRow();
　weatherRow.CityName = weatherData.Substring(weatherData.IndexOf("●")+1,cityName.Length);

　weatherRow.Date1 = DateTime.Now.ToLongDateString();

　weatherRow.Weather1 = weatherData.Substring(weatherData.IndexOf("天气")+"天气".Length,weatherData.IndexOf("气温")-(weatherData.IndexOf("天气")+"天气".Length));

　weatherRow.Temp1 = weatherData.Substring(weatherData.IndexOf("气温")+"气温".Length,weatherData.IndexOf("风力")-(weatherData.IndexOf("气温")+"气温".Length)).Replace("℃-","℃/");

　weatherRow.WindPower1 = weatherData.Substring(weatherData.IndexOf("风力")+"风力".Length,weatherData.IndexOf(tommorow)-(weatherData.IndexOf("风力")+"风力".Length));

　weatherRow.Date2 = DateTime.Today.AddDays(1).ToLongDateString();

　weatherRow.Weather2 = weatherData.Substring(weatherData.LastIndexOf("天气")+"天气".Length,weatherData.LastIndexOf("气温")-(weatherData.LastIndexOf("天气")+"天气".Length));

　weatherRow.Temp2 = weatherData.Substring(weatherData.LastIndexOf("气温")+"气温".Length,weatherData.LastIndexOf("风力")-(weatherData.LastIndexOf("气温")+"气温".Length)).Replace("℃-","℃/");

　weatherRow.WindPower2 = weatherData.Substring(weatherData.LastIndexOf("风力")+"风力".Length);

　return weatherRow;
}

#endregion

#region GetPageString 获取QQ的天气服务

//private string xx="";

[WebMethod(Description="天气预报")]

public string GetPageString(string cityName)
{
　string url=@"http://appnews.qq.com/cgi-bin/news_qq_search";
　return GetPage(url,cityName);
}

private static string GetPage(string url,string cityName)
{
　HttpWebResponse res = null;
　string strResult = "";
　try
　{
　　string postData = "city=" + HttpUtility.UrlEncode(cityName,System.Text.Encoding.GetEncoding("GB2312"));
　　HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
　　req.Method = "POST";
　　req.KeepAlive = true;
　　req.ContentType = "application/x-www-form-urlencoded";
　　StringBuilder UrlEncoded = new StringBuilder();
　　byte[] SomeBytes = Encoding.ASCII.GetBytes(postData);
　　req.ContentLength = SomeBytes.Length;
　　Stream newStream = req.GetRequestStream();
　　newStream.Write(SomeBytes, 0, SomeBytes.Length);
　　newStream.Close();

　　//获得流内容

　　res = (HttpWebResponse)req.GetResponse();
　　System.IO.Stream s=res.GetResponseStream();
　　StreamReader reader = new StreamReader(s,System.Text.Encoding.Default);
　　strResult=reader.ReadToEnd();
　}
　catch(Exception e)
　{
　　strResult = e.ToString();
　}
　finally
　{
　　if ( res != null )
　　{
　　　res.Close();
　　}
　}

　strResult=strResult.Remove(0,strResult.IndexOf("●"));

　if( cityName != "北京" )
　{
　　strResult=strResult.Remove(strResult.IndexOf("北京"),strResult.Length-strResult.IndexOf("北京"));
　}
　else
　{
　　strResult=strResult.Remove(strResult.LastIndexOf("北京"),strResult.Length-strResult.LastIndexOf("北京"));
　}

　strResult=strResult.Trim();
　while(strResult.IndexOf(@"＜") != -1)
　{
　　strResult=strResult.Remove(strResult.IndexOf(@"＜"),strResult.IndexOf(@"＞")-strResult.IndexOf(@"＜")+1);
　}

　while(strResult.IndexOf(@" ") != -1)
　{
　　strResult=strResult.Replace(" ","");
　}

　string x = Encoding.UTF8.GetString(new Byte[]{10});
　string y = Encoding.UTF8.GetString(new Byte[]{9});

　while(strResult.IndexOf(x) != -1)
　{
　　strResult=strResult.Replace(x,"");
　}

　while(strResult.IndexOf(y) != -1)
　{
　　strResult=strResult.Replace(y,"");
　}
　return strResult;
}

#endregion
}
}

　　记得将在Web.Config文件加入以下节点，使得WebService能被外部访问

＜!-- WebService 获取的途径 --＞
＜webServices＞
＜protocols＞
＜add name="HttpSoap"/＞
＜add name="HttpPost"/＞
＜add name="HttpGet"/＞
＜add name="HttpPostLocalhost"/?
＜add name="Documentation"/＞
＜/protocols＞
＜/webServices＞
　三、新建手机应用程序项目

　　1、新建一个智能设备应用程序，在主面板上拖放如图2所示的几个控件，其中timer是用来检查是否数据已经下载完毕的。

screen.width-600)this.style.width=screen.width-600;" border=0>
图1－新建智能设备应用程序

screen.width-600)this.style.width=screen.width-600;" border=0>
图2－界面设计

　　2、引用建好的WebService

screen.width-600)this.style.width=screen.width-600;" border=0>
图3－引用WebService

　　3、WeatherService智能手机上运行的程序源代码

using System;
using System.Drawing;
using System.Collections;
using System.Windows.Forms;
using System.Data;

namespace WeatherService
{
　/// ＜summary＞
　/// Summary description for MainForm.
　/// ＜/summary＞

　public class MainForm : System.Windows.Forms.Form
　{
　　private System.Windows.Forms.ComboBox comboBox_City;
　　private System.Windows.Forms.MenuItem menuItem1;
　　private System.Windows.Forms.Label txt_Weather1;
　　private System.Windows.Forms.Label txt_Date1;
　　private System.Windows.Forms.Label txt_Temp1;
　　private System.Windows.Forms.Label txt_WindPower1;
　　private System.Windows.Forms.Label txt_Temp2;
　　private System.Windows.Forms.Label txt_WindPower2;
　　private System.Windows.Forms.Label txt_Date2;
　　private System.Windows.Forms.Label txt_Weather2;
　　private System.Windows.Forms.MainMenu mainMenu1;
　　private System.Windows.Forms.MenuItem menuItem_Menu;
　　private System.Windows.Forms.MenuItem menuItem_Exit;
　　private System.Windows.Forms.Label label_City;
　　private System.Windows.Forms.Timer timer1;
　　private System.Windows.Forms.MenuItem menuItem2;
　　private System.Windows.Forms.MenuItem menuItem3;

　　public string[] cityList = new string[]
　　{
　　　"北京",
　　　"上海",
　　　"天津",
　　　"石家庄",
　　　"哈尔滨",
　　　"沈阳",
　　　"长春",
　　　"太原",
　　　"济南",
　　　"郑州",
　　　"天津",
　　　"呼和浩特",
　　　"西安",
　　　"银川",
　　　"兰州",
　　　"西宁",
　　　"乌鲁木齐",
　　　"合肥",
　　　"南昌",
　　　"南京",
　　　"杭州",
　　　"武汉",
　　　"长沙",
　　　"广州",
　　　"深圳",
　　　"福州",
　　　"厦门",
　　　"南宁",
　　　"桂林",
　　　"海口",
　　　"重庆",
　　　"成都",
　　　"贵阳",
　　　"昆明",
　　　"拉萨",
　　　"香港",
　　　"澳门",
　　　"台北",
　　};

　　public MainForm()
　　{
　　　InitializeComponent();
　　　foreach( string x in cityList)
　　　{
　　　　this.comboBox_City.Items.Add(x);
　　　}

　　　this.comboBox_City.SelectedIndex = 0;
　　}

　　/// ＜summary＞
　　/// Clean up any resources being used.
　　/// ＜/summary＞

　　protected override void Dispose( bool disposing )
　　{
　　　base.Dispose( disposing );
　　}

　　#region Windows Form Designer generated code

　　/// ＜summary＞
　　/// Required method for Designer support - do not modify
　　/// the contents of this method with the code editor.
　　/// ＜/summary＞

　　private void InitializeComponent()
　　{
　　　this.mainMenu1 = new System.Windows.Forms.MainMenu();
　　　this.menuItem1 = new System.Windows.Forms.MenuItem();
　　　this.menuItem_Menu = new System.Windows.Forms.MenuItem();
　　　this.menuItem_Exit = new System.Windows.Forms.MenuItem();
　　　this.menuItem3 = new System.Windows.Forms.MenuItem();
　　　this.menuItem2 = new System.Windows.Forms.MenuItem();
　　　this.comboBox_City = new System.Windows.Forms.ComboBox();
　　　this.label_City = new System.Windows.Forms.Label();
　　　this.txt_Weather1 = new System.Windows.Forms.Label();
　　　this.txt_Date1 = new System.Windows.Forms.Label();
　　　this.txt_Temp1 = new System.Windows.Forms.Label();
　　　this.txt_WindPower1 = new System.Windows.Forms.Label();
　　　this.txt_Temp2 = new System.Windows.Forms.Label();
　　　this.txt_WindPower2 = new System.Windows.Forms.Label();
　　　this.txt_Date2 = new System.Windows.Forms.Label();
　　　this.txt_Weather2 = new System.Windows.Forms.Label();
　　　this.timer1 = new System.Windows.Forms.Timer();

　　　//
　　　// mainMenu1
　　　//

　　　this.mainMenu1.MenuItems.Add(this.menuItem1);
　　　this.mainMenu1.MenuItems.Add(this.menuItem_Menu);
　　　//
　　　// menuItem1
　　　//

　　　this.menuItem1.Text = "确定";
　　　this.menuItem1.Click += new System.EventHandler(this.menuItem1_Click);

　　　//
　　　// menuItem_Menu
　　　//

　　　this.menuItem_Menu.MenuItems.Add(this.menuItem_Exit);
　　　this.menuItem_Menu.MenuItems.Add(this.menuItem3);
　　　this.menuItem_Menu.MenuItems.Add(this.menuItem2);
　　　this.menuItem_Menu.Text = "菜单";

　　　//
　　　// menuItem_Exit
　　　//

　　　this.menuItem_Exit.Text = "退出";
　　　this.menuItem_Exit.Click += new System.EventHandler(this.menuItem_Exit_Click);

　　　//
　　　// menuItem3
　　　//

　　　this.menuItem3.Text = "-";

　　　//
　　　// menuItem2
　　　//

　　　this.menuItem2.Text = "关于";
　　　this.menuItem2.Click += new System.EventHandler(this.menuItem2_Click);

　　　//
　　　// comboBox_City
　　　//

　　　this.comboBox_City.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.comboBox_City.Location = new System.Drawing.Point(52, 8);
　　　this.comboBox_City.Size = new System.Drawing.Size(114, 22);

　　　//
　　　// label_City
　　　//

　　　this.label_City.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Bold);
　　　this.label_City.Location = new System.Drawing.Point(4, 12);
　　　this.label_City.Size = new System.Drawing.Size(52, 16);
　　　this.label_City.Text = "城市：";
　　　this.label_City.TextAlign = System.Drawing.ContentAlignment.TopCenter;

　　　//
　　　// txt_Weather1
　　　//

　　　this.txt_Weather1.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_Weather1.Location = new System.Drawing.Point(12, 50);
　　　this.txt_Weather1.Size = new System.Drawing.Size(152, 14);
　　　this.txt_Weather1.Text = "天气:";

　　　//
　　　// txt_Date1
　　　//

　　　this.txt_Date1.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_Date1.Location = new System.Drawing.Point(12, 34);
　　　this.txt_Date1.Size = new System.Drawing.Size(152, 14);
　　　this.txt_Date1.Text = "日期:";

　　　//
　　　// txt_Temp1
　　　//

　　　this.txt_Temp1.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_Temp1.Location = new System.Drawing.Point(12, 68);
　　　this.txt_Temp1.Size = new System.Drawing.Size(152, 14);
　　　this.txt_Temp1.Text = "气温:";

　　　//
　　　// txt_WindPower1
　　　//

　　　this.txt_WindPower1.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_WindPower1.Location = new System.Drawing.Point(12, 84);
　　　this.txt_WindPower1.Size = new System.Drawing.Size(152, 14);
　　　this.txt_WindPower1.Text = "风力:";

　　　//
　　　// txt_Temp2
　　　//

　　　this.txt_Temp2.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_Temp2.Location = new System.Drawing.Point(12, 140);
　　　this.txt_Temp2.Size = new System.Drawing.Size(152, 14);
　　　this.txt_Temp2.Text = "气温:";

　　　//
　　　// txt_WindPower2
　　　//

　　　this.txt_WindPower2.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_WindPower2.Location = new System.Drawing.Point(12, 156);
　　　this.txt_WindPower2.Size = new System.Drawing.Size(152, 14);
　　　this.txt_WindPower2.Text = "风力:";

　　　//
　　　// txt_Date2
　　　//

　　　this.txt_Date2.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_Date2.Location = new System.Drawing.Point(12, 108);
　　　this.txt_Date2.Size = new System.Drawing.Size(152, 14);
　　　this.txt_Date2.Text = "日期:";

　　　//
　　　// txt_Weather2
　　　//

　　　this.txt_Weather2.Font = new System.Drawing.Font("Nina", 9F, System.Drawing.FontStyle.Regular);
　　　this.txt_Weather2.Location = new System.Drawing.Point(12, 124);
　　　this.txt_Weather2.Size = new System.Drawing.Size(152, 14);
　　　this.txt_Weather2.Text = "天气:";

　　　//
　　　// timer1
　　　//

　　　this.timer1.Interval = 200;
　　　this.timer1.Tick += new System.EventHandler(this.timer1_Tick);

　　　//
　　　// MainForm
　　　//

　　　this.Controls.Add(this.comboBox_City);
　　　this.Controls.Add(this.txt_Date1);
　　　this.Controls.Add(this.txt_Weather1);
　　　this.Controls.Add(this.label_City);
　　　this.Controls.Add(this.txt_Temp1);
　　　this.Controls.Add(this.txt_WindPower1);
　　　this.Controls.Add(this.txt_Temp2);
　　　this.Controls.Add(this.txt_WindPower2);
　　　this.Controls.Add(this.txt_Date2);
　　　this.Controls.Add(this.txt_Weather2);
　　　this.Menu = this.mainMenu1;
　　　this.Text = "天气预报";
　　}

　　#endregion

　　/// ＜summary＞
　　/// The main entry point for the application.
　　/// ＜/summary＞

　　static void Main()
　　{
　　　Application.Run(new MainForm());
　　}

　　private void menuItem_Exit_Click(object sender, System.EventArgs e)
　　{
　　　this.Dispose();
　　}

　　private void menuItem1_Click(object sender, System.EventArgs e)
　　{
　　　SearchWeather(this.comboBox_City.Text);
　　}

　　private string[] myString = new string[]
　　{
　　　 "日期: ",
　　　 "温度: ",
　　　 "天气: ",
　　　 "风力: ",
　　};

　　public void SearchWeather(string cityName)
　　{
　　　if( this.txt_Date1.Text != myString[0] )
　　　{
　　　　ReSelect();
　　　}

　　　this.Text = "正在下载...";
　　　this.timer1.Enabled = true;

　　　WeatherService.Weather weather = new WeatherService.Weather();
　　　DataSet myDs = weather.GetWeatherDataSet(cityName);

　　　this.txt_Date1.Text = myString[0] + myDs.Tables[0].Rows[0]["Date1"].ToString();
　　　this.txt_Temp1.Text = myString[1] + myDs.Tables[0].Rows[0]["Temp1"].ToString();
　　　this.txt_Weather1.Text = myString[2] + myDs.Tables[0].Rows[0]["Weather1"].ToString();
　　　this.txt_WindPower1.Text = myString[3] + myDs.Tables[0].Rows[0]["WindPower1"].ToString();

　　　this.txt_Date2.Text = myString[0] + myDs.Tables[0].Rows[0]["Date2"].ToString();
　　　this.txt_Temp2.Text = myString[1] + myDs.Tables[0].Rows[0]["Temp2"].ToString();
　　　this.txt_Weather2.Text = myString[2] + myDs.Tables[0].Rows[0]["Weather2"].ToString();
　　　this.txt_WindPower2.Text = myString[3] + myDs.Tables[0].Rows[0]["WindPower2"].ToString();
　　}

　　private void ReSelect()
　　{
　　　this.txt_Date1.Text = myString[0];
　　　this.txt_Temp1.Text = myString[1];
　　　this.txt_Weather1.Text = myString[2];
　　　this.txt_WindPower1.Text = myString[3];
　　　this.txt_Date2.Text = myString[0];
　　　this.txt_Temp2.Text = myString[1];
　　　this.txt_Weather2.Text = myString[2];
　　　this.txt_WindPower2.Text = myString[3];
　　}

　　private void timer1_Tick(object sender, System.EventArgs e)
　　{
　　　if( this.txt_Date1.Text.IndexOf("月") != -1)
　　　{
　　　　this.timer1.Enabled = false;
　　　　this.Text = "天气预报";
　　　}
　　}

　　private void menuItem2_Click(object sender, System.EventArgs e)
　　{
　　　this.Text = "作者:贺星河";
　　　System.Threading.Thread.Sleep(3000);
　　　this.Text = "天气预报";
　　}
　}
}

　　四、在多普达565手机上部署并运行

　　1、在VS.NET2003的“解决方案WeatherService”上点击右键，选择”部署解决方案”，出现一下对话框

screen.width-600)this.style.width=screen.width-600;" border=0>
图4－部署解决方案

　　选择“部署”，“部署”完成后，手机上将显示如下界面

screen.width-600)this.style.width=screen.width-600;" border=0>
图5、手机界面之一－部署

　　因为我的PC机器上安装了.NET Framework1.1SP1，所以会提示这个界面，选择“确定”，继续执行安装部署：

screen.width-600)this.style.width=screen.width-600;" border=0>
图6、手机界面之二－选择安装位置

　　选择安装位置为”Sotrage Card”,选择“完成”,这个时候程序就部署完毕了，

　　使用Resco Explore 2003，找到安装部署后程序所在的目录，在 \Sorage\Program Files\WeatherService\ 目录下面，执行程序WeatherService.exe，将出现如下画面：

screen.width-600)this.style.width=screen.width-600;" border=0>
图7、手机界面之三－开始执行程序选择“是”。

　　之所以出现这个画面，是因为程序没有经过系统的认证，也是微软安全方面的一个体现，即时这个程序会正常执行，也不会冒然打出电话！

　　程序执行之后，会出现如下画面，选择需要查询的城市名称，点“确定”

screen.width-600)this.style.width=screen.width-600;" border=0>
图8、手机界面之四－程序界面

　　之后程序标题会变为“正在下载…”，程序通过GPRS上网读取部署在Internet上的WebService

screen.width-600)this.style.width=screen.width-600;" border=0>
图9、手机界面之五－运行界面

　　稍等几秒钟之后，便会看到所需要的天气信息数据

screen.width-600)this.style.width=screen.width-600;" border=0>
图10、手机界面之六－运行结果

Windows Mobile中的WebService应用

teky — Mon, 13 Nov 2006 08:14:00 GMT

【2006-03-23 16:04】【】【CSDN】

WebService对于开发者来说已经不再是一个陌生概念了。Web Service允许应用程序通过Internet进行通讯和数据交换。随着微软.NET战略的推行，这种可编程的、通过SOAP协议、基于XML的网络协议已经赢得了开发者的心。

　　现在，随着无线数据网络的发展，移动设备如何访问网络资源的问题显得格外突出。我们目前已经拥有了GPRS和CDMA的广域数据通讯网络，很多地方也覆盖了WI-FI的无线数据局域网。如何让我们的应用程序更好的利用网络资源?

　　Windows Mobile移动设备为我们提供了.NET Compact Framework，为我们开发移动应用程序带来的了极大的方便。.NET Compact Framework也提供了方便的Web Service访问方式，帮助开发者来编写基于Web Service的移动应用程序。

　　目前来看，Windows Mobile应用程序访问Web Service的应用主要出现在两个方面:首先是个人应用程序需要获取公共数据服务，比如获取天气预报、地理信息等;其次是，基于Windows Mobile的企业级应用将核心服务发布成Web Service形式，由移动应用程序进行调用。

　　我们这次主要讨论调用公众数据服务Web Service的情况，以Google和MapPoint Web Service为样本，讲述如何在Windows Mobile应用程序中调用搜索引擎和地图服务。

　　访问Google Web Service

　　Google是目前网络上最流行的搜索引擎之一，关键字搜索完全改变了网络信息的组织形式。Google很早就提供了公共Web Service服务，允许应用程序访问Google提供的搜索、拼写检查和页面缓存的功能。Google Web Service的每个帐号一天最多查询一千次。

　　在使用Google之前，我们必须去www.google.com/apis，申请一个Google Account。注册成功后，会收到一个Google的关键字，每次调用的时候，都要提供这个关键字。

　　在申请成功后，我们可以动手开发自己的应用程序了。我们在Visual Studio 2005 Beta 2中创建一个Device Application。然后我们要为Google Web Service添加一个Web引用。在Project菜单中选择Add Web Reference，在URL里输入 http://api.google.com/GoogleSearch.wsdl,选择Add Reference按钮就可以了。这样，我们就把Google Web Service添加到我们的应用程序中来了。

　　我们先来认识一下Google Web Service中的对象。这些对象设计得和Google的主页一样简单。

对象	说明
DirectoryCategory	ODP目录的内容和种类
GoogleSearchResult	Goolge查询结果
GoogleSearchService	Google查询服务对象
ResultElement	查询结果集元素

　　我们下面就来用这些对象来编写一个简单的Google查询的程序。我们首先要介绍一个重要的API:GoogleSearchService下的doGoogleSearch。

public GoogleSearchResult doGoogleSearch(
    string key, // Google Key
    string q, // 查询内容
    int start, // 从第几条结果开始返回
    int maxResults, // 最多返回多少条（最多10条）
    bool filter, // 是否自动过滤相似或来源相同的结果
    string restrict, // 限制查询结果来自Google Web 索引的一个子集
    bool safeSearch, // 是否过滤成年人内容
    string lr, // 语言限制（”lang_zh-CN”为中文）
    string ie, // 输入编码
    string oe) // 输出编码

　　在某些情况下，我们需要设置代理服务器来访问一些网络资源，所以，我们要引入System.Net的命名空间，然后创建一个Web Proxy赋给GlobalProxySelection，才能保证我们调用Web Service的正常。

WebProxy proxy = new WebProxy("itgproxy",80);
proxy.BypassProxyOnLocal = true;
GlobalProxySelection.Select = proxy;

　　在上面的代码里我们首先创建一个WebProxy，地址为” itgproxy”，端口为80。然后选择本地地址不使用代理服务器，最后设置到GlobalProxySelection中。

　　下面我们把完整的代码写出来:

try
{
    WebProxy proxy = new WebProxy("itgproxy",80);
    proxy.BypassProxyOnLocal = true;
    GlobalProxySelection.Select = proxy;

    GoogleSearchService service = new GoogleSearchService();
    GoogleSearchResult result = service.doGoogleSearch(
        key, // 查询Key
        textBox1.Text, // 内容
        0, // 从第几条结果开始返回
        10, // 最多返回的条数（最大10条）
        false, // 是否自动过滤相似或来源相同的结果
        "", // 限制查询结果来自Google Web索引的一个子集
        false, // 是否过滤成年人内容
        "", //"lang_zh-CN", // 语言限制
        "", // 输入编码
        ""); // 输出编码

    for(int i = 0; i <= (result.endIndex - result.startIndex); i++)
    {
        ResultElement element = result.resultElements[i];
        listBox1.Items.Add(element.title);
        listBox1.Items.Add(element.snippet);
        listBox1.Items.Add(element.URL);
    }

MessageBox.Show(result.estimatedTotalResultsCount.ToString());
}
catch (System.Web.Services.Protocols.SoapException ex)
{
MessageBox.Show(ex.Message);
}

　　在设置好代理服务器后，我们创建一个GoogleSearchService的对象，然后调用该对象的doGoogleSearch方法。我们将得到一个GoogleSearchResult的结果集，通过endIndex和startIndex属性，我们可以获得查询结果的数量。我们从结果集对象的resultElements中获得ResultElement对象，然后把标题、简介和URL显示到listBox中去。最后我们可以用结果集对象的estimatedTotalResultsCount属性，来获取一共找到了多少个结果。我们上边曾经说过，每次查询最多只能返回10个结果，但是estimatedTotalResultsCount返回的是所有符合条件的记录。

访问MapPoint Web Service

　　MapPoint是微软提供的一个地图信息的Web Service，提供全球各地的地理信息和商业网点信息(主要是北美和欧洲地区)。MSN Search推出的地理搜索服务也是基于MapPoint Web Service服务的。目前MapPoint还不包括中国的地理信息。

　　Windows Mobile设备的存储空间比较小，所以很难保存大量的地图数据。但是随着无线网络的普及，Windows Mobile设备就可以方便地查询保存在服务器上的地图数据和黄页信息。MapPoint Web Service还可以结合Windows Mobile设备上的GPS定位系统或者LBS服务，查询附近的旅游景点和商业场所，这对于移动应用也具有十分现实的意义。

　　MapPoint是一个收费的Web Service，不过，我们可以申请一个60天的测试帐号。MSDN的订户还可以申请一个为期一年的帐号，用于应用程序的开发。在申请到帐号后，我们不但可以查询公共的地理信息，还可以上传自己的地理信息，用于支持自定义的地理信息查询。

　　我们创建一个Windows Mobile Device Application，然后添加一个Web Reference，URL为“http://staging.mappoint.net/standard-30/mappoint.wsdl”。

　　在编写程序之前，我们先来看一下MapPoint中需要用到的类和方法。

类方法	说明
FindServiceSoap	包括查询服务(find service)的方法和属性
RenderServiceSoap	包括查询结果表示服务(render service)的方法和属性
FindSpecification	用于指定FindServiceSoap.Find的查询信息
FindResults	FindServiceSoap查询操作的单个结果
ViewByScale	包含地图定义地图比例和基准点
MapOptions	包含RenderServiceSoap.GetMap方法的地图显示选项
Pushpin	包括图钉的图标、标签、定位、用户指定数字
MapSpecification	包含地图显示的详细规范
MapImage	RenderServiceSoap.GetMap返回的地图

　　我们首先来创建MapPoint查询过程中最重要的两个对象:

FindServiceSoap fws = new FindServiceSoap();
RenderServiceSoap ws = new RenderServiceSoap();
fws.Credentials = new NetworkCredential(myUserName, myPassword);
ws.Credentials = new NetworkCredential(myUserName, myPassword);

　　FindServiceSoap是提供地图查询服务的主要对象，RenderServiceSoap是表现查询结果地图的主要对象。在使用之前，我们要先创建一个NetworkCredential对象，将MapPoint的用户名和密码传给FindServiceSoap和RenderServiceSoap的Credentials属性。

　　然后我们创建一个FindSpecification对象，指定地图数据库、要查询的地点，然后将其作为FindServiceSoap的Find方法的参数执行查询，并返回FindResults对象中。

FindSpecification myFindSpec = new FindSpecification();
myFindSpec.DataSourceName = "MapPoint.NA";
myFindSpec.InputPlace = this.textBox1.Text;

FindResults results = fws.Find(myFindSpec);
if (0 == results.NumberFound)
{
MessageBox.Show("你找的是什么鬼地方？");
return;
}

　　我们选择的地图数据源是北美地区的数据集“MapPoint.NA”，而InputPlace是要查询的地点，从界面上的文本框中获得。然后调用FindSpecification的Find方法，返回FindResults对象。如果结果集对象的NumberFound属性为0，则说明没找到合适的结果。

　　然后我们创建一个ViewByScale对象，为该对象的CenterPoint属性创建LatLong对象。CenterPoint属性的经纬度分别results.Results[0].FoundLocation.LatLong中的经纬度。然后在ViewByScale对象的MapScale属性中设置地图的比例尺。创建MapOptions对象，在MapOptions.Format设置地图的宽度和长度。创建一个图钉对象Pushpin，将图钉对象的经纬度设置为ViewByScale对象的经纬度。

　　在创建完这些对象后，我们创建一个MapSpecification对象用于指定要显示地图的详细情况。我们要指定MapSpecification对象的地图数据集，并将前边创建的三个对象分别赋给Options、Pushpins、Views属性中。

MapSpecification myMapSpec = new MapSpecification();
myMapSpec.DataSourceName = "MapPoint.NA";
myMapSpec.Options = options;
myMapSpec.Pushpins = pushpins;
myMapSpec.Views = views;

　　在设置完成MapSpecification对象后，我们将其作为参数，调用RenderServiceSoap对象的GetMap方法，获取MapImage对象。然后将MapImage对象中的数据作为MemoryStream内存流，用于创建一个Bitmap对象，最后显示到PictureBox中。

MapImage[] images = ws.GetMap(myMapSpec);
this.pictureBox1.Image = new System.Drawing.Bitmap(new System.IO.MemoryStream(images[0].MimeData.Bits));

　　完整代码如下:

WebProxy proxyObject = new WebProxy(proxy, 80);

// Disable proxy use when the host is local.
proxyObject.BypassProxyOnLocal = true;

// All requests this proxy information.
GlobalProxySelection.Select = proxyObject;

FindSpecification myFindSpec = new FindSpecification();
myFindSpec.DataSourceName = "MapPoint.NA";
myFindSpec.InputPlace = this.textBox1.Text;

FindResults results = fws.Find(myFindSpec);
if (0 == results.NumberFound)
{
MessageBox.Show("你找的是什么鬼地方？");
return;
}

ViewByScale[] views = new ViewByScale[1];
views[0] = new ViewByScale();
views[0].CenterPoint = new LatLong();
views[0].CenterPoint.Latitude = results.Results[0].FoundLocation.LatLong.Latitude;
views[0].CenterPoint.Longitude = results.Results[0].FoundLocation.LatLong.Longitude;
views[0].MapScale = 150000;

MapOptions options = new MapOptions();
options.Format = new ImageFormat();
options.Format.Height = this.pictureBox1.Height;
options.Format.Width = this.pictureBox1.Width;

Pushpin[] pushpins = new Pushpin[1];
pushpins[0] = new Pushpin();
pushpins[0].IconDataSource = "MapPoint.Icons";
pushpins[0].IconName = "0";
pushpins[0].Label = results.Results[0].FoundLocation.Entity.Name;
pushpins[0].LatLong = views[0].CenterPoint;
pushpins[0].ReturnsHotArea = true;

MapSpecification myMapSpec = new MapSpecification();
myMapSpec.DataSourceName = "MapPoint.NA";
myMapSpec.Options = options;
myMapSpec.Pushpins = pushpins;
myMapSpec.Views = views;

MapImage[] images = ws.GetMap(myMapSpec);
this.pictureBox1.Image = new System.Drawing.Bitmap(new System.IO.MemoryStream(images[0].MimeData.Bits));

　　我们上面演示的仅仅是最简单的地图查询功能，我们还可以通过FindAddress, FindByID, FindByProperty, FindNearby 或者 FindNearRoute等方法来查询地址、查询附近的地点等。我们还可以通过MapPoint Web Service来实现智能路标的功能。

　　写在最后

　　上面我们一起了解了如何在Windows Mobile应用程序中加入Google和MapPoint的Web Service。我们还可以通过Web Service来发送短信，获取天气预报。越来越多的服务提供商也开始把自己的服务发布成Web Service，使自己的服务不但可以提供给终端用户，还可以提供给应用程序开发者，从而扩大自己的用户群。

　　现在Web Service和Windows Mobile应用程序都处在发展期。随着无线网络的成熟，加上其他的智能手机操作系统也开始支持Web Service，我们会看到越来越多应用于移动设备上的Web Service案例。