Estás trabajando sin conexión, espera a que vuelva la conexión a Internet

Cómo utilizar con canalizaciones en un programa de 32 bits de Visual Basic

IMPORTANTE: Este artículo ha sido traducido por un software de traducción automática de Microsoft (http://support.microsoft.com/gp/mtdetails) en lugar de un traductor humano. Microsoft le ofrece artículos traducidos por un traductor humano y artículos traducidos automáticamente para que tenga acceso en su propio idioma a todos los artículos de nuestra base de conocimientos (Knowledge Base). Sin embargo, los artículos traducidos automáticamente pueden contener errores en el vocabulario, la sintaxis o la gramática, como los que un extranjero podría cometer al hablar el idioma. Microsoft no se hace responsable de cualquier imprecisión, error o daño ocasionado por una mala traducción del contenido o como consecuencia de su utilización por nuestros clientes. Microsoft suele actualizar el software de traducción frecuentemente.

Haga clic aquí para ver el artículo original (en inglés): 177696
Resumen
Visual Basic pueden crear aplicaciones que se comunican a otros procesos por medio de canalizaciones con nombre. Debe crearse la canalización con nombre en Windows 2000 o Windows NT; sin embargo, puede leer y escribir en esa canalización desde cualquier plataforma de 32 bits.

Este artículo demuestra la comunicación de cliente-servidor mediante una canalización con nombre en Visual Basic.
Más información
En este artículo, el proceso de crear el NamedPipe se denomina servidor y el proceso de conectarse a la canalización con nombre se llama al cliente.

Hay seis pasos para crear un servidor de canalización con nombre:
  1. Crear un token de seguridad para la canalización permitir el acceso a él (para hacer que una canalización con nombre esté disponible a cualquier proceso creando un token de seguridad con un acceso control lista discrecional (DACL) que tiene cero entradas en él).
  2. Crear la canalización con nombre.
  3. Llame a ConnectNamedPipe para bloquear hasta que un cliente se conecta.
  4. Llame a ReadFile y WriteFile comunicarse a través de la canalización.
  5. Llame a DisconnectNamedPipe cuando termine el proceso mediante la canalización.
  6. Ambos CloseHandle de la canalización con nombre o ir al paso 4.
Hay tres pasos para utilizar una canalización con nombre del cliente de canalizaciones con nombre:
  1. Llame a CreateFile para obtener un identificador de canalización con nombre.
  2. Llame a ReadFile y WriteFile comunicarse a través de la canalización.
  3. Llamar a CloseHandle el filehandle creado en CreateFile.
Como alternativa, puede llamar a CallNamedPipe, que realiza una única transacción a través de la canalización. CallNamedPipe la abre la canalización, se escribe en él, lee, y se cierra la canalización. Esto es lo que el cliente siguiente.

En el siguiente ejemplo muestra cómo crear un servidor de canalización con nombre y el cliente. Implementa sólo las funciones necesarias para ello, con una cantidad mínima de comprobación de errores más rudimentarias. Un programa totalmente funcional debe comprobar los valores de retorno de la API que se llama en lugar de suponiendo que se realizaron correctamente.

Servidor de canalización con nombre

  1. Cree un nuevo proyecto. Se creará Form1 de manera predeterminada.
  2. Agregue el código siguiente al formulario:
       Option Explicit   Private Const szPipeName = "\\.\pipe\bigtest"   Private Const BUFFSIZE = 20000   Private BigBuffer(BUFFSIZE) As Byte, pSD As Long   Private sa As SECURITY_ATTRIBUTES   Private hPipe As Long   Private Sub Form_Click()      Dim i As Long, dwOpenMode As Long, dwPipeMode As Long      Dim res As Long, nCount As Long, cbnCount As Long      For i = 0 To BUFFSIZE - 1       'Fill an array of numbers         BigBuffer(i) = i Mod 256      Next i      'Create the NULL security token for the pipe      pSD = GlobalAlloc(GPTR, SECURITY_DESCRIPTOR_MIN_LENGTH)      res = InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)      res = SetSecurityDescriptorDacl(pSD, -1, 0, 0)      sa.nLength = LenB(sa)      sa.lpSecurityDescriptor = pSD      sa.bInheritHandle = True      'Create the Named Pipe      dwOpenMode = PIPE_ACCESS_DUPLEX Or FILE_FLAG_WRITE_THROUGH      dwPipeMode = PIPE_WAIT Or PIPE_TYPE_MESSAGE Or PIPE_READMODE_MESSAGE      hPipe = CreateNamedPipe(szPipeName, dwOpenMode, dwPipeMode, _                              10, 10000, 2000, 10000, sa)      Do  'Wait for a connection, block until a client connects         res = ConnectNamedPipe(hPipe, ByVal 0)         'Read/Write data over the pipe         cbnCount = 4         res = ReadFile(hPipe, nCount, LenB(nCount), cbnCount, ByVal 0)         If nCount <> 0 Then            If nCount > BUFFSIZE Then 'Client requested nCount bytes               nCount = BUFFSIZE      'but only send up to 20000 bytes            End If            'Write the number of bytes requested            res = WriteFile(hPipe, BigBuffer(0), nCount, cbnCount, ByVal 0)            'Make sure the write is finished            res = FlushFileBuffers(hPipe)         End If         'Disconnect the NamedPipe         res = DisconnectNamedPipe(hPipe)      Loop Until nCount = 0      'Close the pipe handle      CloseHandle hPipe      GlobalFree (pSD)      End   End Sub					
  3. Cree un nuevo módulo y agregue las siguientes declaraciones:
       Option Explicit   Public Const FILE_ATTRIBUTE_NORMAL = &H80   Public Const FILE_FLAG_NO_BUFFERING = &H20000000   Public Const FILE_FLAG_WRITE_THROUGH = &H80000000   Public Const PIPE_ACCESS_DUPLEX = &H3   Public Const PIPE_READMODE_MESSAGE = &H2   Public Const PIPE_TYPE_MESSAGE = &H4   Public Const PIPE_WAIT = &H0   Public Const INVALID_HANDLE_VALUE = -1   Public Const SECURITY_DESCRIPTOR_MIN_LENGTH = (20)   Public Const SECURITY_DESCRIPTOR_REVISION = (1)   Type SECURITY_ATTRIBUTES           nLength As Long           lpSecurityDescriptor As Long           bInheritHandle As Long   End Type   Public Const GMEM_FIXED = &H0   Public Const GMEM_ZEROINIT = &H40   Public Const GPTR = (GMEM_FIXED Or GMEM_ZEROINIT)   Declare Function GlobalAlloc Lib "kernel32" ( _      ByVal wFlags As Long, ByVal dwBytes As Long) As Long   Declare Function GlobalFree Lib "kernel32" (ByVal hMem As Long) As Long   Declare Function CreateNamedPipe Lib "kernel32" Alias _      "CreateNamedPipeA" ( _      ByVal lpName As String, _      ByVal dwOpenMode As Long, _      ByVal dwPipeMode As Long, _      ByVal nMaxInstances As Long, _      ByVal nOutBufferSize As Long, _      ByVal nInBufferSize As Long, _      ByVal nDefaultTimeOut As Long, _      lpSecurityAttributes As Any) As Long   Declare Function InitializeSecurityDescriptor Lib "advapi32.dll" ( _      ByVal pSecurityDescriptor As Long, _      ByVal dwRevision As Long) As Long   Declare Function SetSecurityDescriptorDacl Lib "advapi32.dll" ( _      ByVal pSecurityDescriptor As Long, _      ByVal bDaclPresent As Long, _      ByVal pDacl As Long, _      ByVal bDaclDefaulted As Long) As Long   Declare Function ConnectNamedPipe Lib "kernel32" ( _      ByVal hNamedPipe As Long, _      lpOverlapped As Any) As Long   Declare Function DisconnectNamedPipe Lib "kernel32" ( _      ByVal hNamedPipe As Long) As Long   Declare Function WriteFile Lib "kernel32" ( _      ByVal hFile As Long, _      lpBuffer As Any, _      ByVal nNumberOfBytesToWrite As Long, _      lpNumberOfBytesWritten As Long, _      lpOverlapped As Any) As Long   Declare Function ReadFile Lib "kernel32" ( _      ByVal hFile As Long, _      lpBuffer As Any, _      ByVal nNumberOfBytesToRead As Long, _      lpNumberOfBytesRead As Long, _      lpOverlapped As Any) As Long   Declare Function FlushFileBuffers Lib "kernel32" ( _      ByVal hFile As Long) As Long   Declare Function CloseHandle Lib "kernel32" ( _      ByVal hObject As Long) As Long					
  4. Guarde el formulario.

Cliente de canalización con nombre

  1. Cree un nuevo proyecto. Se creará Form1 de manera predeterminada.
  2. Agregue los siguientes controles al formulario:
       Type             Name               Caption/Default Value   ----             ----               ---------------------   TextBox          cbBytes            500   CommandButton    cmdCallNamedPipe   Call Named Pipe   TextBox          txtReceive					
  3. Agregue el código siguiente al formulario:
       Option Explicit   Private Const szPipeName = "\\.\pipe\bigtest", BUFFSIZE = 20000   Private Declare Function CallNamedPipe Lib "kernel32" Alias _      "CallNamedPipeA" ( _      ByVal lpNamedPipeName As String, _      lpInBuffer As Any, _      ByVal nInBufferSize As Long, _      lpOutBuffer As Any, _      ByVal nOutBufferSize As Long, _      lpBytesRead As Long, _      ByVal nTimeOut As Long) As Long   Private Sub cmdCallNamedPipe_Click()      Dim res As Long, myStr As String, i As Long, cbRead As Long      Dim numBytes As Long, bArray() As Byte, temp As String      numBytes = cbBytes.Text      If cbBytes.Text < 0 Then         MsgBox "Value must be at least 0.", vbOKOnly         Exit Sub      End If      If numBytes > BUFFSIZE Then         numBytes = BUFFSIZE      End If      ReDim bArray(numBytes)  'Build the return buffer      'Call CallNamedPipe to do the transaction all at once      res = CallNamedPipe(szPipeName, numBytes, LenB(numBytes), _         bArray(0), numBytes, _         cbRead, 30000) 'Wait up to 30 seconds for a response      If res > 0 Then         temp = Format(bArray(0), " 000")         For i = 1 To cbRead - 1            If (i Mod 16) = 0 Then temp = temp & vbCrLf            temp = temp & " " & Format(bArray(i), "000")         Next i         txtReceive.Text = temp      Else         MsgBox "Error number " & Err.LastDllError & _                " attempting to call CallNamedPipe.", vbOKOnly      End If   End Sub					
  4. Tenga en cuenta que si el servidor se está ejecutando en un equipo distinto de donde es el cliente, debe cambiar el '. ' en la variable szPipeName en el nombre de la máquina del servidor.
  5. Guarde el formulario. Para probar el código anterior, primero inicie el servidor y haga clic en cualquier lugar en el formulario. La aplicación de servidor es ahora de bloqueo y aparecerán ha bloqueado, pero realmente está esperando el cliente se conecte. A continuación, inicie la aplicación cliente y haga clic en la canalización"llamada con nombre". El cliente debe enviar el valor de 500 al servidor, responderá con 500 bytes de datos. Puede establecer el valor en el cuadro de texto cbBytes de 0 a 20000 bytes. Para detener el servidor, simplemente envía 0 (cero) desde el cliente. El cliente puede recibir el error 233 (ERROR_PIPE_NOT_CONNECTED), pero esto es normal.

    Otra mejora en el ejemplo puede incluir el uso de puertos de finalización de E/S y el bloqueo no lee y escribe utilizando la E/S superpuesta. Puede encontrar más información sobre estos asuntos en Microsoft Platform SDK.
Referencias
Existen varios métodos de comunicación InterProcess (IPC) en Windows 2000, Windows NT y Windows 95 que permiten la transferencia de datos unidireccional o bidireccional entre múltiples procesos. Para obtener una lista completa de métodos de IPC disponibles en cada plataforma, consulte en contacto con el siguiente artículo en Microsoft Knowledge Base:
95900Comunicación: entre procesos en Windows NT, Windows 95 y Win32s

Advertencia: este artículo se tradujo automáticamente

Propiedades

Id. de artículo: 177696 - Última revisión: 02/12/2007 19:08:32 - Revisión: 2.4

Microsoft Visual Basic 4.0 Professional Edition, Microsoft Visual Basic 5.0 Professional Edition, Microsoft Visual Basic 6.0 Professional Edition, Microsoft Visual Basic 4.0 Enterprise Edition, Microsoft Visual Basic 5.0 Enterprise Edition, Microsoft Visual Basic Enterprise Edition for Windows 6.0, Microsoft Windows NT 4.0, Microsoft Windows NT 3.51 Service Pack 5, Microsoft Windows NT 4.0, Microsoft Windows 98 Standard Edition, Microsoft Win32 Application Programming Interface, the operating system: Microsoft Windows 2000, Microsoft Windows 95, Microsoft Windows Millennium Edition

  • kbmt kbapi kbhowto KB177696 KbMtes
Comentarios
ascript" src="https://c.microsoft.com/ms.js">