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

Zusammenfassung

Dieser Artikel beschreibt die Verwendung von named Pipes in Microsoft Visual Basic .NET oder Microsoft Visual Basic 2005 für prozessübergreifende Kommunikation. Dieser Artikel enthält ein Codebeispiel, das Client-Server-Kommunikation wird anhand einer Namen Pipes in Visual Basic .NET oder Visual Basic 2005. Dieser Artikel beschreibt die IPC named Pipe-Server und named Pipe-Client. Die Kommunikation über die Pipe wird folgendermaßen durchgeführt:
  • Erstellen einer Namen Pipes.
  • Blockieren Sie die Server-Anwendung mit der ConnectNamedPipe Funktion, bis ein Client eine Verbindung herstellt.
  • Verbindung zum Server mithilfe der CallNamedPipe-Funktion
  • Aufrufen der ReadFile-Funktion oder die Funktion WriteFile Kommunikation über die Pipe.
  • Rufen Sie die DisconnectNamedPipe-Funktion bei Beendigung des Prozesses mit der Pipe.
  • Rufen Sie die Funktion CloseHandle named Pipe, nach der Kommunikation über die Pipe.

Einführung

Eine named Pipe ist unidirektional oder bidirektional Pipe für die Kommunikation zwischen einem Pipeserver und einem oder mehrere Pipeclients bereit. Sie können Benutzer benannte Pipes zur Kommunikation zwischen Prozessen auf demselben Computer bzw. zwischen Prozessen auf verschiedenen Computern in einem Netzwerk. Der Begriff "named Pipe-Server" bezieht sich auf einen Prozess, der eine named Pipe erstellt, und der Begriff "named Pipe-Client" bezieht sich auf einen Prozess, der auf eine Instanz einer named Pipe verbindet.


Sie können Microsoft Visual Basic .NET oder Microsoft Visual Basic 2005 Anwendung 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 Applications verwendet.

zurück zum Anfang

Voraussetzungen

Es wird vorausgesetzt, dass Sie mit folgenden Themen vertraut sind:
  • Windows-Anwendung
  • Visual Basic .NET programmieren
  • Mithilfe von pipes
Die folgende Liste enthält die empfohlene Hardware, Software, Netzwerkinfrastruktur und Servicepacks, die Sie benötigen:
  • Microsoft Visual Studio .NET oder Microsoft Visual Studio 2005
  • Microsoft.NET Framework
zurück zum Anfang

Named Pipe-Server erstellen

Named Pipe-Server erstellt und dann über die Pipe mit dem Client kommunizieren, gehen Sie folgendermaßen vor:
  1. Erstellen einer Namen Pipes.
  2. Rufen Sie die ConnectNamedPipe -Funktion, um den Server blockiert, bis ein Client eine Verbindung herstellt.
  3. Aufrufen der ReadFile -Funktion oder die Funktion WriteFile Kommunikation über die Pipe.
  4. Rufen Sie die DisconnectNamedPipe -Funktion bei Beendigung des Prozesses mit der Pipe.
  5. Rufen Sie die Funktion CloseHandle named Pipe.
zurück zum Anfang

Entwerfen einer Windows-Anwendung, die named Pipe-Server erstellt

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

    Hinweis Klicken Sie in Visual Studio 2005 unter Projekttypenauf Visual Basic .
  4. Geben Sie im Feld Name MyServerAppund klicken Sie dann auf OK. Standardmäßig wird ein Formular mit dem Namen Form1 erstellt.
  5. Das Formular Form1 drei Schaltflächen hinzufügen.
  6. Klicken Sie im Menü Ansicht auf Eigenschaftenfenster.
  7. Legen Sie die Text -Eigenschaft der Schaltflächen -Steuerelemente mit den folgenden Werten:
    NameText
    Button1Named Pipe erstellen
    Button2Warten Sie, bis die Clientverbindungen
    Button3Trennen Sie den server
  8. Fügen Sie ein Label -Steuerelement in das Formular Form1 . Das Formular Form1 Label1 Label -Steuerelement hinzugefügt.
zurück zum Anfang

Fügen Sie die Deklarationen auf ein Modul in der Windows-Anwendung

Fügen Sie die Deklarationen, die erforderlich sind, implementieren die prozessübergreifende Kommunikation mit der named Pipe, gehen Sie folgendermaßen vor:
  1. Im Projektmappen-Explorer mit der rechten Maustaste MyServerApp, zeigen Sie auf Hinzufügenund Modul hinzufügenklicken.
  2. Klicken Sie im Dialogfeld Neues Element hinzufügen - MyServerApp Öffnen.
  3. Fügen Sie folgenden Code in Module1.vb Modul:
    Public Const FILE_ATTRIBUTE_NORMAL As Short = &H80SPublic 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

zurück zum Anfang

Schreiben Sie Code zum Erstellen der named Pipe-server

Die Verbindung vom Client warten Sie nach dem Erstellen einer Namen Pipes. Wenn der Client mit dem Server verbunden, lesen oder die Daten über die Pipe zu schreiben. Gehen Sie hierzu folgendermaßen vor:
  1. Im Projektmappen-Explorer mit der rechten Maustaste Form1und dann auf Öffnen.
  2. Doppelklicken Sie in der Entwurfsansicht das Formular Form1 auf Erstellen einer named Pipe, und fügen Sie folgenden Code zur Prozedur Button1_Click :
    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 hinzu:
    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. Doppelklicken Sie in der Entwurfsansicht des Formulars Form1 auf die Clientverbindungen wartenund Button2_Click -Prozedur fügen Sie den folgenden Code hinzu:
    Dim byteCount, i, res, cbnCount As IntegerFor 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. Doppelklicken Sie in der Entwurfsansicht auf Form1, und fügen Sie folgenden Code in der Prozedur Form1_Load :
    Button2.Visible = FalseButton3.Visible = False
  7. Doppelklicken Sie im Projektmappen-Explorer auf Form1.vb.
  8. Doppelklicken Sie in der Entwurfsansicht das Formular Form1 auf dem Server trennen, und fügen Sie folgenden Code für die Prozedur Button3_Click :
    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.
zurück zum Anfang

Erstellen eines named Pipe-Clients

Um die named Pipe-Client kommuniziert mit dem Server erstellen, gehen Sie folgendermaßen vor:
  1. Rufen Sie CreateFile -Funktion, um ein Handle für die named Pipe erstellen.
  2. Aufrufen der ReadFile -Funktion oder die Funktion WriteFile Kommunikation über die Pipe.
  3. Rufen Sie die Funktion CloseHandle Griff der CreateFile -Funktion erstellt.
Sie können auch eine named-Pipe-Transaktion für Client-Server-Kommunikation. Die named Pipe-Transaktion kombiniert ein Schreibvorgang und Lesevorgang in einem einzigen Betrieb. Eine Transaktion kann nur auf eine duplex-Nachrichtentyp Pipe verwendet werden. Prozesse können TransactNamedPipe -Funktion oder die CallNamedPipe -Funktion Sie die benannte Pipe Transaktionen.


In diesem Codebeispiel verwenden Sie die Funktion CallNamedPipe named Pipe-Server verbinden, die Daten in die Pipe zu schreiben und die Daten aus der Pipe gelesen.

zurück zum Anfang

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

Gehen Sie folgendermaßen vor, um eine Visual Basic .NET oder Visual Basic 2005 Windows-Anwendung entwerfen, die Verbindung mit der named Pipe-Server verwendet wird:
  1. Starten Sie Microsoft Visual Studio .NET oder Microsoft Visual Studio 2005.
  2. Klicken Sie im Menü Datei auf neu und klicken Sie dann auf Projekt.
  3. Unter Projekttypenauf Visual Basic-Projekteund klicken Sie unter Vorlagenauf Windows-Anwendung .

    Hinweis Klicken Sie in Visual Studio 2005 unter Projekttypenauf Visual Basic .
  4. Geben Sie im Feld Name MyClientAppund klicken Sie dann auf OK. Standardmäßig wird ein Formular mit dem Namen Form1 erstellt.
  5. Fügen Sie ein Button -Steuerelement in das Formular Form1.
  6. Maustaste auf Button1, und klicken Sie dann auf Eigenschaften.
  7. Legen Sie die Text -Eigenschaft zum Verbinden mit dem Server.
  8. Fügen Sie ein Label -Steuerelement in das Formular Form1. Formular " Form1 " Label1 Label -Steuerelement hinzugefügt.
  9. Die Visible -Eigenschaft des Label1 Label -Steuerelement auf Falsefestgelegt.
  10. Fügen Sie zwei TextBox -Steuerelemente in das Formular Form1.
zurück zum Anfang

Schreiben Sie Code zum named Pipe-Server herstellen

Verbinden Sie mit der named Pipe-Server mithilfe der CallNamedPipe -Funktion. Nach der Verbindung mit dem Server Funktion in die Pipe geschrieben CallNamedPipe aus der Pipe liest und schließt dann die Pipe. Zum Verbinden mit dem Server lesen und Schreiben der Daten, gehen Sie folgendermaßen vor:
  1. Doppelklicken Sie in der Entwurfsansicht auf Verbindung mit dem Serverund Button1_Click -Prozedur fügen Sie den folgenden Code hinzu:
    Dim i, res, cbRead,numBytes As IntegerDim 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 hinzu:
    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.
zurück zum Anfang

Stellen Sie sicher, dass der Code funktioniert

Um sicherzustellen, dass Ihr Code funktioniert, gehen Sie folgendermaßen vor:
  1. Um die Server-Anwendung zu starten, klicken Sie auf Start im Menü Debuggen des Projekts MyServerApp.
  2. Das Formular Form1 auf erstellen eine named Pipeund klicken Sie dann auf die Clientverbindungen warten. Die Anwendung ist blockiert und wartet darauf, dass der Client eine Verbindung herstellen.
  3. Um die Client-Anwendung zu starten, klicken Sie auf Start im Menü Debuggen des Projekts MyClientApp.
  4. Das Formular Form1 Geben Sie 10 im Feld TextBox1 und klicken Sie dann auf Verbindung mit Server herstellen. Das Bytearray sehen, das im Feld TextBox2 empfangen wird.
  5. Um die Client-Anwendung vom Server zu trennen, geben Sie 0 in TextBox1 Feld in der Clientanwendung und klicken Sie dann auf Verbindung mit dem Server.
  6. Schließen Sie die Clientanwendung.
  7. Klicken Sie auf Trennen der Server in der Server-Anwendung das Formular Form1 Trennen der Serverseite named Pipe, und schließen Sie die Serveranwendung.
zurück zum Anfang

Referenzen

Weitere Informationen finden Sie auf folgenden Websites von Microsoft Developer Network (MSDN):zurück zum Anfang
Eigenschaften

Artikelnummer: 871044 – Letzte Überarbeitung: 16.01.2017 – Revision: 1

Feedback