Objekt-Sharing zwischen Anwendungen?

Gibt es ein paar IPC-Technologien, die Sie verwenden können, obwohl die pre-date WCF heute noch relevant sind.

Rohre

Rohre ist eine solche Technologie. Es ist binary, läuft im Kernel-Modus und sehr schnell! Obwohl, es ist ziemlich low-level und hat nicht geben Zugriff auf "Objekte".

.NET Remoting

.NET Remoting geben wird, die den Zugriff auf Objekte ist, aber vielleicht nicht so schnell wie Rohre.

Beide Rohre und .NET remoting schneller als die Serialisierung-Technologien WCF konvertiert Dinge zu verbose-XML/SOAP.

COM

COM ist ein Binär-Protokoll für IPC. COM ist ein client-server-Modell, bei dem der client fordert Daten von der COM-oder OLE-server. Die Schönheit über COM ist, dass Sie direkten Zugang, um Objekte in der server - Sie sind nicht serialisierte. Zum Beispiel das anfordern eines Elements in einer SAFEARRAY.

Einen SAFEARRAY ist ein Automatisierungs-safe-Struktur von beliebigen Dimensionen, bestehend aus Typ-sicheren Daten. Zum Glück .NET verstecken Sie die SAFEARRAY-fressen-de-Kauderwelsch für uns.

In meinem Beispiel habe ich eine Manager Klasse, aussetzen wird die array. Man die Manager ich habe ein factory-pattern, so dass Manager ist im wesentlichen ein singleton.

Legen Sie Ihr Projekt wie folgt:

• MyComLib.Contracts.dll - enthält alle Schnittstellen
• MyComLib.dll - enthält die Implementierung der Factory, Manager

Erste Verträge:

[ComVisible(true)]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IArrayItem
{
    #region Properties

    string Name { get; set; }

    int Whatsit { get; set; }

    #endregion
}

[ComVisible(true)]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IFactory 
{
    #region Methods

    IManager CreateManager();

    #endregion
}

[ComVisible(true)]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IManager
{
    #region Properties

    IArrayItem[] Array { get; }

    #endregion
}

public static class MyComLibConstants
{
    public const string FactoryProgId = "MickyD.MyComLib.Factory.1";

}

Nun für die Fabrik-Muster:

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof (IFactory))]
[Guid("...")]
[ProgId(MyComLibConstants.FactoryProgId)]
public class Factory : MarshalByRefObject, IFactory
{
    #region IFactory Members

    ///<summary>
    ///Creates the manager.
    ///</summary>
    ///<returns></returns>
    public IManager CreateManager()
    {
        return Manager.Instance;
    }


    #endregion
}

Manager:

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof (IManager))]
[Guid("...")]
internal sealed class Manager : MarshalByRefObject, IManager
{
    private static Manager _instance;

    #region Constructor

    ///<summary>
    ///Prevents a default instance of the <see cref="Manager"/> class from being created.
    ///</summary>
    private Manager()
    {
        const int n = 5000;
        Array = new IArrayItem[n];
        for (int i = 0; i < n; i++)
        {
            Array[i]=new ArrayItem();
        }
    }

    #endregion

    #region Properties


    ///<summary>
    ///Gets the instance.
    ///</summary>
    ///<value>
    ///The instance.
    ///</value>
    public static IManager Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new Manager();
            }
            return _instance;
        }
    }

    #endregion

    #region IManager Members

    ///<summary>
    ///Gets the array.
    ///</summary>
    ///<value>
    ///The array.
    ///</value>
    public IArrayItem[] Array { get; private set; }

    #endregion
}

Eine test-app. Dies sollte nur Verweis auf die MyComLib.Contracts.dll und nicht MyComLib.dll.

class Program
{
    static void Main(string[] args)
    {
        var type = Type.GetTypeFromProgID(MyComLibConstants.FactoryProgId);
        var factory = Activator.CreateInstance(type) as IFactory;
        var manager = factory.CreateManager();
        var x = manager.Array[500].Whasit;
    }
}

Ein letzter Schritt ist, dies zu ändern in-Prozess COM-server zu einem out-of-process - COM-server, so dass mehrere Prozesse jede Aktie die gleiche Manager und erstellen Sie nicht Ihr eigenes singletons. In otherwords, einem singleton, das die Bereiche Prozesse. Wenn die Manager läuft, ist es im wesentlichen, in einem eigenen Prozess Raum, getrennt von all den anderen client-Prozesse.

Dafür benötigen Sie zum konfigurieren einer COM-surrogate, die im detail erläutert wird hier.

Datei Mapping/Shared Memory

Schließlich, Datei-Zuordnung ermöglicht die Bearbeitung einer Datei, als ob es nichts weiter als ein großer block von Speicher in den Prozess-Adressbereich. Keine fummeligen Datei suchen; Lesen/schreiben-Operationen. Nehmen Sie sich einfach ein Zeiger auf den Speicherblock und anfangen zu Lesen/schreiben. Das system wird den rest erledigen.

MSDN:

Können Sie eine spezielle Fall der Datei zuordnen zu bieten named shared memory zwischen Prozessen. Wenn Sie angeben, dass das system swapping-Datei beim erstellen eines Datei-Zuordnung-Objekt, wird die Datei-Zuordnung-Objekt behandelt wird, als ein shared-memory-block. Andere Prozesse können auf den gleichen Speicherblock, der durch das öffnen der gleichen Datei-Zuordnung-Objekt. Erzähl mir mehr

Leider tut es immer noch verlangen, dass Sie schreiben Ihre Daten in den ersten Platz und für die es am wirkungsvollsten zu sein, würden Sie brauchen, um Ihre Anwendung zur Behandlung der Speicher-block als Quelle der Wahrheit, anstatt mit dem array im Speicher. Sonst werden Sie serialisiert die ganze Zeit.

Jedoch, shared memory-über die swap-Datei ist technisch erlauben, Sie zu beseitigen serialisieren-de-serialisieren zwischen Ihren client-server-apps und Vervielfältigung von Daten "auf Halde". Obwohl, wie ich sagte, müssen Sie möglicherweise passen Sie Ihre app an die Arbeit mit raw-Puffer eher als Objekte.

Erzähl mir mehr

• Rohr-Operationen in der .NET Framework
• .NET Remoting
• Interprocess Communications

HINWEIS: Entgegen der landläufigen Meinung .NET Remoting ist nicht ganz veraltet. Eine contemory verwenden, denn es ist die Kommunikation zwischen Objekten in verschiedenen AppDomains im gleichen Prozess, etwas, was Sie normalerweise tun, in plug-in systems.