Po pierwsze, pytanie: czy specyfikacje CLR gwarantują, że kod wykonywany w wielu domenach aplikacji w ramach tego samego procesu będzie miał tę samą przestrzeń adresową? „Udostępnianie przestrzeni adresowej” oznacza, że ​​wskaźniki do pamięci przydzielone w jednej z domen aplikacji będą ważne do odczytu i zapisu we wszystkich domenach aplikacji hostowanych w tym samym procesie.

Rozważmy ten samodzielny przykład ilustrujący pytanie: program przydziela aWorker obiekt w oddzielnej domenie aplikacji. TheWorker przydziela blok pamięci dla 10 000 liczb całkowitych i wypełnia go danymi. Program wywołuje następnie granicę domeny aplikacji, aby uzyskać wskaźnik do przydzielonego bloku i sprawdza, czy może odczytać każdy z 10 000 elementów.

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
                    );
                }
            }
        }
    }
}

Prowadziłem to wiele razy i działało to za każdym razem. Intuicyjnie powinno działać: w końcu domeny aplikacji są w jednym procesie, więc muszą współdzielić tę samą wirtualną przestrzeń adresową. Jednak wydaje się, że jest to exploit funkcji, którą Microsoft może zabrać w dowolnym momencie. Czy w specyfikacji CLR jest coś, co potwierdza lub neguje zasadność tej sztuczki?

Jeśli zastanawiasz się, dlaczego zadaję takie dziwne pytanie, szukam sposobu na przekazanie dużych (w gigabajtach) ilości danych przez granicę domeny aplikacji, przy minimalnym obciążeniu zarówno w czasie, jak i przestrzeni. Byłoby to moje idealne rozwiązanie, gdybym mógł udowodnić jego zasadność.