So wird 's gemacht: Verwenden von Named Pipes in Visual Basic-32-Bit-Programmen

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 177696 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

Visual Basic können Anwendungen erstellen, die mit anderen Prozessen über Named Pipes zu kommunizieren. Die Named Pipe muss unter Windows 2000 oder Windows NT erstellt werden; hingegen lesen und Schreiben der Named Pipe von jeder 32-Bit-Plattform.

Dieser Artikel beschreibt, Client-Server-Kommunikation über eine Named Pipe in Visual Basic.

Weitere Informationen

In diesem Artikel der Prozess der NamedPipe erstellen heißt des Servers, und der Prozess mit der named Pipe wird den Client bezeichnet.

Es gibt sechs Schritte zum Erstellen eines named Pipe-Servers:
  1. Erstellen Sie ein Sicherheitstoken für die Pipe zu ermöglichen den Zugriff auf (um eine Named Pipe durch Erstellen eines Sicherheitstokens mit einem DISCRETIONARY Access Control List (), die NULL-Einträge enthält für jeden Prozess zur Verfügung stellen).
  2. Erstellen Sie Named Pipe.
  3. Rufen Sie ConnectNamedPipe zu blockieren, bis ein Client eine Verbindung herstellt.
  4. Rufen Sie ReadFile und/oder WriteFile, um die Kommunikation über die Pipe.
  5. Rufen Sie DisconnectNamedPipe auf, wenn der Vorgang abgeschlossen ist mit die Pipe.
  6. Entweder CloseHandle auf named Pipe oder wechseln Sie zurück zu Schritt 4.
Es gibt drei Schritte eine Named Pipe von Named Pipes-Client verwenden:
  1. Rufen Sie CreateFile um ein Handle zu der Named Pipe zu erhalten.
  2. Rufen Sie ReadFile und/oder WriteFile, um die Kommunikation über die Pipe.
  3. Rufen Sie CloseHandle auf das Filehandle in CreateFile erstellt.
Alternativ konnten Sie CallNamedPipe, aufrufen, die eine einmalige Transaktion über die Pipe führt. CallNamedPipe die Pipe öffnet, es schreibt, liest daraus und schließt die Pipe. Dies ist die Funktionsweise des Clients unten.

Das folgende Beispiel veranschaulicht, wie eine Named Pipe Server- und erstellt. Nur die am häufigsten elementare Funktionen erforderlich, mit einer minimalen Menge der Fehlerüberprüfung dazu implementiert. Ein voll funktionsfähiges Programm sollten überprüfen, die Rückgabewerte der APIs, die aufgerufen werden, sondern vorausgesetzt Sie erfolgreich waren.

Named Pipe-Server

  1. Erstellen Sie ein neues Projekt. Form1 wird standardmäßig erstellt.
  2. Fügen Sie dem Formular folgenden Code hinzu:
       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. Erstellen Sie ein neues Modul und fügen Sie die folgenden Deklarationen:
       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. Speichern Sie das Formular.

Named Pipe-Client

  1. Erstellen Sie ein neues Projekt. Form1 wird standardmäßig erstellt.
  2. Fügen Sie dem Formular folgende Steuerelemente:
       Type             Name               Caption/Default Value
       ----             ----               ---------------------
       TextBox          cbBytes            500
       CommandButton    cmdCallNamedPipe   Call Named Pipe
       TextBox          txtReceive
    					
  3. Fügen Sie dem Formular folgenden Code hinzu:
       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. Beachten Sie, dass der Server ausgeführt wird, auf einem Computer als dem der Client ist, so ändern Sie müssen die '. ' in der Variablen SzPipeName auf den Namen des Servercomputers.
  5. Speichern Sie das Formular. Um den obigen Code zu testen, zunächst starten Sie den Server und klicken Sie an einer beliebigen Stelle auf dem Formular. Die Serveranwendung ist, nun blockieren und angezeigt, die nicht mehr reagiert haben, doch tatsächlich wartet der Client eine Verbindung herstellen. Dann starten Sie die Clientanwendung und klicken Sie auf der "Call Named Pipe." Der Client sollte den Wert 500 an den Server senden, die mit 500 Bytes Daten antwortet. Sie können den Wert in das Textfeld CbBytes von 0 auf 20000 Bytes festgelegt. Um den Server zu beenden, klicken Sie einfach vom Client senden Sie 0 (null). Der Client möglicherweise Fehler 233 (ERROR_PIPE_NOT_CONNECTED) empfangen, aber dies ist normal.

    Im Beispiel eine weitere Verbesserung möglicherweise umfassen die Verwendung von e/A-Abschlussports und/oder Lesevorgänge nicht blockieren und mit überlappende e/a-Schreibvorgänge. Weitere Informationen zu diesen Themen finden Sie im Microsoft Platform SDK.

Informationsquellen

Stehen mehrere IPC (InterProcess Communication) Methoden in Windows 2000, Windows NT und Windows 95, die unidirektionale oder bidirektionale Übertragung von Daten zwischen mehreren Prozessen zu ermöglichen. Eine vollständige Liste der IPC-Methoden auf jeder Plattform zur Verfügung finden Sie in der folgenden Artikel der Microsoft Knowledge Base:
95900Unter Windows NT, Windows 95 und Win32s: prozessübergreifende Kommunikation

Eigenschaften

Artikel-ID: 177696 - Geändert am: Montag, 12. Februar 2007 - Version: 2.4
Die Informationen in diesem Artikel beziehen sich auf:
  • 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
Keywords: 
kbmt kbapi kbhowto KB177696 KbMtde
Maschinell übersetzter Artikel
Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.
Den englischen Originalartikel können Sie über folgenden Link abrufen: 177696
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com