Compartilhar via


Transações em pipes nomeados

Uma transação de pipe nomeada é uma comunicação cliente/servidor que combina uma operação de gravação e uma operação de leitura em uma única operação de rede. Uma transação só pode ser usada em um pipe duplex, tipo de mensagem. As transações melhoram o desempenho das comunicações de rede entre um cliente e um servidor remoto. Os processos podem usar as funções TransactNamedPipe e CallNamedPipe para executar transações de pipe nomeadas.

A função TransactNamedPipe é mais comumente usada por um cliente de pipe para gravar uma mensagem de solicitação no servidor de pipe nomeado e ler a mensagem de resposta do servidor. O cliente de pipe deve especificar GENERIC_READ | GENERIC_WRITE acesso ao abrir o identificador de pipe chamando a função CreateFile . Em seguida, o cliente de pipe define o identificador de pipe para o modo de leitura de mensagem chamando a função SetNamedPipeHandleState . Se o buffer de leitura especificado na chamada para TransactNamedPipe não for grande o suficiente para manter a mensagem inteira gravada pelo servidor, a função retornará zero e GetLastError retornará ERROR_MORE_DATA. O cliente pode ler o restante da mensagem chamando a função ReadFile, ReadFileEx ou PeekNamedPipe .

O TransactNamedPipe normalmente é chamado por clientes de pipe, mas também pode ser usado por um servidor de pipe.

O exemplo a seguir mostra um cliente de pipe usando TransactNamedPipe. Esse cliente de pipe pode ser usado com qualquer um dos servidores de pipe listados em Consulte Também.

#include <windows.h> 
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

#define BUFSIZE 512
 
int _tmain(int argc, TCHAR *argv[]) 
{ 
   HANDLE hPipe; 
   LPTSTR lpszWrite = TEXT("Default message from client"); 
   TCHAR chReadBuf[BUFSIZE]; 
   BOOL fSuccess; 
   DWORD cbRead, dwMode; 
   LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); 

   if( argc > 1)
   {
      lpszWrite = argv[1]; 
   }
 
   // Try to open a named pipe; wait for it, if necessary. 
    while (1) 
   { 
      hPipe = CreateFile( 
         lpszPipename,   // pipe name 
         GENERIC_READ |  // read and write access 
         GENERIC_WRITE, 
         0,              // no sharing 
         NULL,           // default security attributes
         OPEN_EXISTING,  // opens existing pipe 
         0,              // default attributes 
         NULL);          // no template file 
 
      // Break if the pipe handle is valid. 
      if (hPipe != INVALID_HANDLE_VALUE) 
         break; 
 
      // Exit if an error other than ERROR_PIPE_BUSY occurs. 
      if (GetLastError() != ERROR_PIPE_BUSY) 
      {
         printf("Could not open pipe\n"); 
         return 0;
      }
 
      // All pipe instances are busy, so wait for 20 seconds. 
      if (! WaitNamedPipe(lpszPipename, 20000) ) 
      {
         printf("Could not open pipe\n"); 
         return 0;
      }
  } 
 
   // The pipe connected; change to message-read mode. 
   dwMode = PIPE_READMODE_MESSAGE; 
   fSuccess = SetNamedPipeHandleState( 
      hPipe,    // pipe handle 
      &dwMode,  // new pipe mode 
      NULL,     // don't set maximum bytes 
      NULL);    // don't set maximum time 
   if (!fSuccess) 
   {
      printf("SetNamedPipeHandleState failed.\n"); 
      return 0;
   }
 
   // Send a message to the pipe server and read the response. 
   fSuccess = TransactNamedPipe( 
      hPipe,                  // pipe handle 
      lpszWrite,              // message to server
      (lstrlen(lpszWrite)+1)*sizeof(TCHAR), // message length 
      chReadBuf,              // buffer to receive reply
      BUFSIZE*sizeof(TCHAR),  // size of read buffer
      &cbRead,                // bytes read
      NULL);                  // not overlapped 

   if (!fSuccess && (GetLastError() != ERROR_MORE_DATA)) 
   {
      printf("TransactNamedPipe failed.\n"); 
      return 0;
   }
 
   while(1)
   { 
      _tprintf(TEXT("%s\n"), chReadBuf);

      // Break if TransactNamedPipe or ReadFile is successful
      if(fSuccess)
         break;

      // Read from the pipe if there is more data in the message.
      fSuccess = ReadFile( 
         hPipe,      // pipe handle 
         chReadBuf,  // buffer to receive reply 
         BUFSIZE*sizeof(TCHAR),  // size of buffer 
         &cbRead,  // number of bytes read 
         NULL);    // not overlapped 

      // Exit if an error other than ERROR_MORE_DATA occurs.
      if( !fSuccess && (GetLastError() != ERROR_MORE_DATA)) 
         break;
      else _tprintf( TEXT("%s\n"), chReadBuf); 
   }

   _getch(); 

   CloseHandle(hPipe); 
 
   return 0; 
}

Um cliente de pipe usa CallNamedPipe para combinar as chamadas de função CreateFile, WaitNamedPipe (se necessário), TransactNamedPipe e CloseHandle em uma única chamada. Como o identificador de pipe é fechado antes que a função retorne, todos os bytes adicionais na mensagem serão perdidos se a mensagem for maior que o tamanho especificado do buffer de leitura. O exemplo a seguir é o exemplo anterior reescrito para usar CallNamedPipe.

#include <windows.h> 
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

#define BUFSIZE 512
 
int _tmain(int argc, TCHAR *argv[]) 
{ 
   LPTSTR lpszWrite = TEXT("Default message from client"); 
   TCHAR chReadBuf[BUFSIZE]; 
   BOOL fSuccess; 
   DWORD cbRead; 
   LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); 

   if( argc > 1)
   {
      lpszWrite = argv[1]; 
   }
 
   fSuccess = CallNamedPipe( 
      lpszPipename,        // pipe name 
      lpszWrite,           // message to server 
      (lstrlen(lpszWrite)+1)*sizeof(TCHAR), // message length 
      chReadBuf,              // buffer to receive reply 
      BUFSIZE*sizeof(TCHAR),  // size of read buffer 
      &cbRead,                // number of bytes read 
      20000);                 // waits for 20 seconds 
 
   if (fSuccess || GetLastError() == ERROR_MORE_DATA) 
   { 
      _tprintf( TEXT("%s\n"), chReadBuf ); 
    
      // The pipe is closed; no more data can be read. 
 
      if (! fSuccess) 
      {
         printf("\nExtra data in message was lost\n"); 
      }
   }
 
   _getch(); 

   return 0; 
}

Servidor de pipe multithread

Servidor de pipe nomeado usando E/S sobreposta

Servidor de pipe nomeado usando rotinas de conclusão