博客园_ＨＯＨ

WinCE、Windows Mobile GPRS连接类

2011-05-27T03:21:00Z

在做手机应用程序开发的时候，我们经常需要手动建立GPRS连接，下面我提供一个经过简单改动过的GPRS连接类。

这个类核心的代码，在网上都可以找到，我只是在这个基础上，进行了简单的封装，让他可以在后台自动监视连接，在连接断开的时候，可以自动建立，让我们在做业务逻辑的时候，可以不必去管GPRS连接着一块。

/// <summary>
/// GPRS自动连接服务
/// </summary>
public class ConnectionBLL
{
    private static ConnectionBLL _ConnectionBLL = null;
    private bool _autoConnect = false;
    private int _interval = 30000;
    private ConnectState _connectState;

    private ConnectionBLL()
    {
    }

    public static ConnectionBLL Instance
    {
        get
        {
            if (_ConnectionBLL == null)
            {
                lock (typeof(ConnectionBLL))
                {
                    if (_ConnectionBLL == null)
                    {
                        _ConnectionBLL = new ConnectionBLL();
                    }
                }
            }
            return _ConnectionBLL;
        }
    }
    /// <summary>
    /// 连接状态
    /// </summary>
    public ConnectState ConnectState
    {
        get { return _connectState; }
    }
    /// <summary>
    /// 是否自动连接
    /// </summary>
    public bool AutoConnect
    {
        get { return _autoConnect; }
    }

    /// <summary>
    /// 监听频率
    /// </summary>
    public int Interval
    {
        get { return _interval; }
        set { _interval = value; }
    }

    const int S_OK = 0;
    const uint CONNMGR_PARAM_GUIDDESTNET = 0x1;
    const uint CONNMGR_PRIORITY_USERINTERACTIVE = 0x08000;
    const uint INFINITE = 0xffffffff;
    const uint CONNMGR_STATUS_CONNECTED = 0x10;
    const int CONNMGR_MAX_DESC = 128;    // @constdefine Max size of a network description

    const int CONNMGR_FLAG_PROXY_HTTP = 0x1; // @constdefine HTTP Proxy supported
    const int CONNMGR_FLAG_PROXY_WAP = 0x2; // @constdefine WAP Proxy (gateway) supported
    const int CONNMGR_FLAG_PROXY_SOCKS4 = 0x4; // @constdefine SOCKS4 Proxy supported
    const int CONNMGR_FLAG_PROXY_SOCKS5 = 0x8; // @constdefine SOCKS5 Proxy supported

    const UInt16 IDC_WAIT = 32514;
    const UInt16 IDC_ARROW = 32512;

    private IntPtr m_hConnection = IntPtr.Zero;

    public enum ConnMgrStatus
    {
        AuthenticationFailed = 0x2b,
        Connected = 0x10,
        ConnectionCanceled = 0x22,
        ConnectionDisabled = 0x23,
        ConnectionFailed = 0x21,
        ConnectionLinkFailed = 0x2a,
        Disconnected = 0x20,
        ExclusiveConflict = 40,
        NoPathToDestination = 0x24,
        NoPathWithProperty = 0x2c,
        NoResources = 0x29,
        PhoneOff = 0x27,
        Suspended = 0x11,
        Unknown = 0,
        WaitingConnection = 0x40,
        WaitingConnectionAbort = 0x81,
        WaitingDisconnection = 0x80,
        WaitingForNetwork = 0x42,
        WaitingForPath = 0x25,
        WaitingForPhone = 0x26,
        WaitingForResource = 0x41
    }

    public ConnectionBLL()
    {
    }

    ~ConnectionBLL()
    {
        ReleaseConnection();
    }

    /// <summary>
    /// 开始连接
    /// </summary>
    public void Start()
    {
        try
        {
            if (!_autoConnect)
            {
                _autoConnect = true;
                ThreadPool.QueueUserWorkItem(new WaitCallback(Connect));
            }
        }
        catch
        {
        }
    }

    /// <summary>
    /// 停止
    /// </summary>
    public void Stop()
    {
        try
        {
            _autoConnect = false;
            this.ReleaseConnection();
            _connectState = ConnectState.DisConnect;
            _ConnectionBLL = null;
        }
        catch { }
    }

    /// <summary>
    /// 连接
    /// </summary>
    private void Connect(object obj)
    {
        while (this.AutoConnect)
        {
            uint status = 0;
            bool result = false;
            if (m_hConnection != IntPtr.Zero)
            {
                result = WaitForConnected(10, ref status);
            }
            if (!result)
            {
                _connectState = ConnectState.DisConnect;
                //枚举连接
                List<CONNMGR_DESTINATION_INFO> lst = EnumConnDestinations();

                for (int i = 0; i < lst.Count; i++)
                {
                    string str = lst[i].Description;
                    if (str.ToUpper().IndexOf("CMNET") > -1 || str.ToUpper().IndexOf("CMWAP") > -1)
                    {
                        if (EstablishConnection((uint)i))
                        {
                            _connectState = ConnectState.Connected;
                            break;
                        }
                    }
                }
            }
            else
            {
                _connectState = ConnectState.Connected;
            }
            Thread.Sleep(_interval);
        }
    }

    /// <summary>
    /// 枚举网络标识符信息
    /// </summary>
    /// <param name="lstNetIdentifiers"></param>
    public List<CONNMGR_DESTINATION_INFO> EnumConnDestinations()
    {
        List<CONNMGR_DESTINATION_INFO> lstNetIdentifiers = new List<CONNMGR_DESTINATION_INFO>();
        // 得到网络列表
        for (uint dwEnumIndex = 0; ; dwEnumIndex++)
        {
            CONNMGR_DESTINATION_INFO networkDestInfo = new CONNMGR_DESTINATION_INFO();

            if (ConnMgrEnumDestinations((int)dwEnumIndex, ref networkDestInfo) != 0)
            {
                break;
            }
            lstNetIdentifiers.Add(networkDestInfo);
        }

        return lstNetIdentifiers;
    }

    /// <summary>
    /// 建立连接
    /// </summary>
    /// <param name="nIndex"></param>
    /// <returns></returns>
    public bool EstablishConnection(uint nIndex)
    {
        ReleaseConnection();
        // 得到正确的连接信息
        CONNMGR_DESTINATION_INFO DestInfo = new CONNMGR_DESTINATION_INFO();
        int hResult = ConnMgrEnumDestinations((int)nIndex, ref DestInfo);

        if (hResult >= 0)
        {
            // 初始化连接结构
            CONNMGR_CONNECTIONINFO ConnInfo = new CONNMGR_CONNECTIONINFO();

            ConnInfo.cbSize = (uint)Marshal.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.DestID;
            ConnInfo.bExclusive = 1;
            ConnInfo.bDisabled = 0;

            uint dwStatus = 0;
            hResult = ConnMgrEstablishConnectionSync(ref ConnInfo, ref m_hConnection, 10 * 1000, ref dwStatus);
            if (hResult < 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        return false;
    }
    /// <summary>
    /// 连接状态
    /// </summary>
    /// <param name="nTimeoutSec"></param>
    /// <param name="pdwStatus"></param>
    /// <returns></returns>
    public bool WaitForConnected(int nTimeoutSec, ref uint pdwStatus)
    {
        uint dwStartTime = GetTickCount();
        bool bRet = false;

        while (GetTickCount() - dwStartTime < (uint)nTimeoutSec * 1000)
        {
            if (m_hConnection.ToInt32() != 0)
            {
                uint dwStatus = 0;
                int hr = ConnMgrConnectionStatus(m_hConnection, ref dwStatus);
                if (dwStatus != 0) pdwStatus = dwStatus;
                if (hr >= 0)
                {
                    if (dwStatus == CONNMGR_STATUS_CONNECTED)
                    {
                        bRet = true;
                        break;
                    }
                }
            }
            Thread.Sleep(100);
        }

        return bRet;
    }

    /// <summary>
    /// 释放所有连接
    /// </summary>
    public void ReleaseConnection()
    {

        if (m_hConnection.ToInt32() != 0)
        {
            ConnMgrReleaseConnection(m_hConnection, 0);
            m_hConnection = IntPtr.Zero;
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct CONNMGR_CONNECTIONINFO
    {
        public uint cbSize;
        public uint dwParams;
        public uint dwFlags;
        public uint dwPriority;
        public int bExclusive;
        public int bDisabled;
        public GUID guidDestNet;
        public IntPtr hWnd;
        public uint uMsg;
        public uint lParam;
        public uint ulMaxCost;
        public uint ulMinRcvBw;
        public uint ulMaxConnLatency;
    }

    /// <summary>
    /// 此结构的内容对应：注册表中：
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct CONNMGR_DESTINATION_INFO
    {
        public GUID DestID;  // @field GUID associated with network
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CONNMGR_MAX_DESC)]
        public string Description;  // @field Description of network
        public int Secure; // @field Is it OK to allow multi-homing on the network
    }

    public struct GUID
    {          // size is 16
        public uint Data1;
        public UInt16 Data2;
        public UInt16 Data3;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] Data4;
    }

    [DllImport("coredll.dll")]
    public static extern uint GetTickCount();

    [DllImport("coredll.dll")]
    public static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);

    [DllImport("cellcore.dll")]
    public static extern int ConnMgrMapURL(string pwszURL, ref GUID pguid, ref uint pdwIndex);

    [DllImport("cellcore.dll")]
    public static extern int ConnMgrEstablishConnectionSync(ref CONNMGR_CONNECTIONINFO ci, ref IntPtr phConnection, uint dwTimeout, ref uint pdwStatus);

    [DllImport("cellcore.dll")]
    private static extern IntPtr ConnMgrApiReadyEvent();

    [DllImport("cellcore.dll")]
    public static extern int ConnMgrReleaseConnection(IntPtr hConnection, int bCache);

    [DllImport("cellcore.dll")]
    public static extern int ConnMgrEnumDestinations(int nIndex, ref CONNMGR_DESTINATION_INFO pDestInfo);

    [DllImport("cellcore.dll")]
    public static extern int ConnMgrConnectionStatus(IntPtr hConnection,    // @parm Handle to connection, returned from ConnMgrEstablishConnection
        ref uint pdwStatus       // @parm Returns current connection status, one of CONNMGR_STATUS_*
        );

    [DllImport("coredll.dll")]
    private static extern int CloseHandle(IntPtr hObject);
}

/// <summary>
/// 连接状态
/// </summary>
public enum ConnectState
{
    /// <summary>
    /// 断开
    /// </summary>
    DisConnect = 0,
    /// <summary>
    /// 已连接
    /// </summary>
    Connected = 2
}

注意：为了加快连接速度，这里指定了连接移动的CMNET和CMWAP，可以根据需要修改，也可以不指定。

本文链接

向Process传参数

2011-01-25T02:28:00Z

摘要

有的时候，我们需要在一个进程启动另外一个进程，并传递一些参数过去。

正文

我们很容易会想到下面的代码：

ProcessStartInfo startInfo = new ProcessStartInfo();
            startInfo.FileName = @"d:\test.exe";
            startInfo.Arguments = "sasasasasasasa";
            Process.Start(startInfo);

string argument = Environment.GetCommandLineArgs()[0];
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());

然而你会发现，这样你根本得不到传递过来的参数，这也让我很是郁闷，后来才发现，原来传递过来的参数不在0位置，而在1位置，只要用下面的代码就可以得到：

string argument = Environment.GetCommandLineArgs()[1];
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());

本文链接

通过Windows Mobile连接管理器建立网络连接(转载)

2011-01-05T03:08:00Z

原文

:http://www.cnblogs.com/Lisen/archive/2009/12/23/1630585.html

原文为Jim Wilson 的 Establishing Network Connectivity with the Windows Mobile Connection Manager。

概要 Summary

本文主要讲述在托管程序中怎样使用连接管理器建立和释放网络连接。本文的重点是关于使用连接管理器建立和断开连接的概念，而不是如何封装连接管理器API。文章的目的在于涵盖概念使能够适用于任何连接管理器托管API。

适用 Applies to

Windows Mobile 6 Professional

Windows Mobile 6 Standard

Windows Mobile 6 Classic

Windows Mobile 5.0 for Pocket PC Phone Edition

Windows Mobile 5.0 for Smartphone

Windows Mobile 5.0 for Pocket PC

索引

1. Introduction

2. Accessing Connection Manager from Managed Code

3. Establishing a Connection

4. Conclusion

介绍 Introduction

现代Windows Mobile设备包含了许多的网络连接选项，比如Wi-Fi和大量的cellular radios。而且，众所周知，所有Windows Mobile设备能够通过ActiveSync连接桌面计算机访问网络。

所有这些网络选项提供不同的数据速度，并且，在任何时候，0、1或更多的网络连接可能都是可用的。当一个应用程序需要建立一个网络连接时，Windows Mobile提供了一个公共解决方案 —— 那就是连接管理器，而不必要求应用程序自己遍历所有可用的连接然后选择最合适的连接。

就象名字表达的一样，连接管理器负责管理设备上所有的网络连接。当应用程序需要建立一个网络连接时，只需要简单的告诉连接管理器需要哪种连接（比如Internet），连接管理器自己会识别哪些连接可用、选择最佳连接并按照需要建立连接。连接管理器甚至可以在有相同连接需求的多个应用程序中共享一个连接。应用程序完全从细节中抽象出来并且无需考虑任何细节地使用连接。

连接管理器功能强大并提供了大量不同的连接相关的性能。本文主要讲述怎样使用连接管理器建立一个网络连接并且在不需要的时候释放掉。

虽然本文的例子直接p/invoke连接管理Native API，但是本文主要讲述关于使用连接管理建立和断开连接的概念，而不是如何封装连接管理器API。文章的目的在于涵盖概念使能够适用于任何连接管理器托管API。

通过托管代码访问连接管理器 Accessing Connection Manager from Managed Code

连接管理器是Windows Mobile的基础部分，但是当前只以Native API的形式暴露。好消息是大多数API很简单并且能够通过.NET Compact Framework简单地访问。你需要定义一些枚举和结构，但大多数不必去定义，过程非常简单。

注意

Microsoft Visual Studio 2008下.NET Compact Framework 3.5提供了连接管理器API的管理版本实现。即使你打算使用托管版本API，仍然鼓励你读完本文，因为无论是托管API还是P/Invoke本地API，他们的概念意义是一样的。

【李森 - listen附：Connection Manager wrapper 提及了：他本人向Jim Wilson 通过Email问及了Microsoft Visual Studio 2008下.NET Compact Framework 3.5 连接管理器的封装，Jim Wilson回答说微软放弃了添加连接管理器的封装，而Jim Wilson本人也多次要求微软方面删去本段，但是一直没有修改】

函数Connection Manager Functions

Connection Manager API由11个函数组成，但是只需要使用其中的5个就能完成建立和释放网络连接的工作。在许多情况下，你的程序可能只要其中的2个函数就可以了。表1显示了这5个函数

函数	描述
ConnMgrMapURL	取回指定URL的网络标识(Internet or Work) 。
ConnMgrEstablishConnection	为指定的网络标识选择和建立合适的连接。该方法直接返回，并不等待连接完整。使用ConnMgrConnectionStatus去判断网络状态。
ConnMgrEstablishConnectionSync	为指定的网络标识选择和建立合适的连接。该方法直到尝试连接完成了才返回。
ConnMgrReleaseConnection	释放指定连接，可能会关闭连接（并不保证一定关闭）。
ConnMgrConnectionStatus	取回指定连接的状态。

表1 Connection Manager functions used to establish and release a network connection

要从 .NET Compact Framework程序中访问这5个函数，需要P/Invoke，如下：

[DllImport("CellCore.dll")] 
static extern int ConnMgrMapURL(string url, ref Guid networkGuid, int passZero); 
[DllImport("CellCore.dll")] 
static extern int ConnMgrEstablishConnection(ConnMgrConnectionInfo connectionInfo, ref IntPtr connectionHandle); 
[DllImport("CellCore.dll")] 
static extern int ConnMgrEstablishConnectionSync(ConnMgrConnectionInfo connectionInfo, ref IntPtr connectionHandle, uint dwTimeout, ref ConnMgrStatus dwStatus); 
[DllImport("CellCore.dll")] 
static extern int ConnMgrReleaseConnection(IntPtr connectionHandle, int cache); 
[DllImport("CellCore.dll")] 
static extern int ConnMgrConnectionStatus(IntPtr connectionHandle, ref ConnMgrStatus status);

枚举和结构 Connection Manager Enumerations and Structures

当使用连接管理器建立连接时，必须指定连接的特性。本地代码中需要使用CONNMGR_CONNECTIONINFO和几组 #define 宏来指定连接的特性。为了使结构和.NET的特性相容，可以用托管的类来实现结构并命名为，比如ConnMgrConnectionInfo。与其象.NET一样使用常量来定义宏，不如使用枚举来显式地定义每组相关的宏。

注意

如果想查看所有连接管理器native声明，可参见%Program Files%\Windows Mobile 6 SDK\PocketPC\Include\Armv4i 下的connmgr.h头文件

有几个结构依赖于宏，因此首先要定义宏对应的枚举。

第一个枚举对应CONNMGR_PARAM_* 宏集。这些值标识了结构中可用的标准字段，这些字段指定了请求连接中想要的特性。一个连接请求可以指定多个条件，因此，枚举声明应该包含Flags属性。通过表示Flags属性，可以对成员进行位或运算。

[Flags] 
public enum ConnMgrParam : int 
{ 
GuidDestNet = 0x1, 
MaxCost = 0x2, 
MinRcvBw = 0x4, 
MaxConnLatency = 0x8 
}

每个枚举变量就像结构中对应的字段一样拥有相同的名字。下面对于结构定义的讨论将满足每个字段的意义。

下一个枚举对应CONNMGR_FLAG_PROXY_*宏。这些值指定代理服务器的类型，连接管理器使用该类型建立连接。就象ConnMgrParam枚举一样，该声明包含Flags属性。

[Flags] 
public enum ConnMgrProxy : int 
{ 
NoProxy = 0x0, 
Http = 0x1, 
Wap = 0x2, 
Socks4 = 0x4, 
Socks5 = 0x8 
}

下面需要考虑的就是连接请求的优先级。连接管理器负责设备上的所有连接，并尝试服务尽量多连接请求。为了辅助连接管理器决定每个请求的顺序和重要性，每个请求必须指定优先级。连接管理器支持几个不同优先级水平，尽管如此，程序一般只使用几个值。下面的枚举声明显示了通常使用的值：

public enum ConnMgrPriority 
{ 
UserInteractive = 0x8000, 
HighPriorityBackground = 0x0200, 
LowPriorityBackground = 0x0008 
}

表2提供了每个优先级的描述：

优先级	描述
UserInteractive	主动请求连接，用户接口等待连接。该优先级高于大多数其他优先级。
HighPriorityBackground	该请求为高优先级，但是应用程序在后台运行，因此并不影响用户接口。
LowPriorityBackground	该请求仅当更高优先级的程序已经使用了请求路径后才连接。使用该优先级，应用程序可能共享一个已经存在的连接而并不是建立一个新的连接。

表2 Common Connection priorities

连接管理器支持了更多的枚举声明，connmgr.h中的CONNMGR_PRIORITY_*宏提供了完整的列表。在表2中没有提及的优先级值，参考Connection Manager Priority Constants

最后一个枚举是连接状态值。大多数状态值名称无需说明便能理解。对于每个状态值的描述，参见Connection Manager Status Constants或者参见connmgr.h中的CONNMGR_STATUS_*宏。如下：

public enum ConnMgrStatus 
{ 
Unknown = 0x00, 
Connected = 0x10, 
Suspended = 0x11, 
Disconnected = 0x20, 
ConnectionFailed = 0x21, 
ConnectionCanceled = 0x22, 
ConnectionDisabled = 0x23, 
NoPathToDestination = 0x24, 
WaitingForPath = 0x25, 
WaitingForPhone = 0x26, 
PhoneOff = 0x27, 
ExclusiveConflict = 0x28, 
NoResources = 0x29, 
ConnectionLinkFailed = 0x2a, 
AuthenticationFailed = 0x2b, 
NoPathWithProperty = 0x2c, 
WaitingConnection = 0x40, 
WaitingForResource = 0x41, 
WaitingForNetwork = 0x42, 
WaitingDisconnection = 0x80, 
WaitingConnectionAbort = 0x81 
}

所有的枚举定义后，下面要做的就是理解连接请求结构体。可以使用结构或管理类来组织Native结构，一般，类比结构体更流畅，因为类允许提供默认构造函数和成员初始化。上面已经提过了，ConnMgrConnectionInfo管理类代表CONNMGR_CONNECTIONINFO，如下：

[StructLayout(LayoutKind.Sequential)] 
class ConnMgrConnectionInfo 
{ 
Int32 cbSize;                          // DWORD 
public ConnMgrParam dwParams = 0;      // DWORD 
public ConnMgrProxy dwFlags = 0;       // DWORD 
public ConnMgrPriority dwPriority = 0; // DWORD 
public Int32 bExclusive = 0;           // BOOL 
public Int32 bDisabled = 0;            // BOOL 
public Guid guidDestNet = Guid.Empty;  // GUID 
public IntPtr hWnd = IntPtr.Zero;      // HWND 
public UInt32 uMsg = 0;                // UINT 
public Int32 lParam = 0;               // LPARAM 
public UInt32 ulMaxCost = 0;           // ULONG 
public UInt32 ulMinRcvBw = 0;          // ULONG 
public UInt32 ulMaxConnLatency = 0;    // ULONG 
} ;

表3描述了各个字段的意义

字段	描述
cbSize	类的大小，按照字节计算
dwParams	连接管理器参数常量枚举值。
dwFlags	连接请求的代理需求
dwPriority	连接请求的优先级
bExclusive	是否独占连接请求，非0值代表连接不能被其他程序共享
bDisabled	指定连接是否断开。非0值代表连接管理器决定连接是否进行，但并不真正执行连接。当连接管理器需要建立连接时，它会将连接状态设置为ConnMgrStatus.ConnectionDisabled。
guidDestNet	目标GUID。如果该字段可用，那么dwParams字段必须包含ConnMgrParam.GuidDestNet值。
hWnd	接受状态改变消息的窗口句柄，通常为MessageWindow派生类句柄。
uMsg	当发送状态改变消息时，发送该消息到hWnd字段代表的窗口。
lParam	发送给hWnd字段代表的窗口的状态改变消息中的值，该字段当且仅当hWnd字段被设置了一个可用窗口句柄时才可用。在消息中使用该参数包含应用程序指定的数据。
ulMaxCost	可接收的最大连接。如果dwParams字段包含 ConnMgrParam.MaxCost 属性，此字段才可用（大多数程序取消该字段）。
ulMinRcvBw	可接收的最小带宽。如果dwParams字段包含 ConnMgrParam.MinRcvBw 属性，此字段才可用（大多数程序取消该字段）。
ulMaxConnLatency	最大等待时间。如果dwParams字段包含 ConnMgrParam.MaxConnLatency 属性，此字段才可用（大多数程序取消该字段）。

表3 ConnMgrConnectionInfo class members

为了简化ConnMgrConnectionInfo类的使用，该类定义了一组构造函数负责一些通用情况。第一个是默认构造函数，如下：

public ConnMgrConnectionInfo() 
{ 
cbSize = Marshal.SizeOf(typeof(ConnMgrConnectionInfo)); 
}

在给Connection Manager functions传递ConnMgrConnectionInfo类参数时，需要指定ConnMgrConnectionInfo类的大小，因此构造函数自动存储cbSize作为类的大小。

虽然连接管理器类有许多成员，应用程序通常只需要设置目标GUID、优先级，如果需要，还要设置代理。如果包含目标GUDI，那么dwParams字段必须要设置ConnMgrParam.GuidDestNet值。如下：

public ConnMgrConnectionInfo(Guid destination, ConnMgrPriority priority, ConnMgrProxy proxy) 
    : this() 
{ 
guidDestNet = destination; 
dwParams = ConnMgrParam.GuidDestNet; 
dwPriority = priority; 
dwFlags = proxy; 
}

方便起见，该类包含了2个其他的构造函数。第一个接受目标GUID和优先级，不需要代理。第二个参数接受目标GUID，并设置优先级为ConnMgrPriority.UserInteractive，该优先级由程序用户接口等待。

public ConnMgrConnectionInfo(Guid destination, ConnMgrPriority priority) 
    : this(destination, priority, ConnMgrProxy.NoProxy) { } 

public ConnMgrConnectionInfo(Guid destination) 
    : this(destination, ConnMgrPriority.UserInteractive) { }

建立连接 Establishing a Connection

使用Native方法，枚举和结构就可以通过连接管理器建立一个连接了。好消息是困难的工作已经做完了，使用连接管理器是非常容易的事情。建立实际的连接包括两步：确定网络目标标识和发送连接请求。

确定目标网络标识 Determining a Network Destination Identifier

建立连接的第一步是标识你的程序是连接到Internet 还是单位网络（Work network）。每个网络目标有一个指定的GUID.Internet的GUID是436EF144-B4FB-4863-A041-8F905A62C572，单位网络（Work network）的GUID是A1182988-0D73-439e-87AD-2A5B369F808B。

虽然我们都知道每个网络目标的GUID,但大多数程序并不直接使用这些GUID.相反，能够功过ConnMgrMapURL函数确定合适的网络GUID.

连接管理器压缩了逻辑来确定url请求哪个网络。因此，与其硬编码一个网络GUID，不如简单的传递一个目标url给ConnMgrMapURL函数来返回一个合适的GUID。

注意[说明，原文periods在此处翻译为：终结符。比如http:\\www.baidu.com，那么".com"就是periods]
连接管理器根据目标url中是否包含终结符决定请求Internet还是单位网络（Work network）。如果包含终结符，那么请求连接Internet；如果不包含则链接到单位网络（Work network）。如果你的公司在内部网络地址中使用终结符，那么你就必须把那些地址添加到工作URL异常列表中（Work URL exception list）。进入“Start - setting - connections”页面, 选择Connections图标，接着选择Advanced页面，最后选择Exceptions按钮，就可以添加那些URL到工作URL异常列表中了。

下面的代码演示了使用ConnMgrMapURL去确定不同URL的目标GUID。

string url1 = "http://msdn2.microsoft.com/en-us/netframework/bb495180.aspx"; 
string url2 = "http://hedgydev02/test/default.aspx"; 
Guid destination1 = Guid.Empty; 
Guid destination2 = Guid.Empty; 

ConnMgrMapURL(url1, ref destination1, 0); 
ConnMgrMapURL(url2, ref destination2, 0); 

// Write to debug window 
Debug.WriteLine(url1); 
Debug.WriteLine(destination1.ToString()); 
Debug.WriteLine(""); 
Debug.WriteLine(url2); 
Debug.WriteLine(destination2.ToString());

在上面例子中，有两个URL，第一个为Microsoft's MSDN网址，显然是在Internet上。另一个URL则指向内部网络上的某个电脑，因此是在单位网络（Work network）上。图一显示在运行上述代码后，Visual Studio输出窗口上显示的信息。就像看到的那样，Microsoft URL 返回Internet GUID (436EF144-B4FB-4863-A041-8F905A62C572)，而指向内部网的URL则返回Work GUID(A1182988-0D73-439e-87AD-2A5B369F808B)。

图一 The destination network identifiers for an Internet URL and a Work URL

多亏ConnMgrMapURL函数，这也许是你最后一次见到这些GUID了。以后，你只需让ConnMgrMapURL函数为你生成GUID即可。

建立连接 Making the Connection

在这里，只需使用合适的连接标准并且调用合适的连接管理器函数，你就可以创建一个ConnMgrConnectionInfo类实例了。

当请求连接时，你只需调用ConnMgrEstablishConnectionSync函数，该函数将保持阻塞直到连接过程完成；或者使用ConnMgrEstablishConnection函数，该函数立即返回，调用线程无需等待连接过程完成。如果你的应用程序在后台运行，或者你在后台建立连接，可以使用ConnMgrEstablishConnectionSync函数，因为当函数返回时你就能够知道是否成功地建立了连接。下面的代码演示了如何使用ConnMgrEstablishConnectionSync函数建立一个连接：

IntPtr _connectionHandle = IntPtr.Zero; // Class-level field 
const int _syncConnectTimeout = 60000; // 60 seconds 
void DoConnect(string url) 
{ 
Guid networkGuid = Guid.Empty; 
ConnMgrStatus status = ConnMgrStatus.Unknown; 
ConnMgrMapURL(url, ref networkGuid, 0); 
ConnMgrConnectionInfo info = new ConnMgrConnectionInfo(networkGuid, ConnMgrPriority.HighPriorityBackground); 
ConnMgrEstablishConnectionSync(info, ref _connectionHandle, _syncConnectTimeOut, ref status); 

if (status == ConnMgrStatus.Connected) 
Debug.WriteLine("Connect Succeeded"); 
else 
Debug.WriteLine("Connect failed: " + status.ToString()); 
}

注意，前面的代码给ConnMgrEstablishConnectionSync函数传递了一个延时值。你应该提供一个足够大的延时值，因为，在建立连接时，尤其在一个很差的网络时，有时候要花上几十秒时间。如果函数因为时间到了而返回，相比于连接错误，此时的状态值为ConnMgrStatus.WaitingConnection。当你取回ConnMgrStatus.WaitingConnection状态值时，那么如果你提供了足够的延时值，连接就有可能成功。因此，你应该在尝试建立连接时给与足够的延时时间。

为了测试前面的连接模式，我们使用Windows Mobile 6 Professional Device Emulator 和 Cellular Emulator。Cellular Emulator模拟cellular radio，给Device Emulator提供GPRS连接。开始前，你必须连接Device Emulator到Cellular Emulator，具体参照 Cellular Emulator section 里的Developer's Guide to the Arm 。

你需要为模拟器定义GRPS连接，这和使用真实设备连接到服务网络的步骤一样。按照下面的步骤定义GPRS连接：

1. 在设备模拟器中 “Start - setting”

2. 在“setting”页面选择“Connections” 页面

3. 点击“Connections”图标

4. 然后，选择上面“My ISP”下的“Add a new modem connection”

5. 将连接命名为GPRS Internet。该名字对连接行为并不起任何作用。

6. 从“Select a modem”下拉列表中选择“Cellular (GPRS) ”

7. 选择“Next”

8. 保持“Access point name”为空，选择Next

9. 保持本页面所有字段为空（User name, Password, Domain），选择“Finish”

现在就定义好了Internet GPRS连接。同样，定义一个单位网络（Work network）GPRS连接，和上面的一样，只需在第4步选择“My Work Network”下“Add a new modem connection”，接着在第5步将连接命名为“GPRS Work”即可。

注意

之所以能将访问点（Access point）和登录信息设置为空，是因为我们通过Cellular Emulator连接GPRS。如果在真实设备上，你就需要将这些字段设置上信息了。

运行之前的代码后，你就会在几秒后看到Cellular Emulator上“Data Channels”下面的列表有一行上显示有连接活动了。

图二 The Cellular Emulator with an active GPRS connection

Cellular Emulator显示连接以后，ConnMgrEstablishConnectionSync函数就会立即返回了。你应该每次都检查返回状态以确定连接是否真的成功。一个成功的连接返回ConnMgrStatus.Connected状态。

注意要关闭Cellular Emulator的连接，在“Network”下点击“Disconnect GPRS”按钮。

因为ConnMgrEstablishConnectionSync函数在连接进程完全完成以前一直在阻断进程，所以该连接并不适合在面向用户的程序主线程运行，否则将造成程序界面假死现象。为了避免这种情况，就要使用ConnMgrEstablishConnection函数。ConnMgrEstablishConnection 函数并不等待连接完成就直接返回，它只是初始化连接。调用ConnMgrEstablishConnection函数和调用ConnMgrEstablishConnectionSync函数的操作非常相似，如下：

Guid networkGuid = Guid.Empty; 
ConnMgrMapURL(url, ref networkGuid, 0); 
ConnMgrConnectionInfo info = new ConnMgrConnectionInfo(networkGuid); 
ConnMgrEstablishConnection(info, ref _connectionHandle);

如上代码，ConnMgrEstablishConnection函数只是初始化连接然后在连接管理器真正建立连接前就直接返回了。为了检测连接是否真的完成，应该使用SystemState类和ConnMgrConnectionStatus函数协同使用来监测。

下面的代码显示了当连接数发生改变时，SystemState类如何通知应用程序：

SystemState _connectionsCount; 
private void Form1_Load(object sender, EventArgs e) 
{ 
_connectionsCount = new SystemState(SystemProperty.ConnectionsCount); 
_connectionsCount.Changed += new ChangeEventHandler(ConnectionsCount_Changed); 
}

这段代码构造了_connectionsCount实例，并把它和ConnectionsCount属性关联起来，将ConnectionsCount_Changed方法和_connectionsCount.Changed事件关联起来。只要连接数量发生改变时，_connectionsCount实例就调用ConnectionsCount_Changed函数。

一旦你知道活动连接的数量发生改变，你需要检测发生的改变是否是由于你请求的连接造成的。下面的代码描述了如何使用ConnMgrConnectionStatus函数来决定连接数量的改变是否是由你之前通过ConnMgrEstablishConnection 函数建立的连接引起的。

void ConnectionsCount_Changed(object sender, ChangeEventArgs args) 
{ 
ConnMgrStatus status = ConnMgrStatus.Unknown; 
ConnMgrConnectionStatus(_connectionHandle, ref status); 
if (status == ConnMgrStatus.Connected) 
    { 
// Connection Established 
    } 
}

通过上面的代码，当连接状态为ConnMgrStatus.Connected时，你就知道你的连接已成准备好并可以使用了。必须要记住，系统在主线程里调用ConnectionsCount_Changed方法，因此，你不能在该方法中执行任何长时间运行的任务。相反，你应该在后台线程执行任务或者使用异步方法，就像SqlCeReplication类中的BeginSynchronize方法一样。

你可以使用Device Emulator和Cellular Emulator测试你的代码。

注意有许多方法可以检测当前连接的状态。你可以在任何时间使用ConnMgrConnectionStatus 函数检测连接状态以确认连接没有遇到任何异常问题，这很必要。你也可以创建MessageWindow派生类，并且将该类的窗口句柄赋值给ConnMgrConnectionInfo类的hWnd字段，这样，连接管理器每次都会在连接状态发生改变时给MessageWindow派生类发送一个消息。当然你也可以使用ConnMgrRegisterForStatusNotification 函数（将MessageWindow派生类的窗口句柄传递给ConnMgrRegisterForStatusNotification函数的第二个参数，这样连接管理器在连接状态发生改变时也会给MessageWindow派生类发送一个消息）。

释放连接 Releasing the Connection

释放连接的操作非常简单。大多数情况下，你只需要简单的给ConnMgrReleaseConnection函数传递之前从ConnMgrEstablishConnectionSync或ConnMgrEstablishConnection 函数返回的连接句柄即可。ConnMgrReleaseConnection函数给连接管理器发送信号告诉它程序已经使用完连接，但是该函数并没有真正的关闭它。要理解什么时候连接才会真正的关闭，你需要理解ConnMgrReleaseConnection的lCache参数以及连接管理器是如何管理连接缓存的。

缓存连接 Caching the Connection

正如我们所知道的，建立连接会很消耗时间，为了避免在重复建立相同的连接上的花费，有时候在最后一个程序释放完连接以后，连接管理器还会继续维持该连接。这就是连接缓冲机制。应用程序能通过设置ConnMgrReleaseConnection 函数的lCache参数来改变连接管理器缓冲一个连接的时间，但最终做决定的还是连接管理器。表4显示了lCache参数可能的值：

参数值	描述
0	不缓冲连接
1	默认的缓冲时间
大于 1	缓冲用户指定的时间，以秒为单位

表4 ConnMgrReleaseConnection cache parameter values

如表4所示，如果参数设置为0，那么连接管理器立即关闭连接。设置为1则缓冲默认的时间，如下：

// Release the connection and cache it for the default time period. 
ConnMgrReleaseConnection(_connectionHandle, 1);

默认的缓冲时间定义在[HKEY_LOCAL_MACHINE\Comm\ConnMgr\Planner\Settings]注册表下的某个键值中。默认缓冲时间依赖于连接是否以独占模式创建。CacheTime键的值定义了非独占模式的默认缓冲时间，在大多数设备中被设置为600秒（10分钟）。对于独占模式，VPNCacheTime键定义了缓冲时间，大多数设备中位60秒（1分钟）。

注意独占连接只能被创建该连接的程序使用，而不能被其他程序使用。可以通过设置ConnMgrConnectionInfo.bExclusive字段为非0值来设置独占模式。大多数情况下，可以通过设置连接为共享模式（非独占）来更高效的利用设备资源。

Windows Mobile 5.0以前，程序只能指定连接是否能够缓存。Windows Mobile 5.0和Windows Mobile 6以后，你能够指定连接管理器缓存连接的时间。而这些只需要简单给ConnMgrReleaseConnection函数的lCache参数设置想要的时间数，而不是设置为0或1。如下代码，设置缓冲时间为300秒（5分钟）。

// Release the connection and cache it for 5 minutes. 
ConnMgrReleaseConnection(_connectionHandle, 300);

应该时刻记住，应用程序给ConnMgrReleaseConnection函数的lCache参数传递值只是一个请求，而连接管理可以选择忽略该请求。大多数情况下连接管理器不会考虑你的缓冲请求，连接管理器会将连接保持更长的缓冲时间。比如，当通过Ethernet cable连接网络或设备通过ActiveSync连接到桌面网路，那么设备将会有一个持续的连接。象这些类型的连接，网络连接是由Ethernet cable或依托设备（cradled device）建立的，他们会一直保持连接直到物理设备断开了连接。连接管理器管理这些连接，但是实际上却不打开或关闭它们。

另一种情况，连接管理器会在程序发送断开连接请求时保持更长的缓冲时间，那就是在维持该连接并不需要任何花费时。最普通的例子就是GPRS连接，GPRS radios并不消耗电源除非在进行数据传输时才会。而且，大多数情况下，移动运营商是根据连接的流量而不是连接时间来对GPRS收费的。

你可以通过Cellular Emulator看到连接管理器缓冲GPRS连接的过程，此时要确保Device Emulator核Cellular Emulator时刻保持连接。如果Cellular Emulator仍然保持活动的连接，可以通过点击Network页面下Disconnect GPRS按钮来断开连接。现在，运行以下代码：

Guid networkGuid = Guid.Empty; 
ConnMgrStatus status = ConnMgrStatus.Unknown; 
ConnMgrMapURL(url, ref networkGuid, 0); 
ConnMgrConnectionInfo info = new ConnMgrConnectionInfo(networkGuid, ConnMgrPriority.HighPriorityBackground); 
Debug.WriteLine("Attempting Sync Connect"); 
ConnMgrEstablishConnectionSync(info, ref _connectionHandle, _syncConnectTimeOut, ref status); 

if (status == ConnMgrStatus.Connected) 
ConnMgrReleaseConnection(_connectionHandle, 0); 
else 
Debug.WriteLine("Connection failed: " + status.ToString());

代码先调用过ConnMgrEstablishConnectionSync 函数，然后紧接着调用ConnMgrReleaseConnection函数。注意，我们给ConnMgrReleaseConnection函数的Cache参数传递0，来请求连接管理器立即关闭连接。

运行该代码后，你会在Cellular Emulator发现，之前的连接和以前一样还是处于活动状态，你会发现连接根本就没终止。Time(s)列的时间值一直保持增长，连接维持活动状态但是却不传输任何数据，而且，在真实设备中这并不会消耗任何电源。连接管理器忽略了断开请求中的不缓冲请求，而是继续连接而不消耗任何有效资源。

这种连接类型有时被称作“suspend/resume”（挂起/恢复）连接，也就是，当不再使用连接时，连接仍然被保持，只是进入高效的挂起状态。GPRS连接一般会保持无限持续连接状态，直到连接管理器返回该连接给应用程序并使用它时才活动。

结论 Conclusion

连接管理器是Windows Mobile中最强大的因素之一，它压缩了管理连接的细节，自动选择最好的连接，甚至跨程序共享连接。它支持大量特性，有时这会吓到用户，但是，大多数程序不必关心连接管理器的扩展因素。只需使用其中几个函数就可以轻松的建立连接，而让连接管理器去处理内部的细节。

其他资源 See Also

Connection Manager Reference

Windows Mobile Cellular Emulator

Windows Mobile Device Emulator

翻译完了，有点累，呵呵！以上译文，如有错误，欢迎指出！

我将文章所有的代码添加到了下面的工程中，上面的文章在获取连接状态时使用的是SystemState，我在代码里做了添加。另外，我还添加了使用MessageWindow派生类来获取连接状态的方法，并将其窗口句柄传递给ConnMgrConnectionInfo类的hWnd字段。当然，如上所说，你也可以将窗口句柄传递给ConnMgrRegisterForStatusChangeNotification函数的第二个参数，也能达到同样的效果！

本文链接

PDA开发系列：数据库的选择

2010-11-08T12:10:00Z

摘要

程序的最终运行环境是WINCE6.0，所以可以选择的数据库也相对比较的多，比方说：Access、SQLCE,当然还可以用XML来充当数据库，Access有个弊病，我想大家可能都知道，就是运行的时间一长，数据库文件会越来越大，尽管可以通过压缩的方式来释放掉，但是，这并不是一个好的选择；XML毕竟是个文本，效率不够高；SQLCE我不熟悉，在PDA上使用，好像还需要安装一些东西。我在这个项目中，选择的是SQLite数据库。

正文

SQLite是一个十分小巧的数据库，安装使用都非常的简单。我将一一的介绍：

创建数据库

创建我们自己的数据库，我推荐大家用SQLite Developer来创建。打开SQLite Developer，选择“数据库列表”，右键选择“创建数据库”，打开“创建数据库”界面，在“数据库”中选择一个数据库文件存储的位置，在“数据库别名”中，输入数据库名字，这个名字就是我们在程序中用到的名字。然后“确定”，这样，一个SQLite数据库就创建完成了。要创建表，只需要在在左侧的树中，选择刚才创建的数据库，右键选择创建表就可以了。如下：

连接数据库

在代码中连接SQLite数据库很简单，我们只需要添加对System.Data.SQLite.dll的引用，然后把SQLite.Interop.065.DLL放在运行目录下就可以了，然后就可以像操作我们属性的SQL Server一样去操作SQLite数据库。但是，在连接字符串的书写上，我们需要注意。我们需要给出绝对路径。如下面的写法：Data Source=\Userdata\ZFB.db3；通常，我们的数据库文件都是放在主程序所在文件夹下面，这就要求我们能够得到程序的启动路径，在wince6.0中，微软没有直接为我们提供获取程序启动路径的方法，这就要求我们自己去实现，我是这样获取的：

private static string _startPath = string.Empty;

        /// <summary>
        /// 获取应用程序启动的路径
        /// </summary>
        public static string StartPath
        {
            get
            {
                if (string.IsNullOrEmpty(_startPath))
                {
                    _startPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
                }
                return _startPath;
            }
        }

在这里，还有一点需要注意，我们再操作SQLite数据库的时候，如果程序没有找到SQLite数据库的时候，程序不会报“连接数据库失败”，他会在对应的文件夹下面自动创建一个数据库文件，当我们进一步去访问表的时候，就会报类似于“没有找到表”的错误，所以，在编程过程中，如果遇到“没有找到表”的错误，就应该去检查一下，路径下面是否有SQLite数据库文件。

PDA开发系列：GPS模块的调用

2010-11-08T11:26:00Z

摘要

在wince6.0中，要调用GPS模块，其实是一件很容易的事情。

正文

在wince6.0中，如果要调用GPS模块，其实很简单，微软已经为我们做好了这一切，我们只需要在自己的解决方案中，添加对Microsoft.WindowsMobile.Samples.Location.dll的引用就可以了，然后获取一个GPS的实例，如下：

static Gps _Gps = null;
        /// <summary>
        /// 获取GPS设备
        /// </summary>
        public Gps GpsDevice
        {
            get
            {
                if (_Gps == null)
                {
                    lock (typeof(Gps))
                    {
                        if (_Gps == null)
                        {
                            _Gps = new Gps();
                        }
                    }
                }
                return _Gps;
            }
        }

然后注册LocationChanged的事件，打开GPS设备就可以了，如下：

GpsDevice.LocationChanged += new LocationChangedEventHandler(GpsDevice_LocationChanged);

        void GpsDevice_LocationChanged(object sender, LocationChangedEventArgs args)
        {
            try
            {
                if (PdaServer.PDAServer.IsRun && PdaServer.PDAServer.GpsDevice.Opened)
                {
                    //经度
                    double Longitude = args.Position.Longitude;
                    //纬度
                    double Latitude = args.Position.Latitude;
                    if (Longitude > 0 && Latitude > 0)
                    {
                        //上传GPS
                    }
                }
            }
            catch { }
        }

其他相关的属性和方法见该dll。

本文链接

PDA开发系列：连接管理器

2010-10-30T18:11:00Z

摘要

Windows CE6中的连接管理器为我们管理各种网络提供了极大的便利，让我们不必去接触底层的驱动。

正文

ConnMgrApiReadyEvent

这个函数返回一个事件的句柄用来检查连接管理器的接口是否准备好

Syntax
HANDLE WINAPI ConnMgrApiReadyEvent (
    void
);
Parameters

Return Value

返回一个事件的句柄用来检查连接管理器的接口是否准备好，函数的调用者负责在使用完后关闭该事件句柄

Remarks

这个函数提供了一个方法来检查连接管理器的接口是否准备好

ConnMgrConnectionStatus

这个函数返回指定连接的连接状态

Syntax
HRESULT WINAPI ConnMgrConnectionStatus(
  HANDLE  hConnection,
  DWORD   *pdwStatus
); 
Parameters

hConnection

[in] ConnMgrEstablishConnection返回的连接句柄

pdwStatus

[out] 返回指定连接的连接状态

Return Value

S_OK表示成功,其它表示失败

Remarks

ConnMgrEnumDestinations

这个函数枚举出所有可用的网络

Syntax
HRESULT WINAPI ConnMgrEnumDestinations(
  int                      Index,
  CONNMGR_DESTINATION_INFO *pDestInfo
);
Parameters

Index

[in] 网络的序号。如果要获得所有的可用网络信息，需要在第一次调用的时候初始化为0，后面每次调用加1，知道返回一个错误值

pDestInfo

[out] 指向CONNMGR_DESTINATION_INFO结构体，其包含枚举出来的信息

Return Value

S_OK表示成功,其它表示失败

Remarks

ConnMgrEstablishConnection

这个函数创建一个异步连接请求

Syntax

HRESULT WINAPI ConnMgrEstablishConnection(

CONNMGR_CONNECTIONINFO *pConnInfo,

HANDLE *phConnection

);

Parameters

pConnInfo

[in] 指向结构体CONNMGR_CONNECTIONINFO，其中包含请求连接的相关参数

phConnection

[out] 一个指针指向一个连接的句柄

Return Value

S_OK表示成功,其它的值表示失败

Remarks

同一个时刻在手机中只能有一个连接，（彩信与Wifi、彩信与PC连接可以共存）

ConnMgrEstablishConnectionSync

这个函数创建一个同步的连接请求，直到连接成功或者失败后才返回

Syntax

HRESULT WINAPI ConnMgrEstablishConnectionSync(

CONNMGR_CONNECTIONINFO *pConnInfo,

HANDLE *phConnection,

DWORD dwTimeout,

DWORD *pdwStatus

);

Parameters

pConnInfo

[in] 指向结构体CONNMGR_CONNECTIONINFO，其中包含请求连接的相关参数

phConnection

[out] 一个指针指向一个连接的句柄

dwTimeout

[in] 连接超时的时间

pdwStatus

[out] 返回最终的连接状态，pdwStatus是Connection Manager Status Constants中的一个状态

Return Value

S_OK表示成功,其它表示失败

Remarks

同一个时刻在手机中只能有一个连接，（彩信与Wifi、彩信与PC连接可以共存）

dwTimeout参数不支持

ConnMgrMapConRef

这个函数映射连接信息到一个GUID

Syntax
HRESULT WINAPI ConnMgrMapConRef(
  ConnMgrConRefTypeEnum e,
  LPCTSTR               szConRef, 
  GUID                  *pGUID
);
Parameters

e

[in] 连接的类型

szConRef

[in] 与连接相关的信息

pGUID

[out] 返回一个连接的GUID

Return Value

S_OK表示成功,其它表示失败

Remarks

e 不支持

ConnMgrMapURL

这个函数返回一个可以到达指定URL的目的网络的GUID

Syntax
HRESULT WINAPI ConnMgrMapURL(
  LPTSTR   pwszURL,
  GUID     *pguid,
  DWORD    *pdwIndex
); 
Parameters

pwszURL

[in] 指向一个要隐射的URL

pguid

[out] 目标网络的GUID

pdwIndex

[in] 序号

Return Value

S_OK表示成功,其它表示失败

Remarks

pdwIndex不支持

ConnMgrProviderMessage

这个函数从连接管理器中获得一些信息

Syntax
HRESULT WINAPI ConnMgrProviderMessage(
  HANDLE         hConnection,
  const GUID     *pguidProvider,
  DWORD          *pdwIndex,
  DWORD          dwMsg1,
  DWORD          dwMsg2,
  PBYTE          pParams,
  ULONG          cbParamSize
);
Parameters

hConnection

[in] ConnMgrEstablishConnection返回的连接句柄

pguidProvider

[in] 只支持IID_ConnPrv_IProxyExtension

pdwIndex

[in] 不支持

dwMsg1

[in] 不支持

dwMsg2

[in] 不支持

pParams

[in] [out] 获取信息的相应结构体

cbParamSize

[in] pParams的大小

Return Value

S_OK表示成功,其它表示失败

Remarks

只支持获得代理信息

ConnMgrQueryDetailedStatus

这个函数用来查询连接管理器中所有连接的状态

Syntax
HRESULT WINAPI ConnMgrQueryDetailedStatus(
  CONNMGR_CONNECTION_DETAILED_STATUS *pStatusBuffer,
  DWORD                              *pcbBufferSize 
);
Parameters

pStatusBuffer

[in] 指向CONNMGR_CONNECTION_DETAILED_STATUS结构的内存空间，用来保存查询的结果

pcbBufferSize

[in][out] pStatusBuffer 的大小

Return Value

S_OK表示成功,其它表示失败

Remarks

这个函数只返回所有的数据连接，不会返回声音连接

ConnMgrRegisterForStatusChangeNotification

这个函数释放注册一个窗体句柄，当连接状态有变化时发送窗体消息通知

Syntax
HRESULT WINAPI ConnMgrRegisterForStatusChangeNotification(
  BOOL   fEnable,
  HWND   hWnd
);
Parameters

fEnable

[in] 注册或者取消窗体消息通知

hWnd

[in] 需要接收消息的窗体句柄

Return Value

S_OK表示成功,其它表示失败

Remarks

当有连接状态改变时，连接管理器通过窗体消息WM_CONNMGR_STATUS_CHANGE_NOTIFICATION_MSG 通知应用，其值为(WM_USER+0x1501)

ConnMgrReleaseConnection

这个函数释放一个指定的连接

Syntax
HRESULT WINAPI ConnMgrReleaseConnection(
  HANDLE   hConnection,
  LONG     lCache 
);
Parameters

hConnection

[in] ConnMgrEstablishConnection返回的连接句柄

lCache

[in] 在真正断网前的延时时间

Return Value

S_OK表示成功,其它表示失败

Remarks

lCache不支持

ConnMgrSetConnectionPriority

这个函数修改指定连接的优先级

Syntax
HRESULT WINAPI ConnMgrSetConnectionPriority(
  HANDLE   hConnection,
  DWORD    dwPriority
); 
Parameters

hConnection

[in] ConnMgrEstablishConnection返回的连接句柄

dwPriority

[in] 新的优先级

Return Value

S_OK表示成功,其它表示失败

Remarks

（以上函数说明来源自网络）

后续

从下节开始，将逐个介绍函数的用法。

本文链接

AutoIt学习系列：下载与安装

2010-10-30T17:37:00Z

摘要

AutoIt学习系列的文档将从此揭开序幕。首先，我们来装学习环境。

正文

要学习AutoIt，我们首先需要安装基本的运行环境。AutoIt的官方地址是http://www.autoitscript.com/，目前的最新版本是V3版。安装文件的下载地址是：http://www.autoitscript.com/cgi-bin/getfile.pl?autoit3/autoit-v3-setup.exe。

然后根据提示，一直下一步，直到安装结束。安装结束之后，在开始菜单中，将会看到如下新加项：

其中AutoIt Window Info是以个相当于VS安装目下的Spy++的程序，运行界面如下：

拖动Finder Tool，就是界面上的那个圆盘，可以得到指定窗口相关的信息。Run Script是用来运行我们编写的脚本的，SciTE Script Editor就是我们后面用得最多的脚本编辑器。界面如下：

至此，AutoIt的下载和安装部分就介绍到这里。从下节开始，将进入主题。

本文链接

AutoIt学习系列：目录

2010-10-30T17:07:00Z

摘要

AutoIt是一个类似于QTP的自动化工具。他可以模拟键盘在特定文本区输入，也可以模拟鼠标的点击以及拖动窗口。本系列将以官方的帮助文档为依据，力争还原每一个实例。下载安装部分，我将简要介绍。

AutoIt学习系列：基本语法

目录持续更新中。。。

PDA开发系列：BackgroundWorker

2010-10-27T12:51:00Z

摘要

在.net compact framework中，没有BackgroundWorker，应该会让我们这些用惯了BackgroundWorker的人感到非常的不便。BackgroundWorker可以非常方便解决线程和控件之间的互操作问题，做出界面运行非常流畅的引用程序。

正文

在反编译了.net framework的BackgroundWorker后，发现基本上95%以上的代码都可以直接COPY过来，唯一存在问题的就是下面这段代码：

if (this.asyncOperation != null)
        {
            this.asyncOperation.Post(this.progressReporter, arg);
        }
        else
        {
            this.progressReporter(arg);
        }

这段代实际上要做的事情是这样的：如果执行该方法的线程和控件所在的线程不是同一个线程，就把该委托交给控件所在的线程去执行，否则就直接执行，为了实现这个操作，我做了如下的改动，在构造函数中，我这样写：

public BackgroundWorker()
{
    this.threadStart = new WorkerThreadStartDelegate(this.WorkerThreadStart);
    this.operationCompleted = new SendOrPostCallback(this.AsyncOperationCompleted);
    this.progressReporter = new SendOrPostCallback(this.ProgressReporter);
    this.Handler = Thread.CurrentThread.ManagedThreadId;
}

所以，上面的代码我做了如下的改写：

if (Thread.CurrentThread.ManagedThreadId!= this.Handler)
{
Post(this.progressReporter, arg);
}
else
{
this.progressReporter(arg);
}

Post方法的代码如下：

public virtual void Post(SendOrPostCallback d, object state)
{
    if (d != null && controlToSendTo != null)
    {
        controlToSendTo.Invoke(d, state);
    }
}

controlToSendTo 是调用该BackgroundWorker得用户控件。该BackgroundWorker得所有代码是这样的：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

namespace ZFB.PDA.Dao
{
    public class BackgroundWorker : Component
    {
        private bool canCancelWorker;
        private bool cancellationPending;
        private static readonly object doWorkKey = new object();
        private bool isRunning;
        private readonly SendOrPostCallback operationCompleted;
        private static readonly object progressChangedKey = new object();
        private readonly SendOrPostCallback progressReporter;
        private static readonly object runWorkerCompletedKey = new object();
        private readonly WorkerThreadStartDelegate threadStart;
        private readonly int Handler = 0;
        private Control controlToSendTo = null;


        /// <summary>
        /// 开始后台任务
        /// </summary>
        public event DoWorkEventHandler DoWork
        {
            add
            {
                base.Events.AddHandler(doWorkKey, value);
            }
            remove
            {
                base.Events.RemoveHandler(doWorkKey, value);
            }
        }

        /// <summary>
        /// 后台任务执行的进度
        /// </summary>
        public event ProgressChangedEventHandler ProgressChanged
        {
            add
            {
                base.Events.AddHandler(progressChangedKey, value);
            }
            remove
            {
                base.Events.RemoveHandler(progressChangedKey, value);
            }
        }

        /// <summary>
        /// 后台任务完成
        /// </summary>
        public event RunWorkerCompletedEventHandler RunWorkerCompleted
        {
            add
            {
                base.Events.AddHandler(runWorkerCompletedKey, value);
            }
            remove
            {
                base.Events.RemoveHandler(runWorkerCompletedKey, value);
            }
        }

        public BackgroundWorker()
        {
            this.threadStart = new WorkerThreadStartDelegate(this.WorkerThreadStart);
            this.operationCompleted = new SendOrPostCallback(this.AsyncOperationCompleted);
            this.progressReporter = new SendOrPostCallback(this.ProgressReporter);
            this.Handler = Thread.CurrentThread.ManagedThreadId;
        }

        private void AsyncOperationCompleted(object arg)
        {
            this.isRunning = false;
            this.cancellationPending = false;
            this.OnRunWorkerCompleted((RunWorkerCompletedEventArgs)arg);
        }

        public void CancelAsync()
        {
            this.cancellationPending = true;
        }

        protected virtual void OnDoWork(DoWorkEventArgs e)
        {
            DoWorkEventHandler handler = (DoWorkEventHandler)base.Events[doWorkKey];
            if (handler != null)
            {
                handler(this, e);
            }
        }

        protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
        {
            ProgressChangedEventHandler handler = (ProgressChangedEventHandler)base.Events[progressChangedKey];
            if (handler != null)
            {
                handler(this, e);
            }
        }

        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
        {
            RunWorkerCompletedEventHandler handler = (RunWorkerCompletedEventHandler)base.Events[runWorkerCompletedKey];
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private void ProgressReporter(object arg)
        {
            this.OnProgressChanged((ProgressChangedEventArgs)arg);
        }

        public void ReportProgress(int percentProgress)
        {
            this.ReportProgress(percentProgress, null);
        }

        public void ReportProgress(int percentProgress, object userState)
        {
            ProgressChangedEventArgs arg = new ProgressChangedEventArgs(percentProgress, userState);
            if (Thread.CurrentThread.ManagedThreadId!= this.Handler)
            {
                Post(this.progressReporter, arg);
            }
            else
            {
                this.progressReporter(arg);
            }
        }

        public void RunWorkerAsync(Control ctl)
        {
            this.RunWorkerAsync(ctl,null);
        }

        public void RunWorkerAsync(Control ctl,object argument)
        {
            if (this.isRunning)
            {
                throw new InvalidOperationException("BackgroundWorker_WorkerAlreadyRunning");
            }
            if (ctl == null)
            {
                throw new Exception();
            }
            controlToSendTo = ctl;
            this.isRunning = true;
            this.cancellationPending = false;
            this.threadStart.Invoke(argument);
        }

        private void WorkerThreadStart(object argument)
        {
            object result = null;
            Exception error = null;
            bool cancelled = false;
            try
            {
                DoWorkEventArgs e = new DoWorkEventArgs(argument);
                this.OnDoWork(e);
                if (e.Cancel)
                {
                    cancelled = true;
                }
                else
                {
                    result = e.Result;
                }
            }
            catch (Exception exception2)
            {
                error = exception2;
            }
            RunWorkerCompletedEventArgs arg = new RunWorkerCompletedEventArgs(result, error, cancelled);
            if (Thread.CurrentThread.ManagedThreadId != this.Handler)
            {
                Post(this.operationCompleted, arg);
            }
            else
            {
                this.operationCompleted(arg);
            }
        }

        public bool CancellationPending
        {
            get
            {
                return this.cancellationPending;
            }
        }

        public bool IsBusy
        {
            get
            {
                return this.isRunning;
            }
        }

        public bool WorkerSupportsCancellation
        {
            get
            {
                return this.canCancelWorker;
            }
            set
            {
                this.canCancelWorker = value;
            }
        }

        public virtual void Post(SendOrPostCallback d, object state)
        {
            if (d != null && controlToSendTo != null)
            {
                controlToSendTo.Invoke(d, state);
            }
        }

        private delegate void WorkerThreadStartDelegate(object argument);
        public delegate void SendOrPostCallback(object state);
    }

}

后续

如果大家有更好的办法，希望大家给我留言。。。

代码下载：BackgroundWorker

本文链接

PDA开发系列：Google地图接口

2010-10-23T14:44:00Z

摘要

Google的地图接口，相信大家都不陌生，N多人都比我这个菜鸟熟悉得多，我就不班门弄斧了，在这里我只介绍在我们项目中用到的几个实现。

正文

在我们的项目中，需求很简单，主要有以下几个方面：

1.在地图上描点，显示已经标注过的点的名字。

2.在地图上用不同的点显示在线人员的位置。

3.显示人员的移动轨迹。

我们用的Google的地图API的V3版本，因为V2版本要根据网址生成不同的密钥，很麻烦，而V3就不需要。下面是实现的效果：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML><HEAD>

<title>Google Maps</title>
<link href="http://code.google.com/apis/maps/documentation/javascript/examples/default.css" rel="stylesheet" type="text/css" />
<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=true"></script>
<script type="text/javascript" src="http://code.google.com/apis/gears/gears_init.js"></script>

<SCRIPT type=text/javascript>
window.onload=function()
{
    var myLatlng = new google.maps.LatLng(31.165598, 121.519861); 
    var myOptions = {   zoom: 15,   center: myLatlng,   mapTypeId: google.maps.MapTypeId.ROADMAP };
    var map = new google.maps.Map(document.getElementById("map_canvas"), myOptions);

      var marker = new google.maps.Marker({       position: myLatlng,       title:"白宫"   });        
      marker.setMap(map);

      var flightPlanCoordinates = [     new google.maps.LatLng(31.165598, 121.519861),     new google.maps.LatLng(31.166598, 121.518861),     new google.maps.LatLng(31.163598, 121.516861),     new google.maps.LatLng(31.164598, 121.517861)   ];   var flightPath = new google.maps.Polyline({     path: flightPlanCoordinates,     strokeColor: "green",     strokeOpacity: 1.0,     strokeWeight: 5   });    flightPath.setMap(map); 

      var contentString = '白宫';  var infowindow = new google.maps.InfoWindow({     content: contentString });  
      google.maps.event.addListener(marker, 'click', function() {   infowindow.open(map,marker); });

      var image = new google.maps.MarkerImage("http://files.cnblogs.com/HOH/User.ico");
      var myLatLng = new google.maps.LatLng(31.165798, 121.517861); 
      var beachMarker = new google.maps.Marker({position: myLatLng,map: map,icon: image,title:"奥巴马"   });
}
</SCRIPT>
</HEAD>
<BODY >
<DIV style="WIDTH: 500; HEIGHT: 500" id=map_canvas></DIV></BODY></HTML>

下面是运行的效果：

地图

卫星

混合

地形

本文链接