书中给了一些建议和方法：

一是有计划地对付错误。

对应用程序展开适当的调试，应该是远在你使用调试器之前就开始了。多多使用ASSERT调试措施。（ASSERT背后的概念是安全和速度之间的交换。程序运行因此运行得比较慢，但是Debug Build的制造就是为了调试，所以可以理解）在每一个你的假设之处做检验工作。进入一个函数时，确认所有状态。不要只是检查指针是否合法；如果可能，检查一下指针所指的结构中的数据是否一致。

二是Bench Testing

其实这种方法就是先撇开多线程的环境，测试程序逻辑的正确性。如果OK了，然后再考虑与线程相关的东西。

三是线程对话框

这里主要讨论了对一个特定的线程如何调试，方法是挂起所有的线程——除了我们关注的那个。书中介绍的方法在vs 2005我没有找到。

四是日志记录

这里主要是在控制台窗口显示一些运行信息，我们可以使用printf等函数在控制台输出一些信息来查看线程的运行次序。

五是内存记号

使用内存记号的好处就是降低彼此干扰的可能性。但是也要注意它不是同步操作，可能会因为两个线程的同时写入引来问题。

六是硬件调试寄存器

前面的这六种方法我也只用过三种，有一些还真是第一次见到。不过不怕下次搞不定问题的时候可以拿来进行尝试，来抓一抓隐藏在程序中的“臭虫们”。

成功消除多线程程序的“臭虫”，作者说需要具备三种素养：决心、耐心、创造力。同时也不要蛮干，要采用科学的方法：观察、预测、测试。

总结一下：借助方法，观察现象，大胆预测，勇敢尝试，完备测试。

项目中也碰到了多线程的使用。未来可能多线程的使用会越来越多，不能停留在完成功能和任务上，应该多思考多测试。避免多线程的不可确定性带来的一些困扰。

学习书籍：《Win32 多线程程序设计》侯捷译

　　可以自行创建一接入点。以下代码创建一个CMWAP接入点：

CString strFavoriteXml =
L"<wap-provisioningdoc>"
L"<characteristic type="CM_Networks">"
L"<characteristic type="Test_GPRS">"
L"<parm name="DestId" value="{D1D06580-C364-55ec-9421-6ACF34129C58}" />"
L"</characteristic>"
L"</characteristic>"
L"<characteristic type="CM_GPRSEntries">"
L"<characteristic type="Test_GPRS">"
L"<parm name="DestId" value="{D1D06580-C364-55ec-9421-6ACF34129C58}" />"
L"<characteristic type="DevSpecificCellular">"
L"<parm name="BearerInfoValid" value="1" />"
L"<parm name="GPRSInfoValid" value="1" />"
L"<parm name="GPRSInfoProtocolType" value="2" />"
L"<parm name="GPRSInfoL2ProtocolType" value="PPP" />"
L"<parm name="GPRSInfoAccessPointName" value="cmwap" />"
L"<parm name="GPRSInfoAddress" value="" />"
L"<parm name="GPRSInfoDataCompression" value="1" />"
L"<parm name="GPRSInfoHeaderCompression" value="1" />"
L"<parm name="GPRSInfoParameters" value="" />"
L"</characteristic>"
L"</characteristic>"
L"</characteristic>"
L"<characteristic type="CM_ProxyEntries">"
L"<characteristic type="WAP">"
L"<parm name="SrcId" value="{D1D06580-C364-55ec-9421-6ACF34129C58}" />"
L"<parm name="DestId" value="{436EF144-B4FB-4863-A041-8F905A62C572}" />"
L"<parm name="Proxy" value="10.0.0.172:80" />"
L"<parm name="Enable" value="1" />"
L"<parm name="Type" value="1" />"
L"</characteristic>"
L"</characteristic>"
L"</wap-provisioningdoc>";
　　
LPWSTR pszwXMLout = NULL;
HRESULT hr = DMProcessConfigXML(strFavoriteXml, CFGFLAG_PROCESS, &pszwXMLout);
　　
if ( pszwXMLout )
{
　delete [] pszwXMLout;
　pszwXMLout = NULL;
}

Windows Mobile 6 SDK 中的 Cellular Emulator

  if (SUCCEEDED(SimReadPhonebookEntry(lphSim, SIM_PBSTORAGE_SIM, i+1, &phoneent)))
  {
   CONTACTSTRUCT tempContact = {0};

   wcsncpy(tempContact.szName, phoneent.lpszText, 31); // 姓名
   wcsncpy(tempContact.szTelNum, phoneent.lpszAddress, 31); // 电话

   vContact.push_back(tempContact );
  }
 }

 //最后别忘了清理      
 SimDeinitialize(lphSim);
 lphSim = NULL;

这里读取的时候用了dwTotal，是因为听有经验的人说，sim卡的存储可能不连续，如果用dwUsed的话，可能会有问题。

积累一下，有时间再好好看一下outlook联系人的。

参考文章：
Pocket 中获取SIM卡中联系人信息
http://blog.csdn.net/xulg1984/archive/2008/05/30/2497712.aspx

转自: http://www.cnblogs.com/dotnetearthworm/archive/2009/02/02/1382488.html

.sln：解决方案文件，为解决方案资源管理器提供显示管理文件的图形接口所需的信息。

.csproj:项目文件，创建应用程序所需的引用、数据连接、文件夹和文件的信息。

.aspx：Web 窗体页由两部分组成：视觉元素（HTML、服务器控件和静态文本）和该页的编程逻辑。Visual Studio 将这两个组成部分分别存储在一个单独的文件中。视觉元素在.aspx 文件中创建。

.ascx：ASP.NET的用户控件（也叫做“pagelets”），是作为一种封装了特定功能和行为（这两者要被用在Web应用程序的各种页面上）的Web页面被开发的。一个用户控件包含了HTML、代码和其他Web或者用户控件的组合，并在Web服务器上以自己的文件格式保存，其扩展名是*.ascx。ASP.NET里的缺省配置并不允许Web客户端通过URL来访问这些文件，但是这个网站的其他页面可以集成这些文件里所包含的功能。

.aspx.cs：Web 窗体页的编程逻辑位于一个单独的类文件中，该文件称作代码隐藏类文件（.aspx.cs）。

.cs： 类模块代码文件。业务逻辑处理层的代码。

.asax：Global.asax 文件（也叫做 ASP.NET 应用程序文件）是一个可选的文件，该文件包含响应 ASP.NET 或 HTTP 模块引发的应用程序级别事件的代码。

.config：Web.config 文件向它们所在的目录和所有子目录提供配置信息。

.aspx.resx/.resx：资源文件，资源是在逻辑上由应用程序部署的任何非可执行数据。通过在资源文件中存储数据，无需重新编译整个应用程序即可更改数据。 51aspx.com

.XSD:XML schema的一种.从DTD,XDR发展到XSD

.pdb:PDB（程序数据库）文件保持着调试和项目状态信息，从而可以对程序的调试配置进行增量链接。

.suo:解决方案用户选项,记录所有将与解决方案建立关联的选项，以便在每次打开时，它都包含您所做的自定义设置。

.asmx：.asmx文件包含 WebService 处理指令，并用作 XML Web services 的可寻址入口点 51aspx。

.vsdisco（项目发现）文件 基于 XML 的文件，它包含为 Web 服务提供发现信息的资源的链接 (URL-51aspx )。

.htc:一个HTML文件,包含脚本和定义组件的一系列HTC特定元素.htc提供在脚本中implement组件的机制

来源： .Net中文社区（http://www.aspxcs.net/)

上面是我看到的一些介绍,这里再补充一些:
  .clw   支持ClassWizard  
  .ncb   支持ClassView  
  .opt   保存工作空间的配置  
  .aps   支持ResourceView  
  .bsc   浏览器信息文件  
  .dsp   项目文件  
  .dsw   工作空间文件  
  .mak   外部的创建文件  
  .plg   建立日志文件 

Let's analyze what a title like Learn Pascal in Three Days could mean:

Learn: In 3 days you won't have time to write several significant programs, and learn from your successes and failures with them. You won't have time to work with an experienced programmer and understand what it is like to live in that environment. In short, you won't have time to learn much. So they can only be talking about a superficial familiarity, not a deep understanding. As Alexander Pope said, a little learning is a dangerous thing.

Pascal: In 3 days you might be able to learn the syntax of Pascal (if you already knew a similar language), but you couldn't learn much about how to use the syntax. In short, if you were, say, a Basic programmer, you could learn to write programs in the style of Basic using Pascal syntax, but you couldn't learn what Pascal is actually good (and bad) for. So what's the point? Alan Perlis once said: "A language that doesn't affect the way you think about programming, is not worth knowing". One possible point is that you have to learn a tiny bit of Pascal (or more likely, something like Visual Basic or javascript) because you need to interface with an existing tool to accomplish a specific task. But then you're not learning how to program; you're learning to accomplish that task.

in Three Days: Unfortunately, this is not enough, as the next section shows.
Teach Yourself Programming in Ten Years
Researchers (Hayes, Bloom) have shown it takes about ten years to develop expertise in any of a wide variety of areas, including chess playing, music composition, painting, piano playing, swimming, tennis, and research in neuropsychology and topology. There appear to be no real shortcuts: even Mozart, who was a musical prodigy at age 4, took 13 more years before he began to produce world-class music. In another genre, the Beatles seemed to burst onto the scene, appearing on the Ed Sullivan show in 1964. But they had been playing since 1957, and while they had mass appeal early on, their first great critical success, Sgt. Peppers, was released in 1967. Samuel Johnson thought it took longer than ten years: "Excellence in any department can be attained only by the labor of a lifetime; it is not to be purchased at a lesser price." And Chaucer complained "the lyf so short, the craft so long to lerne."
Here's my recipe for programming success:

Get interested in programming, and do some because it is fun. Make sure that it keeps being enough fun so that you will be willing to put in ten years.

Talk to other programmers; read other programs. This is more important than any book or training course.

Program. The best kind of learning is learning by doing. To put it more technically, "the maximal level of performance for individuals in a given domain is not attained automatically as a function of extended experience, but the level of performance can be increased even by highly experienced individuals as a result of deliberate efforts to improve." (p. 366) and "the most effective learning requires a well-defined task with an appropriate difficulty level for the particular individual, informative feedback, and opportunities for repetition and corrections of errors." (p. 20-21) The book Cognition in Practice: Mind, Mathematics, and Culture in Everyday Life is an interesting reference for this viewpoint.

If you want, put in four years at a college (or more at a graduate school). This will give you access to some jobs that require credentials, and it will give you a deeper understanding of the field, but if you don't enjoy school, you can (with some dedication) get similar experience on the job. In any case, book learning alone won't be enough. "Computer science education cannot make anybody an expert programmer any more than studying brushes and pigment can make somebody an expert painter" says Eric Raymond, author of The New Hacker's Dictionary. One of the best programmers I ever hired had only a High School degree; he's produced a lot of great software, has his own news group, and through stock options is no doubt much richer than I'll ever be.

Work on projects with other programmers. Be the best programmer on some projects; be the worst on some others. When you're the best, you get to test your abilities to lead a project, and to inspire others with your vision. When you're the worst, you learn what the masters do, and you learn what they don't like to do (because they make you do it for them).

Work on projects after other programmers. Be involved in understanding a program written by someone else. See what it takes to understand and fix it when the original programmers are not around. Think about how to design your programs to make it easier for those who will maintain it after you.

Learn at least a half dozen programming languages. Include one language that supports class abstractions (like Java or C++), one that supports functional abstraction (like Lisp or ML), one that supports syntactic abstraction (like Lisp), one that supports declarative specifications (like Prolog or C++ templates), one that supports coroutines (like Icon or Scheme), and one that supports parallelism (like Sisal).

Remember that there is a "computer" in "computer science". Know how long it takes your computer to execute an instruction, fetch a word from memory (with and without a cache miss), read consecutive words from disk, and seek to a new location on disk. (Answers here.)

Get involved in a language standardization effort. It could be the ANSI C++ committee, or it could be deciding if your local coding style will have 2 or 4 space indentation levels. Either way, you learn about what other people like in a language, how deeply they feel so, and perhaps even a little about why they feel so.

Have the good sense to get off the language standardization effort as quickly as possible.
With all that in mind, its questionable how far you can get just by book learning. Before my first child was born, I read all the How To books, and still felt like a clueless novice. 30 Months later, when my second child was due, did I go back to the books for a refresher? No. Instead, I relied on my personal experience, which turned out to be far more useful and reassuring to me than the thousands of pages written by experts.
Fred Brooks, in his essay No Silver Bullets identified a three-part plan for finding great software designers:

Systematically identify top designers as early as possible.

Assign a career mentor to be responsible for the development of the prospect and carefully keep a career file.

Provide opportunities for growing designers to interact and stimulate each other.

This assumes that some people already have the qualities necessary for being a great designer; the job is to properly coax them along. Alan Perlis put it more succinctly: "Everyone can be taught to sculpt: Michelangelo would have had to be taught how not to. So it is with the great programmers".
So go ahead and buy that Java book; you'll probably get some use out of it. But you won't change your life, or your real overall expertise as a programmer in 24 hours, days, or even months.

References
Bloom, Benjamin (ed.) Developing Talent in Young People, Ballantine, 1985.

Brooks, Fred, No Silver Bullets, IEEE Computer, vol. 20, no. 4, 1987, p. 10-19.

Hayes, John R., Complete Problem Solver Lawrence Erlbaum, 1989.

Lave, Jean, Cognition in Practice: Mind, Mathematics, and Culture in Everyday Life, Cambridge University Press, 1988.
http://www.norvig.com/

在Windows Mobile 5.0SDK的HelloSMS例子中，发送短信的代码是这样写的

void SendSMS(BOOL bSendConfirmation, BOOL bUseDefaultSMSC, LPCTSTR lpszSMSC, LPCTSTR lpszRecipient, LPCTSTR lpszMessage)
{
    SMS_HANDLE smshHandle;
    SMS_ADDRESS smsaSource;
    SMS_ADDRESS smsaDestination;
    TEXT_PROVIDER_SPECIFIC_DATA tpsd;
    SMS_MESSAGE_ID smsmidMessageID;

    // try to open an SMS Handle
    if(FAILED(SmsOpen(SMS_MSGTYPE_TEXT, SMS_MODE_SEND, &smshHandle, NULL)))
    {
        MessageBox(NULL,
                    (LPCTSTR)LoadString(ghInstance, IDS_ERROR_SMSOPEN, 0, 0), 
                    (LPCTSTR)LoadString(ghInstance, IDS_CAPTION_ERROR, 0, 0),
                    MB_OK | MB_ICONERROR);
        return;
    }

    // Create the source address
    if(!bUseDefaultSMSC)
    {
        smsaSource.smsatAddressType = SMSAT_INTERNATIONAL;
        _tcsncpy(smsaSource.ptsAddress, lpszSMSC, SMS_MAX_ADDRESS_LENGTH);
    }

    // Create the destination address
    smsaDestination.smsatAddressType = SMSAT_INTERNATIONAL;
    _tcsncpy(smsaDestination.ptsAddress, lpszRecipient, SMS_MAX_ADDRESS_LENGTH);

    // Set up provider specific data
    memset(&tpsd, 0, sizeof(tpsd));
    tpsd.dwMessageOptions = bSendConfirmation ? PS_MESSAGE_OPTION_STATUSREPORT : PS_MESSAGE_OPTION_NONE;
    tpsd.psMessageClass = PS_MESSAGE_CLASS1;
    tpsd.psReplaceOption = PSRO_NONE;
    tpsd.dwHeaderDataSize = 0;

    // Send the message, indicating success or failure
    if(SUCCEEDED(SmsSendMessage(smshHandle, ((bUseDefaultSMSC) ? NULL : &smsaSource), 
                                 &smsaDestination, NULL, (PBYTE) lpszMessage, 
                                 _tcslen(lpszMessage) * sizeof(TCHAR), (PBYTE) &tpsd, 
                                 sizeof(TEXT_PROVIDER_SPECIFIC_DATA), SMSDE_OPTIMAL, 
                                 SMS_OPTION_DELIVERY_NONE, &smsmidMessageID)))
    {
        MessageBox(NULL,
                    (LPCTSTR)LoadString(ghInstance, IDS_SMSSENT, 0, 0), 
                    (LPCTSTR)LoadString(ghInstance, IDS_CAPTION_SUCCESS, 0, 0),
                    MB_OK);
    }
    else
    {
        MessageBox(NULL,
                    (LPCTSTR)LoadString(ghInstance, IDS_ERROR_SMSSEND, 0, 0), 
                    (LPCTSTR)LoadString(ghInstance, IDS_CAPTION_ERROR, 0, 0),
                    MB_OK | MB_ICONERROR);
    }

    // clean up
    VERIFY(SUCCEEDED(SmsClose(smshHandle)));
}

这段代码在一般情况下是运行正确的，对于手机与手机的发送是不存在问题的，但是与SP的交互在某些省区就存在短信发送不出去的情况。

为了更好的理解这段代码，我们先来熟悉一下SmsSendMessage及各个参数。

SmsSendMessage

功能：Use the SmsSendMessage function to create and send an Short Message Service (SMS) message.（创建和发送短信，但短信发送后并不保存到发件箱中）

原型：

HRESULT SmsSendMessage (

const SMS_HANDLE smshHandle, // 调用SmsOpen时获得的短信句柄

const SMS_ADDRESS * const psmsaSMSCAddress, //指向短信中心号码的地址

const SMS_ADDRESS * const psmsaDestinationAddress, // 发送的目的地址

const SYSTEMTIME * const pstValidityPeriod, // 发送时间的有效期

const BYTE * const pbData, // 信息的内容部分

const DWORD dwDataSize,// 信息内容的长度

const BYTE * const pbProviderSpecificData, //运营商的附加数据

const DWORD dwProviderSpecificDataSize, // 附加数据的长度

const SMS_DATA_ENCODING smsdeDataEncoding, // 短信编码

const DWORD dwOptions, // 其他选项

SMS_MESSAGE_ID * psmsmidMessageID); // 用于得到系统回执的信息

（具体介绍可查看http://msdn.microsoft.com/en-us/library/aa455068.aspx）

在实际应用中短信发送不出去，但是SmsSendMessage的返回值是S_OK值。在一些文章中有人这样认为是短信编码的问题造成的。

如果编码格式不对可能造成短信中心网关把短信给吞掉的情况，程序虽然调用成功，但是就是目标号码收不到短信。函数参数中的后三个参数可以不用或设默认值都可以。

起初我也是认为这个地方造成的，很是兴奋。短信的回复内容恰为字母，我误以为短信内容此时是7-BIT的短消息，短信网关把短信给吞掉了，造成目标号码收不到短信。在练习中却也阴差阳错的成功了。很高兴的把理由归到了这个地方。并这样总结：SmsSendMessage可以支持7-bit的ASCII码的短消息，也支持16-bit的unicode的短消息。但内容为ASCII的时候，短信编码为 SMSDE_GSM或SMSDE_OPTIMAL，当内容不全是ASCII的时候，短信编码为SMSDE_GSM或SMSDE_OPTIMAL。所以回复内容改为汉字即可。

但是这样对么？起初我认为我的解释很合理.但是我却发现我的一个参数与原来的程序不一样.

是我在尝试中无意修改了一个参数,将

tpsd.psMessageClass = PS_MESSAGE_CLASS1;

修改为了

tpsd.psMessageClass = PS_MESSAGE_CLASSUNSPECIFIED;

这是发送短信中的运营商的指定数据TEXT_PROVIDER_SPECIFIC_DATA,它的参数psMessageClass是指

Text Short Message Service (SMS) messages with the appropriate flag can replace previously received notifications with a similar flag and originating address.

它有以下五个值:

PS_MESSAGE_CLASS0: The message should be displayed immediately but not stored. The MS shall send an acknowledgement to the service center when the message has successfully reached the MS. （被接受后立即显示但不存储(称为闪信)。需要向SMSC发送确认信息。）

PS_MESSAGE_CLASS1：The message should be stored and an acknowledgement should be sent to the Service Center when it is stored.（接收后被存储，一旦存储，需要向SMSC发送确认信息。）

PS_MESSAGE_CLASS2：The message should be transferred to the SMS data field in the subscriber identity module (SIM) before an acknowledgement is sent to the Service Center.

PS_MESSAGE_CLASS3：When the message has successfully reached the destination and can be stored, an acknowledgement is sent to the Service Center.

PS_MESSAGE_CLASSUNSPECIFIED：The message Class is not set in the outgoing or incoming message. （对发出或收到的短信不进行设置）

分析以上五个值，前四个值有一个共同的特点，都需要向SMSC发送确认。而最后一个值没有设定。

这个值的改动，解决了我所遇到的问题。但究其原因,我有些想不通为什么?
    但是在实际应用中，出现了tmail.exe的异常。不知道是这个值的变动带来的问题，还是实际模块中存在的问题。还需要继续研究一下。

如果大家有知道的,给些建议哈.

我对这段话的理解是：当空闲内存小于Hibernate时，系统便会尝试释放内存。首先他会向所有有效的程序发送WM_HIBERNATE。应用程序收到该消息后，会尽量释放资源来释放内存。如果还低于这个值的话，将发送WM_CLOSE消息给最近很少使用的程序。如果还低于该值的，就强行关闭该程序了。

这个方法似乎有效，但是用户再起来程序的话，还是一样的效果，并不是达到了什么释放内存的效果。如何记录最近很少使用的程序，这个是不是有什么方法获得呢？

就可以像系统提示的那样，内存不足，请释放一些内存。手工做一些比较好。

也看了一些相近的程序的做法，似乎效果也没有大家说的那么好。

在How the Windows Mobile 5.0 Shell Handles Low Memory Situations的最后，这样写的

What can my Application do?

The best thing your application can do when faced with a low memory situation is to play nicely with the rest of the device. 

1、If your application receives a WM_HIBERNATE message free up any resources not absolutely required. 
2、If you are planning on allocating a large amount of memory (or if a large allocation fails) you should call SHCloseApps, which will invoke the shell low memory check routine and will try to ensure that enough free memory exists. See below for an example:

#define MIN_MEMORY_TO_RUN 2*1024*1024

MEMORYSTATUS mst;

mst.dwLength  = sizeof(MEMORYSTATUS);

GlobalMemoryStatus(&mst);

If (mst.dwAvailPhys < MIN_MEMORY_TO_RUN)

{

    // Try to free memory by asking Shell to shutdown apps

    if (!SHCloseApps(MIN_MEMORY_TO_RUN))

    {

        // Handle the case where memory could not be freed

        …

例子：

void ShowError()
{
    DWORD dwError = GetLastError();

    HLOCAL hlocal = NULL;

    // Use the default system locale since we look for Windows messages.
    // Note: this MAKELANGID combination has 0 as value
    DWORD systemLocale = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);

    BOOL fOk = FormatMessage(
        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |
        FORMAT_MESSAGE_ALLOCATE_BUFFER, 
        NULL, dwError, systemLocale, 
        (PTSTR) &hlocal, 0, NULL);

    if (!fOk) {
        // Is it a network-related error?
        HMODULE hDll = LoadLibraryEx(TEXT("netmsg.dll"), NULL, 
            DONT_RESOLVE_DLL_REFERENCES);

        if (hDll != NULL) {
            fOk = FormatMessage(
                FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS |
                FORMAT_MESSAGE_ALLOCATE_BUFFER,
                hDll, dwError, systemLocale,
                (PTSTR) &hlocal, 0, NULL);
            FreeLibrary(hDll);
        }
    }

    if (fOk && (hlocal != NULL))
    {
        OutputDebugString((PCTSTR) LocalLock(hlocal));
        LocalFree(hlocal);
    }
}

      这个是书中的例子的代码，我只是将它归结为了一个函数ErrorShow。这样我们在一个函数的后面调用，直接可以知道错误的原因。不过环境我是在smart device 的DEBUG环境下调时的，OutputDebugString会输出相应的字符串。

      这个例子中同时展示了FormatMessage的两种用法。观察一下第二个参数就明白了。

      visual studio 也提供了一个查询错误的小工具，为Error Lookup。通过以上的示例，我们就知道其相应的工作原理呢。

      这本书的源码的下载地址：http://wintellect.com/Books.aspx 
      大家如果对windows 编程感兴趣的话，不妨下来看看。

BOOL WriteFile(

 HANDLE hFile, // 文件句柄

 LPCVOID lpBuffer, // 包含写向文件的数据

 DWORD nNumberOfBytesToWrite, // 数据包含的字符串的个数

 LPDWORD lpNumberOfBytesWritten,

 LPOVERLAPPED lpOverlapped

);

第一次我写的程序很简单

BOOL WriteOwnFile(TCHAR* pFileName, TCHAR* pBuffer, DWORD dwLen)

{

        HANDLE hFile = CreateFile(pFileName,

                       GENERIC_WRITE,

                                              FILE_SHARE_WRITE,

                                              NULL,

                                              CREATE_ALWAYS,

                                              FILE_ATTRIBUTE_NORMAL,

                                              NULL

                                              ）；

                 if (INVALID_HANDLE_VALUE != hFile)

               {

                                              DWORD dwSize = 0;

                                              WriteFile(hFile, pBuffer, dwLen, &dwSize, NULL );

                                              CloseHandle(hFile);

                                              return TRUE;

               }

               return FALSE;

}

这样是完成了，但是写出来的文件是乱码。所以没有进行字符的转换，我们需要将pBuffer进行转换。这就要用到了WideCharToMultiByte.如何用呢？

首先我的方法比较笨，我是这么用的：

char* pchBuffer = new char[dwLen+1];

WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, pchBuffer, dwLen+1, NULL, FALSE );

WriteFile(hFile, pBuffer, dwLen+1, &dwSize, NULL );

 Delete[] pchBuffer;

此时注意，我在WriteFile中用了dwLen+1。结果就是在文件的末尾出现了乱码，正好多一个乱码出来。所以WriteFile中nNumberOfBytesToWrite是写的字符串的数目，是不包括’\0’的。

这个方法笨，是因为我们的函数可以缩减为两个参数。是因为如下这么写时，dwLen是所要转换的字符串的个数，此时转换的字符串是包括’\0’的。

DWORD dwLen = WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, NULL, NULL, NULL, FALSE );

所以我们再来看一下改写以后的代码

BOOL WriteOwnFile(TCHAR* pFileName, TCHAR* pBuffer)

{

        HANDLE hFile = CreateFile(pFileName,

                       GENERIC_WRITE,

                                              FILE_SHARE_WRITE,

                                              NULL,

                                              CREATE_ALWAYS,

                                              FILE_ATTRIBUTE_NORMAL,

                                              NULL

                                              ）；

                               if (INVALID_HANDLE_VALUE != hFile)

               {

                                              DWORD dwSize = 0;

                                              DWORD dwLen = WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, NULL, NULL, NULL, FALSE );

                                              char* pchBuffer = new char[dwLen];

                                              WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, pchBuffer, dwLen, NULL, FALSE );

                                              WriteFile(hFile, pBuffer, dwLen+1, &dwSize, NULL );

                                               delete[] pchBuffer;

                                              CloseHandle(hFile);

                                              return TRUE;

               }

               return FALSE;

}

这样感觉代码好看多了。

对于第二个问题，文件打开的时候文件创建失败，还没有想好办法解决。我在想是不是我的某些认知存在问题，文件打开的时候，是否可以用CreateFile来打开呢？

HWND hwnd,

SHCHANGENOTIFYENTRY * pshcne

);

  其中,hwnd,为接收change notification的窗口;

pshcne是一个指向SHCHANGENOTIFYENTRY结构的指针,它用来指明窗口接收的change notification的类型.如果设为NULL,窗口将接收all file system, network 和 media类型的notifications.

SHCHANGENOTIFYENTRY是什么样的一个结构,我们看一下它的定义

typedef  struct  tagSHCHANGENOTIFYENTRY {

   DWORD dwEventMask;

   LPTSTR pszWatchDir;

 BOOL fRecursive;

} SHCHANGENOTIFYENTRY;

dwEventMask 指定发生什么时间来发送notification 消息

pszWatchDir 指定监控路径，该值为NULL的情况下，是监控所有的文件。

fRecursive指定是否只监控指定路径还是监控指定路径及其子文件夹。

知道了这些，我们不妨写一个这样的函数，来启动文件监控。

代码如下：

2、如何处理WM_FILECHANGEINFO消息

WM_FILECHANGEINFO 中的参数lParam，指向FILECHANGENOTIFY，含有相关的数据。所以我们在收到该消息后，先作的一部操作就是

FILECHANGENOTIFY *lpfcn = (FILECHANGENOTIFY*)lParam;

FILECHANGENOTIFY的结构为：

typedef struct tagFILECHANGENOTIFY {

 DWORD dwRefCount;

 FILECHANGEINFO fci;

} FILECHANGENOTIFY;

我们主要用到了其中的fci参数。

FILECHANGEINFO的结构为：

struct _FILECHANGEINFO {

 DWORD cbSize;

 LONG wEventId;

 ULONG uFlags;

 DWORD dwItem1;

 DWORD dwItem2;

 DWORD dwAttributes;

 FILETIME ftModified;

 ULONG nFileSize;

} FILECHANGEINFO, *LPFILECHANGEINFO;

dwEventId 与SHCHANGENOTIFYENTRY结构中的dwEventMask对应。

dwItem1,dwItem2是事件依赖的值，里面包括了我们需要的文件的完整路径。如果是进行创建文件的操作，则dwItem1是创建后文件的完整路径，如果是对文件进行重新命名操作的话，则dwItem2是修改后文件的完整路径。此处对其他参数不做介绍，大家需要的话，可以查看一下。

我们做完相应的操作后，要知道释放，此时要用到SHChangeNotifyFree。这个用起来就简单很多，如SHChangeNotifyFree（lpfcn）。

下面给大家一小段示例代码，如下

3、如何停止文件监控

   停止文件监控比较简单，只要使该窗口不接收WM_FILECHANGEINFO消息即可。使用SHChangeNotifyDeregister(hWnd)即可。

以上是我今天学习的一些总结，此外需要注意的一个小地方，在mobile上，把一个文件从一个文件夹拷到另一个文件夹，此时响应的事件是SHCNE_CREATE，二从电脑上拷贝一个文件到mobile上，响应的消息为SHCNE_RENAME。我注意到从电脑上拷贝的话，mobile会先生成一个Temp文件夹内生成一个临时文件，然后再在我们指定的文件夹内生成一个文件。这个机制我还不是很清楚为什么。

error C3861: 'CeMountDBVolEx': identifier not found
error C3861: 'CeMountDBVolEx': identifier not found
error C3861: 'CeCreateDatabaseWithProps': identifier not found
error C3861: 'CeCreateSession': identifier not found
error C3861: 'CeOpenDatabaseInSession': identifier not found

我在.cpp文件的开头加入了

#define EDB
#include <windows.h>
#include <windbase.h>

但是错误还依然存在

从网上搜索了一些方法

在博文《mobile数据库遇到的问题》

http://blog.sina.com.cn/s/blog_4c5ad0740100cvxg.html

它里面建议使用

extern "C"
{
  #include <windbase_edb.h>
}

但是使用后，问题变成了lnk的错误

error LNK2019: unresolved external symbol

有人在论坛里建议

#include Windbase_edb.h

也是同样的问题

最后，我问了一下我的同事

他建议我在

stdafx.h 头文件中添加

#define EDB
#include <windows.h>
#include <windbase.h>

这样的确解决了问题。

进程间通信有以下方法
Using named objects
Waiting for multiple objects
Waiting in a message loop
Using mutex objects
Using semaphore objects
Using event objects
Using critical section objects
Using timer queues
Using waitable timer objects
 进程间的通讯实现（IPC）的11种方法   

进程通常被定义为一个正在运行的程序的实例，它由两个部分组成：
一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方
 另一个是地址空间，它包含所有的可执行模块或DLL模块的代码和数据。它还包含动态分配的空间。如线程堆栈和堆分配空间。每个进程被赋予它自己的虚拟地址空间，当进程中的一个线程正在运行时，该线程可以访问只属于它的进程的内存。属于其它进程的内存则是隐藏的，并不能被正在运行的线程访问。
   为了能在两个进程之间进行通讯，由以下几种方法可供参考：

在16位时代常使用的方式，CWnd中提供支持
1。窗口消息 标准的Windows消息以及专用的WM_COPYDATA消息 SENDMESSAGE()接收端必须有一个窗口

2。使用共享内存方式（Shared Memory)
a.设定一块共享内存区域       
     HANDLE CreateFileMapping(HANDLE,LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD,  LPCSTR)
     产生一个file-mapping核心对象
     LPVOID MapViewOfFile(
         HANDLE hFileMappingObject,
        DWORD  dwDesiredAcess,
         DWORD  dwFileOffsetHigh,
         DWORD  dwFileOffsetLow,
          DWORD  dwNumberOfBytesToMap
     );
得到共享内存的指针
   b.找出共享内存
    决定这块内存要以点对点（peer to peer)的形式呈现
每个进程都必须有相同的能力，产生共享内存并将它初始化。每个进程
都应该调用CreateFileMapping(),然后调用GetLastError().如果传回的错误代码是ERROR_ALREADY_EXISTS,那么进程就可以假设这一共享内存区         域已经被别的进程打开并初始化了，否则该进程就可以合理的认为自己 排在第一位，并接下来将共享内存初始化。还是要使用client/server架构中只有server进程才应该产生并初始化共享内存。所有的进程都应该使用
HANDLE OpenFileMapping(DWORD dwDesiredAccess,
                                   BOOL bInheritHandle,
                                   LPCTSTR lpName);
        再调用MapViewOfFile(),取得共享内存的指针
   c.同步处理(Mutex)
   d.清理(Cleaning up) BOOL UnmapViewOfFile(LPCVOID lpBaseAddress);
    CloseHandle()

3。动态数据交换（DDE）通过维护全局分配内存使的应用程序间传递成为可能
   其方式是再一块全局内存中手工放置大量的数据，然后使用窗口消息传递内存    指针.这是16位WIN时代使用的方式，因为在WIN32下已经没有全局和局部内存    了，现在的内存只有一种就是虚存。  

4。消息管道(Message Pipe)
   用于设置应用程序间的一条永久通讯通道，通过该通道可以象自己的应用程序
   访问一个平面文件一样读写数据。
   名管道(Anonymous Pipes)
    单向流动，并且只能够在同一电脑上的各个进程之间流动。
   命名管道(Named Pipes)
   双向，跨网络，任何进程都可以轻易的抓住，放进管道的数据有固定的格式，而使用ReadFile()只能读取该大小的倍数。可以被使用于I/O Completion Ports

5邮件槽(Mailslots)
    广播式通信,在32系统中提供的新方法，可以在不同主机间交换数据，在        WIN9X下只支持邮件槽客户

6Windows套接字(Windows Socket)
   它具备消息管道所有的功能，但遵守一套通信标准使的不同操作系统之上的应    用程序之间可以互相通信。

7Internet通信 它让应用程序从Internet地址上载或下载文件

8。RPC：远程过程调用，很少使用，因其与UNIX的RPC不兼容。

9。串行/并行通信(Serial/Parallel Communication)
   它允许应用程序通过串行或并行端口与其他的应用程序通信

10。COM/DCOM
     通过COM系统的代理存根方式进行进程间数据交换，但只能够表现在对接口     函数的调用时传送数据，通过DCOM可以在不同主机间传送数据。

std::vector<ITEMDATA> vcData;

GetValue(vcData);

B 中的代码为
   

void GetValue(std::vector<ITEMDATA> &vcData)
{
   ……
    ITEMDATA item;
   ……
    vcData.push_back(item);
    ……
}

这是最近看的一片短文的title，当时就很好奇。
经常查阅MSDN的程序员都会有这个印象，微软code sample中常见的是ZeroMemory，而不是语言提供的“{0}”清零功能（不过，我一直也没有问个why）。c++语法中声明对数组或纯结构（struct），可以使用例如SPerson sTest = {0}; 来将所有成员置0.

那篇文章的解释是，Microsoft使用ZeroMemory会更clear，因为“= {0}” 这样的语法有些生僻，不是所有人都可以一下子明白。

实际上，两者还是有一些区别。
其一，ZeroMemory会将结构所有字节置0，而={0}只会将成员置0，其中padding字节不变。

其二，但一个struct有构造函数或虚函数时，ZeroMemory可以，而={0}会编译不过。显然，后者起到了一些保护作用，因为对一个有虚函数的对象使用ZeroMemory时，会将其虚函数的指针置0，这是非常危险的，因为调用虚函数时，程序显然会crash。参看如下代码：

struct SPerson
{
    //SPerson(){    }
    char c;
    float s;
};

class CTestVirtual
{
public:
    CTestVirtual()
    {
    }

    virtual int Draw()
    {
        return 10;
    }

    int a;
};

void Test() 
{
    char sztmp[20];
    ZeroMemory(sztmp, sizeof(sztmp));

    SPerson sTest = {0};
    int i = sizeof(SPerson);

    //CTestVirtual otv = {0};    //Compire error
    CTestVirtual tv;
    ZeroMemory(&tv, sizeof(tv));
    tv.Draw();        //As it is an object, don't use the virtual function pointer, so don't crash.
    CTestVirtual *pTv = &tv;
    pTv->Draw();    //Crash!!!
}