Archive. Posts from 2004 to 2016, kept as they were written. My current blog is at dariuszparys.com.

Es gibt verschiedene Wege zwischen Prozessen zu kommunizieren. Es gibt eine Reihe von Möglichkeiten dies zu tun. .NET Remoting, MSMQ, Web Services, Named Pipes sind nur einige Möglichkeiten die man hat. Aber habt Ihr schonmal was von MailSlots gehört?

Mailslots sind unidirektionale Nachrichten die entweder zu einem dedizierten Rechner oder über die gesamte Domäne hinweg versendet werden. Es handelt sich hier um kurze Nachrichten, ähnlich wie man das früher von dem Kommando "net send xyz" her kennt.

Die Nachrichten werden im Speicher gehalten. Eine Anwendung kann einen Mailslot aufmachen und Nachrichten auf diesem empfangen. Ist die Anwendung über mehrere Rechner verteilt, wird auf jedem Rechner ein solches Postfach erstellt.

Die Anwendung erstellt einen dedizierten Mailslot über folgende Syntax:

\.\mailslot\meinpostfach

Möchte man nun eine Nachricht zu dieser Anwendung schicken, so kann man entweder den Rechner direkt adressieren

\zielrechner\mailslot\meinpostfach

oder, für den Fall das die Anwendung auf mehreren Rechnern läuft und man an alle Anwendungen eine Nachricht schicken möchte, ist die Syntax folgende:

\*\mailslot\meinpostfach

Hierbei steht das Asterisk für die primäre Domäne. Um eine dedizierte Domäne anzusprechen kann man dementsprechend auch folgendes schreiben:

\diedomäne\mailslot\meinpostfach

Wichtig ist das meinpostfach eindeutig über das Netzwerk ist. Des Weiteren kann man auch hierarchien einführen um spezielle Nachrichten zu gruppieren

\.\mailslot\meinpostfach\gruppea

\.\mailslot\meinpostfach\gruppeb

usw.

Ein Problem gibt es allerdings hierbei. Es gibt keine .NET API dafür. Die Methoden CreateMailSlot, GetMailSlotInfo und CreateFile müssen in C# deklariert werden (mittels DllImport).

Da es auch kein vernünftiges Beispiel gibt wie das zu tun ist, habe ich ein kleines Sample geschrieben. Zuerst die Deklarationen der verschiedenen API's die benötigt werden:

[DllImport( "kernel32.dll",
    CharSet = CharSet.Auto,
    CallingConvention = CallingConvention.StdCall,
    SetLastError = true )]

public static extern SafeFileHandle CreateFile(
      string lpFileName,
      uint dwDesiredAccess,
      uint dwShareMode,
      uint SecurityAttributes,
      uint dwCreationDisposition,
      uint dwFlagsAndAttributes,
      int hTemplateFile
      );

[DllImport( "kernel32.dll",
    CharSet = CharSet.Auto,
    CallingConvention = CallingConvention.StdCall,
    SetLastError = true )]

public static extern SafeFileHandle CreateMailslot(
    string lpName,
    uint nMaxMessageSize,
    int lReadTimeout,
    IntPtr lpSecurityAttributes );

[DllImport( "kernel32.dll",
    CharSet = CharSet.Auto,
    CallingConvention = CallingConvention.StdCall,
    SetLastError = true )]

public static extern bool GetMailslotInfo( SafeFileHandle hMailslot,
    out IntPtr lpMaxMessageSize,
    out IntPtr lpNextSize,
    out IntPtr lpMessageCount,
    out IntPtr lpReadTimeout );

Nun gilt es die Anwendung zu schreiben die das Postfach erzeugt und auf Nachrichten wartet. Die Schritte die Notwendig sind um ein solches Mailslot Postfach zu erzeugen sind zusammengefasst:

  1. Mit CreateMailSlot ein Mailslot Postfach erzeugen
  2. Mit GetMailSlotInfo prüfen ob neue Nachrichten angekommen sind
  3. Mit dem StreamReader die Nachrichten lesen

Die Anwendung die dann Nachrichten schicken möchte hat folgende Aufgaben zu tun:

  1. Mit CreateFile ein Mailslot Postfach öffnen
  2. Mit dem StreamWriter die Nachricht wegschreiben

Nachfolgender Sourcecode zeigt einen Server und einen Client. Wichtig: Der Quellcode prüft keine Fehler und sonstige möglichen Fehlerquellen. Er dient nur zur Veranschaulichung.

Server:

static void Main( string[] args )
{

    SafeFileHandle slotHandle =
        External.CreateMailslot( @"\\.\mailslot\myapp", 0, -1, IntPtr.Zero );

    IntPtr messageMaxSize = new IntPtr();
    IntPtr messageSize = new IntPtr();
    IntPtr numberOfMessages = new IntPtr();
    IntPtr readTimeout = new IntPtr();

    if( slotHandle.IsInvalid )
    {
        Console.WriteLine( "Could not create MailSlot!" );
        return;
    }

    while( true )
    {
        Thread.Sleep( 3000 );
        External.GetMailslotInfo( slotHandle,
            out messageMaxSize,
            out messageSize,
            out numberOfMessages,
            out readTimeout );
        {
            Console.WriteLine( "Next size: {0}", messageSize.ToString() );
            if( numberOfMessages.ToInt32() == 0 )
            {
                Console.WriteLine( "No new messages" );
                continue;
            }

            Console.WriteLine( "Number of waiting messages: {0}",
                numberOfMessages.ToInt32() );

            using( FileStream fs = new FileStream( slotHandle.DangerousGetHandle(),
                                                    FileAccess.Read, false ) )
            {
                using( StreamReader sr = new StreamReader( fs ) )
                {
                    char[] msg = new char[ messageSize.ToInt32() ];
                    sr.Read( msg, 0, messageSize.ToInt32() );

                    string message = new string( msg );

                    Console.WriteLine( "Message: {0}", message.ToString() );
                }
            }
        }
    }
}

Client:

static void Main( string[] args )
{
    string slotname = @"\\dparys1\mailslot\myapp";

    SafeFileHandle slotHandle = External.CreateFile( slotname,
        ( uint ) FileAccess.Write,
        ( uint ) FileShare.Read,
        0,
        ( uint ) FileMode.Open,
        ( uint ) FileAttributes.Normal,
        0 );

    if( slotHandle.IsInvalid )
    {
        Console.WriteLine( "Could not open mailslot!" );
        return;
    }

    using( FileStream fs = new FileStream( slotHandle.DangerousGetHandle(),
                                            FileAccess.Write, false, 400 ) )
    {
        using( StreamWriter sw = new StreamWriter( fs ) )
        {
            for( int i = 0; i < 5; i++ )
            {
                sw.Write( "Hello, world." );
                sw.Flush();

                Thread.Sleep( 1000 );
            }
        }
    }
}

Ansonsten kann man auch das Visual Studio Projekt hier runterladen.