Zunächst die Frage: Stellen CLR-Spezifikationen sicher, dass der Code, der in mehreren Anwendungsdomänen innerhalb desselben Prozesses ausgeführt wird, denselben Adressraum verwendet? Mit "Freigabe des Adressraums" meine ich, dass in einer der App-Domänen zugewiesene Zeiger auf den Arbeitsspeicher für das Lesen und Schreiben in allen App-Domänen gültig sind, die im selben Prozess gehostet werden.

Betrachten Sie dieses in sich geschlossene Beispiel zur Veranschaulichung der Frage: Das Programm weist a zuWorker Objekt in einer separaten App-Domain. DasWorker Ordnet einen Speicherblock für 10.000 Ganzzahlen zu und füllt ihn mit Daten. Das Programm ruft dann über die Anwendungsdomänengrenze auf, um den Zeiger auf den zugewiesenen Block abzurufen, und überprüft, ob alle 10.000 Elemente gelesen werden können.

using System;
using System.Reflection;
using System.Runtime.InteropServices;

namespace crossapp {
    public class Worker : MarshalByRefObject {
        private readonly IntPtr myData;
        public const int DataLength = 10000;
        public Worker() {
            Console.Error.WriteLine(
                "Memory allocation happens in app domain '{0}'"
            ,   Assembly.GetExecutingAssembly().FullName
            );
            myData = Marshal.AllocHGlobal(sizeof(int) * DataLength);
            unsafe {
                var ptr = (int*) myData.ToPointer();
                for (var i = 0 ; i != DataLength ; i++) {
                    ptr[i] = 2*i + 1;
                }
            }
        }
        public IntPtr GetData() {
            return myData;
        }
    }
    class Program {
        static void Main() {
            var ad = AppDomain.CreateDomain("New domain");
            var wrk = (Worker)ad.CreateInstanceAndUnwrap(
                Assembly.GetExecutingAssembly().FullName
            ,   "crossapp.Worker"
            );
            var data = wrk.GetData();
            var badCount = 0;
            unsafe {
                var ptr = (int*)data.ToPointer();
                for (var i = 0 ; i != Worker.DataLength ; i++) {
                    var expect = 2*i + 1;
                    if (ptr[i] != expect) {
                        Console.Error.WriteLine(
                            "Mismatch in position {0}: {1} != {2}"
                        ,   i, expect, ptr[i]
                        );
                        badCount++;
                    }
                }
                if (badCount == 0) {
                    Console.Error.WriteLine(
                        "All {0} items have matched."
                    ,   Worker.DataLength
                    );
                } else {
                    Console.Error.WriteLine(
                        "Found {0} mismatches out of {1}."
                    ,   badCount
                    ,   Worker.DataLength
                    );
                }
            }
        }
    }
}

Ich bin so oft gelaufen und es hat jedes Mal funktioniert. Intuitiv sollte es funktionieren: Schließlich befinden sich App-Domänen in einem einzigen Prozess, sodass sie denselben virtuellen Adressraum gemeinsam nutzen müssen. Dies fühlt sich jedoch wie ein Exploit einer Funktion an, die Microsoft jederzeit entfernen kann. Bestätigt oder leugnet etwas in der Spezifikation der CLR die Legitimität dieses Tricks?

Für den Fall, dass Sie sich fragen, warum ich eine so seltsame Frage stelle, suche ich nach einer Möglichkeit, große Datenmengen (in Gigabyte) über die Anwendungsdomänengrenzen hinweg mit minimalem Aufwand sowohl räumlich als auch zeitlich zu übertragen. Dies wäre meine ideale Lösung, wenn ich ihre Legitimität nachweisen könnte.