程序博客网 > 哪些数据库 触发器

进程通信

来源：互联网 发布：哪些数据库 触发器 编辑：程序博客网 时间：2024/05/22 06:42

进程通信之一 使用WM_COPYDATA C++及C#实现

进程间通信最简单的方式就是发送WM_COPYDATA消息。本文提供C++及C#程序相互通信的二种实现方式。这样消息的接收端可以用C++实现，发送端可以用C++或C#实现。

 

发送WM_COPYDATA消息：

SendMessage(接收窗口句柄, WM_COPYDATA, (WPARAM)发送窗口句柄, (LPARAM)&CopyData);

 

其中的CopyData为COPYDATASTRUCT结构类型，该结构定义如下：

typedef struct tagCOPYDATASTRUCT {

DWORD dwData;  // Specifies data to be passed to the receiving application.

DWORD cbData;  //Specifies the size, in bytes, of the data pointed to by the lpData member.

 PVOID lpData;    // Pointer to data to be passed to the receiving application. can be NULL.

} COPYDATASTRUCT, *PCOPYDATASTRUCT;

注意：该消息只能由SendMessage()来发送，而不能使用PostMessage()。因为系统必须管理用以传递数据的缓冲区的生命期，如果使用了PostMessage()，数据缓冲区会在接收方（线程）有机会处理该数据之前，就被系统清除和回收。此外如果lpData指向一个带有指针或某一拥有虚函数的对象时，也要小心处理。

 

如果传入的句柄不是一个有效的窗口或当接收方进程意外终止时，SendMessage()会立即返回，因此发送方在这种情况下不会陷入一个无穷的等待状态中。

 

返回值问题，MSDN上说如果接收方处理了，返回TRUE，否则返回FALSE，但是本人在实验时，都是返回0（接收方已经处理）。

 

接收WM_COPYDATA消息：

只要用COPYDATASTRUCT *pCopyData = (COPYDATASTRUCT*)lParam;就可以了。接收方应认为这些数据是只读的。

 

由于发送方在接收方处理WM_COPYDATA消息完毕前都是处于等待中，所以接收方应当尽快处理WM_COPYDATA消息。

 

以一个简单的例子来说明如何使用WM_COPYDATA消息，有二个程序，一个用来发送表示当前时间信息的字符串，另一个接收数据后显示到编辑框中。例子中有几点要注意：

1．如何得到当前控制台窗口句柄？VS2008下可以直接使用HWND GetConsoleWindow(void);函数。

2．使用char *ctime(const time_t *timer);将一个time_t类型转化成一个字符串时，函数会在字符串末尾加下'\n'，因为发送前要将这个'\n'去掉。

 

发送消息的程序代码（VS2008下编译通过）：

[cpp] view plaincopy
  1. #include <windows.h>  
  2. #include <time.h>  
  3. #include <conio.h>  
  4. #include <stdio.h>  
  5. int main()  
  6. {  
  7.     const char szDlgTitle[] = "RecvMessage";  
  8.   
  9.     HWND hSendWindow = GetConsoleWindow ();  
  10.     if (hSendWindow == NULL)  
  11.         return -1;  
  12.     HWND hRecvWindow = FindWindow(NULL, szDlgTitle);  
  13.     if (hRecvWindow == NULL)  
  14.         return -1;  
  15.   
  16.     char szSendBuf[100];  
  17.     time_t  timenow;  
  18.     COPYDATASTRUCT CopyData;  
  19.   
  20.     for (int i = 0; i < 10; i++)  
  21.     {  
  22.         time(&timenow);  
  23.         sprintf(szSendBuf, "%s", ctime(&timenow));//注意，ctime()返回的字符串后面带了'\n'  
  24.         CopyData.dwData = i;  
  25.         CopyData.cbData = strlen(szSendBuf);  
  26.         szSendBuf[CopyData.cbData - 1] = '\0';  
  27.         CopyData.lpData = szSendBuf;  
  28.   
  29.         SendMessage(hRecvWindow, WM_COPYDATA, (WPARAM)hSendWindow, (LPARAM)&CopyData);  
  30.         printf("%s\n", szSendBuf);  
  31.         Sleep(1000);  
  32.     }  
  33.     return 0;  
  34. }  

接收消息程序代码（VC6.0下编译通过）：

程序中的IDC_EDIT_RECVMESSAGE为编辑框的ID。

[cpp] view plaincopy
  1. #include "stdafx.h"  
  2. #include "resource.h"  
  3. #include <stdio.h>  
  4. BOOL CALLBACK DlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);  
  5. int APIENTRY WinMain(HINSTANCE hInstance,  
  6.                      HINSTANCE hPrevInstance,  
  7.                      LPSTR     lpCmdLine,  
  8.                      int       nCmdShow)  
  9. {  
  10.     // TODO: Place code here.  
  11.     DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DlgProc);  
  12.     return 0;  
  13. }  
  14. BOOL CALLBACK DlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)  
  15. {  
  16.     const char szDlgTitle[] = "RecvMessage";  
  17.     static HWND s_hEditShowRecv;  
  18.   
  19.     switch (message)  
  20.     {  
  21.     case WM_INITDIALOG:  
  22.         SetWindowText(hDlg, szDlgTitle);  
  23.         s_hEditShowRecv = GetDlgItem(hDlg, IDC_EDIT_RECVMESSAGE);  
  24.         return TRUE;  
  25.   
  26.     case WM_COMMAND:  
  27.         switch (LOWORD(wParam))  
  28.         {  
  29.         case IDOK:  
  30.         case IDCANCEL:  
  31.             EndDialog(hDlg, LOWORD(wParam));  
  32.             return TRUE;  
  33.         }  
  34.         break;  
  35.   
  36.     case WM_COPYDATA:  
  37.         {  
  38.             COPYDATASTRUCT *pCopyData = (COPYDATASTRUCT*)lParam;  
  39.             char szBuffer[300];  
  40.   
  41.             memset(szBuffer, 0, sizeof(szBuffer));  
  42.             sprintf(szBuffer, "dwData:%d cbData:%d\r\nlpData:0x%08x = %s\r\n\r\n",   
  43.                 pCopyData->dwData, pCopyData->cbData,   
  44.                 (PVOID)pCopyData->lpData, (char*)pCopyData->lpData);  
  45.             //在编辑框中追加数据  
  46.             SendMessage(s_hEditShowRecv, EM_SETSEL, (WPARAM)-1, (LPARAM)-1); // (0, -1)表示全选, (-1，任意)表示全不选  
  47.             SendMessage(s_hEditShowRecv, EM_REPLACESEL, FALSE, (LPARAM)szBuffer);  
  48.             SendMessage(s_hEditShowRecv, EM_SCROLLCARET, 0, 0);  
  49.         }  
  50.         return TRUE;  
  51.     }  
  52.     return FALSE;  
  53. }  

运行结果如下 （先启动接收消息程序再运行发送消息程序）：

 

 

 

有的时候，发送消息程序用C#实现起来更加方便，因此在这也提供了用C#实现的例子发送消息程序供大家参考：

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5. using System.Runtime.InteropServices;  //[DllImport("user32.dll")]中DllImport的命名空间  
  6.   
  7. namespace UseWMCOPYDATA  
  8. {  
  9.     class Program  
  10.     {  
  11.         static void Main(string[] args)  
  12.         {  
  13.             string strDlgTitle = "RecvMessage";   
  14.   
  15.             //接收端的窗口句柄  
  16.             IntPtr hwndRecvWindow = ImportFromDLL.FindWindow(null, strDlgTitle);  
  17.             if (hwndRecvWindow == IntPtr.Zero)  
  18.             {  
  19.                 Console.WriteLine("请先启动接收消息程序");  
  20.                 return;  
  21.             }  
  22.   
  23.             //自己的窗口句柄  
  24.             IntPtr hwndSendWindow = ImportFromDLL.GetConsoleWindow();  
  25.             if (hwndSendWindow == IntPtr.Zero)  
  26.             {  
  27.                 Console.WriteLine("获取自己的窗口句柄失败，请重试");  
  28.                 return;  
  29.             }  
  30.   
  31.             for (int i = 0; i < 10; i++)  
  32.             {  
  33.                 string strText = DateTime.Now.ToString();  
  34.                 //填充COPYDATA结构  
  35.                 ImportFromDLL.COPYDATASTRUCT copydata = new ImportFromDLL.COPYDATASTRUCT();  
  36.                 copydata.cbData = Encoding.Default.GetBytes(strText).Length; //长度 注意不要用strText.Length;  
  37.                 copydata.lpData = strText;                                   //内容  
  38.   
  39.                 ImportFromDLL.SendMessage(hwndRecvWindow, ImportFromDLL.WM_COPYDATA, hwndSendWindow, ref copydata);  
  40.   
  41.                 Console.WriteLine(strText);  
  42.                 Thread.Sleep(1000);  
  43.             }  
  44.   
  45.         }  
  46.     }  
  47.   
  48.     public class ImportFromDLL  
  49.     {  
  50.         public const int WM_COPYDATA = 0x004A;  
  51.   
  52.         //启用非托管代码  
  53.         [StructLayout(LayoutKind.Sequential)]   
  54.         public struct COPYDATASTRUCT   
  55.         {  
  56.             public int dwData;    //not used  
  57.             public int cbData;    //长度  
  58.             [MarshalAs(UnmanagedType.LPStr)]  
  59.             public string lpData;   
  60.         }  
  61.   
  62.         [DllImport("User32.dll")]  
  63.         public static extern int SendMessage(  
  64.             IntPtr hWnd,　　　  // handle to destination window   
  65.             int Msg,　　　      // message  
  66.             IntPtr wParam,　   // first message parameter   
  67.             ref COPYDATASTRUCT pcd // second message parameter   
  68.         );  
  69.   
  70.         [DllImport("User32.dll", EntryPoint = "FindWindow")]  
  71.         public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);  
  72.   
  73.         [DllImport("Kernel32.dll", EntryPoint = "GetConsoleWindow")]  
  74.         public static extern IntPtr GetConsoleWindow();  
  75.   
  76.     }  
  77. }  

 

运行结果如下 （先启动接收消息程序再运行发送消息程序）：

 

 下一篇《进程通信之二 管道技术第一篇 输入输出的重定向》示范了程序输入输出的重定向，以及如何用管道来完成进程之间的通信。


进程通信之二 管道技术第一篇 输入输出的重定向

继上一篇《进程通信之一使用WM_COPYDATA C++及C#实现》，进程通信之二将分为三篇文章讲解如何使用管道技术来完成进程通信功能。三篇文章目录如下：

1．《进程通信之二 管道技术第一篇 输入输出的重定向》

2．《进程通信之二 管道技术第二篇 匿名管道》

3．《进程通信之二 管道技术第三篇 命名管道》

 

本篇将介绍输入输出的重定向问题，先来看一个小小的实例，设有一个程序，该程序的输入输出为标准输入输出即从键盘上输入，输出到屏幕。现在要重定向输入法输出，使程序从文件中读取数据，处理后输出到文件。程序代码如下（称此程序为示例程序）：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. int main()  
  3. {  
  4.     int n;  
  5.     while (scanf("%d", &n) != EOF) //标准输入时，可按ctrl+z来输入EOF  
  6.     {  
  7.         n *= 2;  
  8.         printf("%d\n", n);  
  9.     }  
  10. }  

试给出几种不同的实现方法，另外如果没有程序代码，只有可执行文件，又应该如何做了？

实现方法一使用C语言的freopen()函数

函数功能：重定向控制台的输入输出

函数原型：

FILE *freopen(

   const char *path,

   const char *mode,

   FILE *stream

);

函数说明：

第一个参数为文件指针（也可以用来指向标准输入输出）。

第二个参数为打开方式，"w"表示写，"r"表示读，"a"表示追加。其它设置可以参考MSDN。

第三个参数为FILE类型的指针，传入stdin表示标准输入，传入stdout表示标准输出。

 

这样用只要用简单一句freopen("infile.txt", "r", stdin);就可以使程序中的scanf()函数从文件中读取数据作为输入，同样freopen("outfile.txt", "w", stdout);可以使程序中的printf()函数将输出由标准输出改成输出到文件。现在有个问题，将程序的输入输出重定向到文件后，还能改回到标准输入输出吗？答案是可以的，对第一个参数传入"CON"这个字符串就可以了（linux为"/dev/console"）。

 

下面就给出修改后的代码：

[cpp] view plaincopy
  1. //直接使用freopen()函数 来改变控制台的标准输入输出  
  2. #include <stdio.h>  
  3. int main()  
  4. {  
  5.     //将控制台的标准输入输出改成从文件中读取写入  
  6.     FILE *pFileRead = freopen("infile.txt", "r", stdin);  
  7.     FILE *pFileWrite = freopen("outfile.txt", "w", stdout);  
  8.   
  9.     int n;  
  10.     while (scanf("%d", &n) != EOF)  
  11.     {  
  12.         n *= 2;  
  13.         printf("%d\n", n);  
  14.     }  
  15.   
  16.     fclose(pFileRead);  
  17.     fclose(pFileWrite);  
  18.   
  19.     //回到到控制台的标准输入输出 windows为"CON" linux为"/dev/console"  
  20.     freopen("CON", "r", stdin);  
  21.     freopen("CON", "w", stdout);   
  22.     printf("Finish 输入0表示结束:\n");  
  23.     do{  
  24.         scanf("%d", &n);  
  25.     }while (n != 0);  
  26.       
  27.     return 0;  
  28. }  

运行结果如下图所示：

 

可以看出该程序的输出输入已经完成了重定向。

 

实现方法2 使用C++的ifstream和ofstream类

有些场合使用类来完成输入输出的重定向任务会更加方便和习惯一些。所幸C++中就有ifstream和ofstream这二个类来帮助我们完成这一任务。这个二类的详细功能就不细说了。下面介绍下如何使用这二个类来重定向程序的输入输出（看的时候看慢点喔，不会会被很多类名给搞晕去^_^）。

 

这二个类可以以读的方式和写的方法打开一个文件（ifstream的首字母i就表示in，而ofstream的首字母o就表示out），在iosfwd文件中找到：

    typedef basic_ifstream<char, char_traits<char> > ifstream;

    typedef basic_ofstream<char, char_traits<char> > ofstream;

然后可以在fstream文件中找到basic_ifstream类是继承于basic_istream类，basic_ofstream类是继承于basic_ostream类。

 

然后再来看看C++中大家平常使用的cin和cout，可以在iostream文件中找到cin和cout的定义，这二个实际是istream类型和ostream类型的变量：

    extern _CRTIMPistream cin;

    extern _CRTIMPostream cout;

然后在iosfwd文件中可以找到：

    typedef basic_istream<char, char_traits<char> > istream;

    typedef basic_ostream<char, char_traits<char> > ostream;

 

明显cin和cout与ifstream类和ofstream类有着非常密切关系——cin是basic_istream类的变量，而ifstream则是basic_istream类的派生类。cout是basic_ostream类的变量，而ofstream则是basic_ostream类的派生类。

 

有了这个后，猜测很可能会有某个成员函数能将它们联系到一起，从而让cin和cout由标准输入输出重定向到从文件中读取，输出到文件。事实上在basic_istream类实际是虚继承于basic_ioso类，basic_ostream类实际是虚继承于basic_ios类。这二个类都有个rdbuf()成员函数，这个函数允许我们访问和修改类中一个类型为basic_streambuf类的成员变量。改动这个变量就能重定向输入输出。因此对cin和cout调用这个rdbuf()函数并传入ifstream和ofstream的rdbuf()就可以将控制台的标准输入输出改成从文件中读取和输出到文件。

 

OK，方法既然找到了，那下面就使用C++的方法来重定向输入输出：

[cpp] view plaincopy
  1. //使用ifstream和ofstream及cin和cout的rdbuf()  
  2. #include <iostream>  
  3. #include <fstream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.     printf("   使用ifstream和ofstream及cin和cout的rdbuf()来改变控制台的标准输入输出\n");    
  8.     printf("  --by MoreWindows( http://blog.csdn.net/MoreWindows )--\n\n");   
  9.     //将控制台的标准输入输出改成从文件中读取写入  
  10.     ifstream inFile("infile.txt");  
  11.     ofstream outFile("outfile.txt");  
  12.     //保存原来的输入输出方式 streambuf类就是basic_streambuf类  
  13.     streambuf *strmin_buf = cin.rdbuf();  
  14.     streambuf *strmout_buf = cout.rdbuf();  
  15.   
  16.     printf("开始处理文件\n....\n");  
  17.     //重定向到文件  
  18.     cin.rdbuf(inFile.rdbuf());  
  19.     cout.rdbuf(outFile.rdbuf());  
  20.   
  21.     //原程序代码  
  22.     int n;  
  23.     while (cin>>n)  
  24.     {  
  25.         n *= 2;  
  26.         cout<<n<<endl;  
  27.     }  
  28.   
  29.     inFile.close();  
  30.     outFile.close();  
  31.   
  32.     //回到控制台的标准输入输出  
  33.     cin.rdbuf(strmin_buf);  
  34.     cout.rdbuf(strmout_buf);  
  35.   
  36.     cout<<"文件已经处理完毕 输入0表示结束:"<<endl;  
  37.     do{  
  38.         cin>>n;  
  39.     }while (n != 0);  
  40.   
  41.     return 0;  
  42. }  

运行结果如下图所示：

 

同样，这个程序也完成了输入输出的重定向。

 

上面的方法都是建立在修改源代码的基础上，如果只有程序文件即.exe文件那应该怎么做了？请参阅下一篇《进程通信之二 管道技术第二篇 匿名管道》

 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7390350

如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。

 进程通信之二 管道技术第二篇 匿名管道

上一篇《进程通信之二 管道技术第一篇 输入输出的重定向》示范了增加若干程序代码来完成程序输入输出的重定向，并提出了如果没有程序源代码，只有程序文件如何来完成重定向。本篇就介绍如何使用匿名管道来完成这一任务。

 

计算机中管道pipe类似于现实世界中的水管道，在一端放入水流，另一端就会流出来。在计算机机中水流自然被数据流所代替了。计算机中管道分为匿名管道和命名管道，本篇将主要介绍用匿名管道来完成这一重定向输出任务，命名管道就留给下一篇来介绍了。

先来看看如何创建和使用匿名管道。

 

第一个 CreatePipe

函数功能：创建管道

函数原型：

BOOLWINAPICreatePipe(

  PHANDLEhReadPipe,

  PHANDLEhWritePipe,

  LPSECURITY_ATTRIBUTESlpPipeAttributes,

  DWORDnSize

);

函数说明：

第一个参数返回新创建的管道的读取端句柄。

第二个参数返回新创建的管道的写入端句柄。

注意不能在管道的读取端写入数据也不能在写入端读取数据。

第三个参数表示管道的安全属性，通常可以作如下设置：

       SECURITY_ATTRIBUTES sa; 

       sa.nLength             = sizeof(SECURITY_ATTRIBUTES);

       sa.lpSecurityDescriptor   = NULL;

       sa.bInheritHandle       = TRUE;

第四个参数表示管道的缓冲区容量，为0表示使用默认大小。

函数执行成功返回TRUE，否则返回FALSE。

 

第二个 ReadFile

函数功能：从管道中读取数据

函数原型：

BOOLReadFile(

  HANDLEhFile,

  LPVOIDlpBuffer,

  DWORDnNumberOfBytesToRead,

  LPDWORDlpNumberOfBytesRead,

  LPOVERLAPPEDlpOverlapped

);

函数说明：

第一个参数为句柄，可以是创建文件函数CreateFile()的返回值也可以是管道。

第二个参数是一个指向缓冲区的指针，函数将读取的数据写入该缓冲区。

第三个参数的表达非常好，光从名字上就可以知道这是用来指定读取的字节数。

第四个参数将返回实际读取到的字节数。

第五个参数是用于异步操作方面，一般传入NULL即可。

 

第三个 WriteFile

函数功能：向管道写入数据

函数原型：

BOOLWriteFile(

  HANDLEhFile,

  LPCVOIDlpBuffer,

  DWORDnNumberOfBytesToWrite,

  LPDWORDlpNumberOfBytesWritten,

  LPOVERLAPPEDlpOverlapped

);

函数说明：

第一个参数为句柄，可以是创建文件函数CreateFile()的返回值也可以是管道。

第二个参数是一个指针，该指针指向待写入管道的数据。

第三个参数表示要写入的字节数。

第四个参数将返回实际写入管道的字节数。

第五个参数是用于异步操作方面，一般传入NULL即可。

 

第四个CloseHandle

函数功能：关闭管道的一端

函数原型：BOOLCloseHandle(HANDLEhObject);

函数说明：当读取和写入端都关闭后，系统会关闭管道并回收资源。

 

从后面三个函数可以看出，向管道中读取和写入数据就和向文件中读取和写入数据是一样的（事实上管道也是一种特殊的文件——内存映射文件）。

 

使用管道要注意的一个地方是：读取和写入数据时，一定要注意顺序，MSDN上说，如果管道中没有数据，调用ReadFile()会造成阻塞，直到有其它线程将数据写入管道。同样，当有线程正在管道中读取数据时，其它试图将数据写入管道的的线程也会被阻塞。

 

因此对上一篇的示例程序进行重定向时，可以先创建二个管道，一个用来存放输入数据，称为数据输入管道，另一个用来存放输出数据，称为数据输出管道。然后从输入文件中读取数据并写入数据输入管道。再启动示例程序作为子进程，子进程的输入输出已经改成从数据输入管道中读取和输出到数据输出管道。子进程运行结束后，从数据输出管道中将数据写入到输出文件即可。整个流程图如下所示：

下面给出使用管道的示例代码：

[cpp] view plaincopy
  1. //用管道来完成子进程的重定向。  
  2. //流程如下:  
  3. // infile.txt -> Input管道 -> 标准程序.exe -> Output管道 -> outfile.txt  
  4. #include <windows.h>  
  5. #include <stdio.h>  
  6. int main()  
  7. {  
  8.     printf("   使用管道来重定向子进程的输入输出\n");    
  9.     printf("  --by MoreWindows( http://blog.csdn.net/MoreWindows )--\n\n");   
  10.   
  11.     char sz[3][50] = {"示例程序.exe", "infile.txt", "outfile.txt"};  
  12.     HANDLE hPipeInputRead, hPipeInputWrite, hPipeOutputRead, hPipeOutputWrite;  
  13.   
  14.     //创建两个管道  
  15.     SECURITY_ATTRIBUTES sa;    
  16.     sa.nLength              = sizeof(SECURITY_ATTRIBUTES);  
  17.     sa.lpSecurityDescriptor = NULL;  
  18.     sa.bInheritHandle       = TRUE;  
  19.     //数据输入管道  
  20.     CreatePipe(&hPipeInputRead, &hPipeInputWrite, &sa, 0);  
  21.     //数据输出管道  
  22.     CreatePipe(&hPipeOutputRead, &hPipeOutputWrite, &sa, 0);  
  23.       
  24.     printf("创建数据输入管道和数据输出管道完毕\n");  
  25.   
  26.     //从文件中读取数据,写入管道ReadFile中.  
  27.     const int BUFSIZE  = 4096;  
  28.     CHAR chBuf[BUFSIZE] = {0};   
  29.     DWORD dwRead, dwWritten;  
  30.     BOOL  fSuccess;  
  31.     HANDLE hInputFile = CreateFile(sz[1], GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);  
  32.     while (true)   
  33.     {  
  34.         //从文件中读取数据  
  35.         fSuccess = ReadFile(hInputFile, chBuf, BUFSIZE, &dwRead, NULL);  
  36.         if (!fSuccess || dwRead == 0)  
  37.             break;   
  38.         //将数据写入管道  
  39.         fSuccess = WriteFile(hPipeInputWrite, chBuf, dwRead, &dwWritten, NULL);  
  40.         if (!fSuccess)   
  41.             break;   
  42.     }   
  43.     //关闭输入数据管道  
  44.     CloseHandle(hInputFile);  
  45.     hInputFile = NULL;  
  46.     CloseHandle(hPipeInputWrite);  
  47.     hPipeInputWrite = NULL;  
  48.       
  49.     printf("已经从文件中读取数据并写入数据输入管道\n");  
  50.     printf("启动示例程序并重定向到管道中\n....\n");  
  51.     //启动示例程序作为子进程  
  52.     STARTUPINFO si;  
  53.     si.cb = sizeof(STARTUPINFO);  
  54.     GetStartupInfo(&si);   
  55.     si.hStdInput   = hPipeInputRead;   //输入由标准输入 -> 从管道中读取  
  56.     si.hStdOutput  = hPipeOutputWrite; //输出由标准输出 -> 输出到管道  
  57.     si.wShowWindow = SW_HIDE;    
  58.     si.dwFlags     = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;    
  59.     PROCESS_INFORMATION pi;   
  60.     CreateProcess( sz[0], NULL, NULL, NULL, TRUE, NULL, NULL, NULL, &si, &pi);  
  61.     WaitForSingleObject(pi.hProcess, INFINITE);  
  62.   
  63.     //关闭输入数据管道  
  64.     CloseHandle(hPipeInputRead);  
  65.     hPipeInputRead = NULL;  
  66.     CloseHandle(hPipeOutputWrite);  
  67.     hPipeOutputWrite = NULL;  
  68.       
  69.     printf("示例程序完成处理，现在将数据输出管道中的数据写入文件\n");  
  70.   
  71.     //将输出数据管道中的数据写入到文件中  
  72.     HANDLE hOutputFile = CreateFile(sz[2], GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);   
  73.     while (true)  
  74.     {   
  75.         //从管道中读取  
  76.         fSuccess = ReadFile(hPipeOutputRead, chBuf, BUFSIZE, &dwRead, NULL);  
  77.         if( !fSuccess || dwRead == 0)   
  78.             break;   
  79.         //写入输出文件  
  80.         fSuccess = WriteFile(hOutputFile, chBuf, dwRead, &dwWritten, NULL);  
  81.         if (!fSuccess)   
  82.             break;   
  83.     }   
  84.     //关闭输出数据管道  
  85.     CloseHandle(hOutputFile);  
  86.     hOutputFile = NULL;  
  87.     CloseHandle(hPipeOutputRead);  
  88.     hPipeOutputRead = NULL;  
  89.       
  90.     printf("数据输出管道中的数据写入文件完毕\n");  
  91.     return 0;  
  92. }  

运行结果如下图：

结果完全正确，说明我们的程序已经完成了启动其它程序并对它进行重定向这一功能。

 

对匿名管道总结一下：匿名管道有读取端和写入端。匿名管道创建(CreatePipe)后就可以像读写文件一样的对管道中的数据读写(ReadFile与WriteFile)，但要注意读写顺序。匿名管道在关闭两端后会由系统销毁并回收资源。

 

匿名管道的使用比较常见，下面是二个安装程序的截图。

QQ游戏的安装过程截图：

五笔编码及时查的安装过程截图：

对比下这二个截图，显示的内容都差不多，都是解压缩文件并移动到指定地方。唯一不同的是一个是控制台界面，另一个是图形界面。联想上面的程序，不难得知QQ游戏的安装实际也是使用管道将一个控制台程序的输出内容显示到图形界面，这样既美观又便于维护。

 

下一篇《进程通信之二 管道技术第三篇 命名管道》将介绍命名管道的使用，欢迎参阅。

 

注：不知道程序代码的情况下还可以使用批处理来完成。批处理使用>和<来重定向，>为输出到文件，如果文件不存在就创建，已存在就清空原文件后再写入，<为从文件读取。批处理文件的内容可以这样写：

@echo off

<infile.txt 标准程序.exe >outfile.txt

也可以这样写：

@echo off

标准程序.exe <infile.txt >outfile.txt

批处理重定向的内部实现原理当然也是使用匿名管道。

 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7390441

如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。

 

进程通信之二 管道技术第三篇 命名管道

上一篇《进程通信之二管道技术第二篇匿名管道》中讲解了匿名管道，匿名管道有读取端和写入端，在创建匿名管道(CreatePipe)后就可以像读写文件一样的对管道中进行读写(ReadFile与WriteFile，注意读写顺序)。在关闭匿名管道两端后会由系统负责销毁并回收资源。文章中还示范了父进程如何使用匿名管道来改变子进程的输入输出。

 

本篇将讲解管道技术中的命名管道（Named Pipes），顾名思义，这个管道肯定是有名字的，联想到秒杀多线程面试题中的事件、互斥量、信号量（见附1），它们的名字主要是用于确保多个进程访问同一个对象。因此肯定也可以通过管道的名字来确保多个进程访问同一个管道。事实上，命名管道不仅可在同一台计算机的不同进程之间传输数据，甚至能在跨越一个网络的不同计算机的不同进程之间，支持可靠的、单向或双向的数据通信。

 

先来看看如何创建和使用命名管道。

第一个CreateNamedPipe

函数功能：创建命名管道

函数原型：

HANDLEWINAPICreateNamedPipe(

  LPCTSTRlpName,

  DWORDdwOpenMode,

  DWORDdwPipeMode,

  DWORDnMaxInstances,

  DWORDnOutBufferSize,

  DWORDnInBufferSize,

  DWORDnDefaultTimeOut,

  LPSECURITY_ATTRIBUTESlpSecurityAttributes

);

参数说明：

第一个参数LPCTSTRlpName

表示管道名称，采用的形式是：\\.\pipe\pipename。最多可达256个字符的长度，而且不区分大小写。如果已经有同名管道，则会创建那个管道的一个新实例。

 

第二个参数DWORDdwOpenMode

表示管道的打开方式。下面列出最常用的三种，更多请参阅MSDN。

1．PIPE_ACCESS_DUPLEX

该管道是双向的，服务器和客户端进程都可以从管道读取或者向管道写入数据。

2．PIPE_ACCESS_INBOUND

该管道中数据是从客户端流向服务端，即客户端只能写，服务端只能读。

3．PIPE_ACCESS_OUTBOUND

该管道中数据是从服务端流向客户端，即客户端只能读，服务端只能写。

 

第三个参数DWORDdwPipeMode

表示管道的模式，下面是一些常用模式介绍，更多请参阅MSDN。

1．PIPE_TYPE_BYTE       

数据作为一个连续的字节数据流写入管道。

2．PIPE_TYPE_MESSAGE 

数据用数据块（名为“消息”或“报文”）的形式写入管道。

3．PIPE_READMODE_BYTE

     数据以单独字节的形式从管道中读出。

4．PIPE_READMODE_MESSAGE

数据以名为“消息”的数据块形式从管道中读出（要求指定PIPE_TYPE_MESSAGE）。

5．PIPE_WAIT

同步操作在等待的时候挂起线程。

6．PIPE_NOWAIT

同步操作立即返回。

 

第四个参数DWORDnMaxInstances

表示该管道所能够创建的最大实例数量。必须是1到常数PIPE_UNLIMITED_INSTANCES间的一个值。

在WINBASE.H中有#define PIPE_UNLIMITED_INSTANCES    255

 

第五个参数DWORDnOutBufferSize

表示管道的输出缓冲区容量，为0表示使用默认大小。

 

第六个参数DWORDnInBufferSize

表示管道的输入缓冲区容量，为0表示使用默认大小。

 

第七个参数DWORDnDefaultTimeOut

表示管道的默认等待超时。

 

第八个参数LPSECURITY_ATTRIBUTESlpSecurityAttributes

表示管道的安全属性。

函数返回值：

函数执行成功返回命名管道的句柄，否则返回INVALID_HANDLE_VALUE。

 

第二个ConnectNamedPipe

函数功能：等待客户端连接命名管道

函数原型：

BOOLWINAPIConnectNamedPipe(

  HANDLEhNamedPipe,

  LPOVERLAPPEDlpOverlapped

);

函数说明：

第一个参数表示命名管道的句柄。

第二个参数是一个指向OVERLAPPED结构的指针，一般置为NULL就可以了。

 

第三个WaitNamedPipe

函数功能：客户端连接命名管道

函数原型：

BOOLWINAPIWaitNamedPipe(

  LPCTSTRlpNamedPipeName,

  DWORDnTimeOut

);

函数说明：

第一个参数LPCTSTRlpNamedPipeName

表示管道名称，采用的形式是：\\servername\pipe\pipename。如果是本机管道，servername用“.”来表示。

 

第二个参数DWORDnTimeOut

表示等待命名管道的一个实例有效的超时时间，单位毫秒。也可以用NMPWAIT_USE_DEFAULT_WAIT表示使用命名管道的设定值（在调用CreateNamedPipe创建命名管道时指定的），NMPWAIT_WAIT_FOREVER表示无限等待。

函数返回值：

在指定时间内连接成功返回TRUE，否则返回FALSE。

注意

1：如果指定名称的命名管道还没创建，函数立即返回，返回值为FALSE。

2：如果函数执行成功返回TRUE，表示至少有一个命名管道的实例有效，接下来应该使用CreateFile函数打开命名管道的一个句柄，但是CreateFile可能会打开管道失败，因为该实例有可能被服务端关闭或被已经被其他客户端打开。

 

 

下面给出使用命名管道的实例，该实例分为命名管道的服务端和客户端。服务端和客户端的主要步骤如下所示：

1. 服务端用CreateNamedPipe创建一个命名管道并使用ConnectNamedPipe等待客户端的连接。

2. 客户端使用WaitNamedPipe连接成功后，用CreateFile打开管道并使用WriteFile向管道中写入一段数据（即向服务端发送消息）。

3. 服务端使用ReadFile从管道中读取数据后（即收到消息）再向管道中写入确认信息表明已经收到客户端传输的数据（即通知客户端已收到）。

4. 客户端收到确认信息后结束，调用CloseHandle关闭管道（该管道是CreateFile打开的）。

5．服务端使用DisconnectNamedPipe和CloseHandle关闭管道。

代码中的CreateFile，WriteFile，ReadFile请参见上一篇《进程通信之二管道技术第二篇匿名管道》中的介绍。

 

服务端代码如下：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <windows.h>  
  3. #include <conio.h>  
  4. const char *pStrPipeName = "\\\\.\\pipe\\NamePipe_MoreWindows";  
  5. int main()  
  6. {  
  7.     printf("        命名管道 服务器\n");    
  8.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  9.       
  10.     printf("创建命名管道并等待连接\n");  
  11.     HANDLE hPipe = CreateNamedPipe(pStrPipeName, PIPE_ACCESS_DUPLEX,   
  12.         PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,   
  13.         PIPE_UNLIMITED_INSTANCES, 0, 0, NMPWAIT_WAIT_FOREVER, 0);  
  14.     if (ConnectNamedPipe(hPipe, NULL) != NULL)//等待连接。  
  15.     {  
  16.         printf("连接成功，开始接收数据\n");  
  17.   
  18.         const int BUFFER_MAX_LEN = 256;  
  19.         char szBuffer[BUFFER_MAX_LEN];  
  20.         DWORD dwLen;  
  21.   
  22.         //接收客户端发送的数据  
  23.         ReadFile(hPipe, szBuffer, BUFFER_MAX_LEN, &dwLen, NULL);//读取管道中的内容（管道是一种特殊的文件）  
  24.         printf("接收到数据长度为%d字节\n", dwLen);  
  25.         printf("具体数据内容如下：%s\n", szBuffer);  
  26.   
  27.         //确认已收到数据  
  28.         printf("向客户端发送已经收到标志\n");  
  29.         strcpy(szBuffer, "服务器已经收到");  
  30.         WriteFile(hPipe, szBuffer, strlen(szBuffer) + 1, &dwLen, NULL);  
  31.     }  
  32.     DisconnectNamedPipe(hPipe);   
  33.     CloseHandle(hPipe);//关闭管道  
  34.     return 0;  
  35. }  

客户端代码如下：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <windows.h>  
  3. #include <conio.h>  
  4. const char *pStrPipeName = "\\\\.\\pipe\\NamePipe_MoreWindows";  
  5. int main()  
  6. {  
  7.     printf("        命名管道 客户端\n");    
  8.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  9.   
  10.     printf("按任意键以开始连接命名管道\n");  
  11.     getch();  
  12.     printf("开始等待命名管道\n");  
  13.     if (WaitNamedPipe(pStrPipeName, NMPWAIT_WAIT_FOREVER) == FALSE)  
  14.     {  
  15.         printf("Error! 连接命名管道失败\n");  
  16.         return 0;  
  17.     }  
  18.   
  19.     printf("打开命名管道\n");  
  20.     HANDLE hPipe = CreateFile(pStrPipeName, GENERIC_READ | GENERIC_WRITE, 0,  
  21.         NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);  
  22.   
  23.     printf("向服务端发送数据\n");  
  24.     const int BUFFER_MAX_LEN = 256;  
  25.     char szBuffer[BUFFER_MAX_LEN];  
  26.     DWORD dwLen = 0;  
  27.   
  28.     //向服务端发送数据  
  29.     sprintf(szBuffer,"进程%d说\"%s\"", GetCurrentProcessId(), "Hello World!");  
  30.     WriteFile(hPipe, szBuffer, strlen(szBuffer) + 1, &dwLen, NULL);  
  31.     printf("数据写入完毕共%d字节\n", dwLen);  
  32.   
  33.     //接收服务端发回的数据  
  34.     ReadFile(hPipe, szBuffer, BUFFER_MAX_LEN, &dwLen, NULL);//读取管道中的内容（管道是一种特殊的文件）  
  35.     printf("接收服务端发来的确认信息长度为%d字节\n", dwLen);  
  36.     printf("具体数据内容如下：%s\n", szBuffer);  
  37.       
  38.     CloseHandle(hPipe);  
  39.     return 0;  
  40. }  

运行结果如下所示，运行时先启动服务器，然后再运行客户端：

 

命名管道就先介绍到这里了，管道技术上、中、下三篇到此也就全部结束下，下面给出目录，方便大家查看。

《进程通信之二管道技术第一篇输入输出的重定向》

《进程通信之二管道技术第二篇匿名管道》

《进程通信之二管道技术第三篇命名管道》

后面将有文章介绍进程通信中最底层，最高效的方法——共享内存。欢迎继续浏览。


 

附1 其实进程线程同步除了使用秒杀多线程面试题系列中的介绍的关键段、事件、互斥量、信号量、读写锁。管道也可以用于线程的同步。


 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/8260087

Windows编程系列文章地址：http://blog.csdn.net/morewindows/article/category/862060

欢迎关注新浪微博：http://weibo.com/MoreWindows

 

---------------------------------------------------华丽的分割线-----------------------------------------------------------------

 CSDN博客之星评选活动正在进行，觉得本博客对您有帮助，麻烦投我一票，非常感谢。您的支持就是我写作的最大动力。

投票地址：http://vote.blog.csdn.net/item/blogstar/MoreWindows 

谢谢大家！


进程通信之三 父进程传参数与子进程返回值

本文配套程序下载地址为：http://download.csdn.net/detail/morewindows/5165733

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/8646902

欢迎关注微博：http://weibo.com/MoreWindows

 

前面已经写了使用WM_COPYDATA消息来完成进程之间的通信

1．《进程通信之一使用WM_COPYDATA C++及C#实现》

http://blog.csdn.net/morewindows/article/details/6804157

然后用了三篇文章来讲解如何使用管道技术来完成进程通信功能。

1．《进程通信之二管道技术第一篇输入输出的重定向》

http://blog.csdn.net/morewindows/article/details/7390350

2．《进程通信之二管道技术第二篇匿名管道》

http://blog.csdn.net/morewindows/article/details/7390441

3．《进程通信之二管道技术第三篇命名管道》

http://blog.csdn.net/morewindows/article/details/8260087

 

    本篇介绍一个简单而又实用的进程通信方式——父进程向子进程传入参数并获取子进程返回值。这个非常简单：

1．父进程向子进程传入参数可以由CreateProcess()函数来完成，注意子进程是通过GetCommandLine()来获取这个参数而且不是char *argv[]。

2．父进程要获取子进程的返回值可以在等待子进程结束后通过GetExitCodeProcess并传入子进程句柄来获取子进程中main或WinMain函数的返回值。

下面就结出实例代码，首先来看子进程的程序代码：

[cpp] view plaincopy
  1. //进程通信之三 父进程传参数与子进程返回值  
  2. //http://blog.csdn.net/morewindows/article/details/8683830  
  3. //By MoreWindows( http://blog.csdn.net/MoreWindows )  
  4. #include <windows.h>  
  5. #include <stdio.h>  
  6. #include <stdlib.h>  
  7. #include <time.h>  
  8. #include <string.h>  
  9. int main(int argc, char *argv[])  
  10. {  
  11.     // 通过GetCommandLine()获取父进程通过CreateProcess传给子进程的参数  
  12.     // 注意这与argv[]不同如strlen(argv[1])会出错  
  13.     srand((unsigned int)time(NULL));  
  14.     return strlen(GetCommandLine()) + rand() % 10;  
  15. }  

然后是父进程的程序代码，代码中的AdjustProcessCurrentDirectory();函数可以参考《Windows VC++ 调整进程当前目录为程序可执行文件所在目录》（http://blog.csdn.net/morewindows/article/details/8683519）：

[cpp] view plaincopy
  1. //进程通信之三 父进程传参数与子进程返回值  
  2. //http://blog.csdn.net/morewindows/article/details/8683830  
  3. //By MoreWindows( http://blog.csdn.net/MoreWindows )  
  4. #include <windows.h>  
  5. #include <stdio.h>  
  6. #include <string.h>  
  7. #include <conio.h>  
  8. // 启动子进程并传入参数，等待子进程结束后获取其返回值。  
  9. BOOL GetChildProcessExitCode(const char *pstrChildProcessExeFileName,   
  10.                              char *pstrConmandLine,   
  11.                              DWORD *pdwExitCode, BOOL fHide = TRUE)  
  12. {  
  13.     //子进程启动信息设置  
  14.     STARTUPINFO si;    
  15.     si.cb = sizeof(STARTUPINFO);    
  16.     GetStartupInfo(&si);      
  17.     si.wShowWindow = fHide ? SW_HIDE : SW_SHOW;  
  18.     si.dwFlags     = STARTF_USESHOWWINDOW;    
  19.   
  20.     // 运行子进程并等待其结束  
  21.     PROCESS_INFORMATION pi;     
  22.     CreateProcess(pstrChildProcessExeFileName, pstrConmandLine, NULL, NULL, TRUE, NULL, NULL, NULL, &si, &pi);    
  23.     WaitForSingleObject(pi.hProcess, INFINITE);    
  24.       
  25.     // 获取子进程返回值  
  26.     BOOL flag = GetExitCodeProcess(pi.hProcess, pdwExitCode);  
  27.   
  28.     CloseHandle(pi.hProcess);  
  29.     CloseHandle(pi.hThread);  
  30.   
  31.     return flag;  
  32. }  
  33.   
  34. int main()  
  35. {  
  36.     printf("    进程通信之三 父进程传参数与子进程返回值\n");          
  37.     printf(" - http://blog.csdn.net/morewindows/article/details/8683830 -\n");  
  38.     printf(" -- By MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  39.   
  40.     AdjustProcessCurrentDirectory();  
  41.       
  42.     const char *pstrChildProcessExeFileName = "ChildProcess.exe";  
  43.     const int RUN_CHILDPROCESS_NUMBER = 5;  
  44.     char szCommandLine[30] = "MoreWindows";  
  45.     int nCommandLineLen = strlen(szCommandLine);  
  46.     for (int i = 0; i < RUN_CHILDPROCESS_NUMBER; i++)  
  47.     {  
  48.         // 运行子进程并获取返回值  
  49.         DWORD dwExitCode;  
  50.         if (GetChildProcessExitCode(pstrChildProcessExeFileName, szCommandLine, &dwExitCode, TRUE))  
  51.             printf("子进程返回值为 %d\n", dwExitCode - nCommandLineLen);  
  52.         else  
  53.             printf("GetExitCodeProcess()失败  %d\n", GetLastError());  
  54.   
  55.         Sleep(1000);  
  56.     }  
  57.     getch();  
  58.     return 0;  
  59. }  

程序运行结果如下：

 

 本文配套程序下载地址为：http://download.csdn.net/detail/morewindows/5165733

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/8646902

欢迎关注微博：http://weibo.com/MoreWindows




哪些数据库 触发器 哪些数据库 触发器
原创粉丝点击
热门IT博客
软件脱壳后源码软件脱壳后源码
cad软件自学网cad软件自学网
seo编辑工作内容
大庆龙江网络400电话
黑暗之光神器升阶数据
电脑管家u盘数据恢复
js entertainment选拔
虎豹骑 优化
淘宝手机验证 转圈
剑灵龙女捏脸数据
大富翁炒股软件下载
东莞用友erp软件
think python 豆瓣
吴亦凡为什么能红 知乎
python 图片隐写
域名如何转让
淘宝订单记录消失了
不朽传奇光翼进阶数据
剑网三数据互通
mysql 删除所有的表
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 乐平北站 司乐平 乐平房价 乐平二手房 龙珠乐平 乐平在线网 三水乐平 乐平吧 乐平在哪里 乐平中学 韦乐平 中至乐平 乐平市属于哪个市 正宗乐平麻将 江西省乐平市 乐平三中校花赵美琪 乐平正宗麻将 乐平在线招聘 乐平中至麻将下载 乐平西站动车开动工 乐平在线房产 2019年12月31乐平北站 乐广 乐府双璧 江南汉乐府 汉乐府江南 汉乐府 乐府长歌行 乐府江南 江南乐府 乐府诗 乐府 乐府诗集 汉乐府拼音 新乐府运动 东坡乐府 乐府诗特点 乐府双壁 汉乐府诗集 汉乐府古诗 新乐府

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里