好贴子可不能找不到了

Windows Mobile中如何建立GPRS连接以便Socket能正常通信

teky — Wed, 18 Mar 2009 03:04:00 GMT

转Windows Mobile中如何建立GPRS连接以便Socket能正常通信谢红伟 http://www.vckbase.com/document/viewdoc/?id=1803

　　最近编写一个医疗项目的程序，需要用 Windows Mobile 来做通信处理，需要将手机端的数据通过GPRS传送至公网上的一个服务器上。数据传输我采用的是socket，用数据线+ActiveSync调试通过，数据传输正常，在准备将软件提交给质检部门的时候，用真正的GPRS来做通信测试时，问题出来了，连接始终建立不了，但用手机的IE浏览器却能正常打开网页，而且奇怪的是只要用IE浏览器成功访问过一次网页，我的 socket 就能正常进行数据通信，看来传说中的GPRS常连接被我误解了。
　　手机开通GPRS以后，我们的socket 程序还不能直接建立网络连接，需要用连接管理器来获取当前可用连接，并自动选择一个最佳的连接途径，然后启用这个连接，在连接启动成功以后再用socket 进行网络连接方可正常进行。大概GPRS拨号和连接过程就是在这里自动进行的吧。源代码中封装了一个连接管理的类和测试代码，可以清楚地看到Windows Mobile 在socket 编程之前到底需要做什么样的操作。

首先需要枚举当前可用的连接

void CConnectManager::EnumNetIdentifier ( OUT CStringArray &StrAry )
{
	CONNMGR_DESTINATION_INFO networkDestInfo = {0};

	// 得到网络列表
	for ( DWORD dwEnumIndex=0; ; dwEnumIndex++ )
	{
		memset ( &networkDestInfo, 0, sizeof(CONNMGR_DESTINATION_INFO) );
		if ( ConnMgrEnumDestinations ( dwEnumIndex, &networkDestInfo ) == E_FAIL )
		{
			break;
		}
		StrAry.Add ( networkDestInfo.szDescription );
	}
}

接下来找到“Internet”这个连接，可用远程URL映射的方式来完成，这样可以让系统自动选取一个最好的连接。

int CConnectManager::MapURLAndGUID ( LPCTSTR lpszURL, OUT GUID &guidNetworkObject, OUT CString *pcsDesc/*=NULL*/ )
{
	if ( !lpszURL || lstrlen(lpszURL) < 1 )
		return FALSE;

	memset ( &guidNetworkObject, 0, sizeof(GUID) );
	int nIndex = 0;
	HRESULT hResult = ConnMgrMapURL ( lpszURL, &guidNetworkObject, (DWORD*)&nIndex );
	if ( FAILED(hResult) )
	{
		nIndex = -1;
		DWORD dwLastError = GetLastError ();
		AfxMessageBox ( _T("Could not map a request to a network identifier") );
	}
	else
	{
		if ( pcsDesc )
		{
			CONNMGR_DESTINATION_INFO DestInfo = {0};
			if ( SUCCEEDED(ConnMgrEnumDestinations(nIndex, &DestInfo)) )
			{
				*pcsDesc = DestInfo.szDescription;
			}
		}
	}

	return nIndex;
}

以下代码是用来启用指定编号的连接

BOOL CConnectManager::EstablishConnection ( DWORD dwIndex )
{
	ReleaseConnection ();

	// 得到正确的连接信息
	CONNMGR_DESTINATION_INFO DestInfo = {0};
	HRESULT hResult = ConnMgrEnumDestinations(dwIndex, &DestInfo);
	BOOL bRet = FALSE;
	if(SUCCEEDED(hResult))
	{
		// 初始化连接结构
		CONNMGR_CONNECTIONINFO ConnInfo;

		ZeroMemory(&ConnInfo, sizeof(ConnInfo));
		ConnInfo.cbSize = sizeof(ConnInfo);
		ConnInfo.dwParams = CONNMGR_PARAM_GUIDDESTNET;
		ConnInfo.dwFlags = CONNMGR_FLAG_PROXY_HTTP | 
				CONNMGR_FLAG_PROXY_WAP | 
				CONNMGR_FLAG_PROXY_SOCKS4 | 
				CONNMGR_FLAG_PROXY_SOCKS5;
		ConnInfo.dwPriority = CONNMGR_PRIORITY_USERINTERACTIVE;
		ConnInfo.guidDestNet = DestInfo.guid;
		ConnInfo.bExclusive	= FALSE; 
		ConnInfo.bDisabled = FALSE;

		DWORD dwStatus = 0;
		hResult = ConnMgrEstablishConnectionSync(&ConnInfo, &m_hConnection, 10*1000, &dwStatus );
		if(FAILED(hResult))
		{
			m_hConnection = NULL;
		}
		else bRet = TRUE;
	}

	return bRet;
}

　　为了确保连接是否真正可用，需要检测连接状态，在规定的时间内如果未取得“连接成功”的状态，则认为连接未能正常启用，可能需要配置手机的连接管理器界面

BOOL CConnectManager::WaitForConnected ( int nTimeoutSec, DWORD *pdwStatus/*=NULL*/ )
{
	DWORD dwStartTime = GetTickCount ();
	BOOL bRet = FALSE;
	while ( GetTickCount ()-dwStartTime < (DWORD)nTimeoutSec * 1000 )
	{
		if ( m_hConnection )
		{
			DWORD dwStatus = 0;
			HRESULT hr = ConnMgrConnectionStatus ( m_hConnection, &dwStatus );
			if ( pdwStatus ) *pdwStatus = dwStatus;
			if ( SUCCEEDED(hr) )
			{
				if ( dwStatus == CONNMGR_STATUS_CONNECTED )
				{
					bRet = TRUE;
					break;
				}
			}
		}
		Sleep ( 100 );
	}

	return bRet;
}

　　至此，我们的连接启用工作已经做完了，我们可以用我们熟悉的 socket 来编写网络通信程序了。下面是一个测试 socket 测试网络连接是否能正常建立的例子：

SetWaitCursor ();
CSocket sock;
sock.Create ();
if ( sock.Connect ( _T("www.baidu.com"), 80 ) )
{
	RestoreCursor ();
	AfxMessageBox ( _T("Connect to www.baidu.com successfully"), MB_ICONINFORMATION );
}
else
{
	RestoreCursor ();
	AfxMessageBox ( _T("Connect to www.baidu.com failed") );
}

GPRSDemo.exe 的使用
程序启动以后出现如下界面：

连接可用性 – 检测连接管理器是否可用
映射URL – 是让系统自动寻找一个最好的连接
枚举网络标识符 – 将当前系统中所有可用的连接都会被枚举出来
连接网络 – 将枚举出来的连接选中的那个连接进行连接启用操作。
连接状态 – 表示可以获取到当前连接的状态；
连接到公网测试 – 利用 www.baidu.com 来测试连接是否已经正常启动。

操作步骤：

可以直接按“枚举网络标识符”，程序将所有当前在用的网络枚举出来并添加到 ListBox 控件中；
连接网络。选择一个连接（例如：Internet），按“连接网络”按钮，当提示 Connection net successfully 表示连接已经正常启用了。
按“连接到公网测试”按钮，软件自动和 www.baidu.com 进行连接测试。

RIA和未来的软件开发架构

teky — Mon, 22 Sep 2008 08:44:00 GMT

从97年左右开始，分布式软件分化为B/S和C/S这两种泾渭分明的设计架构。B/S架构的软件的用途主要是一些Internet应用，而C/S架构的软件用途则主要是一些企业应用。但那时候B/S应用还比较少，大量的分布式应用依然还是C/S架构。而到了2000年以后，随着Internet的普及，B/S应用软件的发展速度越来越快。因为B/S程序有一些天生优势，比如无须大规模部署客户端，导致很多企业应用也纷纷转向采用B/S架构。那时候B/S架构一度成为先进技术的代名词。而在近一到两年来，一个新名词在B/S软件开发中慢慢升温直到大红大紫，那就是Ajax。很多人觉得Ajax是新瓶装旧酒，因为Ajax所采用的技术早在几年前就有人使用，只是那时候还没有这样一个响亮的名字而已。但我觉得，不应该站在技术的角度去看待Ajax现象，Ajax的流行不是因为出现了一个什么新技术，而是代表了用户对体验需求的提升，用户已经不满足于有这个功能就可以，而是还要求要用得舒服。

从软件架构的发展趋势来看，以前纯B/S结构的应用程序，由于客户对体验的需求提高，导致客户端越来越复杂，各软件开发商都在想方设法的增加客户端的处理量，Ajax技术的流行正是这个结果。而从纯C/S结构的应用来看，由于受到客户对无须部署的要求和一些开发上的限制，导致客户端越来越瘦，除了完全转换到B/S的开发商以外，剩下的也慢慢转成了C/S/S这样的结构（比如SmartClient技术）。

如果说B/S代表了Internet应用，而C/S代表了企业应用（其实企业应用对Internet的依赖也慢慢增加）。则近十年来的发展趋势可以证明，无论是互联网应用还是企业应用，其实大家都在向着同一个中间点靠拢：RIA。

RIA的全称是Rich Internet Application，直接翻译过来就是富互联网应用。这里的富其实是一个专有词，相对于Thin（瘦）来说的，指的是应用软件客户端的复杂程度。我认为一个可以被称之为RIA的应用必须具有以下几个特点：

1、零部署

客户无须安装任何专用的软件，可以用一个通用解释程序负责界面的展现和程序的执行，比如浏览器可以展现HTML，并可以执行JS脚本。

2、良好的用户体验

要求在大部分情况下能达到和桌面应用差不多的客户端体验。包括操作便捷性，响应速度等。除了无全屏刷新这种基本要求外，对流媒体，矢量图形，即时动画等支持也是很必要的。

3、最好能跨平台

如果能支持Windows的话，这个要求不是必须。但是如果能支持多种操作系统，则可以应付将来可能会发生的关于操作系统的变化。

其实总而言之，RIA也就是在保留B/S架构的所有优势情况下，尽量提升瘦客户端的处理能力，以达到和桌面应用差不多的效果。

再来看看到底有那些技术符合这几项要求。

SmartClient：微软在2002年大力推广的技术，客户端使用.Net的Winform，后台不直接连数据库，而是通过远程调用（比如WEB SERVICE）连接应用服务器。优点是可以完全达到桌面级的用户体验，但是主要缺点是需要安装客户端，虽然客户端可以通过自动更新等机制完成部署，但是终归是没有零部署爽快。而且客户端还需要安装一个20多M的.Net Framework，也很难跨平台（但不是没有可能）。

Ajax：Ajax可以看成是普通的B/S应用的增强版，继承了所有B/S应用的优点，天生跨平台。但是，即便是最近Ajax大红大紫，但是我觉得Ajax还是有很致命的缺陷。那就是受限制于HTML和Javascript。HTML起初是为浏览静态文档而设计的，并不适合于提供内容丰富、交互性强和数据驱动的应用程序，而且Javascript开发复杂，运行速度慢，无法适应未来对更复杂的软件应用要求。

WPF：如果除去对客户端操作系统的要求，我觉得WPF可能是最好的RIA平台。她无与伦比的界面展现能力，让任何人看了都会心动。但因为她对客户端的要求太高，只有可能会是下下一代的RIA主流，而在近三年内都无法成为RIA的首选平台。

Flex+Flash：Flex是Adobe在收购Dream Weaver之后推出的以Flash为核心的RIA整体架构。Flex拥有成熟的技术，庞大的体系和数量众多的Flash设计人员作为后盾。但我觉得Flex成也萧何，败也萧何。Flash是二进制的，如果整个应用完全用Flash来搭建的话，那么搜索引擎无法搜索到里面的任何内容。当然，这个缺点对企业应用来说无所谓。

Silverlight：原名是叫做WPF/E，也就是WPF的一个精简版。虽然Silverlight和WPF都是采用XAML作为界面描述语言。但是他们的体系有很大不同，WPF需要借助安装在客户端的.Net 3.0来进行解释和执行代码。而Silverlight则是专门由一个只有4M大小的浏览器插件来进行绘图和运行程序。虽然Silverlight体积不大，但是功能却很强，不仅可以将XAML表述为高质量的图形和动画，并且还自带了一个小型的.Net运行时，支持VB，PYTHON，RUBY等动态语言，还支持LINQ等高级特性。而且还是跨平台的。

就目前来说，我觉得Flex和Silverlight是目前最有前途的两个RIA平台。Flex的优势是成熟的Flash技术和大量的设计人员，而Silverlight的优势是更先进的技术和大量的开发人员。未来或许是一场设计人员vs开发人员的对决。

下面预测一下未来软件开发架构的趋势。

1、虽然RIA将会成为未来的最主要的软件使用方式，但桌面应用依然存在。对于一些比较特殊的需求，比如对于需要极大数据量的传输，需要极高的操作响应速度，需要客户端进行极其复杂的数据处理等领域，却不得不交给专门开发的的客户端来进行处理。所以，我觉得未来依然会有SmartClient这样的软件生存机会。Adobe不是也还要推出Apollo吗？这是Adobe向桌面领域进攻的一个标志。

2、由于客户端处理能力变强了，所以服务器端慢慢向功能单一化发展。WEB服务器不再过多考虑如何展现数据，而是专注于如何提供数据。Web服务会大行其道，而像REST这样的纯资源服务也将会慢慢多起来。

3、整个Internet会变成一个巨大的应用服务器。提供各种各样的标准格式的数据管理接口，接口趋向于稳定和高效率。

4、动态语言作为使用方便，高效率的黏合器，会运行在各种各样的客户端上。而动态语言的无须编译，开发方便，灵活的特性将得到极大的发挥。

5、HTML和Ajax面临淘汰。

flex开发技术详解

teky — Mon, 22 Sep 2008 08:28:00 GMT

1、什么是flex？
将桌面软件丰富的功能同 web 的广度相结合，使企业级应用程序更为有效。 Macromedia Flex 表示服务器提供为开发者所熟悉、基于标准的编程框架和功能强大的组件，来为企业级应用程序创建功能更丰富、回应迅速的表示层。查看 Flex 数据表 (Flash or PDF, 156K) 查看 Flex Builder 数据表 (Flash or PDF, 81K) Flex 1.5 的新特性 Rich Internet 应用程序：释放应用程序 ROI 的关键现今的 web 应用程序有效利用了 web 的广度，但在提供易于使用和功能丰富的表示层却常常达不到用户的期望。这妨碍了应用程序的广泛使用，降低应用程序转化率，增加了培训成本，减少了整体 ROI。 Rich Internet 应用程序通过将桌面软件的丰富功能与 web 的最大广度相结合来提高 ROI。这下一代技术在改善用户体验的同时减少带宽占用和服务器负载。 Macromedia Flex 表示服务器提供为开发者所熟悉、基于标准的编程框架，用以提供 Rich Internet 应用程序的表示层。增强应用程序效能通过提升最终用户体验来增加 ROI 提高应用程序转化率改善用户满意度增强应用程序的使用广度减少带宽占用和服务器负载为开发者所熟悉兼容现有的工具、流程和基础结构可使用从记事本到 Eclipse 的任何集成开发环境进行编程启发性和声明性的编程流程基于 XML、SOAP 和 ECMAScript 等标准与现有组件和框架（包括 EJB 和 Struts 等）相集成功能强大企业级功能丰富的、可扩展的用户界面构件库高性能的运行时服务完整的调试和简介功能配置在现有基础架构
2、Flex的优势？
不需要进行浏览器兼容测试
AJAX的一个特点就是它比普通的XHTML和一些CSS要复杂的多。浏览器兼容性测试从此变成了可怕的梦魇。因为Flex应用程序编译成Flash SWF文件，所以不论你用什么样的操作系统和浏览器，它都同样下载为像素。
E4X：只要是解析过XML的人都知道解析的痛苦。Flex 2中的Actionscrip包含了针对XML的Ecmascript或者叫做E4X。它通过把XML看作一个原始变量使得操作一个XML对象变得简单。看一下这些简单的例子吧。
不再有布局界面的痛苦
我们都曾经忍受过这种痛苦。所有热衷于使用CSS布局的都知道试图适当地布局那些DIV标签时的痛苦。确实很痛苦。通过使用基于容器的Flex标记语言（MXML），把确定的（fixed）和流动的（liquid）布局设计转变成想要的布局结果变得非常容易。
简单的域验证
所有创建过商业程序或者电子商务应用程序的人都处理过表单域验证。邮政编码。信用卡号。这些在Flex中都是内置的并且很容易使用。
丰富的媒体支持
Flash平台让以前占统治地位的Web媒体播放器（Real，Windows Media）完全失去优势。Flash平台是轻量级的，并且工作时不需要安装任何东西。Flex使得你在程序适当的地方嵌入音频或者视频内容变得简单。
实现表现层和内容的真正分离
多年来，开发者都在说把数据从表现层分离出来的优点。当然，在Web世界中，说总比做容易。绝大多数的web应用程序都是和一些形式的动态内容有关联的模版。使用Flex，可以把数据巧妙地从任何地方（简单的XML，SOAP，等）中取出并帮定到界面中的元素上。这样做可以促进更严格的分离。你的服务器现在只传输数据就行了。当你这样做的时候，你不只拥有了一个应用程序，你还拥有了一个API。
Flex开发环境
所有的Javascript开发者都知道开发AJAX/JS应用程序的痛苦。调试是件烦人的工作而且没有任何有关AJAX/Javascript的可视化的开发环境。Flex Builder 2是一个Flex可视化编程环境，它是像Visual Studio和Jbuilder一样的已经产业化的IDE。它是建立在Eclipse IDE平台的基础上的。
CSS 支持
我们在Arc90已经得到了一些认真的CSS天才，我们也很高兴的看到Flex的很多样式也是由CSS控制的。颜色。字体。倾斜度。那些CSS技巧仍然可以应用到皮肤和自定义Flex应用程序上。你可以看一下Flex Style Explorer对Flex的CSS有个简单的认识。
Web存档文件的部署
在 J2EE 服务器上或 servlet 容器中将 Flex 应用程序打包及部署成标准的 WAR 文件。

3、Flex的难易程度？
Flex开发对于一个熟悉ActionScript和XML语法的人来说比我想象中的要简单，效果也非常显著。也不要把Flex想象的非常神秘，查看生成的页面可以看到Flex不过通过服务器端的转换把xml文件编译成一个SWF文件显示在网页中（而且还不是显示在屏幕中间）。如果熟悉样式表的使用的话，mxml的属性也很容易理解和掌握。

4、我们都可以掌握flex吗？
你至少需要了解两种语言才能开发Flex应用程序：MXML和ActionScript。MXML是一种XML标记语言，主要用来设置Flex的用户界面，还包括一些不可见的元素，例如访问数据源、数据绑定等。ActionScript是一种面向对象的编程语言，采用ECMAScript第4版的标准，用来完成程序逻辑和响应用户的交互。一个典型的Flex应用程序开发可以遵循下面的步骤：
        使用编辑器或可视化工具创建包含根标记的一个MXML文件；
        添加一个或多个容器；
        添加对容器的控制，如输入框、按钮和输出框；
        定义数据模型；
        添加WebService，HTTPService或请求远程Java对象操作；
        添加对数据字段的验证；
添加脚本扩展组件；
        调试

5、为何选择学习flex？
Flex带给了JSP\ASP等广大的web application开发人员相近的工作流程与编程思路, 采用了XML declaration + procedural scripting language的模型, 建立了一整套的Flex class library来做为UI描述的tags, 使得开发Flash Form application式的swf的过程就像开发html page一样类似.

6、Flex与其他同类的区别？与flash的区别？
Flex 是 Macromedia发布的presentation server（展现服务），它是java web container或者.net server的一个应用，根据.mxml文件（纯粹的xml描述文件和actionscript）产生相应得.swf文件，传送到客户端，由客户端的flash player或者shockwave player解释执行，给用户以丰富的客户体验。
大名鼎鼎的Macromedia Flash是强大的矢量动画编辑工具，在作动画起家之后，Flash一直在谋求rich internet application(ria富客户端)的霸主地位，最有影响的是，已经推出了面向对象的编成脚本actionscript2.0，并且建立起类似于java swing的类库和相应component(组件)。Flex是通过java或者.net等非Flash途径，解释.mxml文件组织components，并生成相应得.swf文件。Flex的component和flash的component很相似，但是有所改进增强。
Flex和j2ee/.net其实没什么关系，Macromedia用java做出来个应用把flash的技术融合到j2ee里面，再用.net的技术做出来个.net应用把flash技术融合到.net里面去；应该说flex解决了j2ee里面和.net最繁琐的问题那就是web 客户端的问题。
Flex应用程序与传统的HTML应用程序的主要区别在于Flex应用程序处理最适合在客户端运行，如字段校验、数据格式、分类、过滤、工具提示、合成视频、行为及效果等。Flex 可使开发人员更好地交付应用程序，这种应用程序使用户可以迅速反应、在不同状态与显示间流畅过渡，并提供毫无中断的连续的工作流。
7、flex的功能和应用
利用Flash建构高互动性网站：
相较于Workplace的Rich Client是企业内部协同合作的应用，IBM与Macromedia合作推出的Flex展示服务器，则是针对电子商务推出的解决方案，希望藉由RIA（Rich Internet Application）的接口，颠覆目前的网站操作经验，协助企业建置互动性更强的网站。透过Flash提供的客户端经验，Macromedia称之为「Halo」，是Rich Internet Application的一种跨平台经验模式，Flex就是藉由Halo模式，结合桌面应用程序的反应力与丰富性，及网页应用程序的散播力，以协助企业目前网页应用程序缺乏客户端智能的情况。
Flash Player是散播应用的通路：
根据NPD Group的统计，Flash Player的安装率高达98%，所以若采用Rich Client的架构，客户端额外安装的负担减少很多。此外，Flash Player档案并不大，全新下载Flash Player的话，档案大小约400k；如果仅是功能更新，Flash引擎会自动侦测下载需要更新的部分，使用者不见得会察觉系统更新行为。Macromedia把Flash Player定位为一个「通路」，目前支持的平台包括计算机及PDA，未来将延伸应用到手机及数字电视。由于Flash使用向量技术，不论下载至任何平台，Flash档不用重写，只需调整需要呈现的内容即可，所以不但可减轻开发人员的负担，也可保证用户拥有一致的使用经验。
相较于网页资料无法保存状态，Flex应用程序在Flash Player虚拟机器上执行，可呈现实时的信息，及处理字段验证、资料格式化、排序、过滤、提示、整合影像、行为及效果等客户端工作，无需换页或返回上一页。如果以Flash呈现网站内容，由于Flex展示服务器会编译MXML档案，成SWF格式的Flash档，因此客户端无法检视原始程序代码，安全控管机制不易被破解，因此可避免传统网页可能的安全性问题。
Flash 6.0以后的版本，已支持数据链路的功能，Flex提供Flash Remoting、Web Services、Java Object、Http Query及XML等，四种执行期服务（Runtime Services）串连后端服务器，整合企业资源。此外，Flash整合视讯功能，可以对象形式加入影音内容。
Flex解决方案架构：
在多层式（N-Tier）应用程序架构中，Flex展示服务器位于接口层，用以改善目前HTML网页夹带客户端程序代码的问题。企业既有的架构导入Flex，不需要更动商业逻辑层，只是加入一个展示服务器，强化接口层。Flex展示服务器以WAR档部署在现有的Java应用服务器，并在应用服务器中执行。目前Flex支持IBM WebSphere、BEA WebLogic、Macromedia JRun及Apache Tomcat，预计年底推出.NET的版本。
Flex应用程序由MXML及ActionScript组成，MXML用以宣告定义应用程序中使用者接口的元素；而ActionScript 2.0则处理客户端逻辑与控制程序。程序背后的Flex类别链接库，包含Flex组件、资料系结、行为与其它功能，开发者运用类别链接库建立使用者接口及程序行为。
Flex展示服务器不是发布赤裸裸的MXML文件及ActionScript程序，而是由Flex应用程序编译成SWF格式的Flash檔，下载至客户端以Flash Player执行。利用执行期服务，Flex应用程序也可与应用服务器及数据库沟通交换资料，以对客户端使用者的动作产生响应。
ActionScript 2.0瞄准C#及Java开发者：
过去Macromedia提供Flash MX作为开发工具，却遭遇一大瓶颈，因为虽然业界有很多Flash的设计人员，却不见得有足够的Flash开发人员。由于ActionScript开发应用程序相当复杂，Flash独有的时间轴、舞台及动画等的概念，与一般程序开发的逻辑大不相同，导致学习的门槛让开发人员感到挫折。
因此Macromedia针对新推出的Flex做了大幅的修正，以MXML设计使用者接口，而ActionScript 2.0则撰写商业逻辑及组件的行为。为降低开发的门槛，Macromedia遵循ECMAScript 4标准，改写了ActionScript推出ActionScript 2.0，是对象导向的程序语言，瞄准C#及Java的开发人员，采用传统的程序化开发方法，语法与Java相同，只是引用的对象及方法不同，所以熟悉Java的开发人员将很容易上手。
由于Flex是IBM与Macromedia合作的产品，因此未来Java开放原始码开发工具Eclipse，会推出Flex的外挂程序，至于其它的开发工具，Macromedia会释出Flex的链接库，只要加入Feature Plug-in，即可支持Flex。
设计客户端接口的MXML：
跟HTML一样，MXML是描述使用者接口内容及功能的标记语言，然而不同的是，MXML分隔接口与商业逻辑的关联性，客户端逻辑由ActionScript 2.0处理。Flex展示服务器会编译两者成为SWF格式的Flash文件，如果要修改接口内容，只需调整MXML档，无需更动ActionScript 2.0程序，可提高应用程序的重复使用性，强化生产力。
MXML是以XML为基础的标记语言，目前除了Macromedia Flash MX外，记事本及UltraEdit等文字编辑器均可撰写MXML，不过如同手工撰写HTML是不够直觉的经验，Macromedia预计今年暑假推出代号「Brady」的设计工具，是MXML的可视化设计工具，以类似Dreamwaver的接口，提升设计MXML的便利性。
Flash Player的版本影响Flash的效能：
根据浏览网站的经验分析，虽然参杂Flash的效果令人目眩神迷，却也需要一段等待下载Flash档的时间。尤其是首页的Flash档，如果只是增加效果的动画，使用者可能宁愿选择跳过。零壹科技技术顾问陈子龙表示：「这与Flash的最佳化经验有关，有很多方式可以避免过长的等待时间。如果以Flex展示服务器架构电子商务网站，Flash与HTML执行效能比较，的确是企业衡量的条件之一，陈子龙表示：「效能是重要的议题之一，不过对电子商务而言，快速的开发方式及更好的使用者体验更为重要。」Flash的做法是先把需要的资料下载到客户端，及时在客户端运算，所以第一次会稍微慢些。不过后续的效能跟及时性，与HTML必须不断更新网页的使用经验相较，是较优质的体验。此外，效能也与Flash Player的版本有关，较新版的Flash Player，提供较好的效能品质。
适合Flex的应用类型：
并不是所有应用程序都适合采用Flex导入RIA解决方案，零壹科技指出需要多个步骤才能完成的流程例如订房系统，利用Flash整合所有步骤在单一窗口，可避免逐步设定不断换页的麻烦。以现今的购物网站为例，使用者在选择产品类型之后，还需选择品牌、比对功能及价位，来回点选寻找适合的产品花费很多时间。结合Flex以Flash展现，使用者可在单一画面设定产品的条件，后端服务器即自动筛选出适合的产品，使用者再拖放需要的产品至购物车，这些程序都不需要换页，将带给使用者全新的网络购物经验。此外，诸如需要许多手动操作的系统，及必须呈现可视化内容的网站，也都是Flex适合的范围。
8、Flex的市场前景？
市场对Flex技术的反应整整比ajax慢一年多，这也跟macormedia对flex的推广失利有关，到06年4月份人才市场才表现出对flex开发者的需求，直到06年7月flex2推出后，需求稳步增长。试想，如果flex2早些推出，那么现在又是一番景象了，从今年年初笔者开始关注flex以来，亲眼目睹了这一爆发式的增长，Ted patrick的这篇文章印证了这个过程。可以预见，在adobe一系列活动的推动下，再加上apollo平台带来的冲击效应，未来将会有越来越多的flex工作机会。

9、flex人才
flex2才发布不长时间，所以没有见到开发者的大规模增长也是正常的，但是现在情况已是大不相同，最近flex开发者的数量稳步增长，而且大企业对flex开发者的需求也越来越多，flex正在adobe的多项政策的推动下逐步深入企业和开发者视野中。
第一重初级程序员
Flex初级程序员是指经过一周到一个月的间歇性学习(自学)和模仿而形成的上手级开发者。这个定义主要从投入精力和学习路线来规定的，这个层次的程序员往往是出于一时的爱好或者项目的需要而进入改领域的学习。其特点是能做一些简单的应用，能搞清楚flex应用的开发过程，使用flexbuilder能拖拽出一个界面来，并能写简单的AS脚本，从而完成一个基本的Flex应用。这类程序员从此就再没有深入研究，而且没有完整的看过官方的所有开发文档，也没有体会到Flex/RIA开发的思想，基本上就在该领域停滞不前了。
第二重中级程序员
该阶段的程序员是指超过三个月的学习(自学)并完成至少一个项目的进阶级开发者。位于此阶段的Flex开发者通过扎实系统的文档学习并通过实战的演练，对Flex整个框架有很全面的认识，能够熟练使用IDE进行MXML/AS开发RIA应用，对程序结构、程序运行流程、对于flex应用与传统web应用的区别都有很好的理解，能独立的实现flex为前端技术的web应用。这类程序员注重基础、细节，尤其是flex应用与web应用与桌面应用的差别与联系，而且善于钻研技术，非常具有软件开发的潜力，而且只需加以时日便可进一步上升成为高手。
第三重高级程序员
Flex高级程序员是指连续从事一年以上企业级Flash/Flex应用开发并在项目中承担主要角色的高手级开发者。这个层次的修炼很不容易，首先需要自己不断的努力，而且最难办到的是能在一个长期使用Flex技术的公司(team)中持续锻炼。处于这个层次的Flex程序员往往对企业级RIA架构比如cairngorm非常熟悉，而且能对各种RIA架构做出自己的评价。对新项目的功能和模块、组件的划分都有清晰的认识，对于Flex应用的方方面面例如幕后的运行过程、显示结构的模式、事件流顺序、组件的制作手法、程序规模和性能的控制都有深刻的理解。对于这个层次的flex程序员来说，自定义一个通用的组件是很容易的事情，因为他对于Flex的组件体系甚至组件的源码他都了如指掌。夸张的来说，他们写flex应用很少看语法参考，写代码甚至可以在记事本里完成。这样的flex开发者在全球都很少，属于高手中的高手，是大公司争强的对象，也是广大flex开发者努力的目标。
第四重资深程序员
资深Flex程序员是指有着多年的RIA开发经验(超过10年的软件行业从业时间)并有广泛的软件开发相关技术背景的大牛级人物。这样的人物，只要是你接触Flex这一领域就能听到他的大名，他们的博客是众多Flex开发者的圣殿，他们的声音就是整个社区的福音和号角，他们的著作是我们的圣经，这样的人物常常会在大型活动比如360Flex或者adobe MAX大会上经常出现，他们代表着这个领域的前沿和潮流。这样的程序员往往是Flex技术进步和发展的原动力，是我们Flex开发者努力一生的目标，甚至是我们的偶像，比如Ted Patric以及他的博客上的Disruptive Evangelism(突破性的传道者)，总共才11个人(都是Adobe公司的)。
10、Flex人才的年薪？
作为一名程序员，年薪10万-30万不等，由于flex是门比较新的技术，所以他的前景是非常广阔的，因此flex人才的年薪不会低于其他的程序人员。

改进基于 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案例。

Creating a P/Invoke Library

teky — Mon, 09 Oct 2006 06:07:00 GMT

Creating a P/Invoke Library

Geoff Schwab
Excell Data Corporation

Contributors:
Jonathan Wells
Microsoft Corporation

Registry Sample:
Dan Elliott
Microsoft Corporation

Wave Samples:
Seth Demsey
Microsoft Corporation

Jonathan Wells
Microsoft Corporation

January 2004

Applies to:
Microsoft® .NET Compact Framework 1.0
Microsoft Visual Studio® .NET 2003

Summary: This sample demonstrates how to P/Invoke numerous useful native functions that are not directly available through the .NET Compact Framework. A test Form is provided that enumerates all available test procedures and allows the user to select and run them. (18 printed pages)

Download Sample

Introduction
The Test Application
Input
Memory
Memory Status
Performance Counters
Power Status
SIP
System Reset
System Time
Wave Out
Wave In
Windows
Registry
Phone
Folders

Introduction

The intent of this sample is to provide a collection of P/Invokes, as well test procedures that demonstrate their application. This sample provides several of the most commonly requested P/Invoke functions as well as a class that handles the enumeration and invoking of the various test procedures. This class is used by a Form to allow the user to select and run the tests from a selection list.

Note: For the sake of brevity and to facilitate searches, all function parameters and class definitions have been omitted from code blocks. Refer to the sample for full implementations of all code.

The Test Application

The test application is comprised of two components, the test application Form and the MainTest class. The Form provides the user with a list of all available tests and allows the user to select and run one or all of the tests with a press of the "Run Test" button. The results of the tests are displayed on the Form and can be cleared by pressing the "Clear Results" button.

The MainTest class provides the Form with the number and name of all available tests through Reflection. All classes defined in the Assembly are enumerated and searched for a static method named "TestProc." If this method is defined for a class then it is considered to be a P/Invoke test and is therefore added to the list. If the user runs a test then Reflection is again used to determine the MethodInfo for the TestProc and it is invoked.

Results from the tests are displayed via a delegate defined to take a string. This delegate is provided by the Form to the MainTest constructor and is, in turn, provided to each TestProc method as its only parameter.

Figure 1 shows a sample of the MemoryStatus test being run.

Figure 1. P/Invoke Library Test Application.

Input

The Input class provides the ability to override hardware hot keys and detect button presses regardless of which Control has input focus. Figure 2 shows sample output from this test.

Note: Some hardware keys may not be replicated on some emulators, causing this test to wait indefinitely for the proper key to be pressed.

Figure 2. Input Test Results.

The following functions are implemented in the Input class.

// C#
[DllImport("coredll.dll")]
protected static extern uint RegisterHotKey

[DllImport("coredll.dll")]
protected static extern uint UnregisterFunc1

[DllImport("coredll.dll")]
protected static extern short GetAsyncKeyState

'VB
<DllImport("coredll.dll")> 
Protected Shared Function RegisterHotKey

<DllImport("coredll.dll")> 
Protected Shared Function UnregisterFunc1

<DllImport("coredll.dll")> 
Protected Shared Function GetAsyncKeyState

Memory

The Memory class provides methods for allocating, reallocating, and freeing memory from the heap. Figure 3 shows output from a sample test.

Figure 3. Memory Test Results.

The following functions are implemented in the Memory class.

//c#
[DllImport("coredll.dll")]
extern public static IntPtr LocalAlloc

[DllImport("coredll.dll")]
extern public static IntPtr LocalFree

[DllImport("coredll.dll")]
extern public static IntPtr LocalReAlloc

'VB
<DllImport("coredll.dll")> 
Public Shared Function LocalAlloc 

<DllImport("coredll.dll")> 
Public Shared Function LocalFree 

<DllImport("coredll.dll")> 
Public Shared Function LocalReAlloc

Memory Status

The MemoryStatus class provides methods for determining the status of the device's memory. Figure 4 shows sample output from this test.

Figure 4. Memory Status Test Results.

The MemoryStatus class implements the following classes and functions.

//C#
public class MEMORYSTATUS

[DllImport("CoreDll.dll")]
public static extern void GlobalMemoryStatus

[DllImport("CoreDll.dll")]
public static extern int GetSystemMemoryDivision

'VB
Public Class MEMORYSTATUS

<DllImport("CoreDll.dll")> 
Public Shared Sub GlobalMemoryStatus 

<DllImport("CoreDll.dll")> 
Public Shared Function GetSystemMemoryDivision

Performance Counters

The PerfCounter class provides methods for accessing the device's performance counters. For more information on Performance Counters, see "HOWTO: Use a Performance Counter". Figure 5 shows sample output from the Performance Counter test.

Figure 5. Performance Counter Test Results.

The following functions are implemented by the PerfCounter class.

C#
[DllImport("CoreDll.dll")]
public static extern int QueryPerformanceFrequency

[DllImport("CoreDll.dll")]
public static extern int QueryPerformanceCounter

'VB
<DllImport("CoreDll.dll")> 
Public Shared Function QueryPerformanceFrequency 

<DllImport("CoreDll.dll")> 
Public Shared Function QueryPerformanceCounter

Power Status

The PowerStatus class provides methods for determining the status of the device's power configuration, e.g., batter life, AC line status. For more information on Power Status, see "HOWTO: Get the Device Power Status". Figure 6 shows sample output from the Power Status test.

Figure 6. Power Status Test Results.

The PowerStatus class implements the following classes and functions.

C#
public class SYSTEM_POWER_STATUS_EX2

public class SYSTEM_POWER_STATUS_EX

[DllImport("coredll")]
public static extern uint GetSystemPowerStatusEx

[DllImport("coredll")]
public static extern uint GetSystemPowerStatusEx2

'VB
Public Class SYSTEM_POWER_STATUS_EX2

Public Class SYSTEM_POWER_STATUS_EX

<DllImport("coredll")>
Public Shared Function GetSystemPowerStatusEx

<DllImport("coredll")>
Public Shared Function GetSystemPowerStatusEx2

SIP

The SIP class provides methods for controlling the state of the Software Input Panel. During execution of the test, the SIP is temporarily displayed and then removed. Figure 7 shows sample output from the SIP test.

Figure 7. SIP Test Results.

The SIP class implements the following classes and functions.

C#
[DllImport("coredll.dll")]
public extern static void SipShowIM

[DllImport("coredll.dll")]
public extern static uint SipStatus();

public struct RECT

public class SIPINFO

[DllImport("coredll.dll")]
public extern static uint SipGetInfo

[DllImport("coredll.dll")]
public extern static uint SipSetInfo

'VB
<DllImport("coredll.dll")>
Public Shared Sub SipShowIM

<DllImport("coredll.dll")>
Public Shared Function SipStatus() As Integer

Public Structure RECT

Public Class SIPINFO

<DllImport("coredll.dll")>
Public Shared Function SipGetInfo

<DllImport("coredll.dll")>
Public Shared Function SipSetInfo

System Reset

The SystemReset class provides a mechanism for executing kernel IO controls and specifically demonstrates how to soft reset a device. The user is provided with a warning and the chance to back out, as shown in Figure 8.

Figure 8. System Reset Test Warning.

The SystemReset class implements the following function.

C#
[DllImport("Coredll.dll")]
public extern static uint KernelIoControl

'VB
<DllImport("Coredll.dll")>
Public Shared Function KernelIoControl

System Time

The SystemTime class provides methods for accessing and setting the system time of the device. The test accesses the time, increments it by one hour, then sets it back to the original. Figure 9 shows sample output from the System Time test.

Figure 9. System Time Test Results.

The SystemTime class implements the following structures and functions.

//C#
public struct SYSTEMTIME 

[DllImport("coredll.dll")]
public extern static void GetSystemTime

[DllImport("coredll.dll")]
public extern static uint SetSystemTime

'VB
Public Structure SYSTEMTIME

<DllImport("coredll.dll")>
Public Shared Sub GetSystemTime

<DllImport("coredll.dll")>
Public Shared Function SetSystemTime

Wave Out

The WaveOut class provides methods and classes for playing a .wav file. Due to the complexity of the Waveform Audio Interface, a WaveFile class is provided which encapsulates all of the functionality required to use the WaveOut P/Invoke functions. This class provides a mechanism for streaming audio via a specified buffer size. For more information on this sample, see the article "Recording and Playing Sound with the Waveform Audio Interface". Figure 10 shows sample output from the Wave Out test.

Figure 10. Wave Out Test Results.

Note: A helper class named Wave is provided as a common interface to the .wav audio format for both the WaveIn and WaveOut classes.

The following classes and functions are implemented in the WaveOut class.

//C#
[DllImport ("coredll.dll")]
protected static extern int waveOutGetNumDevs();

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveOutOpen

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutGetVolume

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutSetVolume

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveOutPrepareHeader

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveOutWrite

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveOutUnprepareHeader

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutClose

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutReset

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutPause

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutRestart

protected class MMTIME

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutGetPosition

protected class WAVEOUTCAPS

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveOutGetDevCaps

'VB
<DllImport("coredll.dll")>
Protected Shared Function waveOutGetNumDevs() As Integer

<DllImport("coredll.dll")>
Private Shared Function waveOutOpen

<DllImport("coredll.dll")>
Protected Shared Function waveOutGetVolume

<DllImport("coredll.dll")>
Protected Shared Function waveOutSetVolume

<DllImport("coredll.dll")>
Private Shared Function waveOutPrepareHeader

<DllImport("coredll.dll")>
Private Shared Function waveOutWrite

<DllImport("coredll.dll")>
Private Shared Function waveOutUnprepareHeader

<DllImport("coredll.dll")>
Protected Shared Function waveOutClose

<DllImport("coredll.dll")>
Protected Shared Function waveOutReset

<DllImport("coredll.dll")>
Protected Shared Function waveOutPause

<DllImport("coredll.dll")>
Protected Shared Function waveOutRestart

Protected Class MMTIME

<DllImport("coredll.dll")>
Protected Shared Function waveOutGetPosition

Protected Class WAVEOUTCAPS

<DllImport("coredll.dll")>
Protected Shared Function waveOutGetDevCaps

Wave In

The WaveIn class provides methods and classes for recording a .wav file. Due to the complexity of the Waveform Audio Interface, a WaveFile class is provided which encapsulates all of the functionality required to use the WaveIn P/Invoke functions. For more information on this sample, see the article "Recording and Playing Sound with the Waveform Audio Interface". Figure 11 shows sample output from the Wave In test.

Figure 11. Wave In Test Results.

Note: A helper class named Wave is provided as a common interface to the .wav audio format for both the WaveIn and WaveOut classes.

The following classes and functions are implemented in the WaveIn class.

C#
[DllImport ("coredll.dll")]
protected static extern int waveInGetNumDevs();

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveInOpen

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveInPrepareHeader

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveInUnprepareHeader

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveInClose

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveInReset

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveInStart

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveInStop

[DllImport ("coredll.dll")]
private static extern Wave.MMSYSERR waveInAddBuffer

protected class WAVEINCAPS

[DllImport ("coredll.dll")]
protected static extern Wave.MMSYSERR waveInGetDevCaps

'VB
<DllImport("coredll.dll")>
Protected Shared Function waveInGetNumDevs() As Integer
End Function

<DllImport("coredll.dll")>
Private Shared Function waveInOpen

<DllImport("coredll.dll")>
Private Shared Function waveInPrepareHeader

<DllImport("coredll.dll")>
Private Shared Function waveInUnprepareHeader

<DllImport("coredll.dll")>
Protected Shared Function waveInClose

<DllImport("coredll.dll")>
Protected Shared Function waveInReset

<DllImport("coredll.dll")>
Protected Shared Function waveInStart

<DllImport("coredll.dll")>
Protected Shared Function waveInStop

<DllImport("coredll.dll")>
Private Shared Function waveInAddBuffer

Protected Class WAVEINCAPS

<DllImport("coredll.dll")>
Protected Shared Function waveInGetDevCaps

Windows

The Windows class provides methods for accessing the handle of a window, as well as controlling the state of the window. The test sample creates an invisible Form and then accesses its handle via the various methods. Figure 12 shows sample output from the Windows test.

Figure 12. Windows Test Results

The following functions are implemented by the Windows class.

//C#
[DllImport("coredll.dll")]
public static extern IntPtr GetCapture();

[DllImport("CoreDll")]
public static extern IntPtr FindWindow

[DllImport("CoreDll")]
public static extern bool ShowWindow

'VB
<DllImport("coredll.dll")>
Public Shared Function GetCapture() As IntPtr

<DllImport("CoreDll")>
Public Shared Function FindWindow

<DllImport("CoreDll")>
Public Shared Function ShowWindow

Registry

The Registry class provides methods for accessing the registry on the device. The test sample creates a key and two values, retrieves the values, deletes the values, and then deletes the key. Figure 13 shows sample output from the Registry test.

Figure 13. Registry test results.

The following functions are implemented by the Registry class

//C#
[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegCreateKeyEx

[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegDeleteKey

[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegOpenKeyEx

[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegQueryValueEx

[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegSetValueEx

[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegDeleteValue

[DllImport("coredll.dll", SetLastError=true)]
public static extern int RegCloseKey

'VB
<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegCreateKeyEx

<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegDeleteKey

<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegOpenKeyEx

<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegQueryValueEx

<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegSetValueEx

<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegDeleteValue

<DllImport("coredll.dll", SetLastError:=True)> _
Public Shared Function RegCloseKey

Phone

The Phone class provides methods for accessing the Phone API on Pocket PC Phone Edition devices. The test sample accesses the call log and attempts to call the number 555-5555. Figure 14 shows sample output from the Phone test.

Figure 14. Phone test results.

The following functions are implemented by the Phone class

//C#
[DllImport("Phone.dll")]
private static extern int PhoneMakeCall

[DllImport("Phone.dll")]
private static extern void PhoneOpenCallLog

[DllImport("Phone.dll")]
private static extern void PhoneCloseCallLog

[DllImport("Phone.dll")]
private static extern void PhoneGetCallLogEntry

[DllImport("Phone.dll")]
private static extern void PhoneSeekCallLog

'VB
<DllImport("Phone.dll")> _
Private Shared Function PhoneMakeCall

<DllImport("Phone.dll")> _
Private Shared Sub PhoneOpenCallLog

<DllImport("Phone.dll")> _
Private Shared Sub PhoneCloseCallLog

<DllImport("Phone.dll")> _
Private Shared Sub PhoneGetCallLogEntry

<DllImport("Phone.dll")> _
Private Shared Sub PhoneSeekCallLog

Folders

The Folders class provides methods for accessing folder information. The test sample enumerates all storage devices on the device, retrieves the path to the Programs folder, and determines the available space of the Programs folder. Figure 15 shows sample output from the Folders test.

Figure 15. Folders test results.

The following functions are implemented by the Folder class

//C#
[DllImport("Coredll.dll")]
static extern int SHGetSpecialFolderPath

[DllImport("coredll.dll")]
public static extern bool GetDiskFreeSpaceEx

'VB
<DllImport("Coredll.dll")> _
Shared Function SHGetSpecialFolderPath

<DllImport("coredll.dll")> _
Public Shared Function GetDiskFreeSpaceEx

MMS彩信是怎么炼成地

teky — Tue, 12 Sep 2006 07:36:00 GMT

sorry，原文地址teky找不到了，网上都转的，不知道是哪位大大原创，国际惯例，先感谢一下。

一、概述

MMS彩信大家都看到过，或者都编辑过。在这里，利用一系列的文章来说明彩信的编辑、发送和接收的过程。首先这里，简单描述一下彩信的编辑过程。这是彩信的第一步。

二、MMS的表述（presentation）语言——SMIL概述

MMS由一系列类似于“power point style”类型的slide组成，由这些slide来组织各种格式的文本、音频、视频信息。这些我们在发送或者接受彩信的时候都有切身的体会，就不说了。

为了把这些多媒体信息组织到一起，通过网络发送，并且这些信息在接收者那里能够保证按照发送者的样式进行播放。这里就需要采用一种技术，用于描述彩信的组织和播放方法。这种方法就是利用SMIL语言。看过这个语言的规范之后，我想大部分熟悉HTML和XML的人都会会心的笑了，的确，这就是SMIL语言。

MMS使用SMIL（Synchronized Multimedia Integration Language）的子集作为表述语言，SMIL是由W3C（world wide web consortium）制定的基于XML的表述语言标准（可以参见附录中之处的RFC文档）。相当于HTML之于web。SMIL语言可以控制多媒体对象的layout和timing（播放时间）。

在初期，MMS只使用了SMIL的简单基础子集，称作“MMS SMIL”。每个MMS信息都是由SMIL表述语言文件组成。在这个文件中所有的slide有相同的layout。每个slide至少包含两个region，一个包含文本，一个包含图像。事实上，每个slide都是一个frame，每个frame包含layout和指向内容（text、images、audio、video）的索引。每个slide的播放周期以秒计算，在每个slide的内部，文本和图像的播放时间可以单独设定。

由于每个移动设备的尺寸不尽相同，所以SMIL被设计成可以根据终端的不同表现形式作以重新安排。简单说来，SMIL具有下列特点：

§来自于W3C的规范定义

§ SMIL只是简单地限定了各种message元素在何时、在什么地方显式

§ SMIL文件以<smil>标记开始，接下来是head和body标记，最后以</smil>结束

§ Head标记元素限定了

§Body标记元素限定了被插入内容的参考索引（references），并且限定了何时、何地播放以及每个元素播放的时间。

下面一段文字来自于IBM，说明了在MMS之外SMIL的广泛用途。

SMIL 2.0 是同步多媒体集成语言（Synchronized Multimedia Integration Language），它已开始成为将多媒体集成到 Web 内容的重要新方法。SMIL 提供基于 XML 的方法来控制多媒体元素的定时和表示，它已开始获得众多大的软件供应商和工具制作商的支持，这使得开发人员使用它变得越来越容易。

SMIL 支持已开始成为 Adobe、Microsoft 以及（也许是最重要的）媒体传递领先者 Real Networks 支持的技术之一。众多较小的供应商已开始提供 SMIL 创作工具和播放器。

在不久的将来，随着对当前 2.0 规范支持的增长，对于任何在工作中需要某种形式的多媒体资产控制的开发人员，使用 SMIL 将成为他们的标准策略。如果把正在增长的工具创建者的名单作为某种指示，那么用 SMIL 构建表示也会变得更简单。

正如前面提到的那样，最广泛的 SMIL 2.0 实现可能来自 Real Networks。RealOne Player 支持 SMIL 2.0 语言概要文件（SMIL 2.0 Language Profile），它结合了 SMIL 支持的大多数（尽管不是全部）模块。除了支持大多数标准 SMIL 模块以外，RealNetworks 还开发了自己的几个 SMIL 扩展。要使用这些扩展，开发人员必须遵守标准 XML 声明.

通过使用少量的一系列基于 SMIL 的 XML 元素和属性，Microsoft 的 HTML+TIME 给 HTML 页面添加了定时和多媒体支持。为了给 HTML 文档添加定时，开发人员要向现有的 HTML 元素添加新属性。创建新元素是为了使向 HTML 页面添加媒体变得简单。

为了使用任何 HTML+TIME 元素，开发人员必须在 HTML 标记中声明 XML 名称空间 t：

不同于上述这两个供应商，大多数创作工具和播放器开发人员主要分为两种，

§ 一种是只关注 SMIL 的完整台式机部署

§ 另一种至少要关心一下用于占用资源较小的移动设备的基本 SMIL 2.0 子集。

此外，随着无线网络的发展，关注 MMS 部署的 SMIL 播放器应该对 SMIL 创作有新的考虑。

三、 SMIL简单示例

下面给出了一个MMS消息的SMIL示例：

<smil>

<head>

<root-layout width="160" height="120"/>

<region id="Image" width="100%"

height="80" left="0" top="0" />

<region id="Text" width="100%"

height="40" left="0" top="80" />

</layout>

</head>

<body>

</par>

</par>

</body>

</smil>

具体的SMIL描述语言的解释可以参见附录的参考文档，那里给出了每种标记的解释说明。

至于在手机软件上实现，也不是很困难的事情。想想看。

利用结构数组，把所有的MMS中的slide存储到其中，最后，结合SMIL语言的规范，把彩信

打包成上述文件的格式，注意，这里，并不需要把具体的多媒体文件内容添加到smil文件中，只需要加在smil文件中，作为附件就可以了。具体的数据的加载，请看下一篇——MMS的打包部分吧！

参考资料：

Nokia:

[N1] How_To_Create_MMS_Services.pdf http://www.forum.nokia.com

[N2] MMSCenterAppDevGuide.pdf http://www.forum.nokia.com

OMA:

　　[O1] WAP-205-MMSArchOverview-20010425-a.pdf

一、MMS的封装（Encapsulation）——MIME

对于使用SMIL语言描述的MMS，在通过无线网络发送的时候，我们必须通过某种方式把SMIL和附属的内容包装在一起，一边能够以一个unit（整体）的形式发送出去，以便SMIL文件各个部分内容的reference变得有效。

这个解决的办法就是MIME（Multipart Internet Mail Extensions）规范，这个规范的最初作用是在email的plain text的主体中加入不同的内容。比如说，发送带有附件的email，这个时候你就使用了MIME的规范。MIME负责把所有的独立的文本、图像、声音、视频内容以及SMIL文件本身捆绑在一起，这个规范称为MIME Encapsulation Aggregate Documents，用于告诉接受的终端这个MMS的内容是相互相关（related to one another）并且相互参考的（referenced to one another）。

1. MIME封装示例

下面是根据RFC文档给出的MIME的封装示例：

Content-Type: multipart/related; boundary="boundary-example";

type="text/html"

--boundary-example

Content-Type: text/html; charset="US-ASCII"

... ... <IMG SRC="fiction1/fiction2"> ... ...

... ... <IMG SRC="cid:97116092811xyz@foo.bar.net"> ... ...

--boundary-example

Content-Type: image/gif

Content-ID: <97116092511xyz@foo.bar.net>

Content-Location: fiction1/fiction2

--boundary-example

Content-Type: image/gif

Content-ID: <97116092811xyz@foo.bar.net>

Content-Location: fiction1/fiction3

--boundary-example--

§ Content-type

位于信息头部的content-type用于通知接收的终端消息的各个不同部分的内容是相互关联的、并且可能是相互索引的（refer to one another）。

§Boundary

Boundary用于分割各个不同的消息part。第一个部分是一个html类型的消息，这里只是取得了相关的部分。第二和第三部分省略了实际的images图像的实体。

§Location and ID

在HTML文本部分我们可以看到，我们可以利用两种方式来索引消息内容的不同部分。这两种不同的方式是 content-ID 和 content – Location。

如果一部分的消息体想通过content-ID指向（refer to）另外一部分的消息体，可以使用“CID”.

关于MIME的部分的信息可以参考附录中列出的RFC文档（RFC2387和RFC2357）。

2. 利用MIME封装MMS的示例

下面给出一个利用MIME封装MMS的示例：

Content-Type: multipart/related;

Type="application/smil"; Start="<AAAA>";boundary="----=_Part_24362_271418.1110357304160"

------=_Part_24362_271418.1110357304160

content-type: text/x-vCalendar;Charset=UTF-8;Name="slide1.vcs"

content-id: <slide1.vcs>

content-location: slide1.vcs

Content-Transfer-Encoding: base64

QkVHSU46VkNBTEVOREFSDQpWRVJTSU9OOjEuMA0KQkVHSU46VkVWRU5UDQpEVFNUQVJUOjIwMDUw

MzA4VDA5MDAwMFoNCkRURU5EOjIwMDUwMzA4VDEwMDAwMFoNClNVTU1BUlk7Q0hBUlNFVD1VVEYt

ODtFTkNPRElORz1RVU9URUQtUFJJTlRBQkxFOuaYr+WQpg0KQ0FURUdPUklFUztDSEFSU0VUPVVU

Ri04O0VOQ09ESU5HPVFVT1RFRC1QUklOVEFCTEU6QVBQT0lOVE1FTlRTDQpFTkQ6VkVWRU5UDQpF

TkQ6VkNBTEVOREFSDQo=

------=_Part_24362_271418.1110357304160

content-type: application/smil;Charset=UTF-8;Name="20050309163706.smil"

content-id: <AAAA>

Content-Transfer-Encoding: base64

PHNtaWw+PGhlYWQ+PGxheW91dD48cm9vdC1sYXlvdXQgd2lkdGg9IjE3NiIgaGVpZ2h0PSIxNzQi

Lz48cmVnaW9uIGlkPSJmdWxsIiB3aWR0aD0iMTc2IiBoZWlnaHQ9IjE3NCIgbGVmdD0iMCIgdG9w

PSIwIiAvPjwvbGF5b3V0PjwvaGVhZD48Ym9keT48cGFyIGR1cj0iNXMiPjx0ZXh0IHNyYz0ic2xp

ZGUxLnZjcyIgcmVnaW9uPSJmdWxsIiAvPjwvcGFyPjwvYm9keT48L3NtaWw+

------=_Part_24362_271418.1110357304160--

下图给出的图示说明各个部分之间的关系：

3. 一个完整的MIME封装MMS示例

下表给出了一个完整的MIME封装MMS的示例：

MIME Object
Date: Fri, 14 Dec 2001 15:13:21 -0500 (EST) X-Mms-Expiry: Thu, 20 Dec 2001 21:52:25 -0500 (EST) X-Mms-Delivery-Time: Wed, 19 Dec 2001 21:52:25 -0800 (PST) X-Mms-Priority: Normal X-Mms-Sender-visibility: Show X-Mms-Message-Class: Personal X-Mms-Delivery-report: yes X-Mms-3GPP-MM3-Version: 4.3.0 From: mms-email-sample@sample-email.ericsson.com To: +12345@mmc.sample-mms.ericsson.com Subject: Sample SMIL Mime-Version: 1.0 Content-Type: multipart/related; boundary="---- =_MIME_Boundary_MMS_Reference_Sample_001"	MIME Headers
"----=_MIME_Boundary_MMS_Reference_Sample_001"	MIME Start boundary
Content-ID: <index.smil> Content-Type: application/smil; charset="US-ASCII"; name=index.smil <smil> <head> <layout><root-layout/> <region id="region1_2" top="0" left="0" height="100%" width="100%"/> <region id="region1_1" top="0" left="0" height="100%" width="100%"/> </layout> </head> <body> <par dur="2000ms"> <text src="Cid:image" region="region1_2"/> </par> <par dur="2000ms"> <img src="Cid:txt" region="region1_1" fit="fill"/> </par> </body> </smil>	SMIL document
"----=_MIME_Boundary_MMS_Reference_Sample_001"	MIME boundary
Content-Type: text/plain; name=mms.txt Content-Transfer-Encoding: 7bit Content-ID: <txt> Content-Disposition: attachment; filename=mms.txt This is a sample MMS message, for use as a reference.	Text Document
"----=_MIME_Boundary_MMS_Reference_Sample_001"	MIME boundary
Content-Type: image/gif; name=sample.gif Content-Transfer-Encoding: base64 Content-ID: <image> Content-Disposition: attachment; filename=sample.gif R0lGODlhZQBQAPcAAOYeAClUpyAtb/XNjlo8RqoUFHSa2ZCKjHiCWrzf/2iQ1J m66Yeq4cXm/6ys <entire encoded image not shown for the sake of brevity> kBiJkjiJlFiJlniJmJiJmriJnNiJnviJoBiKogh5AQEAOw==	Image
"----=_MIME_Boundary_MMS_Reference_Sample_001"	MIME boundary

二、MMS的MIME结构

综述来说，每个MMS信息按照MIME规范的基本结构如下图所示：

从图示看出，每个MMS都是由MMS Header和MMS Body组成，MMS Header根据WAP-209协议和RFC2387的规定，由一系列的域组成，下表列出了部分的域（给出的示范的内容表示），其中有些是强制必须实现的(用黑体表示)。

X-Mms-Message-Type	m-send-req
X-Mms-Transaction-ID	1234
X-Mms-MMS-Version	1.0
Date	星期五, 18 三月 2005 06:43:40 GMT
From	mms-editor@toolkit
To	33333333333333
Cc	33333333333333
Bcc
Subject	test
X-Mms-Message-Class	Personal
X-Mms-Expiry	星期六, 19 三月 2005 06:43:40 GMT
X-Mms-Delivery-Time	星期五, 18 三月 2005 06:43:40 GMT
X-Mms-Priority	low
X-Mms-Sender-Visibility	Show
X-Mms-Delivery-Report	No
X-Mms-Read-Reply	No
Content-Type	application/vnd.wap.multipart.related; start="<presentation-part>" type="application/smil"

1. MMS承载的内容elements

MMS只是用于发送消息的载体，根据规范，我们可以发送各种不同类型的内容元素。这些内容元素组成MMS中各个不同的部分。根据元素类型的不容，每个part Header部分的content-type也不尽相同。下面给以示例：

文本：文本包含很多类型，普通文本的类型可以表示为——text/plain，而vcard类型的文本表示为text/x-vCard。
静态图像：静态图像存在各种不同的类型，根据不同的编码方式由不同的后缀名表示。如image/gif 和image/jpeg。

音效是什么呢？没有介绍，应该是audio/mid 吧..

OldKitty(老猫)关于mms的一个回复也把它贴在这里：

MMS概括来说包括两大部分的内容:内容和传输.其中内容包括上面各位说的文字/图象/声音等等,而且有多种不同的格式(content type and content format),而这些内容可以通过SMIL组合起来,控制显示/播放的顺序和位置等.
传输则是我上面所说的那些,理论上讲可以采用多种方式,因为3gpp只是定义了需要用到的各个源语及其功能和可包含的域,但并未定义具体的格式,因此wapforum就制定了在wap的基础上如何实现MMS的规范,其中具体定义了各个源语的格式.所以目前来说,见到的手机上的MMS实现应该都是基于wap的.当然了,由于wsp与http有着密切的联系和基本的对应关系,因此利用http也可以获取和发送mms,在wap2.0中其实就直接可以使用针对无线修改过的http(如果我没有记错的话),而wsp/wtp/wtls/wdp等协议已经退居二线了

Teky说：

网上的开发mms彩信发送/接受的资料还是比较少的，也不全面，据说相关技术被几家大公司垄断，和和，不知真假，反正要真正写出实现代码还是有很大困难的。
在这里佩服下老兄James lee ，能在这么短时间内写出来，还真是强悍。
不过目前少了mms中的音效部分，不知道在多媒体包头中音效的包头要如何来打包，继续研究...

P2P之UDP穿透NAT的原理与实现

teky — Fri, 14 Apr 2006 08:43:00 GMT

P2P之UDP穿透NAT的原理与实现

抱歉，网上这片文章太多了，所以teky找不到原作者了，在此向作者表示敬意和感谢

论坛上经常有对P2P原理的讨论，但是讨论归讨论，很少有实质的东西产生（源代码）。呵呵，在这里我就用自己实现的一个源代码来说明UDP穿越NAT的原理。

首先先介绍一些基本概念：
    NAT(Network Address Translators)，网络地址转换：网络地址转换是在IP地址日益缺乏的情况下产生的，它的主要目的就是为了能够地址重用。NAT分为两大类，基本的NAT和NAPT(Network Address/Port Translator)。
    最开始NAT是运行在路由器上的一个功能模块。

    最先提出的是基本的NAT，它的产生基于如下事实：一个私有网络（域）中的节点中只有很少的节点需要与外网连接（呵呵，这是在上世纪90年代中期提出的）。那么这个子网中其实只有少数的节点需要全球唯一的IP地址，其他的节点的IP地址应该是可以重用的。
    因此，基本的NAT实现的功能很简单，在子网内使用一个保留的IP子网段，这些IP对外是不可见的。子网内只有少数一些IP地址可以对应到真正全球唯一的IP地址。如果这些节点需要访问外部网络，那么基本NAT就负责将这个节点的子网内IP转化为一个全球唯一的IP然后发送出去。(基本的NAT会改变IP包中的原IP地址，但是不会改变IP包中的端口)
    关于基本的NAT可以参看RFC 1631

    另外一种NAT叫做NAPT，从名称上我们也可以看得出，NAPT不但会改变经过这个NAT设备的IP数据报的IP地址，还会改变IP数据报的TCP/UDP端口。基本NAT的设备可能我们见的不多（呵呵，我没有见到过），NAPT才是我们真正讨论的主角。看下图：
                                Server S1
                         18.181.0.31:1235
                                      |
          ^ Session 1 (A-S1) ^      |
          | 18.181.0.31:1235 |      |
          v 155.99.25.11:62000 v      |
                                      |
                                     NAT
                                 155.99.25.11
                                      |
          ^ Session 1 (A-S1) ^      |
          | 18.181.0.31:1235 |      |
          v   10.0.0.1:1234    v      |
                                      |
                                   Client A
                                10.0.0.1:1234
    有一个私有网络10.*.*.*，Client A是其中的一台计算机，这个网络的网关（一个NAT设备）的外网IP是155.99.25.11(应该还有一个内网的IP地址，比如10.0.0.10)。如果Client A中的某个进程（这个进程创建了一个UDP Socket,这个Socket绑定1234端口）想访问外网主机18.181.0.31的1235端口，那么当数据包通过NAT时会发生什么事情呢？
    首先NAT会改变这个数据包的原IP地址，改为155.99.25.11。接着NAT会为这个传输创建一个Session（Session是一个抽象的概念，如果是TCP，也许Session是由一个SYN包开始，以一个FIN包结束。而UDP呢，以这个IP的这个端口的第一个UDP开始，结束呢，呵呵，也许是几分钟，也许是几小时，这要看具体的实现了）并且给这个Session分配一个端口，比如62000，然后改变这个数据包的源端口为62000。所以本来是（10.0.0.1:1234->18.181.0.31:1235）的数据包到了互联网上变为了（155.99.25.11:62000->18.181.0.31:1235）。
    一旦NAT创建了一个Session后，NAT会记住62000端口对应的是10.0.0.1的1234端口，以后从18.181.0.31发送到62000端口的数据会被NAT自动的转发到10.0.0.1上。（注意：这里是说18.181.0.31发送到62000端口的数据会被转发，其他的IP发送到这个端口的数据将被NAT抛弃）这样Client A就与Server S1建立以了一个连接。

    呵呵，上面的基础知识可能很多人都知道了，那么下面是关键的部分了。
    看看下面的情况：
    Server S1                                     Server S2
18.181.0.31:1235                              138.76.29.7:1235
        |                                             |
        |                                             |
        +----------------------+----------------------+
                               |
   ^ Session 1 (A-S1) ^      |      ^ Session 2 (A-S2) ^
   | 18.181.0.31:1235 |      |      | 138.76.29.7:1235 |
   v 155.99.25.11:62000 v      |      v 155.99.25.11:62000 v
                               |
                            Cone NAT
                          155.99.25.11
                               |
   ^ Session 1 (A-S1) ^      |      ^ Session 2 (A-S2) ^
   | 18.181.0.31:1235 |      |      | 138.76.29.7:1235 |
   v   10.0.0.1:1234    v      |      v   10.0.0.1:1234    v
                               |
                            Client A
                         10.0.0.1:1234
    接上面的例子，如果Client A的原来那个Socket(绑定了1234端口的那个UDP Socket)又接着向另外一个Server S2发送了一个UDP包，那么这个UDP包在通过NAT时会怎么样呢？
    这时可能会有两种情况发生，一种是NAT再次创建一个Session，并且再次为这个Session分配一个端口号（比如：62001）。另外一种是NAT再次创建一个Session，但是不会新分配一个端口号，而是用原来分配的端口号62000。前一种NAT叫做Symmetric NAT，后一种叫做Cone NAT。我们期望我们的NAT是第二种，呵呵，如果你的NAT刚好是第一种，那么很可能会有很多P2P软件失灵。（可以庆幸的是，现在绝大多数的NAT属于后者，即Cone NAT）

    好了，我们看到，通过NAT,子网内的计算机向外连结是很容易的（NAT相当于透明的，子网内的和外网的计算机不用知道NAT的情况）。
    但是如果外部的计算机想访问子网内的计算机就比较困难了（而这正是P2P所需要的）。
    那么我们如果想从外部发送一个数据报给内网的计算机有什么办法呢？首先，我们必须在内网的NAT上打上一个“洞”（也就是前面我们说的在NAT上建立一个Session），这个洞不能由外部来打，只能由内网内的主机来打。而且这个洞是有方向的，比如从内部某台主机（比如：192.168.0.10）向外部的某个IP(比如：219.237.60.1)发送一个UDP包，那么就在这个内网的NAT设备上打了一个方向为219.237.60.1的“洞”，（这就是称为UDP Hole Punching的技术）以后219.237.60.1就可以通过这个洞与内网的192.168.0.10联系了。（但是其他的IP不能利用这个洞）。

呵呵，现在该轮到我们的正题P2P了。有了上面的理论，实现两个内网的主机通讯就差最后一步了：那就是鸡生蛋还是蛋生鸡的问题了，两边都无法主动发出连接请求，谁也不知道谁的公网地址，那我们如何来打这个洞呢？我们需要一个中间人来联系这两个内网主机。
现在我们来看看一个P2P软件的流程，以下图为例：

    首先，Client A登录服务器，NAT A为这次的Session分配了一个端口60000，那么Server S收到的Client A的地址是202.187.45.3:60000，这就是Client A的外网地址了。同样，Client B登录Server S，NAT B给此次Session分配的端口是40000，那么Server S收到的B的地址是187.34.1.56:40000。
    此时，Client A与Client B都可以与Server S通信了。如果Client A此时想直接发送信息给Client B，那么他可以从Server S那儿获得B的公网地址187.34.1.56:40000，是不是Client A向这个地址发送信息Client B就能收到了呢？答案是不行，因为如果这样发送信息，NAT B会将这个信息丢弃（因为这样的信息是不请自来的，为了安全，大多数NAT都会执行丢弃动作）。现在我们需要的是在NAT B上打一个方向为202.187.45.3（即Client A的外网地址）的洞，那么Client A发送到187.34.1.56:40000的信息,Client B就能收到了。这个打洞命令由谁来发呢，呵呵，当然是Server S。
    总结一下这个过程：如果Client A想向Client B发送信息，那么Client A发送命令给Server S，请求Server S命令Client B向Client A方向打洞。呵呵，是不是很绕口，不过没关系，想一想就很清楚了，何况还有源代码呢（侯老师说过：在源代码面前没有秘密 8）），然后Client A就可以通过Client B的外网地址与Client B通信了。

    注意：以上过程只适合于Cone NAT的情况，如果是Symmetric NAT，那么当Client B向Client A打洞的端口已经重新分配了，Client B将无法知道这个端口（如果Symmetric NAT的端口是顺序分配的，那么我们或许可以猜测这个端口号，可是由于可能导致失败的因素太多，我们不推荐这种猜测端口的方法）。

    下面是一个模拟P2P聊天的过程的源代码，过程很简单，P2PServer运行在一个拥有公网IP的计算机上，P2PClient运行在两个不同的NAT后（注意，如果两个客户端运行在一个NAT后，本程序很可能不能运行正常，这取决于你的NAT是否支持loopback translation，详见http://midcom-p2p.sourceforge.net/draft-ford-midcom-p2p-01.txt，当然，此问题可以通过双方先尝试连接对方的内网IP来解决，但是这个代码只是为了验证原理，并没有处理这些问题），后登录的计算机可以获得先登录计算机的用户名，后登录的计算机通过send username message的格式来发送消息。如果发送成功，说明你已取得了直接与对方连接的成功。
    程序现在支持三个命令：send , getu , exit

    send格式：send username message
    功能：发送信息给username

    getu格式：getu
    功能：获得当前服务器用户列表

    exit格式：exit
    功能：注销与服务器的连接（服务器不会自动监测客户是否吊线）

    代码很短，相信很容易懂，如果有什么问题，可以给我发邮件zhouhuis22@sina.com 或者在CSDN上发送短消息。同时，欢迎转发此文，但希望保留作者版权8-）。

    最后感谢CSDN网友 PiggyXP 和 Seilfer的测试帮助

P2PServer.c

/* P2P 程序服务端
*
* 文件名：P2PServer.c
*/
#pragma comment(lib, "ws2_32.lib")

#include "windows.h"
#include "..\proto.h"
#include "..\Exception.h"

UserList ClientList;

void InitWinSock()
{
WSADATA wsaData;

if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
printf("Windows sockets 2.2 startup");
throw Exception("");
}
else{
printf("Using %s (Status: %s)\n",
   wsaData.szDescription, wsaData.szSystemStatus);
printf("with API versions %d.%d to %d.%d\n\n",
   LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion),
   LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion));

}
}

SOCKET mksock(int type)
{
SOCKET sock = socket(AF_INET, type, 0);
if (sock < 0)
{
printf("create socket error");
throw Exception("");
}
return sock;
}

stUserListNode GetUser(char *username)
{
for(UserList::iterator UserIterator=ClientList.begin();
      UserIterator!=ClientList.end();
       ++UserIterator)
{
if( strcmp( ((*UserIterator)->userName), username) == 0 )
   return *(*UserIterator);
}
throw Exception("not find this user");
}

int main(int argc, char* argv[])
{
try{
InitWinSock();

SOCKET PrimaryUDP;
PrimaryUDP = mksock(SOCK_DGRAM);

sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port= htons(SERVER_PORT);
local.sin_addr.s_addr = htonl(INADDR_ANY);
int nResult=bind(PrimaryUDP,(sockaddr*)&local,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
throw Exception("bind error");

sockaddr_in sender;
stMessage recvbuf;
memset(&recvbuf,0,sizeof(stMessage));

// 开始主循环.
// 主循环负责下面几件事情:
// 一:读取客户端登陆和登出消息,记录客户列表
// 二:转发客户p2p请求
for(;;)
{
   int dwSender = sizeof(sender);
   int ret = recvfrom(PrimaryUDP, (char *)&recvbuf, sizeof(stMessage), 0, (sockaddr *)&sender, &dwSender);
   if(ret <= 0)
   {
    printf("recv error");
    continue;
   }
   else
   {
    int messageType = recvbuf.iMessageType;
    switch(messageType){
    case LOGIN:
     {
      // 将这个用户的信息记录到用户列表中
      printf("has a user login : %s\n", recvbuf.message.loginmember.userName);
      stUserListNode *currentuser = new stUserListNode();
      strcpy(currentuser->userName, recvbuf.message.loginmember.userName);
      currentuser->ip = ntohl(sender.sin_addr.S_un.S_addr);
      currentuser->port = ntohs(sender.sin_port);

      ClientList.push_back(currentuser);

      // 发送已经登陆的客户信息
      int nodecount = (int)ClientList.size();
      sendto(PrimaryUDP, (const char*)&nodecount, sizeof(int), 0, (const sockaddr*)&sender, sizeof(sender));
      for(UserList::iterator UserIterator=ClientList.begin();
        UserIterator!=ClientList.end();
        ++UserIterator)
      {
       sendto(PrimaryUDP, (const char*)(*UserIterator), sizeof(stUserListNode), 0, (const sockaddr*)&sender, sizeof(sender));
      }

      break;
     }
    case LOGOUT:
     {
      // 将此客户信息删除
      printf("has a user logout : %s\n", recvbuf.message.logoutmember.userName);
      UserList::iterator removeiterator = NULL;
      for(UserList::iterator UserIterator=ClientList.begin();
       UserIterator!=ClientList.end();
       ++UserIterator)
      {
       if( strcmp( ((*UserIterator)->userName), recvbuf.message.logoutmember.userName) == 0 )
       {
        removeiterator = UserIterator;
        break;
       }
      }
      if(removeiterator != NULL)
       ClientList.remove(*removeiterator);
      break;
     }
    case P2PTRANS:
     {
      // 某个客户希望服务端向另外一个客户发送一个打洞消息
      printf("%s wants to p2p %s\n",inet_ntoa(sender.sin_addr),recvbuf.message.translatemessage.userName);
      stUserListNode node = GetUser(recvbuf.message.translatemessage.userName);
      sockaddr_in remote;
      remote.sin_family=AF_INET;
      remote.sin_port= htons(node.port);
      remote.sin_addr.s_addr = htonl(node.ip);

      in_addr tmp;
      tmp.S_un.S_addr = htonl(node.ip);
      printf("the address is %s,and port is %d\n",inet_ntoa(tmp), node.port);

      stP2PMessage transMessage;
      transMessage.iMessageType = P2PSOMEONEWANTTOCALLYOU;
      transMessage.iStringLen = ntohl(sender.sin_addr.S_un.S_addr);
      transMessage.Port = ntohs(sender.sin_port);

      sendto(PrimaryUDP,(const char*)&transMessage, sizeof(transMessage), 0, (const sockaddr *)&remote, sizeof(remote));

      break;
     }

    case GETALLUSER:
     {
      int command = GETALLUSER;
      sendto(PrimaryUDP, (const char*)&command, sizeof(int), 0, (const sockaddr*)&sender, sizeof(sender));

int nodecount = (int)ClientList.size();
sendto(PrimaryUDP, (const char*)&nodecount, sizeof(int), 0, (const sockaddr*)&sender, sizeof(sender));

      for(UserList::iterator UserIterator=ClientList.begin();
        UserIterator!=ClientList.end();
        ++UserIterator)
      {
       sendto(PrimaryUDP, (const char*)(*UserIterator), sizeof(stUserListNode), 0, (const sockaddr*)&sender, sizeof(sender));
      }
      break;
     }
    }
   }
}

}
catch(Exception &e)
{
printf(e.GetMessage());
return 1;
}

return 0;
}

/* P2P 程序客户端
*
* 文件名：P2PClient.c
*/

#pragma comment(lib,"ws2_32.lib")

#include "windows.h"
#include "..\proto.h"
#include "..\Exception.h"
#include <iostream>
using namespace std;

UserList ClientList;

#define COMMANDMAXC 256
#define MAXRETRY 5

SOCKET PrimaryUDP;
char UserName[10];
char ServerIP[20];

bool RecvedACK;

void InitWinSock()
{
WSADATA wsaData;

SOCKET mksock(int type)
{
SOCKET sock = socket(AF_INET, type, 0);
if (sock < 0)
{
printf("create socket error");
throw Exception("");
}
return sock;
}

void BindSock(SOCKET sock)
{
sockaddr_in sin;
sin.sin_addr.S_un.S_addr = INADDR_ANY;
sin.sin_family = AF_INET;
sin.sin_port = 0;

if (bind(sock, (struct sockaddr*)&sin, sizeof(sin)) < 0)
throw Exception("bind error");
}

void ConnectToServer(SOCKET sock,char *username, char *serverip)
{
sockaddr_in remote;
remote.sin_addr.S_un.S_addr = inet_addr(serverip);
remote.sin_family = AF_INET;
remote.sin_port = htons(SERVER_PORT);

stMessage sendbuf;
sendbuf.iMessageType = LOGIN;
strncpy(sendbuf.message.loginmember.userName, username, 10);

sendto(sock, (const char*)&sendbuf, sizeof(sendbuf), 0, (const sockaddr*)&remote,sizeof(remote));

int usercount;
int fromlen = sizeof(remote);
int iread = recvfrom(sock, (char *)&usercount, sizeof(int), 0, (sockaddr *)&remote, &fromlen);
if(iread<=0)
{
throw Exception("Login error\n");
}

// 登录到服务端后，接收服务端发来的已经登录的用户的信息
cout<<"Have "<<usercount<<" users logined server:"<<endl;
for(int i = 0;i<usercount;i++)
{
stUserListNode *node = new stUserListNode;
recvfrom(sock, (char*)node, sizeof(stUserListNode), 0, (sockaddr *)&remote, &fromlen);
ClientList.push_back(node);
cout<<"Username:"<<node->userName<<endl;
in_addr tmp;
tmp.S_un.S_addr = htonl(node->ip);
cout<<"UserIP:"<<inet_ntoa(tmp)<<endl;
cout<<"UserPort:"<<node->port<<endl;
cout<<""<<endl;
}
}

void OutputUsage()
{
cout<<"You can input you command:\n"
<<"Command Type:\"send\",\"exit\",\"getu\"\n"
<<"Example : send Username Message\n"
<<" exit\n"
<<" getu\n"
<<endl;
}

/* 这是主要的函数：发送一个消息给某个用户(C)
*流程：直接向某个用户的外网IP发送消息，如果此前没有联系过
*      那么此消息将无法发送，发送端等待超时。
*      超时后，发送端将发送一个请求信息到服务端，
*      要求服务端发送给客户C一个请求，请求C给本机发送打洞消息
*      以上流程将重复MAXRETRY次
*/
bool SendMessageTo(char *UserName, char *Message)
{
char realmessage[256];
unsigned int UserIP;
unsigned short UserPort;
bool FindUser = false;
for(UserList::iterator UserIterator=ClientList.begin();
      UserIterator!=ClientList.end();
      ++UserIterator)
{
if( strcmp( ((*UserIterator)->userName), UserName) == 0 )
{
   UserIP = (*UserIterator)->ip;
   UserPort = (*UserIterator)->port;
   FindUser = true;
}
}

if(!FindUser)
return false;

strcpy(realmessage, Message);
for(int i=0;i<MAXRETRY;i++)
{
RecvedACK = false;

sockaddr_in remote;
remote.sin_addr.S_un.S_addr = htonl(UserIP);
remote.sin_family = AF_INET;
remote.sin_port = htons(UserPort);
stP2PMessage MessageHead;
MessageHead.iMessageType = P2PMESSAGE;
MessageHead.iStringLen = (int)strlen(realmessage)+1;
int isend = sendto(PrimaryUDP, (const char *)&MessageHead, sizeof(MessageHead), 0, (const sockaddr*)&remote, sizeof(remote));
isend = sendto(PrimaryUDP, (const char *)&realmessage, MessageHead.iStringLen, 0, (const sockaddr*)&remote, sizeof(remote));

// 等待接收线程将此标记修改
for(int j=0;j<10;j++)
{
   if(RecvedACK)
    return true;
   else
    Sleep(300);
}

// 没有接收到目标主机的回应，认为目标主机的端口映射没有
// 打开，那么发送请求信息给服务器，要服务器告诉目标主机
// 打开映射端口（UDP打洞）
sockaddr_in server;
server.sin_addr.S_un.S_addr = inet_addr(ServerIP);
server.sin_family = AF_INET;
server.sin_port = htons(SERVER_PORT);

stMessage transMessage;
transMessage.iMessageType = P2PTRANS;
strcpy(transMessage.message.translatemessage.userName, UserName);

sendto(PrimaryUDP, (const char*)&transMessage, sizeof(transMessage), 0, (const sockaddr*)&server, sizeof(server));
Sleep(100);// 等待对方先发送信息。
}
return false;
}

// 解析命令，暂时只有exit和send命令
// 新增getu命令，获取当前服务器的所有用户
void ParseCommand(char * CommandLine)
{
if(strlen(CommandLine)<4)
return;
char Command[10];
strncpy(Command, CommandLine, 4);
Command[4]='\0';

if(strcmp(Command,"exit")==0)
{
stMessage sendbuf;
sendbuf.iMessageType = LOGOUT;
strncpy(sendbuf.message.logoutmember.userName, UserName, 10);
sockaddr_in server;
server.sin_addr.S_un.S_addr = inet_addr(ServerIP);
server.sin_family = AF_INET;
server.sin_port = htons(SERVER_PORT);

sendto(PrimaryUDP,(const char*)&sendbuf, sizeof(sendbuf), 0, (const sockaddr *)&server, sizeof(server));
shutdown(PrimaryUDP, 2);
closesocket(PrimaryUDP);
exit(0);
}
else if(strcmp(Command,"send")==0)
{
char sendname[20];
char message[COMMANDMAXC];
int i;
for(i=5;;i++)
{
   if(CommandLine[i]!=' ')
    sendname[i-5]=CommandLine[i];
   else
   {
    sendname[i-5]='\0';
    break;
   }
}
strcpy(message, &(CommandLine[i+1]));
if(SendMessageTo(sendname, message))
   printf("Send OK!\n");
else
   printf("Send Failure!\n");
}
else if(strcmp(Command,"getu")==0)
{
int command = GETALLUSER;
sockaddr_in server;
server.sin_addr.S_un.S_addr = inet_addr(ServerIP);
server.sin_family = AF_INET;
server.sin_port = htons(SERVER_PORT);

sendto(PrimaryUDP,(const char*)&command, sizeof(command), 0, (const sockaddr *)&server, sizeof(server));
}
}

// 接受消息线程
DWORD WINAPI RecvThreadProc(LPVOID lpParameter)
{
sockaddr_in remote;
int sinlen = sizeof(remote);
stP2PMessage recvbuf;
for(;;)
{
int iread = recvfrom(PrimaryUDP, (char *)&recvbuf, sizeof(recvbuf), 0, (sockaddr *)&remote, &sinlen);
if(iread<=0)
{
   printf("recv error\n");
   continue;
}
switch(recvbuf.iMessageType)
{
case P2PMESSAGE:
   {
    // 接收到P2P的消息
    char *comemessage= new char[recvbuf.iStringLen];
    int iread1 = recvfrom(PrimaryUDP, comemessage, 256, 0, (sockaddr *)&remote, &sinlen);
    comemessage[iread1-1] = '\0';
    if(iread1<=0)
     throw Exception("Recv Message Error\n");
    else
    {
     printf("Recv a Message:%s\n",comemessage);

     stP2PMessage sendbuf;
     sendbuf.iMessageType = P2PMESSAGEACK;
     sendto(PrimaryUDP, (const char*)&sendbuf, sizeof(sendbuf), 0, (const sockaddr*)&remote, sizeof(remote));
    }

delete []comemessage;
break;

   }
case P2PSOMEONEWANTTOCALLYOU:
   {
    // 接收到打洞命令，向指定的IP地址打洞
    printf("Recv p2someonewanttocallyou data\n");
    sockaddr_in remote;
    remote.sin_addr.S_un.S_addr = htonl(recvbuf.iStringLen);
    remote.sin_family = AF_INET;
    remote.sin_port = htons(recvbuf.Port);

    // UDP hole punching
    stP2PMessage message;
    message.iMessageType = P2PTRASH;
    sendto(PrimaryUDP, (const char *)&message, sizeof(message), 0, (const sockaddr*)&remote, sizeof(remote));

    break;
   }
case P2PMESSAGEACK:
   {
    // 发送消息的应答
    RecvedACK = true;
    break;
   }
case P2PTRASH:
   {
    // 对方发送的打洞消息，忽略掉。
    //do nothing ...
    printf("Recv p2ptrash data\n");
    break;
   }
case GETALLUSER:
   {
    int usercount;
    int fromlen = sizeof(remote);
    int iread = recvfrom(PrimaryUDP, (char *)&usercount, sizeof(int), 0, (sockaddr *)&remote, &fromlen);
    if(iread<=0)
    {
     throw Exception("Login error\n");
    }

    ClientList.clear();

    cout<<"Have "<<usercount<<" users logined server:"<<endl;
    for(int i = 0;i<usercount;i++)
    {
     stUserListNode *node = new stUserListNode;
     recvfrom(PrimaryUDP, (char*)node, sizeof(stUserListNode), 0, (sockaddr *)&remote, &fromlen);
     ClientList.push_back(node);
     cout<<"Username:"<<node->userName<<endl;
     in_addr tmp;
     tmp.S_un.S_addr = htonl(node->ip);
     cout<<"UserIP:"<<inet_ntoa(tmp)<<endl;
     cout<<"UserPort:"<<node->port<<endl;
     cout<<""<<endl;
    }
    break;
   }
}
}
}

int main(int argc, char* argv[])
{
try
{
InitWinSock();

PrimaryUDP = mksock(SOCK_DGRAM);
BindSock(PrimaryUDP);

cout<<"Please input server ip:";
cin>>ServerIP;

cout<<"Please input your name:";
cin>>UserName;

ConnectToServer(PrimaryUDP, UserName, ServerIP);

HANDLE threadhandle = CreateThread(NULL, 0, RecvThreadProc, NULL, NULL, NULL);
CloseHandle(threadhandle);
OutputUsage();

for(;;)
{
   char Command[COMMANDMAXC];
   gets(Command);
   ParseCommand(Command);
}
}
catch(Exception &e)
{
printf(e.GetMessage());
return 1;
}
return 0;
}

/* 异常类
*
* 文件名：Exception.h
*/

#ifndef __HZH_Exception__
#define __HZH_Exception__

#define EXCEPTION_MESSAGE_MAXLEN 256
#include "string.h"

class Exception
{
private:
char m_ExceptionMessage[EXCEPTION_MESSAGE_MAXLEN];
public:
Exception(char *msg)
{
strncpy(m_ExceptionMessage, msg, EXCEPTION_MESSAGE_MAXLEN);
}

char *GetMessage()
{
return m_ExceptionMessage;
}
};

#endif

好贴子可不能找不到了

Windows Mobile中如何建立GPRS连接以便Socket能正常通信

RIA和未来的软件开发架构

flex开发技术详解

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

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

目录

简介

测量性能

减少方法调用的数目

自上而下地创建控件

更多信息

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

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

本页内容

简介

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

构建更好的类

小结

SmartPhone手机上查看QQ天气预报

Windows Mobile中的WebService应用

Creating a P/Invoke Library

Creating a P/Invoke Library

Contents

Introduction

The Test Application

Input

Memory

Memory Status

Performance Counters

Power Status

SIP

System Reset

System Time

Wave Out

Wave In

Windows

Registry

Phone

Folders

MMS彩信是怎么炼成地

P2P之UDP穿透NAT的原理与实现