Verwendung von named Pipes für prozessübergreifende Kommunikation in Visual Basic .NET oder Visual Basic 2005

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

Auf dieser Seite

Zusammenfassung

dieser in einzelne Schritte gegliederte Artikel beschreibt named Pipes in Microsoft Visual Basic .NET oder in Microsoft Visual Basic 2005 für die prozessübergreifende Kommunikation. Dieser Artikel enthält ein Codebeispiel, das Client-Server-Kommunikation mithilfe einer Namen Pipes in Visual Basic .NET oder in Visual Basic 2005 veranschaulicht. Dieser Artikel beschreibt die prozessübergreifende Kommunikation durch Erstellen einer named Pipe-Server und ein named Pipe-Client. Die Kommunikation über die Pipe erfolgt in folgender Weise:
  • Erstellen Sie eine benannte Pipe.
  • blockieren die Serveranwendung mithilfe von ConnectNamedPipe-Funktion bis ein Client eine Verbindung herstellt.
  • mit dem Server mithilfe der CallNamedPipe-Funktion.
  • ReadFile-Funktion oder die Funktion WriteFile für die Kommunikation über aufrufen die Pipe.
  • Rufen Sie die DisconnectNamedPipe-Funktion auf Beendigung des Prozesses mithilfe der Pipe.
  • Rufen Sie die CloseHandle-Funktion die named Pipe nach Abschluss der Kommunikation über die Pipe.

EINFÜHRUNG

Eine named Pipe ist eine unidirektionale oder duplex Pipe für die Kommunikation zwischen ein Pipe-Server und einem oder mehreren Pipe-Clients. Sie können Benutzer named Pipes zur Kommunikation zwischen Prozessen auf demselben Computer oder zwischen Prozessen auf verschiedenen Computern über ein Netzwerk. Der Begriff "benannte Pipe-Server" bezieht sich auf einen Prozess, der eine named Pipe erstellt und der Begriff "benannte Pipe-Client" auf einen Prozess verweist, die eine Verbindung zu einer Instanz einer named Pipe herstellt.

Sie können Microsoft Visual Basic .NET oder Microsoft Visual Basic 2005 Anwendungen erstellen, die mit anderen Prozessen kommunizieren über named Pipes. Dieser Artikel enthält ein Codebeispiel, eine named Pipe für die Kommunikation zwischen zwei Visual Basic .NET oder Visual Basic 2005 Windows-Anwendungen verwendet.

Voraussetzungen

In diesem Artikel wird vorausgesetzt, dass Sie über Erfahrungen auf den folgenden Gebieten verfügen:
  • Windows-Anwendungen
  • Visual Basic .NET-Programmierung
  • Mithilfe von pipes
Die folgende Liste führt die empfohlene Hardware, Software, Netzwerkinfrastruktur und Servicepacks, die Sie benötigen:
  • Microsoft Visual Studio .NET oder Microsoft Visual Studio 2005
  • Microsoft .NET framework

Erstellen Sie einen named Pipe-server

Gehen Sie folgendermaßen vor um einen named Pipe-Server erstellen und anschließend über die Pipe mit dem Client kommunizieren,
  1. Erstellen Sie eine named Pipe.
  2. Rufen Sie die ConnectNamedPipe -Funktion auf den Server blockiert, bis ein Client eine Verbindung herstellt.
  3. Rufen Sie ReadFile -Funktion oder die Funktion WriteFile Kommunikation über die Pipe auf.
  4. Rufen Sie die DisconnectNamedPipe -Funktion, mit die Pipe nach Beendigung des Prozesses.
  5. Rufen Sie die CloseHandle -Funktion die named Pipe.

Entwerfen Sie eine Windows Anwendung, die einen named Pipe-Server erstellt

Gehen Sie folgendermaßen vor eine Windows-Anwendung entwerfen, die einen named Pipe-Server mithilfe von Visual Basic .NET oder Visual Basic 2005 erstellt,
  1. Starten Sie Microsoft Visual Studio .NET oder Microsoft Visual Studio 2005.
  2. Zeigen im Menü Datei auf neu , und klicken Sie dann auf Projekt .
  3. Klicken Sie unter Projekttypen auf Visual Basic-Projekte und klicken Sie dann unter Vorlagen auf Windows-Anwendung .

    Hinweis: Klicken Sie in Visual Studio 2005 unter Projekttypen auf Visual Basic .
  4. Geben Sie in das Feld Name MyServerApp und klicken Sie dann auf OK . Standardmäßig wird ein Formular, die mit dem Namen Form1 erstellt.
  5. Fügen Sie drei Button -Steuerelemente auf das Formular Form1.
  6. Klicken Sie im Menü Ansicht auf Eigenschaftenfenster .
  7. Legen Sie die Text -Eigenschaft des Button -Steuerelemente, die folgenden Werte:
    Tabelle minimierenTabelle vergrößern
    Name Text
    Button1Eine named Pipe erstellen
    Button2Warten Sie, die Clientverbindungen
    Button3Trennen Sie den server
  8. Das Formular Form1 ein Label -Steuerelement hinzugefügt. Das Label1 Label -Steuerelement wird das Formular Form1 hinzugefügt.

Fügen Sie die Deklarationen zu einem Modul in der Windows-Anwendung hinzu

Gehen Sie folgendermaßen vor um die Funktionsdeklarationen hinzuzufügen, die für die prozessübergreifende Kommunikation mithilfe der Namen Pipes implementieren erforderlich sind,
  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf MyServerApp , zeigen Sie auf Hinzufügen und klicken Sie dann auf Modul hinzufügen .
  2. Klicken Sie im Dialogfeld Neues Element hinzufügen - MyServerApp auf Öffnen .
  3. Add the following code to the Module1.vb module:
    Public Const FILE_ATTRIBUTE_NORMAL As Short = &H80S
    Public Const FILE_FLAG_NO_BUFFERING As Integer = &H20000000
    Public Const FILE_FLAG_WRITE_THROUGH As Integer = &H80000000
    
    Public Const PIPE_ACCESS_DUPLEX As Short = &H3S
    Public Const PIPE_READMODE_MESSAGE As Short = &H2S
    Public Const PIPE_TYPE_MESSAGE As Short = &H4S
    Public Const PIPE_WAIT As Short = &H0S
    
    Public Const INVALID_HANDLE_VALUE As Short = -1
    
    Declare Function CreateNamedPipe Lib "kernel32" Alias "CreateNamedPipeA" _
    (ByVal lpName As String, ByVal dwOpenMode As Integer, _
    ByVal dwPipeMode As Integer, ByVal nMaxInstances As Integer, _
    ByVal nOutBufferSize As Integer, ByVal nInBufferSize As Integer, _
    ByVal nDefaultTimeOut As Integer, ByVal lpSecurityAttributes As IntPtr _
    ) As Integer
    
    Declare Function ConnectNamedPipe Lib "kernel32" _
        (ByVal hNamedPipe As Integer, ByVal lpOverlapped As Integer) As Integer
    
    Declare Function DisconnectNamedPipe Lib "kernel32" _
        (ByVal hNamedPipe As Integer) As Integer
    
    Declare Function WriteFile Lib "kernel32" _
    (ByVal hFile As Integer, ByRef lpBuffer() As Byte, _
    ByVal nNumberOfBytesToWrite As Integer, ByRef lpNumberOfBytesWritten As Integer, _
    ByVal lpOverlapped As Integer _
    ) As Integer
    
    Declare Function ReadFile Lib "kernel32" _
    (ByVal hFile As Integer, ByRef lpBuffer As Integer, _
    ByVal nNumberOfBytesToRead As Integer, ByRef lpNumberOfBytesRead As Integer, _
    ByVal lpOverlapped As Integer _
    ) As Integer
    
    Declare Function FlushFileBuffers Lib "kernel32" _
        (ByVal hFile As Integer) As Integer
    
    Declare Function CloseHandle Lib "kernel32" _
        (ByVal hObject As Integer) As Integer
    

Schreiben Sie Code, um einen named Pipe-Server erstellen

Nachdem Sie eine named Pipe erstellt haben, warten Sie die Verbindungen vom Client aus. Wenn der Client eine Verbindung zum Server herstellt, lesen oder Schreiben der Daten über die Pipe. Gehen Sie hierzu folgendermaßen vor:
  1. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf Form1 und klicken Sie dann auf Öffnen .
  2. In der Entwurfsansicht des Formulars Form1 , doppelklicken Sie auf eine named Pipe erstellen , und fügen Sie der Button1_Click -Prozedur folgenden Code hinzu:
    Dim openMode, pipeMode As Integer
    'Create the named pipe
    openMode = PIPE_ACCESS_DUPLEX Or FILE_FLAG_WRITE_THROUGH
    pipeMode = PIPE_WAIT Or PIPE_TYPE_MESSAGE Or PIPE_READMODE_MESSAGE
    hPipe = CreateNamedPipe(pipeName, openMode, pipeMode, 10, 10000, 2000, 10000, IntPtr.Zero)
    Label1.Text = "Created the named pipe and waiting for the clients."
    Button1.Visible = False
    Button2.Visible = True
    Button3.Visible = True
  3. Fügen Sie vor der Button1_Click -Prozedur folgenden Code:
    Private Const pipeName As String = "\\.\pipe\MyPipe"
    Private Const BUFFSIZE As Short = 10000
    Private Buffer(BUFFSIZE) As Byte
    Private hPipe As Integer
  4. Doppelklicken Sie im Projektmappen-Explorer auf Form1.vb .
  5. In Design view of the Form1 form, double-click Wait for the client connections, and then add the following code to the Button2_Click procedure:
    Dim byteCount, i, res, cbnCount As Integer
    For i = 0 To BUFFSIZE - 1 'Fill an array of numbers
       Buffer(i) = i Mod 256
    Next i
    'Wait for a connection, block until a client connects
    Label1.Text = "Waiting for client connections"
    Me.Refresh()
    Do
       res = ConnectNamedPipe(hPipe, 0)
       'Read the data sent by the client over the pipe
       cbnCount = 4
       res = ReadFile(hPipe, byteCount, Len(byteCount), cbnCount, 0)
       If byteCount > BUFFSIZE Then 'Client requested for byteCount bytes
           byteCount = BUFFSIZE 'but only send up to 20000 bytes
       End If
       'Write the number of bytes requested by the client 
       res = WriteFile(hPipe, Buffer, byteCount, cbnCount, 0)
       res = FlushFileBuffers(hPipe)
       'Disconnect the named pipe.
       res = DisconnectNamedPipe(hPipe)
       'Loop until the client makes no more requests for data. 
    Loop Until byteCount = 0
    Label1.Text = "Read or Write completed"
    Button2.Visible = False
  6. In der Entwurfsansicht, doppelklicken Sie auf Form1, und fügen Sie den folgenden Code hinzu der Form1_Load -Prozedur:
    Button2.Visible = False
    Button3.Visible = False
  7. Doppelklicken Sie im Projektmappen-Explorer auf Form1.vb .
  8. In der Entwurfsansicht das Formular Form1 doppelklicken Sie auf Trennen der Server , und fügen dann an die Prozedur Button3_Click den folgenden Code hinzu:
    Dim res As Integer
    'Close the pipe handle when the client makes no requests
    CloseHandle(hPipe)
    Label1.Text = "Disconnected the named pipe"
  9. Klicken Sie im Menü Erstellen auf Projektmappe erstellen .

Erstellen eines named Pipe-Clients

Gehen Sie folgendermaßen vor um einen named Pipe-Client, der kommuniziert mit dem Server zu erstellen:
  1. Rufen Sie die CreateFile -Funktion, um ein Handle für die named Pipe zu erstellen.
  2. Rufen Sie ReadFile -Funktion oder die Funktion WriteFile Kommunikation über die Pipe auf.
  3. Rufen Sie die CloseHandle -Funktion auf den Ziehpunkt, der in die CreateFile -Funktion erstellt wird.
Sie können auch eine named Pipe-Transaktion für die Client-Server-Kommunikation verwenden. Die named Pipe-Transaktion kombiniert ein Schreibvorgang und einen Lesevorgang in einem einzelnen Netzwerk-Vorgang. Eine Transaktion kann nur auf eine duplex, Nachrichtentyp Pipe verwendet werden. Prozesse können die TransactNamedPipe -Funktion oder die CallNamedPipe -Funktion verwenden, um die named Pipe-Transaktionen ausführen.

In diesem Beispielcode verwenden Sie die CallNamedPipe -Funktion, um mit dem named Pipe-Server verbinden, die Daten in die Pipe zu schreiben und Lesen Sie dann die Daten aus der Pipe.

Entwerfen Sie eine Windows Anwendung, die mit der named Pipe-Server kommuniziert

Gehen Sie folgendermaßen vor eine Visual Basic .NET oder Visual Basic 2005 Windows-Anwendung entwerfen, die zum Verbinden mit der named Pipe-Server,
  1. Starten Sie Microsoft Visual Studio .NET oder Microsoft Visual Studio 2005.
  2. Zeigen im Menü Datei auf neu , und klicken Sie dann auf Projekt .
  3. Klicken Sie unter Projekttypen auf Visual Basic-Projekte und klicken Sie dann unter Vorlagen auf Windows-Anwendung .

    Hinweis: Klicken Sie in Visual Studio 2005 unter Projekttypen auf Visual Basic .
  4. Geben Sie in das Feld Name MyClientApp und klicken Sie dann auf OK . Standardmäßig wird ein Formular, die mit dem Namen Form1 erstellt.
  5. Das Formular Form1 ein Button -Steuerelement hinzugefügt.
  6. Klicken Sie mit der rechten Maustaste auf Button1 , und klicken Sie dann auf Eigenschaften .
  7. Legen Sie für die Text -Eigenschaft mit dem Server .
  8. Das Formular Form1 ein Label -Steuerelement hinzugefügt. Formular "Form1 " wird das Label1 Label -Steuerelement hinzugefügt.
  9. Legen Sie die Visible -Eigenschaft Label1 Label -Steuerelements auf false fest.
  10. Fügen Sie zwei TextBox -Steuerelemente hinzu das Formular Form1.

Schreiben Sie Code, mit dem named Pipe-Server verbinden

Verbindung mit dem named Pipe-Server mithilfe der CallNamedPipe -Funktion herstellen. Nach dem Herstellen der Verbindung an den Server Funktion schreibt in die Pipe CallNamedPipe aus der Pipe liest und schließt dann die Pipe. Gehen Sie folgendermaßen vor um eine Verbindung mit dem Server herzustellen und zu lesen oder Schreiben Sie die Daten:
  1. In Design view, double-click Connect to the server, and then add the following code to the Button1_Click procedure:
    Dim i, res, cbRead,numBytes As Integer
    Dim bArray() As Byte
    Dim temp As String
    
    numBytes = CInt(TextBox1.Text)
    If numBytes < 0 Then
        MessageBox.Show("Value must be at least 0.", MsgBoxStyle.OKOnly)
        Exit Sub
    End If
    If numBytes = 0 Then
        Label1.Visible = True
        Label1.Text = "The connection to the server is disconnected."
        Button1.Visible = False
        TextBox1.Visible = False
        TextBox2.Visible = False
    End If
    If numBytes > BUFFSIZE Then
        numBytes = BUFFSIZE
    End If
    
    ReDim bArray(numBytes) 'Create the return buffer
    'Call the CallNamedPipe function to do the transactions
     res = CallNamedPipe(pipeName, numBytes, Len(numBytes), bArray(0), numBytes, cbRead, 30000) 
    'Wait up to 30 seconds for a response
    'Format the data received, and then display the data in the text box
    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
        TextBox2.Text = temp
    Else
    MessageBox.Show("Error number " & Err.LastDllError & _
    "while trying to call the CallNamedPipe function.", MsgBoxStyle.OKOnly)
    End If
  2. Fügen Sie vor der Button1_Click -Prozedur folgenden Code:
    Private Const pipeName As String = "\\.\pipe\MyPipe"
    Private Const BUFFSIZE As Integer = 10000
    Private hpipe As Integer
        
    Public Const INVALID_HANDLE_VALUE As Short = -1
    Public Declare Function CallNamedPipe Lib "kernel32" Alias "CallNamedPipeA" _
    (ByVal lpNamedPipeName As String, _
    ByRef lpInBuffer As Integer, _
    ByVal nInBufferSize As Integer, _
    ByRef lpOutBuffer As Byte, _
    ByVal nOutBufferSize As Integer, _
    ByRef lpBytesRead As Integer, ByVal nTimeOut As Integer) As Integer
  3. Klicken Sie im Menü Erstellen auf Projektmappe erstellen .

Überprüfen Sie, ob der Code funktioniert

Um zu überprüfen, dass Ihr Code funktioniert, gehen Sie folgendermaßen vor:
  1. Klicken Sie auf Start im Menü Debuggen des Projekts MyServerApp, um die Server-Anwendung zu starten.
  2. Klicken Sie auf dem Formular Form1 auf eine named Pipe erstellen , und klicken Sie auf die Clientverbindungen warten . Die Anwendung wird jetzt blockiert und wartet, bis der Client eine Verbindung herstellen.
  3. Klicken Sie auf Start im Menü Debuggen des Projekts MyClientApp, um die Client-Anwendung zu starten.
  4. Das Formular Form1 Geben Sie 10 im Feld TextBox1 und klicken Sie dann auf Verbindung mit dem Server herstellen . Sie finden das Bytearray, das im Feld TextBox2 empfangen wird.
  5. Um die Clientanwendung den Server zu trennen, Typ 0 in TextBox1 in der Clientanwendung ein, und klicken Sie dann auf Verbindung mit dem Server herstellen .
  6. Schließen Sie die Clientanwendung.
  7. Klicken Sie auf Trennen der Server auf dem Formular Form1 der Serveranwendung, um das Serverende der named Pipe zu trennen, und schließen Sie die Serveranwendung.

Informationsquellen

Weitere Informationen finden Sie auf der folgenden Microsoft Developer Network (MSDN)-Websites:
Named pipes
http://msdn2.microsoft.com/en-us/library/aa365590.aspx
Buchungen für named pipes
http://msdn2.microsoft.com/en-us/library/aa365789.aspx
Pipe-Funktionen
http://msdn2.microsoft.com/en-us/library/aa365781.aspx

Eigenschaften

Artikel-ID: 871044 - Geändert am: Donnerstag, 11. Januar 2007 - Version: 2.4
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual Basic 2005
  • Microsoft Visual Basic .NET 2003 Standard Edition
  • Microsoft Visual Basic .NET 2002 Standard Edition
Keywords: 
kbmt kbvs2005swept kbvs2005applies kbserver kbpipes kbipc kbclient kbhowtomaster kbhowto KB871044 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: 871044
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